diff --git a/clients/bigquery/bigquery_test.go b/clients/bigquery/bigquery_test.go index 08050d5df..8aae4e5bf 100644 --- a/clients/bigquery/bigquery_test.go +++ b/clients/bigquery/bigquery_test.go @@ -16,9 +16,9 @@ func (b *BigQueryTestSuite) TestTableRelName() { { // All the possible errors _, err := tableRelName("project.dataset") - assert.Error(b.T(), err) + assert.ErrorContains(b.T(), err, "invalid fully qualified name: project.dataset") _, err = tableRelName("project") - assert.Error(b.T(), err) + assert.ErrorContains(b.T(), err, "invalid fully qualified name: project") } } diff --git a/clients/bigquery/merge_test.go b/clients/bigquery/merge_test.go index 844e3f9be..6fdef0468 100644 --- a/clients/bigquery/merge_test.go +++ b/clients/bigquery/merge_test.go @@ -13,7 +13,6 @@ func (b *BigQueryTestSuite) TestBackfillColumn() { type _testCase struct { name string col columns.Column - expectErr bool backfillSQL string commentSQL string } @@ -62,11 +61,6 @@ func (b *BigQueryTestSuite) TestBackfillColumn() { var index int for _, testCase := range testCases { err := shared.BackfillColumn(config.Config{}, b.store, testCase.col, fqTableName) - if testCase.expectErr { - assert.Error(b.T(), err, testCase.name) - continue - } - assert.NoError(b.T(), err, testCase.name) if testCase.backfillSQL != "" && testCase.commentSQL != "" { backfillSQL, _ := b.fakeStore.ExecArgsForCall(index) diff --git a/clients/s3/s3_test.go b/clients/s3/s3_test.go index f7d695fb0..3e92967f4 100644 --- a/clients/s3/s3_test.go +++ b/clients/s3/s3_test.go @@ -14,15 +14,6 @@ import ( ) func TestObjectPrefix(t *testing.T) { - type _testCase struct { - name string - tableData *optimization.TableData - config *config.S3Settings - - expectError bool - expectedFormat string - } - td := optimization.NewTableData(nil, config.Replication, nil, kafkalib.TopicConfig{ Database: "db", TableName: "table", @@ -30,10 +21,17 @@ func TestObjectPrefix(t *testing.T) { }, "table") td.LatestCDCTs = time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC) - testCases := []_testCase{ + testCases := []struct { + name string + tableData *optimization.TableData + config *config.S3Settings + + expectedErr string + expectedFormat string + }{ { name: "nil", - expectError: true, + expectedErr: "failed to validate settings: s3 settings are nil", }, { name: "valid #1 (no prefix)", @@ -62,8 +60,8 @@ func TestObjectPrefix(t *testing.T) { for _, tc := range testCases { store, err := LoadStore(config.Config{S3: tc.config}) - if tc.expectError { - assert.Error(t, err, tc.name) + if tc.expectedErr != "" { + assert.ErrorContains(t, err, tc.expectedErr, tc.name) } else { assert.NoError(t, err, tc.name) actualObjectPrefix := store.ObjectPrefix(tc.tableData) diff --git a/clients/snowflake/staging_test.go b/clients/snowflake/staging_test.go index 664be8b1b..3985f1bb0 100644 --- a/clients/snowflake/staging_test.go +++ b/clients/snowflake/staging_test.go @@ -57,13 +57,6 @@ func (s *SnowflakeTestSuite) TestCastColValStaging() { func (s *SnowflakeTestSuite) TestBackfillColumn() { fqTableName := "db.public.tableName" - type _testCase struct { - name string - col columns.Column - expectErr bool - backfillSQL string - commentSQL string - } backfilledCol := columns.NewColumn("foo", typing.Boolean) backfilledCol.SetDefaultValue(true) @@ -75,7 +68,12 @@ func (s *SnowflakeTestSuite) TestBackfillColumn() { needsBackfillColDefault := columns.NewColumn("default", typing.Boolean) needsBackfillColDefault.SetDefaultValue(true) - testCases := []_testCase{ + testCases := []struct { + name string + col columns.Column + backfillSQL string + commentSQL string + }{ { name: "col that doesn't have default val", col: columns.NewColumn("foo", typing.Invalid), @@ -101,11 +99,6 @@ func (s *SnowflakeTestSuite) TestBackfillColumn() { var count int for _, testCase := range testCases { err := shared.BackfillColumn(config.Config{}, s.stageStore, testCase.col, fqTableName) - if testCase.expectErr { - assert.Error(s.T(), err, testCase.name) - continue - } - assert.NoError(s.T(), err, testCase.name) if testCase.backfillSQL != "" && testCase.commentSQL != "" { backfillSQL, _ := s.fakeStageStore.ExecArgsForCall(count) diff --git a/lib/cdc/mongo/debezium_test.go b/lib/cdc/mongo/debezium_test.go index 1f5cac4c8..fd5db4c3e 100644 --- a/lib/cdc/mongo/debezium_test.go +++ b/lib/cdc/mongo/debezium_test.go @@ -255,7 +255,7 @@ func (p *MongoTestSuite) TestMongoDBEventCustomerBefore() { func (p *MongoTestSuite) TestGetEventFromBytesTombstone() { _, err := p.Debezium.GetEventFromBytes(typing.Settings{}, nil) - assert.Error(p.T(), err) + assert.ErrorContains(p.T(), err, "empty message") } func (p *MongoTestSuite) TestMongoDBEventWithSchema() { diff --git a/lib/cdc/mysql/debezium_test.go b/lib/cdc/mysql/debezium_test.go index 1c549da96..568a15850 100644 --- a/lib/cdc/mysql/debezium_test.go +++ b/lib/cdc/mysql/debezium_test.go @@ -13,7 +13,7 @@ import ( func (m *MySQLTestSuite) TestGetEventFromBytesTombstone() { _, err := m.GetEventFromBytes(typing.Settings{}, nil) - assert.Error(m.T(), err) + assert.ErrorContains(m.T(), err, "empty message") } func (m *MySQLTestSuite) TestGetEventFromBytes() { diff --git a/lib/cdc/postgres/debezium_test.go b/lib/cdc/postgres/debezium_test.go index ae0b52698..229dd5206 100644 --- a/lib/cdc/postgres/debezium_test.go +++ b/lib/cdc/postgres/debezium_test.go @@ -18,7 +18,7 @@ var validTc = &kafkalib.TopicConfig{ func (p *PostgresTestSuite) TestGetEventFromBytesTombstone() { _, err := p.GetEventFromBytes(typing.Settings{}, nil) - assert.Error(p.T(), err) + assert.ErrorContains(p.T(), err, "empty message") } func (p *PostgresTestSuite) TestGetPrimaryKey() { diff --git a/lib/config/config.go b/lib/config/config.go index 6999a07a8..59c1d916f 100644 --- a/lib/config/config.go +++ b/lib/config/config.go @@ -70,7 +70,7 @@ func (s *S3Settings) Validate() error { } if !constants.IsValidS3OutputFormat(s.OutputFormat) { - return fmt.Errorf("invalid s3 output format, format: %v", s.OutputFormat) + return fmt.Errorf("invalid s3 output format %q", s.OutputFormat) } return nil diff --git a/lib/config/config_test.go b/lib/config/config_test.go index 2ffcc8757..e5498f3c4 100644 --- a/lib/config/config_test.go +++ b/lib/config/config_test.go @@ -164,7 +164,6 @@ outputSource: none assert.Nil(t, err) validErr := config.Validate() - assert.Error(t, validErr) assert.ErrorContains(t, validErr, "invalid destination") } @@ -318,7 +317,7 @@ func TestReadFileNotYAML(t *testing.T) { config, err := readFileToConfig(randomFile) assert.Nil(t, config) - assert.Error(t, err, "failed to read config file, because it's not proper yaml.") + assert.ErrorContains(t, err, "yaml: unmarshal errors", "failed to read config file, because it's not proper yaml.") } func TestReadFileToConfig_Snowflake(t *testing.T) { @@ -544,7 +543,7 @@ func TestConfig_Validate(t *testing.T) { // Now that we have a valid output, let's test with S3. cfg.Output = constants.S3 - assert.Error(t, cfg.Validate()) + assert.ErrorContains(t, cfg.Validate(), "s3 settings are nil") cfg.S3 = &S3Settings{ Bucket: "foo", AwsSecretAccessKey: "foo", diff --git a/lib/config/config_validate_test.go b/lib/config/config_validate_test.go index 089568952..5477625b8 100644 --- a/lib/config/config_validate_test.go +++ b/lib/config/config_validate_test.go @@ -9,58 +9,56 @@ import ( ) func TestS3Settings_Validate(t *testing.T) { - type _testCase struct { - Name string - S3 *S3Settings - ExpectErr bool - } - - testCases := []_testCase{ + testCases := []struct { + name string + s3 *S3Settings + expectedErr string + }{ { - Name: "nil", - ExpectErr: true, + name: "nil", + expectedErr: "s3 settings are nil", }, { - Name: "empty", - S3: &S3Settings{}, - ExpectErr: true, + name: "empty", + s3: &S3Settings{}, + expectedErr: "one of s3 settings is empty", }, { - Name: "missing bucket", - S3: &S3Settings{ + name: "missing bucket", + s3: &S3Settings{ AwsSecretAccessKey: "foo", AwsAccessKeyID: "bar", }, - ExpectErr: true, + expectedErr: "one of s3 settings is empty", }, { - Name: "missing aws access key id", - S3: &S3Settings{ + name: "missing aws access key id", + s3: &S3Settings{ AwsSecretAccessKey: "foo", Bucket: "bucket", }, - ExpectErr: true, + expectedErr: "one of s3 settings is empty", }, { - Name: "missing aws secret access key", - S3: &S3Settings{ + name: "missing aws secret access key", + s3: &S3Settings{ AwsAccessKeyID: "bar", Bucket: "bucket", }, - ExpectErr: true, + expectedErr: "one of s3 settings is empty", }, { - Name: "missing output format", - S3: &S3Settings{ + name: "missing output format", + s3: &S3Settings{ Bucket: "bucket", AwsSecretAccessKey: "foo", AwsAccessKeyID: "bar", }, - ExpectErr: true, + expectedErr: `invalid s3 output format ""`, }, { - Name: "valid", - S3: &S3Settings{ + name: "valid", + s3: &S3Settings{ Bucket: "bucket", AwsSecretAccessKey: "foo", AwsAccessKeyID: "bar", @@ -70,36 +68,34 @@ func TestS3Settings_Validate(t *testing.T) { } for _, testCase := range testCases { - err := testCase.S3.Validate() - if testCase.ExpectErr { - assert.Error(t, err, testCase.Name) + err := testCase.s3.Validate() + if testCase.expectedErr != "" { + assert.ErrorContains(t, err, testCase.expectedErr, testCase.name) } else { - assert.NoError(t, err, testCase.Name) + assert.NoError(t, err, testCase.name) } } } func TestCfg_ValidateRedshift(t *testing.T) { - type _testCase struct { - Name string - Redshift *Redshift - ExpectErr bool - } - - testCases := []_testCase{ + testCases := []struct { + name string + redshift *Redshift + expectedErr string + }{ { - Name: "nil", - Redshift: nil, - ExpectErr: true, + name: "nil", + redshift: nil, + expectedErr: "redshift cfg is nil", }, { - Name: "redshift settings exist, but all empty", - Redshift: &Redshift{}, - ExpectErr: true, + name: "redshift settings exist, but all empty", + redshift: &Redshift{}, + expectedErr: "one of redshift settings is empty", }, { - Name: "redshift settings all set (missing port)", - Redshift: &Redshift{ + name: "redshift settings all set (missing port)", + redshift: &Redshift{ Host: "host", Database: "db", Username: "user", @@ -107,11 +103,11 @@ func TestCfg_ValidateRedshift(t *testing.T) { Bucket: "bucket", CredentialsClause: "creds", }, - ExpectErr: true, + expectedErr: "redshift invalid port", }, { - Name: "redshift settings all set (neg port)", - Redshift: &Redshift{ + name: "redshift settings all set (neg port)", + redshift: &Redshift{ Host: "host", Port: -500, Database: "db", @@ -120,11 +116,11 @@ func TestCfg_ValidateRedshift(t *testing.T) { Bucket: "bucket", CredentialsClause: "creds", }, - ExpectErr: true, + expectedErr: "redshift invalid port", }, { - Name: "redshift settings all set", - Redshift: &Redshift{ + name: "redshift settings all set", + redshift: &Redshift{ Host: "host", Port: 123, Database: "db", @@ -138,14 +134,14 @@ func TestCfg_ValidateRedshift(t *testing.T) { for _, testCase := range testCases { cfg := &Config{ - Redshift: testCase.Redshift, + Redshift: testCase.redshift, Output: constants.Redshift, } err := cfg.ValidateRedshift() - if testCase.ExpectErr { - assert.Error(t, err, testCase.Name) + if testCase.expectedErr != "" { + assert.ErrorContains(t, err, testCase.expectedErr, testCase.name) } else { - assert.NoError(t, err, testCase.Name) + assert.NoError(t, err, testCase.name) } } } diff --git a/lib/debezium/keys.go b/lib/debezium/keys.go index b8b9b9076..fbb71283a 100644 --- a/lib/debezium/keys.go +++ b/lib/debezium/keys.go @@ -54,7 +54,7 @@ func parsePartitionKeyString(keyBytes []byte) (map[string]any, error) { for _, kvPartString := range strings.Split(parsedKeyString, ",") { kvParts := strings.Split(kvPartString, "=") if len(kvParts) < 2 { - return nil, fmt.Errorf("malformed key value pair: %s", kvPartString) + return nil, fmt.Errorf("malformed key value pair: %q", kvPartString) } retMap[kvParts[0]] = strings.Join(kvParts[1:], "=") diff --git a/lib/debezium/keys_test.go b/lib/debezium/keys_test.go index 3eb68a96c..4d8deaa2d 100644 --- a/lib/debezium/keys_test.go +++ b/lib/debezium/keys_test.go @@ -34,32 +34,35 @@ func TestParsePartitionKeyString(t *testing.T) { assert.Nil(t, err) assert.Equal(t, kv["uuid"], "d4a5bc26-9ae6-4dd4-8894-39cbcd2d526c") - badDataCases := []string{ - "", - "Struct{", - "Struct{}", - "}", - "Struct{uuid=a,,}", - "Struct{,,}", + badDataCases := []struct { + value string + expectedErr string + }{ + {"", "key is nil"}, + {"Struct{", "key is too short"}, + {"Struct{}", "key is too short"}, + {"}", "key is too short"}, + {"Struct{uuid=a,,}", `malformed key value pair: ""`}, + {"Struct{,,}", `malformed key value pair: ""`}, } for _, badData := range badDataCases { - _, err = parsePartitionKeyString([]byte(badData)) - assert.Error(t, err) + _, err = parsePartitionKeyString([]byte(badData.value)) + assert.ErrorContains(t, err, badData.expectedErr) } } func TestParsePartitionKeyStruct(t *testing.T) { - badDataCases := []string{ - "", - "{}", - "{id:", - `{"id":`, + badDataCases := []struct{ value, expectedErr string }{ + {"", "key is nil"}, + {"{}", "key is nil"}, + {"{id:", "failed to json unmarshal: invalid character 'i' looking for beginning of object key string"}, + {`{"id":`, "failed to json unmarshal: unexpected end of JSON input"}, } for _, badData := range badDataCases { - _, err := parsePartitionKeyStruct([]byte(badData)) - assert.Error(t, err, badData) + _, err := parsePartitionKeyStruct([]byte(badData.value)) + assert.ErrorContains(t, err, badData.expectedErr, badData) } kv, err := parsePartitionKeyStruct([]byte(`{"id": 47}`)) diff --git a/lib/debezium/schema_test.go b/lib/debezium/schema_test.go index c3c7192bc..b358d1824 100644 --- a/lib/debezium/schema_test.go +++ b/lib/debezium/schema_test.go @@ -17,19 +17,17 @@ import ( ) func TestField_GetScaleAndPrecision(t *testing.T) { - type _tc struct { + tcs := []struct { name string parameters map[string]any - expectErr bool + expectedErr string expectedScale int expectedPrecision *int - } - - tcs := []_tc{ + }{ { - name: "Test Case 1: Empty Parameters", - parameters: map[string]any{}, - expectErr: true, + name: "Test Case 1: Empty Parameters", + parameters: map[string]any{}, + expectedErr: "object is empty", }, { name: "Test Case 2: Valid Scale Only", @@ -52,7 +50,7 @@ func TestField_GetScaleAndPrecision(t *testing.T) { parameters: map[string]any{ "scale": "invalid", }, - expectErr: true, + expectedErr: "key: scale is not type integer", }, { name: "Test Case 5: Invalid Precision Type", @@ -60,7 +58,7 @@ func TestField_GetScaleAndPrecision(t *testing.T) { "scale": 5, KafkaDecimalPrecisionKey: "invalid", }, - expectErr: true, + expectedErr: "key: connect.decimal.precision is not type integer", }, } @@ -70,8 +68,8 @@ func TestField_GetScaleAndPrecision(t *testing.T) { } scale, precision, err := field.GetScaleAndPrecision() - if tc.expectErr { - assert.Error(t, err, tc.name) + if tc.expectedErr != "" { + assert.ErrorContains(t, err, tc.expectedErr, tc.name) } else { assert.NoError(t, err, tc.name) assert.Equal(t, tc.expectedScale, scale, tc.name) diff --git a/lib/debezium/types_test.go b/lib/debezium/types_test.go index 1915f74b8..21afd5eba 100644 --- a/lib/debezium/types_test.go +++ b/lib/debezium/types_test.go @@ -399,7 +399,7 @@ func TestFromDebeziumTypeTimePrecisionConnect(t *testing.T) { } func TestField_DecodeDecimal(t *testing.T) { - type _testCase struct { + testCases := []struct { name string encoded string params map[string]any @@ -409,20 +409,18 @@ func TestField_DecodeDecimal(t *testing.T) { expectNilPtrPrecision bool expectedScale int expectBigFloat bool - expectError bool - } - - testCases := []_testCase{ + expectedErr string + }{ { name: "No scale (nil map)", - expectError: true, + expectedErr: "object is empty", }, { name: "No scale (not provided)", params: map[string]any{ "connect.decimal.precision": "5", }, - expectError: true, + expectedErr: "key: scale does not exist in object", }, { name: "Precision is not an integer", @@ -430,7 +428,7 @@ func TestField_DecodeDecimal(t *testing.T) { "scale": "2", "connect.decimal.precision": "abc", }, - expectError: true, + expectedErr: "key: connect.decimal.precision is not type integer", }, { name: "NUMERIC(5,0)", @@ -572,8 +570,8 @@ func TestField_DecodeDecimal(t *testing.T) { assert.NoError(t, err) dec, err := field.DecodeDecimal(bytes) - if testCase.expectError { - assert.Error(t, err, testCase.name) + if testCase.expectedErr != "" { + assert.ErrorContains(t, err, testCase.expectedErr, testCase.name) continue } diff --git a/lib/destination/ddl/ddl_sflk_test.go b/lib/destination/ddl/ddl_sflk_test.go index c9cde14eb..0ea1faf87 100644 --- a/lib/destination/ddl/ddl_sflk_test.go +++ b/lib/destination/ddl/ddl_sflk_test.go @@ -84,7 +84,7 @@ func (d *DDLTestSuite) TestAlterIdempotency() { assert.Equal(d.T(), len(cols), d.fakeSnowflakeStagesStore.ExecCallCount(), "called SFLK the same amt to create cols") d.fakeSnowflakeStagesStore.ExecReturns(nil, errors.New("table does not exist")) - assert.Error(d.T(), alterTableArgs.AlterTable(cols...)) + assert.ErrorContains(d.T(), alterTableArgs.AlterTable(cols...), "failed to apply ddl") } func (d *DDLTestSuite) TestAlterTableAdd() { diff --git a/lib/destination/ddl/ddl_test.go b/lib/destination/ddl/ddl_test.go index 3e60d383b..ffeab4dd9 100644 --- a/lib/destination/ddl/ddl_test.go +++ b/lib/destination/ddl/ddl_test.go @@ -104,8 +104,7 @@ func (d *DDLTestSuite) Test_DropTemporaryTable_Errors() { fullTableName := fmt.Sprintf("%s_%s", table, constants.ArtiePrefix) err := ddl.DropTemporaryTable(_dwh, fullTableName, shouldReturnErr) if shouldReturnErr { - assert.Error(d.T(), err) - assert.Contains(d.T(), err.Error(), randomErr.Error()) + assert.ErrorContains(d.T(), err, randomErr.Error()) } else { assert.NoError(d.T(), err) } diff --git a/lib/destination/dml/merge_parts_test.go b/lib/destination/dml/merge_parts_test.go index 0b5af5014..a11ef4b84 100644 --- a/lib/destination/dml/merge_parts_test.go +++ b/lib/destination/dml/merge_parts_test.go @@ -19,7 +19,7 @@ func TestMergeStatementPartsValidation(t *testing.T) { {DestKind: constants.BigQuery}, } { parts, err := arg.GetParts() - assert.Error(t, err) + assert.ErrorContains(t, err, "merge argument does not contain primary keys") assert.Nil(t, parts) } } diff --git a/lib/destination/dml/merge_valid_test.go b/lib/destination/dml/merge_valid_test.go index 56e5447ed..3a6bdcfce 100644 --- a/lib/destination/dml/merge_valid_test.go +++ b/lib/destination/dml/merge_valid_test.go @@ -13,12 +13,6 @@ import ( ) func TestMergeArgument_Valid(t *testing.T) { - type _testCase struct { - name string - mergeArg *MergeArgument - expectErrorMessage string - } - primaryKeys := []columns.Wrapper{ columns.NewWrapper(columns.NewColumn("id", typing.Integer), false, nil), } @@ -28,22 +22,26 @@ func TestMergeArgument_Valid(t *testing.T) { cols.AddColumn(columns.NewColumn("firstName", typing.String)) cols.AddColumn(columns.NewColumn("lastName", typing.String)) - testCases := []_testCase{ + testCases := []struct { + name string + mergeArg *MergeArgument + expectedErr string + }{ { - name: "nil", - expectErrorMessage: "merge argument is nil", + name: "nil", + expectedErr: "merge argument is nil", }, { - name: "no pks", - mergeArg: &MergeArgument{}, - expectErrorMessage: "merge argument does not contain primary keys", + name: "no pks", + mergeArg: &MergeArgument{}, + expectedErr: "merge argument does not contain primary keys", }, { name: "pks but no colsToTypes", mergeArg: &MergeArgument{ PrimaryKeys: primaryKeys, }, - expectErrorMessage: "columns cannot be empty", + expectedErr: "columns cannot be empty", }, { name: "pks, cols, colsTpTypes exists but no subquery or fqTableName", @@ -51,7 +49,7 @@ func TestMergeArgument_Valid(t *testing.T) { PrimaryKeys: primaryKeys, Columns: &cols, }, - expectErrorMessage: "one of these arguments is empty: fqTableName, subQuery", + expectedErr: "one of these arguments is empty: fqTableName, subQuery", }, { name: "pks, cols, colsTpTypes, subquery exists but no fqTableName", @@ -60,7 +58,7 @@ func TestMergeArgument_Valid(t *testing.T) { Columns: &cols, SubQuery: "schema.tableName", }, - expectErrorMessage: "one of these arguments is empty: fqTableName, subQuery", + expectedErr: "one of these arguments is empty: fqTableName, subQuery", }, { name: "pks, cols, colsTpTypes, fqTableName exists but no subquery", @@ -69,7 +67,7 @@ func TestMergeArgument_Valid(t *testing.T) { Columns: &cols, FqTableName: "schema.tableName", }, - expectErrorMessage: "one of these arguments is empty: fqTableName, subQuery", + expectedErr: "one of these arguments is empty: fqTableName, subQuery", }, { name: "did not pass in uppercase esc col", @@ -79,7 +77,7 @@ func TestMergeArgument_Valid(t *testing.T) { FqTableName: "schema.tableName", SubQuery: "schema.tableName", }, - expectErrorMessage: "uppercaseEscNames cannot be nil", + expectedErr: "uppercaseEscNames cannot be nil", }, { name: "missing dest kind", @@ -90,7 +88,7 @@ func TestMergeArgument_Valid(t *testing.T) { FqTableName: "schema.tableName", UppercaseEscNames: ptr.ToBool(false), }, - expectErrorMessage: "invalid destination", + expectedErr: "invalid destination", }, { name: "everything exists", @@ -107,9 +105,8 @@ func TestMergeArgument_Valid(t *testing.T) { for _, testCase := range testCases { actualErr := testCase.mergeArg.Valid() - if len(testCase.expectErrorMessage) > 0 { - assert.Error(t, actualErr, testCase.name) - assert.ErrorContains(t, actualErr, testCase.expectErrorMessage, testCase.name) + if testCase.expectedErr != "" { + assert.ErrorContains(t, actualErr, testCase.expectedErr, testCase.name) } else { assert.NoError(t, actualErr, testCase.name) } diff --git a/lib/jsonutil/jsonutil_test.go b/lib/jsonutil/jsonutil_test.go index 32a86d877..513a7f868 100644 --- a/lib/jsonutil/jsonutil_test.go +++ b/lib/jsonutil/jsonutil_test.go @@ -18,7 +18,7 @@ func TestSanitizePayload(t *testing.T) { { // Invalid JSON string _, err := SanitizePayload("hello") - assert.Error(t, err) + assert.ErrorContains(t, err, "invalid character 'h' looking for beginning of value") } { // Valid JSON string, nothing changed. diff --git a/lib/kafkalib/partition/settings_test.go b/lib/kafkalib/partition/settings_test.go index 79580196f..38058f8f2 100644 --- a/lib/kafkalib/partition/settings_test.go +++ b/lib/kafkalib/partition/settings_test.go @@ -7,28 +7,26 @@ import ( ) func TestBigQuerySettings_Valid(t *testing.T) { - type _testCase struct { + testCases := []struct { name string bigQuerySettings *BigQuerySettings - expectError bool - } - - testCases := []_testCase{ + expectedErr string + }{ { name: "nil", - expectError: true, + expectedErr: "bigQuerySettings is nil", }, { name: "empty partitionType", bigQuerySettings: &BigQuerySettings{}, - expectError: true, + expectedErr: "partitionTypes cannot be empty", }, { name: "empty partitionField", bigQuerySettings: &BigQuerySettings{ PartitionType: "time", }, - expectError: true, + expectedErr: "partitionField cannot be empty", }, { name: "empty partitionBy", @@ -36,7 +34,7 @@ func TestBigQuerySettings_Valid(t *testing.T) { PartitionType: "time", PartitionField: "created_at", }, - expectError: true, + expectedErr: "partitionBy cannot be empty", }, { name: "invalid partitionType", @@ -45,7 +43,7 @@ func TestBigQuerySettings_Valid(t *testing.T) { PartitionField: "created_at", PartitionBy: "daily", }, - expectError: true, + expectedErr: "partitionType must be one of:", }, { name: "invalid partitionBy", @@ -54,7 +52,7 @@ func TestBigQuerySettings_Valid(t *testing.T) { PartitionField: "created_at", PartitionBy: "invalid", }, - expectError: true, + expectedErr: "partitionBy must be one of:", }, { name: "valid", @@ -68,8 +66,8 @@ func TestBigQuerySettings_Valid(t *testing.T) { for _, testCase := range testCases { actualErr := testCase.bigQuerySettings.Valid() - if testCase.expectError { - assert.Error(t, actualErr, testCase.name) + if testCase.expectedErr != "" { + assert.ErrorContains(t, actualErr, testCase.expectedErr, testCase.name) } else { assert.NoError(t, actualErr, testCase.name) } @@ -77,22 +75,20 @@ func TestBigQuerySettings_Valid(t *testing.T) { } func TestBigQuerySettings_GenerateMergeString(t *testing.T) { - type _testCase struct { + testCases := []struct { name string values []string - expectError bool + expectedErr string expectedString string - } - - testCases := []_testCase{ + }{ { name: "nil", - expectError: true, + expectedErr: "values cannot be empty", }, { name: "empty values", values: []string{}, - expectError: true, + expectedErr: "values cannot be empty", }, { name: "valid", @@ -114,8 +110,8 @@ func TestBigQuerySettings_GenerateMergeString(t *testing.T) { } actualValue, actualErr := bigquery.GenerateMergeString(testCase.values) - if testCase.expectError { - assert.Error(t, actualErr, testCase.name) + if testCase.expectedErr != "" { + assert.ErrorContains(t, actualErr, testCase.expectedErr, testCase.name) } else { assert.NoError(t, actualErr, testCase.name) assert.Equal(t, testCase.expectedString, actualValue, testCase.name) diff --git a/lib/maputil/map_test.go b/lib/maputil/map_test.go index cd7ace623..2ce640833 100644 --- a/lib/maputil/map_test.go +++ b/lib/maputil/map_test.go @@ -37,15 +37,13 @@ func TestGetIntegerFromMap(t *testing.T) { "123 (number)": -321, } - type _testCase struct { + testCases := []struct { name string obj map[string]any key string expectedValue int - expectError bool - } - - testCases := []_testCase{ + expectedErr string + }{ { name: "happy path with string value", obj: object, @@ -62,19 +60,19 @@ func TestGetIntegerFromMap(t *testing.T) { name: "non-existing key", obj: object, key: "xyz", - expectError: true, + expectedErr: "key: xyz does not exist in object", }, { name: "boolean value", obj: object, key: "def", - expectError: true, + expectedErr: "key: def is not type integer", }, { name: "non-numeric string value", obj: object, key: "ghi", - expectError: true, + expectedErr: "key: ghi is not type integer", }, { name: "negative number as string", @@ -92,8 +90,8 @@ func TestGetIntegerFromMap(t *testing.T) { for _, testCase := range testCases { value, err := GetIntegerFromMap(testCase.obj, testCase.key) - if testCase.expectError { - assert.Error(t, err, testCase.name) + if testCase.expectedErr != "" { + assert.ErrorContains(t, err, testCase.expectedErr, testCase.name) } else { assert.Equal(t, reflect.Int, reflect.TypeOf(value).Kind()) assert.Equal(t, testCase.expectedValue, value) diff --git a/lib/optimization/table_data_test.go b/lib/optimization/table_data_test.go index f80cf6ffc..e55ae4bd5 100644 --- a/lib/optimization/table_data_test.go +++ b/lib/optimization/table_data_test.go @@ -18,14 +18,12 @@ import ( ) func TestDistinctDates(t *testing.T) { - type _testCase struct { + testCases := []struct { name string rowData map[string]map[string]any // pk -> { col -> val } - expectErr bool + expectedErr string expectedDatesString []string - } - - testCases := []_testCase{ + }{ { name: "no dates", }, @@ -75,7 +73,7 @@ func TestDistinctDates(t *testing.T) { "ts": nil, }, }, - expectErr: true, + expectedErr: "col: ts is not a time column", }, } @@ -85,8 +83,8 @@ func TestDistinctDates(t *testing.T) { } actualValues, actualErr := td.DistinctDates("ts", nil) - if testCase.expectErr { - assert.Error(t, actualErr, testCase.name) + if testCase.expectedErr != "" { + assert.ErrorContains(t, actualErr, testCase.expectedErr, testCase.name) } else { assert.NoError(t, actualErr, testCase.name) assert.Equal(t, true, slicesEqualUnordered(testCase.expectedDatesString, actualValues), diff --git a/lib/parquetutil/parse_values_test.go b/lib/parquetutil/parse_values_test.go index 55867468e..f1c133b49 100644 --- a/lib/parquetutil/parse_values_test.go +++ b/lib/parquetutil/parse_values_test.go @@ -14,15 +14,6 @@ import ( ) func TestParseValue(t *testing.T) { - type _testStruct struct { - name string - colVal any - colKind columns.Column - - expectErr bool - expectedValue any - } - eDecimal := typing.EDecimal eDecimal.ExtendedDecimalDetails = decimal.NewDecimal(ptr.ToInt(30), 5, nil) @@ -35,7 +26,13 @@ func TestParseValue(t *testing.T) { eDateTime := typing.ETime eDateTime.ExtendedTimeDetails = &ext.DateTime - testCases := []_testStruct{ + testCases := []struct { + name string + colVal any + colKind columns.Column + + expectedValue any + }{ { name: "nil value", colVal: nil, @@ -95,11 +92,7 @@ func TestParseValue(t *testing.T) { for _, tc := range testCases { actualValue, actualErr := ParseValue(tc.colVal, tc.colKind, nil) - if tc.expectErr { - assert.Error(t, actualErr, tc.name) - } else { - assert.NoError(t, actualErr, tc.name) - assert.Equal(t, tc.expectedValue, actualValue, tc.name) - } + assert.NoError(t, actualErr, tc.name) + assert.Equal(t, tc.expectedValue, actualValue, tc.name) } } diff --git a/lib/typing/bigquery_test.go b/lib/typing/bigquery_test.go index fb98d490e..1d661134e 100644 --- a/lib/typing/bigquery_test.go +++ b/lib/typing/bigquery_test.go @@ -86,6 +86,6 @@ func TestExpiresDate(t *testing.T) { for _, badString := range []string{"foo", "bad_string", " 2022-09-01"} { _, err := fromExpiresDateStringToTime(badString) - assert.Error(t, err, badString) + assert.ErrorContains(t, err, "cannot parse", badString) } } diff --git a/lib/typing/columns/default_test.go b/lib/typing/columns/default_test.go index de9d4a555..05ac93442 100644 --- a/lib/typing/columns/default_test.go +++ b/lib/typing/columns/default_test.go @@ -15,15 +15,6 @@ import ( ) func TestColumn_DefaultValue(t *testing.T) { - type _testCase struct { - name string - col *Column - args *DefaultValueArgs - expectedValue any - destKindToExpectedValueMap map[constants.DestinationKind]any - expectedEr bool - } - birthday := time.Date(2022, time.September, 6, 3, 19, 24, 942000000, time.UTC) birthdayExtDateTime, err := ext.ParseExtendedDateTime(birthday.Format(ext.ISO8601), nil) assert.NoError(t, err) @@ -38,7 +29,13 @@ func TestColumn_DefaultValue(t *testing.T) { dateTimeKind := typing.ETime dateTimeKind.ExtendedTimeDetails = &ext.DateTime - testCases := []_testCase{ + testCases := []struct { + name string + col *Column + args *DefaultValueArgs + expectedValue any + destKindToExpectedValueMap map[constants.DestinationKind]any + }{ { name: "default value = nil", col: &Column{ @@ -152,11 +149,7 @@ func TestColumn_DefaultValue(t *testing.T) { } actualValue, actualErr := testCase.col.DefaultValue(testCase.args, nil) - if testCase.expectedEr { - assert.Error(t, actualErr, fmt.Sprintf("%s %s", testCase.name, validDest)) - } else { - assert.NoError(t, actualErr, fmt.Sprintf("%s %s", testCase.name, validDest)) - } + assert.NoError(t, actualErr, fmt.Sprintf("%s %s", testCase.name, validDest)) expectedValue := testCase.expectedValue if potentialValue, isOk := testCase.destKindToExpectedValueMap[validDest]; isOk { diff --git a/lib/typing/ext/parse_test.go b/lib/typing/ext/parse_test.go index a868d6c05..c481bf451 100644 --- a/lib/typing/ext/parse_test.go +++ b/lib/typing/ext/parse_test.go @@ -35,14 +35,20 @@ func TestParseFromInterface(t *testing.T) { assert.Equal(t, val, extTime) } - invalidVals := []any{ - nil, - true, - false, + { + // Nil + _, err := ParseFromInterface(nil, nil) + assert.ErrorContains(t, err, "val is nil") } - for _, invalidVal := range invalidVals { - _, err := ParseFromInterface(invalidVal, nil) - assert.Error(t, err) + { + // True + _, err := ParseFromInterface(true, nil) + assert.ErrorContains(t, err, "true is not supported") + } + { + // False + _, err := ParseFromInterface(false, nil) + assert.ErrorContains(t, err, "false is not supported") } } diff --git a/lib/typing/typing_test.go b/lib/typing/typing_test.go index b89d31b58..810fafcbf 100644 --- a/lib/typing/typing_test.go +++ b/lib/typing/typing_test.go @@ -159,7 +159,7 @@ func TestDateTime(t *testing.T) { } ts, err := ext.ParseExtendedDateTime("random", []string{}) - assert.Error(t, err, err) + assert.ErrorContains(t, err, "dtString: random is not supported") assert.Nil(t, ts) } diff --git a/processes/consumer/process_test.go b/processes/consumer/process_test.go index 61bae18dd..afb2413c3 100644 --- a/processes/consumer/process_test.go +++ b/processes/consumer/process_test.go @@ -225,7 +225,7 @@ func TestProcessMessageFailures(t *testing.T) { } tableName, err = args.process(ctx, cfg, memDB, MockDestination{}, metrics.NullMetricsProvider{}) - assert.Error(t, err) + assert.ErrorContains(t, err, "cannot unmarshall event: failed to unmarshal json: invalid character 'o' in literal") assert.Empty(t, tableName) assert.True(t, td.NumberOfRows() > 0) }