Esempio n. 1
0
        public void TestAddNewColumnFamily()
        {
            var scheme = new KeyspaceSchema
            {
                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));
        }
Esempio n. 2
0
        public void TestActualizeWithNullProperties()
        {
            var keyspaceName = TestSchemaUtils.GetRandomKeyspaceName();
            var scheme       = new KeyspaceSchema
            {
                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));
        }
Esempio n. 3
0
        public void TestChangeCompressionProperty()
        {
            var scheme = new KeyspaceSchema
            {
                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 TestActualizeColumnFamily()
        {
            var          keyspaceName     = Guid.NewGuid().ToString("N");
            const string columnFamilyName = "1";
            var          keyspaceScheme   = new KeyspaceSchema
            {
                Name          = keyspaceName,
                Configuration = new KeyspaceConfiguration
                {
                    ReplicationStrategy = SimpleReplicationStrategy.Create(1),
                    ColumnFamilies      = new[]
                    {
                        new ColumnFamily
                        {
                            Name = columnFamilyName,
                            BloomFilterFpChance = null
                        }
                    }
                }
            };

            cassandraSchemaActualizer.ActualizeKeyspaces(new[] { keyspaceScheme }, changeExistingKeyspaceMetadata: false);
            var actualColumnFamily = cassandraCluster.RetrieveClusterConnection().RetrieveKeyspaces().First(x => x.Name == keyspaceName).ColumnFamilies[columnFamilyName];

            Assert.AreEqual(0.01d, actualColumnFamily.BloomFilterFpChance);

            keyspaceScheme.Configuration.ColumnFamilies.First().BloomFilterFpChance = 0.02;
            cassandraSchemaActualizer.ActualizeKeyspaces(new[] { keyspaceScheme }, changeExistingKeyspaceMetadata: false);

            actualColumnFamily = cassandraCluster.RetrieveClusterConnection().RetrieveKeyspaces().First(x => x.Name == keyspaceName).ColumnFamilies[columnFamilyName];
            Assert.AreEqual(0.02d, actualColumnFamily.BloomFilterFpChance);
        }
Esempio n. 5
0
        public void TestChangeCompactionProperties()
        {
            var scheme = new KeyspaceSchema
            {
                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));
        }
Esempio n. 6
0
        public void TestDoubleActualizeWithoutChangingSchema()
        {
            var scheme = new KeyspaceSchema
            {
                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));
        }
Esempio n. 7
0
        public void TestDoubleActualizeWithoutChangingSchema()
        {
            var scheme = new KeyspaceSchema
            {
                Name          = TestSchemaUtils.GetRandomKeyspaceName(),
                Configuration = new KeyspaceConfiguration
                {
                    ColumnFamilies = new[]
                    {
                        new ColumnFamily
                        {
                            Name = "CF1"
                        }
                    }
                }
            };

            Assert.That(cassandraActualizerEventListener.KeyspaceAddedInvokeCount, Is.EqualTo(0));
            cassandraSchemaActualizer.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));
        }
Esempio n. 8
0
 private void ActualizeKeyspaces(KeyspaceSchema schema)
 {
     cassandraSchemaActualizer.ActualizeKeyspaces(new[] { schema }, changeExistingKeyspaceMetadata: true);
 }