public async Task Should_Not_Use_The_LoadBalancingPolicy_When_Targeting_Single_Host()
        {
            var queryPlanCounter = 0;
            var lbp = new TestHelper.CustomLoadBalancingPolicy((cluster, ks, stmt) =>
            {
                Interlocked.Increment(ref queryPlanCounter);
                return(cluster.AllHosts());
            });

            var builder = Cluster.Builder().WithLoadBalancingPolicy(lbp);

            using (var testCluster = SimulacronCluster.CreateNew(new SimulacronOptions {
                Nodes = "3"
            }))
                using (var cluster = builder.AddContactPoint(testCluster.InitialContactPoint).Build())
                {
                    var session = await cluster.ConnectAsync();

                    var host = cluster.AllHosts().Last();
                    Interlocked.Exchange(ref queryPlanCounter, 0);

                    await TestHelper.TimesLimit(() =>
                    {
                        var statement = new SimpleStatement("SELECT * FROM system.local").SetHost(host);
                        return(session.ExecuteAsync(statement));
                    }, 1, 1);

                    Assert.Zero(Volatile.Read(ref queryPlanCounter));
                }
        }
        public void Should_Throw_NoHostAvailableException_When_Targeting_Single_Ignored_Host()
        {
            const string query = "SELECT * FROM system.local";
            // Mark the last host as ignored
            var lbp = new TestHelper.CustomLoadBalancingPolicy(
                (cluster, ks, stmt) => cluster.AllHosts(),
                (cluster, host) => host.Equals(cluster.AllHosts().Last()) ? HostDistance.Ignored : HostDistance.Local);
            var builder = Cluster.Builder().WithLoadBalancingPolicy(lbp);

            using (var testCluster = SimulacronCluster.CreateNew(new SimulacronOptions {
                Nodes = "3"
            }))
                using (var cluster = builder.AddContactPoint(testCluster.InitialContactPoint).Build())
                {
                    var session  = cluster.Connect();
                    var lastHost = cluster.AllHosts().Last();

                    // Use the last host
                    var statement = new SimpleStatement(query).SetHost(lastHost);
                    Parallel.For(0, 10, _ =>
                    {
                        var ex = Assert.ThrowsAsync <NoHostAvailableException>(() => session.ExecuteAsync(statement));
                        Assert.That(ex.Errors.Count, Is.EqualTo(1));
                        Assert.That(ex.Errors.First().Key, Is.EqualTo(lastHost.Address));
                    });
                }
        }