public void SchemaParser_GetQueryTrace_When_Second_QueryAsync_Fails_Exception_Should_Propagate() { var sessionRow = TestHelper.CreateRow(new Dictionary <string, object> { { "duration", 10 }, { "request", "test query" }, { "coordinator", IPAddress.Parse("192.168.12.13") }, { "parameters", null }, { "started_at", DateTimeOffset.Now } }); var queryProviderMock = new Mock <IMetadataQueryProvider>(MockBehavior.Strict); queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system_traces\\.sessions"), It.IsAny <bool>())) .Returns(() => TestHelper.DelayedTask <IEnumerable <Row> >(new[] { sessionRow })); queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system_traces\\.events"), It.IsAny <bool>())) .Returns(() => TaskHelper.FromException <IEnumerable <Row> >(new Exception("Test exception 2"))); var queryTrace = GetQueryTrace(); var parser = GetV1Instance(queryProviderMock.Object); var timer = new HashedWheelTimer(); var ex = Assert.Throws <Exception>(() => TaskHelper.WaitToComplete(parser.GetQueryTrace(queryTrace, timer))); Assert.AreEqual("Test exception 2", ex.Message); timer.Dispose(); }
public void SchemaParser_GetQueryTrace_Should_Not_Try_More_Than_Max_Attempts() { var counter = 0; var queryProviderMock = new Mock <IMetadataQueryProvider>(MockBehavior.Strict); queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system_traces\\.sessions"), It.IsAny <bool>())) .Returns(() => { counter++; var sessionRow = TestHelper.CreateRow(new Dictionary <string, object> { { "duration", null }, { "request", "test query " }, { "coordinator", IPAddress.Parse("192.168.12.13") }, { "parameters", null }, { "started_at", DateTimeOffset.Now } }); return(TestHelper.DelayedTask <IEnumerable <Row> >(new[] { sessionRow })); }); queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system_traces\\.events"), It.IsAny <bool>())) .Returns(() => TaskHelper.ToTask(Enumerable.Empty <Row>())); var queryTrace = GetQueryTrace(); var parser = GetV1Instance(queryProviderMock.Object); var timer = new HashedWheelTimer(); Assert.Throws <TraceRetrievalException>(() => TaskHelper.WaitToComplete(parser.GetQueryTrace(queryTrace, timer))); Assert.AreEqual(counter, 5); timer.Dispose(); }
public void SchemaParserV2_GetTable_Should_Propagate_Exceptions_From_Query_Provider() { var ksRow = TestHelper.CreateRow(new Dictionary <string, object> { { "keyspace_name", "ks1" }, { "durable_writes", true }, { "replication", new Dictionary <string, string> { { "class", "org.apache.cassandra.locator.SimpleStrategy" }, { "replication_factor", "1" } } }, }); var queryProviderMock = new Mock <IMetadataQueryProvider>(MockBehavior.Strict); queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system_schema\\.keyspaces.*ks1"), It.IsAny <bool>())) .Returns(() => TestHelper.DelayedTask <IEnumerable <Row> >(new[] { ksRow })); queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system_schema\\.tables.*ks1"), It.IsAny <bool>())) .Returns(() => TestHelper.DelayedTask(Enumerable.Empty <Row>())); //This will cause the task to be faulted queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system_schema\\.columns.*ks1"), It.IsAny <bool>())) .Returns(() => TaskHelper.FromException <IEnumerable <Row> >(new NoHostAvailableException(new Dictionary <IPEndPoint, Exception>()))); queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system_schema\\.indexes.*ks1"), It.IsAny <bool>())) .Returns(() => TestHelper.DelayedTask(Enumerable.Empty <Row>())); var parser = GetV2Instance(queryProviderMock.Object); var ks = TaskHelper.WaitToComplete(parser.GetKeyspace("ks1")); Assert.NotNull(ks); Assert.Throws <NoHostAvailableException>(() => ks.GetTableMetadata("tbl1")); }
public void SchemaParserV1_GetKeyspace_Should_Retrieve_And_Parse_Keyspace_With_SimpleStrategy() { const string ksName = "ks1"; var row = TestHelper.CreateRow(new Dictionary <string, object> { { "keyspace_name", ksName }, { "durable_writes", true }, { "strategy_class", "Simple" }, { "strategy_options", "{\"replication_factor\": \"4\"}" } }); var queryProviderMock = new Mock <IMetadataQueryProvider>(MockBehavior.Strict); queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system\\.schema_keyspaces.*" + ksName), It.IsAny <bool>())) .Returns(() => TestHelper.DelayedTask <IEnumerable <Row> >(new[] { row })); var parser = GetV1Instance(queryProviderMock.Object); var ks = TaskHelper.WaitToComplete(parser.GetKeyspace(ksName)); Assert.NotNull(ks); Assert.AreEqual(ksName, ks.Name); Assert.AreEqual(true, ks.DurableWrites); Assert.AreEqual("Simple", ks.StrategyClass); CollectionAssert.AreEqual(new Dictionary <string, int> { { "replication_factor", 4 } }, ks.Replication); }
public void SchemaParserV1_GetTable_Should_Throw_ArgumentException_When_A_Table_Column_Not_Defined() { var tableRow = TestHelper.CreateRow(new Dictionary <string, object> { { "keyspace_name", "ks_tbl_meta" }, { "columnfamily_name", "tbl1" }, //{"bloom_filter_fp_chance", 0.01}, ---> not defined { "caching", "{\"keys\":\"ALL\", \"rows_per_partition\":\"NONE\"}" }, { "cf_id", "609f53a0-038b-11e5-be48-0d419bfb85c8" }, { "column_aliases", "[]" }, { "comment", "" }, { "compaction_strategy_class", "org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy" }, { "compaction_strategy_options", "{}" }, { "comparator", "org.apache.cassandra.db.marshal.UTF8Type" }, { "compression_parameters", "{\"sstable_compression\":\"org.apache.cassandra.io.compress.LZ4Compressor\"}" }, { "default_time_to_live", 0 }, { "default_validator", "org.apache.cassandra.db.marshal.BytesType" }, { "dropped_columns", null }, { "gc_grace_seconds", 864000 }, { "index_interval", null }, { "is_dense", false }, { "key_aliases", "[\"id\"]" }, { "key_validator", "org.apache.cassandra.db.marshal.UUIDType" }, { "local_read_repair_chance", 0.1 }, { "max_compaction_threshold", 32 }, { "max_index_interval", 2048 }, { "memtable_flush_period_in_ms", 0 }, { "min_compaction_threshold", 4 }, { "min_index_interval", 128 }, { "read_repair_chance", 0D }, { "speculative_retry", "99.0PERCENTILE" }, { "subcomparator", null }, { "type", "Standard" }, { "value_alias", null } }); var ksRow = TestHelper.CreateRow(new Dictionary <string, object> { { "keyspace_name", "ks1" }, { "durable_writes", true }, { "strategy_class", "Simple" }, { "strategy_options", "{\"replication_factor\": \"1\"}" } }); var queryProviderMock = new Mock <IMetadataQueryProvider>(MockBehavior.Strict); queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system\\.schema_keyspaces.*ks1"), It.IsAny <bool>())) .Returns(() => TestHelper.DelayedTask <IEnumerable <Row> >(new[] { ksRow })); queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system\\.schema_columnfamilies.*ks1"), It.IsAny <bool>())) .Returns(() => TestHelper.DelayedTask <IEnumerable <Row> >(new[] { tableRow })); queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system\\.schema_columns.*ks1"), It.IsAny <bool>())) .Returns(() => TestHelper.DelayedTask(Enumerable.Empty <Row>)); var parser = GetV1Instance(queryProviderMock.Object); var ks = TaskHelper.WaitToComplete(parser.GetKeyspace("ks1")); Assert.NotNull(ks); var ex = Assert.Throws <ArgumentException>(() => ks.GetTableMetadata("ks_tbl_meta")); StringAssert.Contains("bloom_filter_fp_chance", ex.Message); }
public void SchemaParserV1_GetTable_Should_Parse_1_2_Table_With_Partition_And_Clustering_Keys() { var tableRow = TestHelper.CreateRow(new Dictionary <string, object> { { "keyspace_name", "ks_tbl_meta" }, { "columnfamily_name", "tbl1" }, { "bloom_filter_fp_chance", 0.01 }, { "caching", "KEYS_ONLY" }, { "column_aliases", "[\"zck\"]" }, { "comment", "" }, { "compaction_strategy_class", "org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy" }, { "compaction_strategy_options", "{}" }, { "comparator", "org.apache.cassandra.db.marshal.CompositeType(org.apache.cassandra.db.marshal.TimeUUIDType,org.apache.cassandra.db.marshal.UTF8Type)" }, { "compression_parameters", "{\"sstable_compression\":\"org.apache.cassandra.io.compress.SnappyCompressor\"}" }, { "default_validator", "org.apache.cassandra.db.marshal.BytesType" }, { "gc_grace_seconds", 864000 }, { "id", null }, { "key_alias", null }, { "key_aliases", "[\"pk1\",\"apk2\"]" }, { "key_validator", "org.apache.cassandra.db.marshal.CompositeType(org.apache.cassandra.db.marshal.UUIDType,org.apache.cassandra.db.marshal.UTF8Type)" }, { "local_read_repair_chance", 0D }, { "max_compaction_threshold", 32 }, { "min_compaction_threshold", 4 }, { "populate_io_cache_on_flush", false }, { "read_repair_chance", 0.1 }, { "replicate_on_write", true }, { "subcomparator", null }, { "type", "Standard" }, { "value_alias", null } }); var columnRows = new [] { new Dictionary <string, object> { { "keyspace_name", "ks_tbl_meta" }, { "columnfamily_name", "tbl1" }, { "column_name", "val2" }, { "component_index", 1 }, { "index_name", null }, { "index_options", null }, { "index_type", null }, { "validator", "org.apache.cassandra.db.marshal.BytesType" } }, new Dictionary <string, object> { { "keyspace_name", "ks_tbl_meta" }, { "columnfamily_name", "tbl1" }, { "column_name", "valz1" }, { "component_index", 1 }, { "index_name", null }, { "index_options", null }, { "index_type", null }, { "validator", "org.apache.cassandra.db.marshal.Int32Type" } } }.Select(TestHelper.CreateRow); var ksRow = TestHelper.CreateRow(new Dictionary <string, object> { { "keyspace_name", "ks1" }, { "durable_writes", true }, { "strategy_class", "Simple" }, { "strategy_options", "{\"replication_factor\": \"1\"}" } }); var queryProviderMock = new Mock <IMetadataQueryProvider>(MockBehavior.Strict); queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system\\.schema_keyspaces.*ks1"), It.IsAny <bool>())) .Returns(() => TestHelper.DelayedTask <IEnumerable <Row> >(new[] { ksRow })); queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system\\.schema_columnfamilies.*ks1"), It.IsAny <bool>())) .Returns(() => TestHelper.DelayedTask <IEnumerable <Row> >(new[] { tableRow })); queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system\\.schema_columns.*ks1"), It.IsAny <bool>())) .Returns(() => TestHelper.DelayedTask(columnRows)); var parser = GetV1Instance(queryProviderMock.Object); var ks = TaskHelper.WaitToComplete(parser.GetKeyspace("ks1")); Assert.NotNull(ks); var table = ks.GetTableMetadata("ks_tbl_meta"); Assert.False(table.Options.IsCompactStorage); Assert.NotNull(table.Options.Caching); Assert.AreEqual(5, table.TableColumns.Length); CollectionAssert.AreEqual(new[] { "pk1", "apk2" }, table.PartitionKeys.Select(c => c.Name)); CollectionAssert.AreEqual(new[] { "zck" }, table.ClusteringKeys.Select(c => c.Item1.Name)); CollectionAssert.AreEqual(new[] { SortOrder.Ascending }, table.ClusteringKeys.Select(c => c.Item2)); }
public void UpdateLocalNodeInfoModifiesHost() { var metadata = new Metadata(new Configuration()); var cc = new ControlConnection(GetCluster(), metadata); cc.Host = TestHelper.CreateHost("127.0.0.1"); var row = TestHelper.CreateRow(new Dictionary <string, object> { { "cluster_name", "ut-cluster" }, { "data_center", "ut-dc" }, { "rack", "ut-rack" }, { "tokens", null } }); cc.UpdateLocalInfo(row); Assert.AreEqual("ut-cluster", metadata.ClusterName); Assert.AreEqual("ut-dc", cc.Host.Datacenter); Assert.AreEqual("ut-rack", cc.Host.Rack); }
public void UpdateLocalNodeInfoModifiesHost() { var metadata = new Metadata(new Configuration()); var cc = NewInstance(metadata); cc.Host = TestHelper.CreateHost("127.0.0.1"); var row = TestHelper.CreateRow(new Dictionary <string, object> { { "cluster_name", "ut-cluster" }, { "data_center", "ut-dc" }, { "rack", "ut-rack" }, { "tokens", null }, { "release_version", "2.2.1-SNAPSHOT" } }); cc.UpdateLocalInfo(row); Assert.AreEqual("ut-cluster", metadata.ClusterName); Assert.AreEqual("ut-dc", cc.Host.Datacenter); Assert.AreEqual("ut-rack", cc.Host.Rack); Assert.AreEqual(Version.Parse("2.2.1"), cc.Host.CassandraVersion); }
public void UpdateLocalNodeInfoModifiesHost() { var config = new Configuration(); var metadata = new Metadata(config); var cc = NewInstance(Mock.Of <IInternalCluster>(), config, metadata); cc.Host = TestHelper.CreateHost("127.0.0.1"); var row = TestHelper.CreateRow(new Dictionary <string, object> { { "cluster_name", "ut-cluster" }, { "data_center", "ut-dc" }, { "rack", "ut-rack" }, { "tokens", null }, { "release_version", "2.2.1-SNAPSHOT" } }); cc.GetAndUpdateLocalHost(new ConnectionEndPoint( cc.Host.Address, new ServerNameResolver(new ProtocolOptions()), null), row); Assert.AreEqual("ut-cluster", metadata.ClusterName); Assert.AreEqual("ut-dc", cc.Host.Datacenter); Assert.AreEqual("ut-rack", cc.Host.Rack); Assert.AreEqual(Version.Parse("2.2.1"), cc.Host.CassandraVersion); }
public void SchemaParser_GetQueryTrace_Should_Query_Traces_Tables() { var sessionRow = TestHelper.CreateRow(new Dictionary <string, object> { { "duration", 10 }, { "request", "test query" }, { "coordinator", IPAddress.Parse("192.168.12.13") }, { "parameters", null }, { "started_at", DateTimeOffset.Now } }); var eventRow = TestHelper.CreateRow(new Dictionary <string, object> { { "activity", "whatever" }, { "event_id", TimeUuid.NewId() }, { "source_elapsed", 100 }, { "source", IPAddress.Parse("192.168.1.100") }, { "thread", "thread name" } }); var queryProviderMock = new Mock <IMetadataQueryProvider>(MockBehavior.Strict); queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system_traces\\.sessions"), It.IsAny <bool>())) .Returns(() => TestHelper.DelayedTask <IEnumerable <Row> >(new[] { sessionRow })); queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system_traces\\.events"), It.IsAny <bool>())) .Returns(() => TestHelper.DelayedTask <IEnumerable <Row> >(new[] { eventRow })); var queryTrace = GetQueryTrace(); var parser = GetV1Instance(queryProviderMock.Object); var timer = new HashedWheelTimer(); var resultTrace = TaskHelper.WaitToComplete(parser.GetQueryTrace(queryTrace, timer)); Assert.AreSame(queryTrace, resultTrace); Assert.Greater(queryTrace.DurationMicros, 0); Assert.AreEqual("test query", queryTrace.RequestType); Assert.AreEqual(1, queryTrace.Events.Count); Assert.AreEqual("whatever", queryTrace.Events.First().Description); timer.Dispose(); }
public void SchemaParserV1_GetTable_Should_Propagate_Exceptions_From_Query_Provider() { var ksRow = TestHelper.CreateRow(new Dictionary <string, object> { { "keyspace_name", "ks1" }, { "durable_writes", true }, { "strategy_class", "Simple" }, { "strategy_options", "{\"replication_factor\": \"1\"}" } }); var queryProviderMock = new Mock <IMetadataQueryProvider>(MockBehavior.Strict); queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system\\.schema_keyspaces.*ks1"), It.IsAny <bool>())) .Returns(() => TestHelper.DelayedTask <IEnumerable <Row> >(new[] { ksRow })); queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system\\.schema_columnfamilies.*ks1"), It.IsAny <bool>())) .Returns(() => TaskHelper.FromException <IEnumerable <Row> >(new NoHostAvailableException(new Dictionary <IPEndPoint, Exception>()))); //This will cause the task to be faulted queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system\\.schema_columns.*ks1"), It.IsAny <bool>())) .Returns(() => TaskHelper.FromException <IEnumerable <Row> >(new NoHostAvailableException(new Dictionary <IPEndPoint, Exception>()))); var parser = GetV1Instance(queryProviderMock.Object); var ks = TaskHelper.WaitToComplete(parser.GetKeyspace("ks1")); Assert.NotNull(ks); Assert.Throws <NoHostAvailableException>(() => ks.GetTableMetadata("tbl1")); }
public void SchemaParserV1_GetTable_Should_Parse_2_0_Table_With_Compact_Storage() { var tableRow = TestHelper.CreateRow(new Dictionary <string, object> { { "keyspace_name", "ks_tbl_meta" }, { "columnfamily_name", "tbl1" }, { "bloom_filter_fp_chance", 0.01 }, { "caching", "{\"keys\":\"ALL\", \"rows_per_partition\":\"NONE\"}" }, { "cf_id", "609f53a0-038b-11e5-be48-0d419bfb85c8" }, { "column_aliases", "[]" }, { "comment", "" }, { "compaction_strategy_class", "org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy" }, { "compaction_strategy_options", "{}" }, { "comparator", "org.apache.cassandra.db.marshal.UTF8Type" }, { "compression_parameters", "{\"sstable_compression\":\"org.apache.cassandra.io.compress.LZ4Compressor\"}" }, { "default_time_to_live", 0 }, { "default_validator", "org.apache.cassandra.db.marshal.BytesType" }, { "dropped_columns", null }, { "gc_grace_seconds", 864000 }, { "index_interval", null }, { "is_dense", false }, { "key_aliases", "[\"id\"]" }, { "key_validator", "org.apache.cassandra.db.marshal.UUIDType" }, { "local_read_repair_chance", 0.1 }, { "max_compaction_threshold", 32 }, { "max_index_interval", 2048 }, { "memtable_flush_period_in_ms", 0 }, { "min_compaction_threshold", 4 }, { "min_index_interval", 128 }, { "read_repair_chance", 0D }, { "speculative_retry", "99.0PERCENTILE" }, { "subcomparator", null }, { "type", "Standard" }, { "value_alias", null } }); var columnRows = new [] { new Dictionary <string, object> { { "keyspace_name", "ks_tbl_meta" }, { "columnfamily_name", "tbl1" }, { "column_name", "id" }, { "component_index", null }, { "index_name", null }, { "index_options", null }, { "index_type", null }, { "type", "partition_key" }, { "validator", "org.apache.cassandra.db.marshal.UUIDType" } }, new Dictionary <string, object> { { "keyspace_name", "ks_tbl_meta" }, { "columnfamily_name", "tbl1" }, { "column_name", "text1" }, { "component_index", null }, { "index_name", null }, { "index_options", null }, { "index_type", null }, { "type", "regular" }, { "validator", "org.apache.cassandra.db.marshal.UTF8Type" } }, new Dictionary <string, object> { { "keyspace_name", "ks_tbl_meta" }, { "columnfamily_name", "tbl1" }, { "column_name", "text2" }, { "component_index", null }, { "index_name", null }, { "index_options", null }, { "index_type", null }, { "type", "regular" }, { "validator", "org.apache.cassandra.db.marshal.UTF8Type" } } }.Select(TestHelper.CreateRow); var ksRow = TestHelper.CreateRow(new Dictionary <string, object> { { "keyspace_name", "ks1" }, { "durable_writes", true }, { "strategy_class", "Simple" }, { "strategy_options", "{\"replication_factor\": \"1\"}" } }); var queryProviderMock = new Mock <IMetadataQueryProvider>(MockBehavior.Strict); queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system\\.schema_keyspaces.*ks1"), It.IsAny <bool>())) .Returns(() => TestHelper.DelayedTask <IEnumerable <Row> >(new[] { ksRow })); queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system\\.schema_columnfamilies.*ks1"), It.IsAny <bool>())) .Returns(() => TestHelper.DelayedTask <IEnumerable <Row> >(new[] { tableRow })); queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system\\.schema_columns.*ks1"), It.IsAny <bool>())) .Returns(() => TestHelper.DelayedTask(columnRows)); var parser = GetV1Instance(queryProviderMock.Object); var ks = TaskHelper.WaitToComplete(parser.GetKeyspace("ks1")); Assert.NotNull(ks); var table = ks.GetTableMetadata("ks_tbl_meta"); Assert.True(table.Options.IsCompactStorage); Assert.NotNull(table.Options.Caching); Assert.AreEqual(3, table.TableColumns.Length); CollectionAssert.AreEqual(table.TableColumns.Select(c => c.Name), new[] { "id", "text1", "text2" }); Assert.AreEqual(ColumnTypeCode.Uuid, table.TableColumns[0].TypeCode); CollectionAssert.AreEqual(table.PartitionKeys.Select(c => c.Name), new[] { "id" }); Assert.AreEqual(0, table.ClusteringKeys.Length); }
public void SchemaParserV2_GetTable_Should_Parse_3_0_Table_With_SecondaryIndexes() { var tableRow = TestHelper.CreateRow(new SortedDictionary <string, object> { { "keyspace_name", "ks_tbl_meta" }, { "table_name", "tbl4" }, { "bloom_filter_fp_chance", 0.01 }, { "caching", new SortedDictionary <string, string> { { "keys", "ALL" }, { "rows_per_partition", "NONE" } } }, { "comment", "" }, { "compaction", new SortedDictionary <string, string> { { "min_threshold", "4" }, { "max_threshold", "32" }, { "class", "org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy" } } }, { "compression", new SortedDictionary <string, string> { { "chunk_length_in_kb", "64" }, { "class", "org.apache.cassandra.io.compress.LZ4Compressor" } } }, { "dclocal_read_repair_chance", 0.1 }, { "default_time_to_live", 0 }, { "extensions", new SortedDictionary <string, string>() }, { "flags", new [] { "compound" } }, { "gc_grace_seconds", 864000 }, { "id", "8008ae40-5862-11e5-b0ce-c7d0c38d1d8d" }, { "max_index_interval", 2048 }, { "memtable_flush_period_in_ms", 0 }, { "min_index_interval", 128 }, { "read_repair_chance", 0D }, { "speculative_retry", "99PERCENTILE" } }); var columnRows = new[] { new Dictionary <string, object> { { "keyspace_name", "ks1" }, { "table_name", "tbl4" }, { "column_name", "pk" }, { "clustering_order", "none" }, { "column_name_bytes", "0x706b31" }, { "kind", "partition_key" }, { "position", 0 }, { "type", "uuid" } }, new Dictionary <string, object> { { "keyspace_name", "ks1" }, { "table_name", "tbl4" }, { "column_name", "ck" }, { "clustering_order", "desc" }, { "column_name_bytes", "0x7a636b" }, { "kind", "clustering" }, { "position", 0 }, { "type", "timeuuid" } }, new Dictionary <string, object> { { "keyspace_name", "ks1" }, { "table_name", "tbl4" }, { "column_name", "val" }, { "clustering_order", "none" }, { "column_name_bytes", "0x76616c32" }, { "kind", "regular" }, { "position", -1 }, { "type", "blob" } } }.Select(TestHelper.CreateRow); var indexRow = TestHelper.CreateRow(new Dictionary <string, object> { { "keyspace_name", "ks1" }, { "table_name", "tbl4" }, { "index_name", "ix1" }, { "kind", "COMPOSITES" }, { "options", new Dictionary <string, string> { { "target", "val" } } } }); var ksRow = TestHelper.CreateRow(new Dictionary <string, object> { { "keyspace_name", "ks1" }, { "durable_writes", true }, { "replication", new Dictionary <string, string> { { "class", "org.apache.cassandra.locator.SimpleStrategy" }, { "replication_factor", "1" } } }, }); var queryProviderMock = new Mock <IMetadataQueryProvider>(MockBehavior.Strict); queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system_schema\\.keyspaces.*ks1"), It.IsAny <bool>())) .Returns(() => TestHelper.DelayedTask <IEnumerable <Row> >(new[] { ksRow })); queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system_schema\\.tables.*ks1"), It.IsAny <bool>())) .Returns(() => TestHelper.DelayedTask <IEnumerable <Row> >(new[] { tableRow })); queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system_schema\\.columns.*ks1"), It.IsAny <bool>())) .Returns(() => TestHelper.DelayedTask(columnRows)); queryProviderMock .Setup(cc => cc.QueryAsync(It.IsRegex("system_schema\\.indexes.*ks1"), It.IsAny <bool>())) .Returns(() => TestHelper.DelayedTask <IEnumerable <Row> >(new[] { indexRow })); var parser = GetV2Instance(queryProviderMock.Object); var ks = TaskHelper.WaitToComplete(parser.GetKeyspace("ks1")); Assert.NotNull(ks); var table = ks.GetTableMetadata("tbl4"); Assert.False(table.Options.IsCompactStorage); CollectionAssert.AreEquivalent(new[] { "pk", "ck", "val" }, table.TableColumns.Select(c => c.Name)); CollectionAssert.AreEqual(new[] { "pk" }, table.PartitionKeys.Select(c => c.Name)); CollectionAssert.AreEqual(new[] { "ck" }, table.ClusteringKeys.Select(c => c.Item1.Name)); CollectionAssert.AreEqual(new[] { SortOrder.Descending }, table.ClusteringKeys.Select(c => c.Item2)); Assert.NotNull(table.Indexes); Assert.AreEqual(1, table.Indexes.Count); var index = table.Indexes["ix1"]; Assert.AreEqual("ix1", index.Name); Assert.AreEqual(IndexMetadata.IndexKind.Composites, index.Kind); Assert.AreEqual("val", index.Target); Assert.NotNull(index.Options); }