From 566b74b870ceafa1af7ebb27aac89253233f9b25 Mon Sep 17 00:00:00 2001 From: Chris Bannister Date: Sat, 8 Jul 2017 11:34:06 +0100 Subject: [PATCH] tests: use session protocol version not the flag (#934) --- cassandra_test.go | 146 +++++++++++++++++++++++++--------------------- common_test.go | 2 +- tuple_test.go | 13 ++--- udt_test.go | 8 +-- 4 files changed, 89 insertions(+), 80 deletions(-) diff --git a/cassandra_test.go b/cassandra_test.go index cd0b708cb..6a4da0c61 100644 --- a/cassandra_test.go +++ b/cassandra_test.go @@ -185,13 +185,13 @@ func TestTracing(t *testing.T) { } func TestPaging(t *testing.T) { - if *flagProto == 1 { - t.Skip("Paging not supported. Please use Cassandra >= 2.0") - } - session := createSession(t) defer session.Close() + if session.cfg.ProtoVersion == 1 { + t.Skip("Paging not supported. Please use Cassandra >= 2.0") + } + if err := createTable(session, "CREATE TABLE gocql_test.paging (id int primary key)"); err != nil { t.Fatal("create table:", err) } @@ -216,15 +216,15 @@ func TestPaging(t *testing.T) { } func TestCAS(t *testing.T) { - if *flagProto == 1 { - t.Skip("lightweight transactions not supported. Please use Cassandra >= 2.0") - } - cluster := createCluster() cluster.SerialConsistency = LocalSerial session := createSessionFromCluster(cluster, t) defer session.Close() + if session.cfg.ProtoVersion == 1 { + t.Skip("lightweight transactions not supported. Please use Cassandra >= 2.0") + } + if err := createTable(session, `CREATE TABLE gocql_test.cas_table ( title varchar, revid timeuuid, @@ -338,13 +338,13 @@ func TestCAS(t *testing.T) { } func TestMapScanCAS(t *testing.T) { - if *flagProto == 1 { - t.Skip("lightweight transactions not supported. Please use Cassandra >= 2.0") - } - session := createSession(t) defer session.Close() + if session.cfg.ProtoVersion == 1 { + t.Skip("lightweight transactions not supported. Please use Cassandra >= 2.0") + } + if err := createTable(session, `CREATE TABLE gocql_test.cas_table2 ( title varchar, revid timeuuid, @@ -380,13 +380,13 @@ func TestMapScanCAS(t *testing.T) { } func TestBatch(t *testing.T) { - if *flagProto == 1 { - t.Skip("atomic batches not supported. Please use Cassandra >= 2.0") - } - session := createSession(t) defer session.Close() + if session.cfg.ProtoVersion == 1 { + t.Skip("atomic batches not supported. Please use Cassandra >= 2.0") + } + if err := createTable(session, `CREATE TABLE gocql_test.batch_table (id int primary key)`); err != nil { t.Fatal("create table:", err) } @@ -410,19 +410,19 @@ func TestBatch(t *testing.T) { func TestUnpreparedBatch(t *testing.T) { t.Skip("FLAKE skipping") - if *flagProto == 1 { - t.Skip("atomic batches not supported. Please use Cassandra >= 2.0") - } - session := createSession(t) defer session.Close() + if session.cfg.ProtoVersion == 1 { + t.Skip("atomic batches not supported. Please use Cassandra >= 2.0") + } + if err := createTable(session, `CREATE TABLE gocql_test.batch_unprepared (id int primary key, c counter)`); err != nil { t.Fatal("create table:", err) } var batch *Batch - if *flagProto == 2 { + if session.cfg.ProtoVersion == 2 { batch = NewBatch(CounterBatch) } else { batch = NewBatch(UnloggedBatch) @@ -453,12 +453,13 @@ func TestUnpreparedBatch(t *testing.T) { // TestBatchLimit tests gocql to make sure batch operations larger than the maximum // statement limit are not submitted to a cassandra node. func TestBatchLimit(t *testing.T) { - if *flagProto == 1 { - t.Skip("atomic batches not supported. Please use Cassandra >= 2.0") - } session := createSession(t) defer session.Close() + if session.cfg.ProtoVersion == 1 { + t.Skip("atomic batches not supported. Please use Cassandra >= 2.0") + } + if err := createTable(session, `CREATE TABLE gocql_test.batch_table2 (id int primary key)`); err != nil { t.Fatal("create table:", err) } @@ -500,12 +501,13 @@ func TestWhereIn(t *testing.T) { // TestTooManyQueryArgs tests to make sure the library correctly handles the application level bug // whereby too many query arguments are passed to a query func TestTooManyQueryArgs(t *testing.T) { - if *flagProto == 1 { - t.Skip("atomic batches not supported. Please use Cassandra >= 2.0") - } session := createSession(t) defer session.Close() + if session.cfg.ProtoVersion == 1 { + t.Skip("atomic batches not supported. Please use Cassandra >= 2.0") + } + if err := createTable(session, `CREATE TABLE gocql_test.too_many_query_args (id int primary key, value int)`); err != nil { t.Fatal("create table:", err) } @@ -531,12 +533,13 @@ func TestTooManyQueryArgs(t *testing.T) { // TestNotEnoughQueryArgs tests to make sure the library correctly handles the application level bug // whereby not enough query arguments are passed to a query func TestNotEnoughQueryArgs(t *testing.T) { - if *flagProto == 1 { - t.Skip("atomic batches not supported. Please use Cassandra >= 2.0") - } session := createSession(t) defer session.Close() + if session.cfg.ProtoVersion == 1 { + t.Skip("atomic batches not supported. Please use Cassandra >= 2.0") + } + if err := createTable(session, `CREATE TABLE gocql_test.not_enough_query_args (id int, cluster int, value int, primary key (id, cluster))`); err != nil { t.Fatal("create table:", err) } @@ -829,11 +832,13 @@ func matchSliceMap(t *testing.T, sliceMap []map[string]interface{}, testMap map[ } func TestSmallInt(t *testing.T) { - if *flagProto < protoVersion4 { - t.Skip("smallint is only supported in cassandra 2.2+") - } session := createSession(t) defer session.Close() + + if session.cfg.ProtoVersion < protoVersion4 { + t.Skip("smallint is only supported in cassandra 2.2+") + } + if err := createTable(session, `CREATE TABLE gocql_test.smallint_table ( testsmallint smallint PRIMARY KEY, )`); err != nil { @@ -888,13 +893,13 @@ func TestScanWithNilArguments(t *testing.T) { } func TestScanCASWithNilArguments(t *testing.T) { - if *flagProto == 1 { - t.Skip("lightweight transactions not supported. Please use Cassandra >= 2.0") - } - session := createSession(t) defer session.Close() + if session.cfg.ProtoVersion == 1 { + t.Skip("lightweight transactions not supported. Please use Cassandra >= 2.0") + } + if err := createTable(session, `CREATE TABLE gocql_test.scan_cas_with_nil_arguments ( foo varchar, bar varchar, @@ -1083,14 +1088,13 @@ func TestBoundQueryInfo(t *testing.T) { //TestBatchQueryInfo makes sure that the application can manually bind query parameters when executing in a batch func TestBatchQueryInfo(t *testing.T) { + session := createSession(t) + defer session.Close() - if *flagProto == 1 { + if session.cfg.ProtoVersion == 1 { t.Skip("atomic batches not supported. Please use Cassandra >= 2.0") } - session := createSession(t) - defer session.Close() - if err := createTable(session, "CREATE TABLE gocql_test.batch_query_info (id int, cluster int, value text, PRIMARY KEY (id, cluster))"); err != nil { t.Fatalf("failed to create table with error '%v'", err) } @@ -1216,11 +1220,13 @@ func TestPrepare_ReprepareStatement(t *testing.T) { } func TestPrepare_ReprepareBatch(t *testing.T) { - if *flagProto == 1 { - t.Skip("atomic batches not supported. Please use Cassandra >= 2.0") - } session := createSession(t) defer session.Close() + + if session.cfg.ProtoVersion == 1 { + t.Skip("atomic batches not supported. Please use Cassandra >= 2.0") + } + stmt, conn := injectInvalidPreparedStatement(t, session, "test_reprepare_statement_batch") batch := session.NewBatch(UnloggedBatch) batch.Query(stmt, "bar") @@ -1244,7 +1250,7 @@ func TestQueryInfo(t *testing.T) { t.Fatalf("Was not expecting meta data for %d query arguments, but got %d\n", 1, x) } - if *flagProto > 1 { + if session.cfg.ProtoVersion > 1 { if x := len(info.response.columns); x != 2 { t.Fatalf("Was not expecting meta data for %d result columns, but got %d\n", 2, x) } @@ -1594,12 +1600,13 @@ func TestIterHost(t *testing.T) { //TestBatchStats confirms that the stats are returning valid data. Accuracy may be questionable. func TestBatchStats(t *testing.T) { - if *flagProto == 1 { - t.Skip("atomic batches not supported. Please use Cassandra >= 2.0") - } session := createSession(t) defer session.Close() + if session.cfg.ProtoVersion == 1 { + t.Skip("atomic batches not supported. Please use Cassandra >= 2.0") + } + if err := createTable(session, "CREATE TABLE gocql_test.batchStats (id int, PRIMARY KEY (id))"); err != nil { t.Fatalf("failed to create table with error '%v'", err) } @@ -1741,7 +1748,7 @@ func TestGetTableMetadata(t *testing.T) { if table.Keyspace != "gocql_test" { t.Errorf("Expected keyspace for '%s' table metadata to be 'gocql_test' but was '%s'", table.Name, table.Keyspace) } - if *flagProto < 4 { + if session.cfg.ProtoVersion < 4 { // TODO(zariel): there has to be a better way to detect what metadata version // we are in, and a better way to structure the code so that it is abstracted away // from us here @@ -1777,7 +1784,7 @@ func TestGetTableMetadata(t *testing.T) { if testTable == nil { t.Fatal("Expected table metadata for name 'test_table_metadata'") } - if *flagProto == protoVersion1 { + if session.cfg.ProtoVersion == protoVersion1 { if testTable.KeyValidator != "org.apache.cassandra.db.marshal.Int32Type" { t.Errorf("Expected test_table_metadata key validator to be 'org.apache.cassandra.db.marshal.Int32Type' but was '%s'", testTable.KeyValidator) } @@ -1853,7 +1860,7 @@ func TestGetColumnMetadata(t *testing.T) { } } - if *flagProto == 1 { + if session.cfg.ProtoVersion == 1 { // V1 proto only returns "regular columns" if len(testColumns) != 1 { t.Errorf("Expected 1 test columns but there were %d", len(testColumns)) @@ -2269,13 +2276,13 @@ func TestSessionBindRoutingKey(t *testing.T) { } func TestJSONSupport(t *testing.T) { - if *flagProto < 4 { - t.Skip("skipping JSON support on proto < 4") - } - session := createSession(t) defer session.Close() + if session.cfg.ProtoVersion < 4 { + t.Skip("skipping JSON support on proto < 4") + } + if err := createTable(session, `CREATE TABLE gocql_test.test_json ( id text PRIMARY KEY, age int, @@ -2313,13 +2320,13 @@ func TestJSONSupport(t *testing.T) { } func TestUDF(t *testing.T) { - if *flagProto < 4 { - t.Skip("skipping UDF support on proto < 4") - } - session := createSession(t) defer session.Close() + if session.cfg.ProtoVersion < 4 { + t.Skip("skipping UDF support on proto < 4") + } + const query = `CREATE OR REPLACE FUNCTION uniq(state set, val text) CALLED ON NULL INPUT RETURNS set LANGUAGE java AS 'state.add(val); return state;'` @@ -2469,12 +2476,13 @@ close: } func TestUnmarshallNestedTypes(t *testing.T) { - if *flagProto < protoVersion3 { - t.Skip("can not have frozen types in cassandra < 2.1.3") - } session := createSession(t) defer session.Close() + if session.cfg.ProtoVersion < protoVersion3 { + t.Skip("can not have frozen types in cassandra < 2.1.3") + } + if err := createTable(session, `CREATE TABLE gocql_test.test_557 ( id text PRIMARY KEY, val list > > @@ -2601,12 +2609,13 @@ func TestControl_DiscoverProtocol(t *testing.T) { // TestUnsetCol verify unset column will not replace an existing column func TestUnsetCol(t *testing.T) { - if *flagProto < 4 { - t.Skip("Unset Values are not supported in protocol < 4") - } session := createSession(t) defer session.Close() + if session.cfg.ProtoVersion < 4 { + t.Skip("Unset Values are not supported in protocol < 4") + } + if err := createTable(session, "CREATE TABLE gocql_test.testUnsetInsert (id int, my_int int, my_text text, PRIMARY KEY (id))"); err != nil { t.Fatalf("failed to create table with error '%v'", err) } @@ -2629,12 +2638,13 @@ func TestUnsetCol(t *testing.T) { // TestUnsetColBatch verify unset column will not replace a column in batch func TestUnsetColBatch(t *testing.T) { - if *flagProto < 4 { - t.Skip("Unset Values are not supported in protocol < 4") - } session := createSession(t) defer session.Close() + if session.cfg.ProtoVersion < 4 { + t.Skip("Unset Values are not supported in protocol < 4") + } + if err := createTable(session, "CREATE TABLE gocql_test.batchUnsetInsert (id int, my_int int, my_text text, PRIMARY KEY (id))"); err != nil { t.Fatalf("failed to create table with error '%v'", err) } diff --git a/common_test.go b/common_test.go index 1fdfbd16b..724863785 100644 --- a/common_test.go +++ b/common_test.go @@ -102,7 +102,7 @@ func createKeyspace(tb testing.TB, cluster *ClusterConfig, keyspace string) { panic(err) } defer session.Close() - defer log.Println("closing keyspace session") + defer tb.Log("closing keyspace session") err = createTable(session, `DROP KEYSPACE IF EXISTS `+keyspace) if err != nil { diff --git a/tuple_test.go b/tuple_test.go index 7d4a3f457..0cd7ecb89 100644 --- a/tuple_test.go +++ b/tuple_test.go @@ -5,12 +5,11 @@ package gocql import "testing" func TestTupleSimple(t *testing.T) { - if *flagProto < protoVersion3 { - t.Skip("tuple types are only available of proto>=3") - } - session := createSession(t) defer session.Close() + if session.cfg.ProtoVersion < protoVersion3 { + t.Skip("tuple types are only available of proto>=3") + } err := createTable(session, `CREATE TABLE gocql_test.tuple_test( id int, @@ -51,11 +50,11 @@ func TestTupleSimple(t *testing.T) { } func TestTupleMapScan(t *testing.T) { - if *flagProto < protoVersion3 { + session := createSession(t) + defer session.Close() + if session.cfg.ProtoVersion < protoVersion3 { t.Skip("tuple types are only available of proto>=3") } - - session := createSession(t) defer session.Close() err := createTable(session, `CREATE TABLE gocql_test.tuple_map_scan( diff --git a/udt_test.go b/udt_test.go index 198aa3aac..f36fd6fdf 100644 --- a/udt_test.go +++ b/udt_test.go @@ -301,13 +301,13 @@ func TestMapScanUDT(t *testing.T) { } func TestUDT_MissingField(t *testing.T) { - if *flagProto < protoVersion3 { - t.Skip("UDT are only available on protocol >= 3") - } - session := createSession(t) defer session.Close() + if session.cfg.ProtoVersion < protoVersion3 { + t.Skip("UDT are only available on protocol >= 3") + } + err := createTable(session, `CREATE TYPE gocql_test.missing_field( name text, owner text);`)