From 51167ec376839ce2b26dff0908dfba9352699078 Mon Sep 17 00:00:00 2001 From: CJ Brewer Date: Wed, 16 Oct 2024 17:20:40 -0600 Subject: [PATCH 1/2] feat(go): add tests for goeql --- languages/go/goeql/goeql_test.go | 382 +++++++++++++++++++++++++++++++ 1 file changed, 382 insertions(+) create mode 100644 languages/go/goeql/goeql_test.go diff --git a/languages/go/goeql/goeql_test.go b/languages/go/goeql/goeql_test.go new file mode 100644 index 00000000..c94b0e1b --- /dev/null +++ b/languages/go/goeql/goeql_test.go @@ -0,0 +1,382 @@ +package goeql + +import ( + "encoding/json" + "reflect" + "testing" +) + +// Test EncryptedText Serialization +func TestEncryptedText_Serialize(t *testing.T) { + et := EncryptedText("Hello, World!") + table := "test_table" + column := "test_column" + + serializedData, err := et.Serialize(table, column) + if err != nil { + t.Fatalf("Serialize returned error: %v", err) + } + + var ec EncryptedColumn + if err := json.Unmarshal(serializedData, &ec); err != nil { + t.Fatalf("Error unmarshaling serialized data: %v", err) + } + + if ec.K != "pt" { + t.Errorf("Expected K to be 'pt', got '%s'", ec.K) + } + if ec.P != string(et) { + t.Errorf("Expected P to be '%s', got '%s'", et, ec.P) + } + if ec.I.T != table { + t.Errorf("Expected I.T to be '%s', got '%s'", table, ec.I.T) + } + if ec.I.C != column { + t.Errorf("Expected I.C to be '%s', got '%s'", column, ec.I.C) + } + if ec.V != 1 { + t.Errorf("Expected V to be 1, got %d", ec.V) + } +} + +// Test EncryptedText Deserialization +func TestEncryptedText_Deserialize(t *testing.T) { + ec := EncryptedColumn{ + K: "pt", + P: "Hello, World!", + I: TableColumn{T: "test_table", C: "test_column"}, + V: 1, + } + + data, err := json.Marshal(ec) + if err != nil { + t.Fatalf("Error marshaling EncryptedColumn: %v", err) + } + + var et EncryptedText + deserialized, err := et.Deserialize(data) + if err != nil { + t.Fatalf("Deserialize returned error: %v", err) + } + + if deserialized != EncryptedText("Hello, World!") { + t.Errorf("Expected deserialized value to be 'Hello, World!', got '%s'", deserialized) + } +} + +// Test EncryptedJsonb Serialization +// TODO: This test is failing +func TestEncryptedJsonb_Serialize(t *testing.T) { + ej := EncryptedJsonb{ + "name": "Alice", + "age": 30, + "is_member": true, + } + table := "test_table" + column := "test_column" + + serializedData, err := ej.Serialize(table, column) + if err != nil { + t.Fatalf("Serialize returned error: %v", err) + } + + var ec EncryptedColumn + if err := json.Unmarshal(serializedData, &ec); err != nil { + t.Fatalf("Error unmarshaling serialized data: %v", err) + } + + if ec.K != "pt" { + t.Errorf("Expected K to be 'pt', got '%s'", ec.K) + } + + var pData map[string]interface{} + if err := json.Unmarshal([]byte(ec.P), &pData); err != nil { + t.Fatalf("Error unmarshaling P field: %v", err) + } + + if !reflect.DeepEqual(pData, map[string]interface{}(ej)) { + t.Errorf("P field does not match original data") + } +} + +// Test EncryptedJsonb Deserialization +// TODO: This test is failing +func TestEncryptedJsonb_Deserialize(t *testing.T) { + originalData := map[string]interface{}{ + "name": "Alice", + "age": float64(30), + "is_member": true, + } + + jsonString, err := json.Marshal(originalData) + if err != nil { + t.Fatalf("Error marshaling original data: %v", err) + } + + ec := EncryptedColumn{ + K: "pt", + P: string(jsonString), + I: TableColumn{T: "test_table", C: "test_column"}, + V: 1, + } + + data, err := json.Marshal(ec) + if err != nil { + t.Fatalf("Error marshaling EncryptedColumn: %v", err) + } + + var ej EncryptedJsonb + deserialized, err := ej.Deserialize(data) + if err != nil { + t.Fatalf("Deserialize returned error: %v", err) + } + + if !reflect.DeepEqual(deserialized, EncryptedJsonb(originalData)) { + t.Errorf("Deserialized data does not match original data") + } +} + +// Test EncryptedInt Serialization +func TestEncryptedInt_Serialize(t *testing.T) { + ei := EncryptedInt(42) + table := "test_table" + column := "test_column" + + serializedData, err := ei.Serialize(table, column) + if err != nil { + t.Fatalf("Serialize returned error: %v", err) + } + + var ec EncryptedColumn + if err := json.Unmarshal(serializedData, &ec); err != nil { + t.Fatalf("Error unmarshaling serialized data: %v", err) + } + + expectedP := "42" + if ec.P != expectedP { + t.Errorf("Expected P to be '%s', got '%s'", expectedP, ec.P) + } +} + +// Test EncryptedInt Deserialization +func TestEncryptedInt_Deserialize(t *testing.T) { + ec := EncryptedColumn{ + K: "pt", + P: "42", + I: TableColumn{T: "test_table", C: "test_column"}, + V: 1, + } + + data, err := json.Marshal(ec) + if err != nil { + t.Fatalf("Error marshaling EncryptedColumn: %v", err) + } + + var ei EncryptedInt + deserialized, err := ei.Deserialize(data) + if err != nil { + t.Fatalf("Deserialize returned error: %v", err) + } + + if deserialized != EncryptedInt(42) { + t.Errorf("Expected deserialized value to be 42, got %d", deserialized) + } +} + +// Test EncryptedBool Serialization +func TestEncryptedBool_Serialize(t *testing.T) { + eb := EncryptedBool(true) + table := "test_table" + column := "test_column" + + serializedData, err := eb.Serialize(table, column) + if err != nil { + t.Fatalf("Serialize returned error: %v", err) + } + + var ec EncryptedColumn + if err := json.Unmarshal(serializedData, &ec); err != nil { + t.Fatalf("Error unmarshaling serialized data: %v", err) + } + + if ec.P != "true" { + t.Errorf("Expected P to be 'true', got '%s'", ec.P) + } +} + +// Test EncryptedBool Deserialization +func TestEncryptedBool_Deserialize(t *testing.T) { + ec := EncryptedColumn{ + K: "pt", + P: "true", + I: TableColumn{T: "test_table", C: "test_column"}, + V: 1, + } + + data, err := json.Marshal(ec) + if err != nil { + t.Fatalf("Error marshaling EncryptedColumn: %v", err) + } + + var eb EncryptedBool + deserialized, err := eb.Deserialize(data) + if err != nil { + t.Fatalf("Deserialize returned error: %v", err) + } + + if deserialized != EncryptedBool(true) { + t.Errorf("Expected deserialized value to be true, got %v", deserialized) + } +} + +// Test SerializeQuery Function +func TestSerializeQuery(t *testing.T) { + tests := []struct { + value interface{} + table string + column string + expectedP string + }{ + {value: "test_string", table: "table1", column: "column1", expectedP: "test_string"}, + {value: 123, table: "table2", column: "column2", expectedP: "123"}, + {value: true, table: "table3", column: "column3", expectedP: "true"}, + {value: map[string]interface{}{"key": "value"}, table: "table4", column: "column4", expectedP: `{"key":"value"}`}, + } + + for _, tt := range tests { + serializedData, err := SerializeQuery(tt.value, tt.table, tt.column) + if err != nil { + t.Fatalf("SerializeQuery returned error: %v", err) + } + + var ec EncryptedColumn + if err := json.Unmarshal(serializedData, &ec); err != nil { + t.Fatalf("Error unmarshaling serialized data: %v", err) + } + + if ec.P != tt.expectedP { + t.Errorf("Expected P to be '%s', got '%s'", tt.expectedP, ec.P) + } + } +} + +// Test ToEncryptedColumn Function +func TestToEncryptedColumn(t *testing.T) { + tests := []struct { + value interface{} + table string + column string + expectedP string + }{ + {value: "test_string", table: "table1", column: "column1", expectedP: "test_string"}, + {value: 123, table: "table2", column: "column2", expectedP: "123"}, + {value: 123.456, table: "table3", column: "column3", expectedP: "123.456000"}, + {value: true, table: "table4", column: "column4", expectedP: "true"}, + {value: map[string]interface{}{"key": "value"}, table: "table5", column: "column5", expectedP: `{"key":"value"}`}, + } + + for _, tt := range tests { + ec, err := ToEncryptedColumn(tt.value, tt.table, tt.column) + if err != nil { + t.Fatalf("ToEncryptedColumn returned error: %v", err) + } + + if ec.P != tt.expectedP { + t.Errorf("Expected P to be '%s', got '%s'", tt.expectedP, ec.P) + } + } +} + +// Test convertToString Function +func TestConvertToString(t *testing.T) { + tests := []struct { + value interface{} + expectedStr string + expectError bool + }{ + {value: "test_string", expectedStr: "test_string", expectError: false}, + {value: 123, expectedStr: "123", expectError: false}, + {value: 123.456, expectedStr: "123.456000", expectError: false}, + {value: true, expectedStr: "true", expectError: false}, + {value: map[string]interface{}{"key": "value"}, expectedStr: `{"key":"value"}`, expectError: false}, + {value: []int{1, 2, 3}, expectedStr: "", expectError: true}, // Unsupported type + } + + for _, tt := range tests { + str, err := convertToString(tt.value) + if tt.expectError { + if err == nil { + t.Errorf("Expected error for value: %v, but got none", tt.value) + } + } else { + if err != nil { + t.Errorf("Unexpected error for value: %v, error: %v", tt.value, err) + } else if str != tt.expectedStr { + t.Errorf("Expected '%s', got '%s' for value: %v", tt.expectedStr, str, tt.value) + } + } + } +} + +// Test EncryptedInt Deserialization Error +func TestEncryptedInt_Deserialize_Error(t *testing.T) { + ec := EncryptedColumn{ + K: "pt", + P: "not_an_integer", + I: TableColumn{T: "test_table", C: "test_column"}, + V: 1, + } + + data, err := json.Marshal(ec) + if err != nil { + t.Fatalf("Error marshaling EncryptedColumn: %v", err) + } + + var ei EncryptedInt + _, err = ei.Deserialize(data) + if err == nil { + t.Errorf("Expected error during Deserialize, but got none") + } +} + +// Test EncryptedBool Deserialization Error +func TestEncryptedBool_Deserialize_Error(t *testing.T) { + ec := EncryptedColumn{ + K: "pt", + P: "not_a_boolean", + I: TableColumn{T: "test_table", C: "test_column"}, + V: 1, + } + + data, err := json.Marshal(ec) + if err != nil { + t.Fatalf("Error marshaling EncryptedColumn: %v", err) + } + + var eb EncryptedBool + _, err = eb.Deserialize(data) + if err == nil { + t.Errorf("Expected error during Deserialize, but got none") + } +} + +// Test EncryptedJsonb Deserialization Error +func TestEncryptedJsonb_Deserialize_Error(t *testing.T) { + ec := EncryptedColumn{ + K: "pt", + P: "invalid_json", + I: TableColumn{T: "test_table", C: "test_column"}, + V: 1, + } + + data, err := json.Marshal(ec) + if err != nil { + t.Fatalf("Error marshaling EncryptedColumn: %v", err) + } + + var ej EncryptedJsonb + _, err = ej.Deserialize(data) + if err == nil { + t.Errorf("Expected error during Deserialize, but got none") + } +} From dcf1156bb1343244734c372c0bce0f8a27dd3f88 Mon Sep 17 00:00:00 2001 From: CJ Brewer Date: Wed, 16 Oct 2024 18:41:50 -0600 Subject: [PATCH 2/2] fix(go): comment about float unmarshalling --- languages/go/goeql/goeql_test.go | 49 ++++++++++---------------------- 1 file changed, 15 insertions(+), 34 deletions(-) diff --git a/languages/go/goeql/goeql_test.go b/languages/go/goeql/goeql_test.go index c94b0e1b..89086ee4 100644 --- a/languages/go/goeql/goeql_test.go +++ b/languages/go/goeql/goeql_test.go @@ -17,25 +17,13 @@ func TestEncryptedText_Serialize(t *testing.T) { t.Fatalf("Serialize returned error: %v", err) } - var ec EncryptedColumn - if err := json.Unmarshal(serializedData, &ec); err != nil { - t.Fatalf("Error unmarshaling serialized data: %v", err) + desearlizedData, err := et.Deserialize(serializedData) + if err != nil { + t.Fatalf("Deserialize returned error: %v", err) } - if ec.K != "pt" { - t.Errorf("Expected K to be 'pt', got '%s'", ec.K) - } - if ec.P != string(et) { - t.Errorf("Expected P to be '%s', got '%s'", et, ec.P) - } - if ec.I.T != table { - t.Errorf("Expected I.T to be '%s', got '%s'", table, ec.I.T) - } - if ec.I.C != column { - t.Errorf("Expected I.C to be '%s', got '%s'", column, ec.I.C) - } - if ec.V != 1 { - t.Errorf("Expected V to be 1, got %d", ec.V) + if !reflect.DeepEqual(desearlizedData, et) { + t.Errorf("Expected deserialized value to be '%s', got '%s'", et, desearlizedData) } } @@ -65,13 +53,16 @@ func TestEncryptedText_Deserialize(t *testing.T) { } // Test EncryptedJsonb Serialization -// TODO: This test is failing func TestEncryptedJsonb_Serialize(t *testing.T) { + // You must cast any int to float64 to get the correct JSON output + // Deserialization will always return a float64 for ints as json.Unmarshal will + // convert them to float64 by default ej := EncryptedJsonb{ "name": "Alice", - "age": 30, + "age": float64(30), "is_member": true, } + table := "test_table" column := "test_column" @@ -80,27 +71,17 @@ func TestEncryptedJsonb_Serialize(t *testing.T) { t.Fatalf("Serialize returned error: %v", err) } - var ec EncryptedColumn - if err := json.Unmarshal(serializedData, &ec); err != nil { - t.Fatalf("Error unmarshaling serialized data: %v", err) - } - - if ec.K != "pt" { - t.Errorf("Expected K to be 'pt', got '%s'", ec.K) - } - - var pData map[string]interface{} - if err := json.Unmarshal([]byte(ec.P), &pData); err != nil { - t.Fatalf("Error unmarshaling P field: %v", err) + desearlizedData, err := ej.Deserialize(serializedData) + if err != nil { + t.Fatalf("Deserialize returned error: %v", err) } - if !reflect.DeepEqual(pData, map[string]interface{}(ej)) { - t.Errorf("P field does not match original data") + if !reflect.DeepEqual(desearlizedData, ej) { + t.Errorf("Expected deserialized value to be '%s', got '%s'", ej, desearlizedData) } } // Test EncryptedJsonb Deserialization -// TODO: This test is failing func TestEncryptedJsonb_Deserialize(t *testing.T) { originalData := map[string]interface{}{ "name": "Alice",