Clean up.

artie-labs · Oct 15, 2024 · 53d3d01 · 53d3d01
1 parent f12cb67
commit 53d3d01
Show file tree

Hide file tree

Showing 5 changed files with 41 additions and 22 deletions.
diff --git a/clients/snowflake/dialect/dialect_test.go b/clients/snowflake/dialect/dialect_test.go
@@ -174,11 +174,23 @@ func TestSnowflakeDialect_KindForDataType(t *testing.T) {
 }
 
 func TestSnowflakeDialect_KindForDataType_DateTime(t *testing.T) {
-	expectedDateTimes := []string{"DATETIME", "TIMESTAMP", "TIMESTAMP_LTZ", "TIMESTAMP_NTZ(9)", "TIMESTAMP_TZ"}
-	for _, expectedDateTime := range expectedDateTimes {
-		kd, err := SnowflakeDialect{}.KindForDataType(expectedDateTime, "")
-		assert.NoError(t, err)
-		assert.Equal(t, ext.TimestampTz.Type, kd.ExtendedTimeDetails.Type, expectedDateTime)
+	{
+		// Timestamp with time zone
+		expectedDateTimes := []string{"TIMESTAMP", "TIMESTAMP_LTZ", "TIMESTAMP_TZ"}
+		for _, expectedDateTime := range expectedDateTimes {
+			kd, err := SnowflakeDialect{}.KindForDataType(expectedDateTime, "")
+			assert.NoError(t, err)
+			assert.Equal(t, ext.TimestampTz.Type, kd.ExtendedTimeDetails.Type, expectedDateTime)
+		}
+	}
+	{
+		// Timestamp without time zone
+		expectedDateTimes := []string{"DATETIME", "TIMESTAMP_NTZ(9)"}
+		for _, expectedDateTime := range expectedDateTimes {
+			kd, err := SnowflakeDialect{}.KindForDataType(expectedDateTime, "")
+			assert.NoError(t, err)
+			assert.Equal(t, ext.TimestampNTZ.Type, kd.ExtendedTimeDetails.Type, expectedDateTime)
+		}
 	}
 }
 

diff --git a/lib/cdc/relational/debezium_test.go b/lib/cdc/relational/debezium_test.go
@@ -208,7 +208,7 @@ func (r *RelationTestSuite) TestPostgresEventWithSchemaAndTimestampNoTZ() {
 		r.T(),
 		ext.NewExtendedTime(
 			time.Date(2023, time.February, 2, 17, 51, 35, 175445*1000, time.UTC),
-			ext.TimestampTzKindType, ext.RFC3339Microsecond,
+			ext.TimestampNTZKindType, ext.RFC3339MicrosecondNoTZ,
 		),
 		evtData["ts_no_tz1"],
 	)

diff --git a/lib/debezium/converters/timestamp_test.go b/lib/debezium/converters/timestamp_test.go
@@ -9,7 +9,7 @@ import (
 )
 
 func TestTimestamp_Converter(t *testing.T) {
-	assert.Equal(t, typing.NewKindDetailsFromTemplate(typing.ETime, ext.TimestampTzKindType), Timestamp{}.ToKindDetails())
+	assert.Equal(t, typing.NewKindDetailsFromTemplate(typing.ETime, ext.TimestampNTZKindType), Timestamp{}.ToKindDetails())
 	{
 		// Invalid conversion
 		_, err := Timestamp{}.Convert("invalid")
@@ -19,18 +19,18 @@ func TestTimestamp_Converter(t *testing.T) {
 		// Valid conversion
 		converted, err := Timestamp{}.Convert(int64(1_725_058_799_089))
 		assert.NoError(t, err)
-		assert.Equal(t, "2024-08-30T22:59:59.089Z", converted.(*ext.ExtendedTime).String(""))
+		assert.Equal(t, "2024-08-30T22:59:59.089", converted.(*ext.ExtendedTime).String(""))
 	}
 	{
 		// ms is preserved despite it being all zeroes.
 		converted, err := Timestamp{}.Convert(int64(1_725_058_799_000))
 		assert.NoError(t, err)
-		assert.Equal(t, "2024-08-30T22:59:59.000Z", converted.(*ext.ExtendedTime).String(""))
+		assert.Equal(t, "2024-08-30T22:59:59.000", converted.(*ext.ExtendedTime).String(""))
 	}
 }
 
 func TestMicroTimestamp_Converter(t *testing.T) {
-	assert.Equal(t, typing.NewKindDetailsFromTemplate(typing.ETime, ext.TimestampTzKindType), MicroTimestamp{}.ToKindDetails())
+	assert.Equal(t, typing.NewKindDetailsFromTemplate(typing.ETime, ext.TimestampNTZKindType), MicroTimestamp{}.ToKindDetails())
 	{
 		// Invalid conversion
 		_, err := MicroTimestamp{}.Convert("invalid")
@@ -40,18 +40,18 @@ func TestMicroTimestamp_Converter(t *testing.T) {
 		// Valid conversion
 		converted, err := MicroTimestamp{}.Convert(int64(1_712_609_795_827_923))
 		assert.NoError(t, err)
-		assert.Equal(t, "2024-04-08T20:56:35.827923Z", converted.(*ext.ExtendedTime).String(""))
+		assert.Equal(t, "2024-04-08T20:56:35.827923", converted.(*ext.ExtendedTime).String(""))
 	}
 	{
 		// micros is preserved despite it being all zeroes.
 		converted, err := MicroTimestamp{}.Convert(int64(1_712_609_795_820_000))
 		assert.NoError(t, err)
-		assert.Equal(t, "2024-04-08T20:56:35.820000Z", converted.(*ext.ExtendedTime).String(""))
+		assert.Equal(t, "2024-04-08T20:56:35.820000", converted.(*ext.ExtendedTime).String(""))
 	}
 }
 
 func TestNanoTimestamp_Converter(t *testing.T) {
-	assert.Equal(t, typing.NewKindDetailsFromTemplate(typing.ETime, ext.TimestampTzKindType), NanoTimestamp{}.ToKindDetails())
+	assert.Equal(t, typing.NewKindDetailsFromTemplate(typing.ETime, ext.TimestampNTZKindType), NanoTimestamp{}.ToKindDetails())
 	{
 		// Invalid conversion
 		_, err := NanoTimestamp{}.Convert("invalid")
@@ -61,12 +61,12 @@ func TestNanoTimestamp_Converter(t *testing.T) {
 		// Valid conversion
 		converted, err := NanoTimestamp{}.Convert(int64(1_712_609_795_827_001_000))
 		assert.NoError(t, err)
-		assert.Equal(t, "2024-04-08T20:56:35.827001000Z", converted.(*ext.ExtendedTime).String(""))
+		assert.Equal(t, "2024-04-08T20:56:35.827001000", converted.(*ext.ExtendedTime).String(""))
 	}
 	{
 		// nanos is preserved despite it being all zeroes.
 		converted, err := NanoTimestamp{}.Convert(int64(1_712_609_795_827_000_000))
 		assert.NoError(t, err)
-		assert.Equal(t, "2024-04-08T20:56:35.827000000Z", converted.(*ext.ExtendedTime).String(""))
+		assert.Equal(t, "2024-04-08T20:56:35.827000000", converted.(*ext.ExtendedTime).String(""))
 	}
 }
diff --git a/lib/debezium/schema_test.go b/lib/debezium/schema_test.go
@@ -229,14 +229,21 @@ func TestField_ToKindDetails(t *testing.T) {
 		assert.Equal(t, typing.Invalid, kd)
 	}
 	{
-		// Timestamp
-		// Datetime (for now)
-		for _, dbzType := range []SupportedDebeziumType{Timestamp, TimestampKafkaConnect, MicroTimestamp, NanoTimestamp, ZonedTimestamp} {
+		// Timestamp with timezone
+		for _, dbzType := range []SupportedDebeziumType{ZonedTimestamp} {
 			kd, err := Field{DebeziumType: dbzType}.ToKindDetails()
 			assert.NoError(t, err)
 			assert.Equal(t, typing.NewKindDetailsFromTemplate(typing.ETime, ext.TimestampTzKindType), kd)
 		}
 	}
+	{
+		// Timestamp without timezone
+		for _, dbzType := range []SupportedDebeziumType{Timestamp, TimestampKafkaConnect, MicroTimestamp, NanoTimestamp} {
+			kd, err := Field{DebeziumType: dbzType}.ToKindDetails()
+			assert.NoError(t, err)
+			assert.Equal(t, typing.NewKindDetailsFromTemplate(typing.ETime, ext.TimestampNTZKindType), kd)
+		}
+	}
 	{
 		// Dates
 		for _, dbzType := range []SupportedDebeziumType{Date, DateKafkaConnect} {

diff --git a/lib/debezium/types_test.go b/lib/debezium/types_test.go
@@ -302,15 +302,15 @@ func TestField_ParseValue(t *testing.T) {
 				field := Field{Type: Int64, DebeziumType: dbzType}
 				value, err := field.ParseValue(int64(1_725_058_799_000))
 				assert.NoError(t, err)
-				assert.Equal(t, "2024-08-30T22:59:59.000Z", value.(*ext.ExtendedTime).String(""))
+				assert.Equal(t, "2024-08-30T22:59:59.000", value.(*ext.ExtendedTime).String(""))
 			}
 		}
 		{
 			// Nano timestamp
 			field := Field{Type: Int64, DebeziumType: NanoTimestamp}
 			val, err := field.ParseValue(int64(1_712_609_795_827_000_000))
 			assert.NoError(t, err)
-			assert.Equal(t, ext.NewExtendedTime(time.Date(2024, time.April, 8, 20, 56, 35, 827000000, time.UTC), ext.TimestampTzKindType, "2006-01-02T15:04:05.000000000Z07:00"), val.(*ext.ExtendedTime))
+			assert.Equal(t, ext.NewExtendedTime(time.Date(2024, time.April, 8, 20, 56, 35, 827000000, time.UTC), ext.TimestampNTZKindType, "2006-01-02T15:04:05.000000000"), val.(*ext.ExtendedTime))
 		}
 		{
 			// Micro timestamp
@@ -319,13 +319,13 @@ func TestField_ParseValue(t *testing.T) {
 				// Int64
 				val, err := field.ParseValue(int64(1_712_609_795_827_009))
 				assert.NoError(t, err)
-				assert.Equal(t, ext.NewExtendedTime(time.Date(2024, time.April, 8, 20, 56, 35, 827009000, time.UTC), ext.TimestampTzKindType, ext.RFC3339Microsecond), val.(*ext.ExtendedTime))
+				assert.Equal(t, ext.NewExtendedTime(time.Date(2024, time.April, 8, 20, 56, 35, 827009000, time.UTC), ext.TimestampNTZKindType, ext.RFC3339MicrosecondNoTZ), val.(*ext.ExtendedTime))
 			}
 			{
 				// Float64
 				val, err := field.ParseValue(float64(1_712_609_795_827_001))
 				assert.NoError(t, err)
-				assert.Equal(t, ext.NewExtendedTime(time.Date(2024, time.April, 8, 20, 56, 35, 827001000, time.UTC), ext.TimestampTzKindType, ext.RFC3339Microsecond), val.(*ext.ExtendedTime))
+				assert.Equal(t, ext.NewExtendedTime(time.Date(2024, time.April, 8, 20, 56, 35, 827001000, time.UTC), ext.TimestampNTZKindType, ext.RFC3339MicrosecondNoTZ), val.(*ext.ExtendedTime))
 			}
 			{
 				// Invalid (string)