public void TestActualizeWithNullProperties()
        {
            var keyspaceName = TestSchemaUtils.GetRandomKeyspaceName();
            var scheme       = new KeyspaceScheme
            {
                Name          = keyspaceName,
                Configuration = new KeyspaceConfiguration
                {
                    ColumnFamilies = new[]
                    {
                        new ColumnFamily
                        {
                            Name        = "CF1",
                            Compression = ColumnFamilyCompression.Deflate(new CompressionOptions {
                                ChunkLengthInKb = 1024
                            }),
                            Caching = ColumnFamilyCaching.KeysOnly
                        }
                    }
                }
            };

            ActualizeKeyspaces(scheme);

            var actualScheme = cluster.RetrieveKeyspaceConnection(keyspaceName).DescribeKeyspace();

            Assert.That(actualScheme.ColumnFamilies["CF1"].Compression.Algorithm, Is.EqualTo(CompressionAlgorithms.Deflate));

            scheme.Configuration.ColumnFamilies[0].Compression = null;
            scheme.Configuration.ColumnFamilies[0].Caching     = ColumnFamilyCaching.All;
            ActualizeKeyspaces(scheme);

            actualScheme = cluster.RetrieveKeyspaceConnection(keyspaceName).DescribeKeyspace();
            Assert.That(actualScheme.ColumnFamilies["CF1"].Compression.Algorithm, Is.EqualTo(CompressionAlgorithms.LZ4));
        }
        public void TestUpdateKeyspaceWithMultiDcConfiguration()
        {
            var clusterConnection = cluster.RetrieveClusterConnection();

            var keyspaceName    = TestSchemaUtils.GetRandomKeyspaceName();
            var createdKeyspace = new Keyspace
            {
                Name = keyspaceName,
                ReplicationStrategy = NetworkTopologyReplicationStrategy.Create(new[]
                {
                    new DataCenterReplicationFactor("dc1", 3),
                    new DataCenterReplicationFactor("dc2", 5)
                })
            };

            clusterConnection.AddKeyspace(createdKeyspace);

            createdKeyspace.ReplicationStrategy = NetworkTopologyReplicationStrategy.Create(new[]
            {
                new DataCenterReplicationFactor("dc3", 7)
            });
            clusterConnection.UpdateKeyspace(createdKeyspace);

            var keyspaces      = clusterConnection.RetrieveKeyspaces();
            var actualKeyspace = keyspaces.First(x => x.Name == keyspaceName);

            AssertKeyspacePropertiesEquals(createdKeyspace, actualKeyspace);
        }
        private void InternalTestCaching(ColumnFamilyCaching?columnFamilyCaching)
        {
            var name = TestSchemaUtils.GetRandomColumnFamilyName();
            var originalColumnFamily = new ColumnFamily
            {
                Name = name,
                CompactionStrategy = CompactionStrategy.LeveledCompactionStrategy(sstableSizeInMb: 10),
                GCGraceSeconds     = 123,
                ReadRepairChance   = 0.3
            };

            if (columnFamilyCaching != null)
            {
                originalColumnFamily.Caching = columnFamilyCaching.Value;
            }
            keyspaceConnection.AddColumnFamily(originalColumnFamily);

            var columnFamily = keyspaceConnection.DescribeKeyspace().ColumnFamilies[name];

            if (columnFamilyCaching != null)
            {
                Assert.That(columnFamily.Caching, Is.EqualTo(columnFamilyCaching));
            }
            else
            {
                Assert.That(columnFamily.Caching, Is.EqualTo(ColumnFamilyCaching.KeysOnly));
            }
        }
        public void TestChangeCompressionProperty()
        {
            var scheme = new KeyspaceScheme
            {
                Name          = TestSchemaUtils.GetRandomKeyspaceName(),
                Configuration = new KeyspaceConfiguration
                {
                    ColumnFamilies = new[]
                    {
                        new ColumnFamily
                        {
                            Name = "CF1"
                        }
                    }
                }
            };

            ActualizeKeyspaces(scheme);
            Assert.That(cluster.UpdateColumnFamilyInvokeCount, Is.EqualTo(0));
            scheme.Configuration.ColumnFamilies[0].Compression = ColumnFamilyCompression.Deflate(new CompressionOptions {
                ChunkLengthInKb = 1024
            });
            ActualizeKeyspaces(scheme);
            Assert.That(cluster.UpdateColumnFamilyInvokeCount, Is.EqualTo(1));
        }
        public void TestAddNewColumnFamily()
        {
            var scheme = new KeyspaceScheme
            {
                Name          = TestSchemaUtils.GetRandomKeyspaceName(),
                Configuration = new KeyspaceConfiguration
                {
                    ColumnFamilies = new[]
                    {
                        new ColumnFamily
                        {
                            Name = "CF1"
                        }
                    }
                }
            };

            ActualizeKeyspaces(scheme);
            scheme.Configuration.ColumnFamilies = scheme.Configuration.ColumnFamilies.Concat(new[]
            {
                new ColumnFamily
                {
                    Name = "CF2"
                }
            }).ToArray();
            ActualizeKeyspaces(scheme);
            Assert.That(cassandraActualizerEventListener.ColumnFamilyUpdatedInvokeCount, Is.EqualTo(0));
            Assert.That(cassandraActualizerEventListener.ColumnFamilyAddedInvokeCount, Is.EqualTo(1));
        }
 public void TestTryCreateColumnFamilyWithWrongChunkLength()
 {
     Assert.Throws <CassandraClientInvalidRequestException>(
         () => keyspaceConnection.AddColumnFamily(new ColumnFamily
     {
         Name        = TestSchemaUtils.GetRandomColumnFamilyName(),
         Compression = ColumnFamilyCompression.Deflate(new CompressionOptions {
             ChunkLengthInKb = 3
         })
     }));
 }
        public void SetUp()
        {
            cluster = new CassandraCluster(SingleCassandraNodeSetUpFixture.Node.CreateSettings(), Logger.Instance);

            var clusterConnection = cluster.RetrieveClusterConnection();
            var keyspaceName      = TestSchemaUtils.GetRandomKeyspaceName();
            var createdKeyspace   = new Keyspace
            {
                Name = keyspaceName,
                ReplicationStrategy = SimpleReplicationStrategy.Create(1)
            };

            clusterConnection.AddKeyspace(createdKeyspace);

            keyspaceConnection = cluster.RetrieveKeyspaceConnection(keyspaceName);
        }
        public void TestChangeCompactionProperties()
        {
            var scheme = new KeyspaceScheme
            {
                Name          = TestSchemaUtils.GetRandomKeyspaceName(),
                Configuration = new KeyspaceConfiguration
                {
                    ColumnFamilies = new[]
                    {
                        new ColumnFamily
                        {
                            Name = "CF1"
                        }
                    }
                }
            };

            ActualizeKeyspaces(scheme);
            Assert.That(cluster.UpdateColumnFamilyInvokeCount, Is.EqualTo(0));

            scheme.Configuration.ColumnFamilies[0].CompactionStrategy = CompactionStrategy.SizeTieredCompactionStrategy(4, 32);
            ActualizeKeyspaces(scheme);
            Assert.That(cluster.UpdateColumnFamilyInvokeCount, Is.EqualTo(0));

            scheme.Configuration.ColumnFamilies[0].CompactionStrategy = CompactionStrategy.SizeTieredCompactionStrategy(3, 32);
            ActualizeKeyspaces(scheme);
            Assert.That(cluster.UpdateColumnFamilyInvokeCount, Is.EqualTo(1));

            scheme.Configuration.ColumnFamilies[0].CompactionStrategy = CompactionStrategy.SizeTieredCompactionStrategy(3, 31);
            ActualizeKeyspaces(scheme);
            Assert.That(cluster.UpdateColumnFamilyInvokeCount, Is.EqualTo(2));

            ActualizeKeyspaces(scheme);
            Assert.That(cluster.UpdateColumnFamilyInvokeCount, Is.EqualTo(2));

            scheme.Configuration.ColumnFamilies[0].CompactionStrategy = CompactionStrategy.LeveledCompactionStrategy(10);
            ActualizeKeyspaces(scheme);
            Assert.That(cluster.UpdateColumnFamilyInvokeCount, Is.EqualTo(3));

            scheme.Configuration.ColumnFamilies[0].CompactionStrategy = CompactionStrategy.LeveledCompactionStrategy(11);
            ActualizeKeyspaces(scheme);
            Assert.That(cluster.UpdateColumnFamilyInvokeCount, Is.EqualTo(4));

            scheme.Configuration.ColumnFamilies[0].CompactionStrategy = CompactionStrategy.LeveledCompactionStrategy(11);
            ActualizeKeyspaces(scheme);
            Assert.That(cluster.UpdateColumnFamilyInvokeCount, Is.EqualTo(4));
        }
        public void TestDefaultCompression()
        {
            var name = TestSchemaUtils.GetRandomColumnFamilyName();
            var originalColumnFamily = new ColumnFamily
            {
                Name        = name,
                Compression = null
            };

            keyspaceConnection.AddColumnFamily(originalColumnFamily);

            var columnFamily = keyspaceConnection.DescribeKeyspace().ColumnFamilies[name];

            Assert.That(columnFamily.Compression.IsEnabled, Is.True);
            Assert.That(columnFamily.Compression.Algorithm, Is.EqualTo(CompressionAlgorithms.LZ4));
            Assert.That(columnFamily.Compression.Options.ChunkLengthInKb, Is.Null.Or.EqualTo(64));
        }
        public void TestUpdateColumnFamilyCaching()
        {
            var name = TestSchemaUtils.GetRandomColumnFamilyName();
            var originalColumnFamily = new ColumnFamily
            {
                Name = name,
                CompactionStrategy = CompactionStrategy.LeveledCompactionStrategy(sstableSizeInMb: 10),
                GCGraceSeconds     = 123,
                ReadRepairChance   = 0.3,
                Caching            = ColumnFamilyCaching.All
            };
            var keyspaceName    = TestSchemaUtils.GetRandomKeyspaceName();
            var keyspaceSchemes = new[]
            {
                new KeyspaceScheme
                {
                    Name          = keyspaceName,
                    Configuration = new KeyspaceConfiguration
                    {
                        ColumnFamilies = new[]
                        {
                            originalColumnFamily
                        }
                    }
                }
            };

            cluster.ActualizeKeyspaces(keyspaceSchemes);

            originalColumnFamily.Caching = ColumnFamilyCaching.None;
            cluster.ActualizeKeyspaces(keyspaceSchemes);
            Assert.That(cluster.RetrieveKeyspaceConnection(keyspaceName).DescribeKeyspace().ColumnFamilies[name].Caching, Is.EqualTo(ColumnFamilyCaching.None));

            originalColumnFamily.Caching = ColumnFamilyCaching.KeysOnly;
            cluster.ActualizeKeyspaces(keyspaceSchemes);
            Assert.That(cluster.RetrieveKeyspaceConnection(keyspaceName).DescribeKeyspace().ColumnFamilies[name].Caching, Is.EqualTo(ColumnFamilyCaching.KeysOnly));

            originalColumnFamily.Caching = ColumnFamilyCaching.RowsOnly;
            cluster.ActualizeKeyspaces(keyspaceSchemes);
            Assert.That(cluster.RetrieveKeyspaceConnection(keyspaceName).DescribeKeyspace().ColumnFamilies[name].Caching, Is.EqualTo(ColumnFamilyCaching.RowsOnly));

            originalColumnFamily.Caching = ColumnFamilyCaching.All;
            cluster.ActualizeKeyspaces(keyspaceSchemes);
            Assert.That(cluster.RetrieveKeyspaceConnection(keyspaceName).DescribeKeyspace().ColumnFamilies[name].Caching, Is.EqualTo(ColumnFamilyCaching.All));
        }
        public void TestAddKeyspace(bool durableWrites)
        {
            var clusterConnection = cluster.RetrieveClusterConnection();

            var keyspaceName    = TestSchemaUtils.GetRandomKeyspaceName();
            var createdKeyspace = new Keyspace
            {
                Name                = keyspaceName,
                DurableWrites       = durableWrites,
                ReplicationStrategy = SimpleReplicationStrategy.Create(1)
            };

            clusterConnection.AddKeyspace(createdKeyspace);

            var keyspaces      = clusterConnection.RetrieveKeyspaces();
            var actualKeyspace = keyspaces.First(x => x.Name == keyspaceName);

            AssertKeyspacePropertiesEquals(createdKeyspace, actualKeyspace);
        }
        public void TestCreateColumnFamily()
        {
            var name = TestSchemaUtils.GetRandomColumnFamilyName();
            var originalColumnFamily = new ColumnFamily
            {
                Name = name,
                CompactionStrategy = CompactionStrategy.LeveledCompactionStrategy(sstableSizeInMb: 10),
                GCGraceSeconds     = 123,
                ReadRepairChance   = 0.3
            };

            keyspaceConnection.AddColumnFamily(originalColumnFamily);

            var columnFamily = keyspaceConnection.DescribeKeyspace().ColumnFamilies[name];

            Assert.That(columnFamily.Name, Is.EqualTo(originalColumnFamily.Name));
            Assert.That(columnFamily.CompactionStrategy.CompactionStrategyType, Is.EqualTo(originalColumnFamily.CompactionStrategy.CompactionStrategyType));
            Assert.That(columnFamily.CompactionStrategy.CompactionStrategyOptions.SstableSizeInMb, Is.EqualTo(originalColumnFamily.CompactionStrategy.CompactionStrategyOptions.SstableSizeInMb));
            Assert.That(columnFamily.GCGraceSeconds, Is.EqualTo(originalColumnFamily.GCGraceSeconds));
            Assert.That(columnFamily.ReadRepairChance, Is.EqualTo(originalColumnFamily.ReadRepairChance));
        }
        public void TestUpdateColumnFamily()
        {
            var name = TestSchemaUtils.GetRandomColumnFamilyName();
            var originalColumnFamily = new ColumnFamily
            {
                Name = name,
                CompactionStrategy = CompactionStrategy.LeveledCompactionStrategy(sstableSizeInMb: 10),
                GCGraceSeconds     = 123,
                ReadRepairChance   = 0.3,
                Caching            = ColumnFamilyCaching.All
            };

            keyspaceConnection.AddColumnFamily(originalColumnFamily);

            originalColumnFamily.CompactionStrategy = CompactionStrategy.LeveledCompactionStrategy(sstableSizeInMb: 20);
            originalColumnFamily.GCGraceSeconds     = 321;
            originalColumnFamily.ReadRepairChance   = 0.9;
            originalColumnFamily.Caching            = ColumnFamilyCaching.None;
            keyspaceConnection.UpdateColumnFamily(originalColumnFamily);

            var columnFamily = keyspaceConnection.DescribeKeyspace().ColumnFamilies[name];

            Assert.That(columnFamily.Name, Is.EqualTo(originalColumnFamily.Name));
            Assert.That(columnFamily.CompactionStrategy.CompactionStrategyType, Is.EqualTo(originalColumnFamily.CompactionStrategy.CompactionStrategyType));
            Assert.That(columnFamily.CompactionStrategy.CompactionStrategyOptions.SstableSizeInMb, Is.EqualTo(originalColumnFamily.CompactionStrategy.CompactionStrategyOptions.SstableSizeInMb));
            Assert.That(columnFamily.GCGraceSeconds, Is.EqualTo(originalColumnFamily.GCGraceSeconds));
            Assert.That(columnFamily.ReadRepairChance, Is.EqualTo(originalColumnFamily.ReadRepairChance));

            originalColumnFamily.CompactionStrategy = CompactionStrategy.SizeTieredCompactionStrategy(minThreshold: 5, maxThreshold: 17);
            keyspaceConnection.UpdateColumnFamily(originalColumnFamily);

            columnFamily = keyspaceConnection.DescribeKeyspace().ColumnFamilies[name];
            Assert.That(columnFamily.Name, Is.EqualTo(originalColumnFamily.Name));
            Assert.That(columnFamily.CompactionStrategy.CompactionStrategyType, Is.EqualTo(originalColumnFamily.CompactionStrategy.CompactionStrategyType));
            Assert.That(columnFamily.CompactionStrategy.CompactionStrategyOptions.Enabled, Is.EqualTo(originalColumnFamily.CompactionStrategy.CompactionStrategyOptions.Enabled));
            Assert.That(columnFamily.CompactionStrategy.CompactionStrategyOptions.MinThreshold, Is.EqualTo(originalColumnFamily.CompactionStrategy.CompactionStrategyOptions.MinThreshold));
            Assert.That(columnFamily.CompactionStrategy.CompactionStrategyOptions.MaxThreshold, Is.EqualTo(originalColumnFamily.CompactionStrategy.CompactionStrategyOptions.MaxThreshold));
            Assert.That(columnFamily.GCGraceSeconds, Is.EqualTo(originalColumnFamily.GCGraceSeconds));
            Assert.That(columnFamily.ReadRepairChance, Is.EqualTo(originalColumnFamily.ReadRepairChance));
        }
        public void TestDoubleActualizeWithoutChangingSchema()
        {
            var scheme = new KeyspaceScheme
            {
                Name          = TestSchemaUtils.GetRandomKeyspaceName(),
                Configuration = new KeyspaceConfiguration
                {
                    ColumnFamilies = new[]
                    {
                        new ColumnFamily
                        {
                            Name = "CF1"
                        }
                    }
                }
            };

            ActualizeKeyspaces(scheme);
            Assert.That(cluster.UpdateColumnFamilyInvokeCount, Is.EqualTo(0));
            ActualizeKeyspaces(scheme);
            Assert.That(cluster.UpdateColumnFamilyInvokeCount, Is.EqualTo(0));
        }
        private void InternalTestCreateColumnFamilyCompression(ColumnFamilyCompression compression)
        {
            var name = TestSchemaUtils.GetRandomColumnFamilyName();
            var originalColumnFamily = new ColumnFamily
            {
                Name        = name,
                Compression = compression
            };

            keyspaceConnection.AddColumnFamily(originalColumnFamily);

            var columnFamily = keyspaceConnection.DescribeKeyspace().ColumnFamilies[name];

            Assert.That(columnFamily.Compression.Algorithm, Is.EqualTo(originalColumnFamily.Compression.Algorithm));
            if (originalColumnFamily.Compression.Options != null)
            {
                Assert.That(columnFamily.Compression.Options.ChunkLengthInKb, Is.EqualTo(originalColumnFamily.Compression.Options.ChunkLengthInKb));
            }
            else
            {
                Assert.That(columnFamily.Compression.Options, Is.Null);
            }
        }
        public void TestDoubleActualizeWithoutChangingSchema()
        {
            var scheme = new KeyspaceScheme
            {
                Name          = TestSchemaUtils.GetRandomKeyspaceName(),
                Configuration = new KeyspaceConfiguration
                {
                    ColumnFamilies = new[]
                    {
                        new ColumnFamily
                        {
                            Name = "CF1"
                        }
                    }
                }
            };

            Assert.That(cassandraActualizerEventListener.KeyspaceAddedInvokeCount, Is.EqualTo(0));
            actualizer.ActualizeKeyspaces(new[] { scheme }, changeExistingKeyspaceMetadata: true);
            Assert.That(cassandraActualizerEventListener.KeyspaceAddedInvokeCount, Is.EqualTo(1));
            Assert.That(cassandraActualizerEventListener.ColumnFamilyAddedInvokeCount, Is.EqualTo(0));
            Assert.That(cassandraActualizerEventListener.ColumnFamilyUpdatedInvokeCount, Is.EqualTo(0));
        }