From d67361cdd037dba8a368b8a455b3c455e2471f1a Mon Sep 17 00:00:00 2001 From: fimac Date: Thu, 17 Oct 2024 14:30:44 +1100 Subject: [PATCH 1/3] add e2e tests for example queries --- languages/go/xorm/e2e_test.go | 237 ++++++++++++++++++++++++++++++++++ languages/go/xorm/go.mod | 4 + languages/go/xorm/go.sum | 5 +- 3 files changed, 244 insertions(+), 2 deletions(-) create mode 100644 languages/go/xorm/e2e_test.go diff --git a/languages/go/xorm/e2e_test.go b/languages/go/xorm/e2e_test.go new file mode 100644 index 00000000..f590f682 --- /dev/null +++ b/languages/go/xorm/e2e_test.go @@ -0,0 +1,237 @@ +package main + +import ( + "fmt" + "log" + "testing" + + "github.com/encrypt-query-language/go/goeql" + "github.com/stretchr/testify/assert" + "xorm.io/xorm" +) + +func proxyEngine() *xorm.Engine { + + proxyConnStr := "user=postgres password=postgres port=6432 host=localhost dbname=gotest sslmode=disable" + proxyEngine, err := xorm.NewEngine("pgx", proxyConnStr) + + if err != nil { + log.Fatalf("Could not connect to the database: %v", err) + } + + return proxyEngine +} + +func truncateDb(engine *xorm.Engine) error { + query := "TRUNCATE TABLE examples" + _, err := engine.Exec(query) + if err != nil { + return fmt.Errorf("failed to truncate table: %v", err) + } + + return nil +} + +func TestWhereQueryOnUnencryptedColumn(t *testing.T) { + engine := proxyEngine() + truncateDb(engine) + + jsonData := map[string]any{ + "top": map[string]any{ + "integer": float64(101), + "float": 1.234, + }, + "bottom": "value_three", + } + + newExample := Example{NonEncryptedField: "sydney", EncryptedIntField: 23, EncryptedTextField: "test@test.com", EncryptedJsonbField: jsonData} + + _, err := engine.Insert(&newExample) + if err != nil { + t.Fatalf("Could not insert new example: %v", err) + } + + var example Example + text := "sydney" + + has, err := engine.Where("non_encrypted_field = ?", text).Get(&example) + if err != nil { + t.Fatalf("Could not retrieve example: %v", err) + } + + if !has { + t.Errorf("Expected has to equal true, got: %v", has) + } + + assert.Equal(t, newExample.NonEncryptedField, example.NonEncryptedField, "NonEncryptedField should match") + assert.Equal(t, newExample.EncryptedIntField, example.EncryptedIntField, "EncryptedIntField should match") + assert.Equal(t, newExample.EncryptedTextField, example.EncryptedTextField, "EncryptedTextField should match") + assert.Equal(t, newExample.EncryptedJsonbField, example.EncryptedJsonbField, "EncryptedJsonbField should match") +} + +func TestMatchQueryLongString(t *testing.T) { + engine := proxyEngine() + truncateDb(engine) + + jsonData := map[string]any{ + "top": map[string]any{ + "integer": float64(101), + "float": 1.234, + }, + "bottom": "value_three", + } + + examples := []Example{ + { + NonEncryptedField: "sydney", + EncryptedIntField: 23, + EncryptedTextField: "this is a long string", + EncryptedJsonbField: jsonData, + }, + { + NonEncryptedField: "melbourne", + EncryptedIntField: 42, + EncryptedTextField: "quick brown fox jumped", + EncryptedJsonbField: jsonData, + }, + } + + inserted, err := engine.Insert(&examples) + + if err != nil { + t.Errorf("Error inserting examples: %v", err) + } + + assert.Equal(t, int64(2), inserted, "Expected to insert 2 rows") + + query, err := goeql.SerializeQuery("this", "examples", "encrypted_text_field") + if err != nil { + log.Fatalf("Error marshaling encrypted_text_field query: %v", err) + } + + var returnedExample Example + has, err := engine.Where("cs_match_v1(encrypted_text_field) @> cs_match_v1(?)", query).Get(&returnedExample) + if err != nil { + t.Fatalf("Could not retrieve example: %v", err) + } + + if !has { + t.Errorf("Expected has to equal true, got: %v", has) + } + + assert.Equal(t, returnedExample.EncryptedTextField, EncryptedTextField("this is a long string"), "EncryptedTextField should match") +} + +func TestMatchQueryEmail(t *testing.T) { + engine := proxyEngine() + truncateDb(engine) + + jsonData := map[string]any{ + "top": map[string]any{ + "integer": float64(101), + "float": 1.234, + }, + "bottom": "value_three", + } + + examples := []Example{ + { + NonEncryptedField: "sydney", + EncryptedIntField: 23, + EncryptedTextField: "testemail@test.com", + EncryptedJsonbField: jsonData, + }, + { + NonEncryptedField: "melbourne", + EncryptedIntField: 42, + EncryptedTextField: "someone@gmail.com", + EncryptedJsonbField: jsonData, + }, + } + + inserted, err := engine.Insert(&examples) + + if err != nil { + t.Errorf("Error inserting examples: %v", err) + } + + assert.Equal(t, int64(2), inserted, "Expected to insert 2 rows") + + query, err := goeql.SerializeQuery("test", "examples", "encrypted_text_field") + if err != nil { + log.Fatalf("Error marshaling encrypted_text_field query: %v", err) + } + + var returnedExample Example + has, err := engine.Where("cs_match_v1(encrypted_text_field) @> cs_match_v1(?)", query).Get(&returnedExample) + if err != nil { + t.Fatalf("Could not retrieve example: %v", err) + } + + if !has { + t.Errorf("Expected has to equal true, got: %v", has) + } + + assert.Equal(t, returnedExample.EncryptedTextField, EncryptedTextField("testemail@test.com"), "EncryptedTextField should match") +} + +func TestJsonbQuerySimple(t *testing.T) { + engine := proxyEngine() + truncateDb(engine) + + expectedJson := map[string]any{ + "top": map[string]any{ + "integer": float64(101), + "float": 1.234, + "string": "some string", + }, + "bottom": "value_three", + } + + examples := []Example{ + { + NonEncryptedField: "sydney", + EncryptedTextField: "testing", + EncryptedIntField: 42, + EncryptedJsonbField: expectedJson, + }, + { + NonEncryptedField: "melbourne", + EncryptedIntField: 42, + EncryptedTextField: "someone@gmail.com", + EncryptedJsonbField: generateJsonbData("first", "second", "third"), + }, + } + + inserted, err := engine.Insert(&examples) + + if err != nil { + t.Errorf("Error inserting examples: %v", err) + } + + assert.Equal(t, int64(2), inserted, "Expected to insert 2 rows") + + // create a query + jsonbQuery := map[string]any{ + "top": map[string]any{ + "integer": float64(101), + }, + } + + query, errTwo := goeql.SerializeQuery(jsonbQuery, "examples", "encrypted_jsonb_field") + if errTwo != nil { + log.Fatalf("Error marshaling encrypted_jsonb_field: %v", errTwo) + } + + var returnedExample Example + has, err := engine.Where("cs_ste_vec_v1(encrypted_jsonb_field) @> cs_ste_vec_v1(?)", query).Get(&returnedExample) + if err != nil { + t.Fatalf("Could not retrieve example: %v", err) + } + + if !has { + t.Errorf("Expected has to equal true, got: %v", has) + } + + assert.Equal(t, returnedExample.EncryptedJsonbField, EncryptedJsonbField(expectedJson), "EncryptedJsonb field should match") +} diff --git a/languages/go/xorm/go.mod b/languages/go/xorm/go.mod index c1554efa..f1273f4b 100644 --- a/languages/go/xorm/go.mod +++ b/languages/go/xorm/go.mod @@ -4,14 +4,18 @@ go 1.21.3 require ( github.com/encrypt-query-language/go/goeql v0.0.0-00010101000000-000000000000 + github.com/stretchr/testify v1.9.0 ) require ( github.com/cockroachdb/apd v1.1.0 // indirect + github.com/davecgh/go-spew v1.1.1 // indirect github.com/gofrs/uuid v4.0.0+incompatible // indirect github.com/jackc/fake v0.0.0-20150926172116-812a484cc733 // indirect github.com/pkg/errors v0.9.1 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect gopkg.in/yaml.v2 v2.2.2 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect ) require ( diff --git a/languages/go/xorm/go.sum b/languages/go/xorm/go.sum index 69f3cd99..59488534 100644 --- a/languages/go/xorm/go.sum +++ b/languages/go/xorm/go.sum @@ -56,8 +56,8 @@ github.com/shopspring/decimal v1.3.1 h1:2Usl1nmF/WZucqkFZhnfFYxxxu8LG21F6nPQBE5g github.com/shopspring/decimal v1.3.1/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= -github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= -github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/syndtr/goleveldb v1.0.0 h1:fBdIW9lB4Iz0n9khmH8w27SJ3QEJ7+IgjPEwGSZiFdE= github.com/syndtr/goleveldb v1.0.0/go.mod h1:ZVVdQEZoIme9iO1Ch2Jdy24qqXrMMOU6lpPAyBWyWuQ= golang.org/x/crypto v0.27.0 h1:GXm2NjJrPaiv/h1tb2UH8QfgC/hOf/+z0p6PT8o1w7A= @@ -78,6 +78,7 @@ golang.org/x/text v0.18.0 h1:XvMDiNzPAl0jr17s6W9lcaIhGUfUORdGCNsuLmPG224= golang.org/x/text v0.18.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY= golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d h1:vU5i/LfpvrRCpgM/VPfJLg5KjxD3E+hfT1SH+d9zLwg= golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4= gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= From 68bd6de217c18d71573c242c5c1203b66d886e23 Mon Sep 17 00:00:00 2001 From: fimac Date: Thu, 17 Oct 2024 15:33:20 +1100 Subject: [PATCH 2/3] fix up import and require for goeql --- languages/go/xorm/e2e_test.go | 2 +- languages/go/xorm/example_queries.go | 2 +- languages/go/xorm/go.mod | 4 ++-- languages/go/xorm/main.go | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/languages/go/xorm/e2e_test.go b/languages/go/xorm/e2e_test.go index f590f682..1b91b60b 100644 --- a/languages/go/xorm/e2e_test.go +++ b/languages/go/xorm/e2e_test.go @@ -5,7 +5,7 @@ import ( "log" "testing" - "github.com/encrypt-query-language/go/goeql" + "github.com/encrypt-query-language/languages/go/goeql" "github.com/stretchr/testify/assert" "xorm.io/xorm" ) diff --git a/languages/go/xorm/example_queries.go b/languages/go/xorm/example_queries.go index 329c41e7..41497b4b 100644 --- a/languages/go/xorm/example_queries.go +++ b/languages/go/xorm/example_queries.go @@ -5,7 +5,7 @@ import ( "fmt" "log" - "github.com/encrypt-query-language/go/goeql" + "github.com/encrypt-query-language/languages/go/goeql" "xorm.io/xorm" ) diff --git a/languages/go/xorm/go.mod b/languages/go/xorm/go.mod index f1273f4b..567985a1 100644 --- a/languages/go/xorm/go.mod +++ b/languages/go/xorm/go.mod @@ -3,7 +3,7 @@ module go-xorm-app go 1.21.3 require ( - github.com/encrypt-query-language/go/goeql v0.0.0-00010101000000-000000000000 + github.com/encrypt-query-language/languages/go/goeql v0.0.0-00010101000000-000000000000 github.com/stretchr/testify v1.9.0 ) @@ -33,4 +33,4 @@ require ( xorm.io/xorm v1.3.9 ) -replace github.com/encrypt-query-language/go/goeql => ../goeql +replace github.com/encrypt-query-language/languages/go/goeql => ../goeql diff --git a/languages/go/xorm/main.go b/languages/go/xorm/main.go index edbe3e5c..7c92c77c 100644 --- a/languages/go/xorm/main.go +++ b/languages/go/xorm/main.go @@ -6,7 +6,7 @@ import ( "log" "os" - "github.com/encrypt-query-language/go/goeql" // imported using local path until published + "github.com/encrypt-query-language/languages/go/goeql" // imported using local path until published _ "github.com/jackc/pgx/stdlib" // PostgreSQL driver "xorm.io/xorm" From 26c12aa77188d858872a797b3e0f4f298f785333 Mon Sep 17 00:00:00 2001 From: fimac Date: Fri, 18 Oct 2024 10:06:22 +1100 Subject: [PATCH 3/3] more tests --- languages/go/xorm/.envrc.example | 4 +- languages/go/xorm/README.md | 6 + languages/go/xorm/e2e_test.go | 280 ++++++++++++++++++++++++++++++- languages/go/xorm/run.sh | 21 ++- 4 files changed, 300 insertions(+), 11 deletions(-) diff --git a/languages/go/xorm/.envrc.example b/languages/go/xorm/.envrc.example index d8f98313..307aabb8 100644 --- a/languages/go/xorm/.envrc.example +++ b/languages/go/xorm/.envrc.example @@ -8,8 +8,8 @@ export CS_CLIENT_ID= export CS_CLIENT_KEY= # Used by Proxy -export CS_ENCRYPTION__CLIENT_ID= -export CS_ENCRYPTION__CLIENT_KEY= +export CS_ENCRYPTION__CLIENT_ID=$CS_CLIENT_ID +export CS_ENCRYPTION__CLIENT_KEY=$CS_CLIENT_KEY export CS_AUDIT__ENABLED=false export CS_DATABASE__PORT=5432 export CS_DATABASE__USERNAME=postgres diff --git a/languages/go/xorm/README.md b/languages/go/xorm/README.md index bae2d76d..b076d507 100644 --- a/languages/go/xorm/README.md +++ b/languages/go/xorm/README.md @@ -73,3 +73,9 @@ Run examples: ```shell ./run.sh examples ``` + +Run tests: + +```shell +./run.sh tests +``` diff --git a/languages/go/xorm/e2e_test.go b/languages/go/xorm/e2e_test.go index 1b91b60b..fc570057 100644 --- a/languages/go/xorm/e2e_test.go +++ b/languages/go/xorm/e2e_test.go @@ -63,10 +63,10 @@ func TestWhereQueryOnUnencryptedColumn(t *testing.T) { t.Errorf("Expected has to equal true, got: %v", has) } - assert.Equal(t, newExample.NonEncryptedField, example.NonEncryptedField, "NonEncryptedField should match") - assert.Equal(t, newExample.EncryptedIntField, example.EncryptedIntField, "EncryptedIntField should match") - assert.Equal(t, newExample.EncryptedTextField, example.EncryptedTextField, "EncryptedTextField should match") - assert.Equal(t, newExample.EncryptedJsonbField, example.EncryptedJsonbField, "EncryptedJsonbField should match") + assert.Equal(t, newExample.NonEncryptedField, example.NonEncryptedField, "NonEncryptedField does not match") + assert.Equal(t, newExample.EncryptedIntField, example.EncryptedIntField, "EncryptedIntField does not match") + assert.Equal(t, newExample.EncryptedTextField, example.EncryptedTextField, "EncryptedTextField does not match") + assert.Equal(t, newExample.EncryptedJsonbField, example.EncryptedJsonbField, "EncryptedJsonbField does not match") } func TestMatchQueryLongString(t *testing.T) { @@ -235,3 +235,275 @@ func TestJsonbQuerySimple(t *testing.T) { assert.Equal(t, returnedExample.EncryptedJsonbField, EncryptedJsonbField(expectedJson), "EncryptedJsonb field should match") } + +func TestJsonbQueryNested(t *testing.T) { + engine := proxyEngine() + truncateDb(engine) + + expectedJson := map[string]any{ + "top": map[string]any{ + "integer": float64(101), + "float": 1.234, + "string": "some string", + "nested_one": map[string]any{ + "nested_two": "hello world", + }, + }, + "bottom": "value_three", + } + + examples := []Example{ + { + NonEncryptedField: "sydney", + EncryptedTextField: "testing", + EncryptedIntField: 42, + EncryptedJsonbField: expectedJson, + }, + { + NonEncryptedField: "melbourne", + EncryptedIntField: 42, + EncryptedTextField: "someone@gmail.com", + EncryptedJsonbField: generateJsonbData("first", "second", "third"), + }, + } + + inserted, err := engine.Insert(&examples) + + if err != nil { + t.Errorf("Error inserting examples: %v", err) + } + + assert.Equal(t, int64(2), inserted, "Expected to insert 2 rows") + + // create a query + jsonbQuery := map[string]any{ + "top": map[string]any{ + "nested_one": map[string]any{ + "nested_two": "hello world", + }, + }, + } + + query, errTwo := goeql.SerializeQuery(jsonbQuery, "examples", "encrypted_jsonb_field") + if errTwo != nil { + log.Fatalf("Error marshaling encrypted_jsonb_field: %v", errTwo) + } + + var returnedExample Example + has, err := engine.Where("cs_ste_vec_v1(encrypted_jsonb_field) @> cs_ste_vec_v1(?)", query).Get(&returnedExample) + if err != nil { + t.Fatalf("Could not retrieve example: %v", err) + } + + if !has { + t.Errorf("Expected has to equal true, got: %v", has) + } + + assert.Equal(t, returnedExample.EncryptedJsonbField, EncryptedJsonbField(expectedJson), "EncryptedJsonb field should match") +} + +func TestOreStringRangeQuery(t *testing.T) { + engine := proxyEngine() + truncateDb(engine) + expected := EncryptedTextField("whale") + + examples := []Example{ + { + NonEncryptedField: "sydney", + EncryptedTextField: expected, + EncryptedIntField: 42, + EncryptedJsonbField: generateJsonbData("first", "second", "third"), + }, + { + NonEncryptedField: "melbourne", + EncryptedIntField: 42, + EncryptedTextField: "apple", + EncryptedJsonbField: generateJsonbData("first", "second", "third"), + }, + } + + inserted, err := engine.Insert(&examples) + + if err != nil { + t.Errorf("Error inserting examples: %v", err) + } + + assert.Equal(t, int64(2), inserted, "Expected to insert 2 rows") + + // Query + query, errQuery := goeql.SerializeQuery("tree", "examples", "encrypted_text_field") + if errQuery != nil { + log.Fatalf("err: %v", errQuery) + } + + var returnedExample Example + has, err := engine.Where("cs_ore_64_8_v1(encrypted_text_field) > cs_ore_64_8_v1(?)", query).Get(&returnedExample) + if err != nil { + t.Fatalf("Could not retrieve example: %v", err) + } + + if !has { + t.Errorf("Expected has to equal true, got: %v", has) + } + + assert.Equal(t, returnedExample.EncryptedTextField, expected, "EncryptedText field should match") +} + +func TestOreIntRangeQuery(t *testing.T) { + engine := proxyEngine() + truncateDb(engine) + expected := EncryptedIntField(42) + + examples := []Example{ + { + NonEncryptedField: "sydney", + EncryptedTextField: "whale", + EncryptedIntField: expected, + EncryptedJsonbField: generateJsonbData("first", "second", "third"), + }, + { + NonEncryptedField: "melbourne", + EncryptedIntField: 23, + EncryptedTextField: "apple", + EncryptedJsonbField: generateJsonbData("first", "second", "third"), + }, + } + + inserted, err := engine.Insert(&examples) + + if err != nil { + t.Errorf("Error inserting examples: %v", err) + } + + assert.Equal(t, int64(2), inserted, "Expected to insert 2 rows") + + // Query + query, errQuery := goeql.SerializeQuery(32, "examples", "encrypted_int_field") + if errQuery != nil { + log.Fatalf("err: %v", errQuery) + } + + var returnedExample Example + has, err := engine.Where("cs_ore_64_8_v1(encrypted_int_field) > cs_ore_64_8_v1(?)", query).Get(&returnedExample) + if err != nil { + t.Fatalf("Could not retrieve example: %v", err) + } + + if !has { + t.Errorf("Expected has to equal true, got: %v", has) + } + + assert.Equal(t, returnedExample.EncryptedIntField, expected, "EncryptedInt field should match") +} + +func TestOreBoolRangeQuery(t *testing.T) { + engine := proxyEngine() + truncateDb(engine) + expected := EncryptedBoolField(true) + + examples := []Example{ + { + NonEncryptedField: "sydney", + EncryptedTextField: "whale", + EncryptedIntField: 42, + EncryptedJsonbField: generateJsonbData("first", "second", "third"), + EncryptedBoolField: false, + }, + { + NonEncryptedField: "melbourne", + EncryptedIntField: 23, + EncryptedTextField: "pineapple", + EncryptedJsonbField: generateJsonbData("first", "second", "third"), + EncryptedBoolField: expected, + }, + { + NonEncryptedField: "launceston", + EncryptedIntField: 23, + EncryptedTextField: "apple", + EncryptedJsonbField: generateJsonbData("first", "second", "third"), + EncryptedBoolField: false, + }, + } + + inserted, err := engine.Insert(&examples) + + if err != nil { + t.Errorf("Error inserting examples: %v", err) + } + + assert.Equal(t, int64(3), inserted, "Expected to insert 3 rows") + + // Query + query, errQuery := goeql.SerializeQuery(false, "examples", "encrypted_bool_field") + if errQuery != nil { + log.Fatalf("err: %v", errQuery) + } + + var returnedExample Example + has, err := engine.Where("cs_ore_64_8_v1(encrypted_bool_field) > cs_ore_64_8_v1(?)", query).Get(&returnedExample) + if err != nil { + t.Fatalf("Could not retrieve example: %v", err) + } + + if !has { + t.Errorf("Expected has to equal true, got: %v", has) + } + + assert.Equal(t, returnedExample.EncryptedBoolField, expected, "EncryptedBool field should match") +} + +func TestUniqueStringQuery(t *testing.T) { + engine := proxyEngine() + truncateDb(engine) + expected := EncryptedTextField("testing two") + + examples := []Example{ + { + NonEncryptedField: "sydney", + EncryptedTextField: "whale", + EncryptedIntField: 42, + EncryptedJsonbField: generateJsonbData("first", "second", "third"), + EncryptedBoolField: false, + }, + { + NonEncryptedField: "melbourne", + EncryptedIntField: 23, + EncryptedTextField: expected, + EncryptedJsonbField: generateJsonbData("first", "second", "third"), + EncryptedBoolField: true, + }, + { + NonEncryptedField: "launceston", + EncryptedIntField: 23, + EncryptedTextField: "apple", + EncryptedJsonbField: generateJsonbData("first", "second", "third"), + EncryptedBoolField: false, + }, + } + + inserted, err := engine.Insert(&examples) + + if err != nil { + t.Errorf("Error inserting examples: %v", err) + } + + assert.Equal(t, int64(3), inserted, "Expected to insert 3 rows") + + // Query + query, errQuery := goeql.SerializeQuery("testing two", "examples", "encrypted_text_field") + if errQuery != nil { + log.Fatalf("err: %v", errQuery) + } + + var returnedExample Example + has, err := engine.Where("cs_unique_v1(encrypted_text_field) = cs_unique_v1($1)", query).Get(&returnedExample) + if err != nil { + t.Fatalf("Could not retrieve example: %v", err) + } + + if !has { + t.Errorf("Expected has to equal true, got: %v", has) + } + + assert.Equal(t, returnedExample.EncryptedTextField, expected, "EncryptedText field should match") +} diff --git a/languages/go/xorm/run.sh b/languages/go/xorm/run.sh index f6528c74..26d03c71 100755 --- a/languages/go/xorm/run.sh +++ b/languages/go/xorm/run.sh @@ -29,12 +29,23 @@ subproject_teardown() { subproject_examples() { # reset db go run . setupDev - # start proxy # run examples queries go run . runExamples } +subproject_tests(){ + # start postgres and proxy + docker compose up -d + # reset db + go run . setupDev + # run e2e tests + make gotest + # run goeql tests + cd ../goeql + go test +} + subproject_start_proxy() { docker run --env-file .env -p 6432:6432 cipherstash/cipherstash-proxy:latest } @@ -49,14 +60,14 @@ case $subcommand in subproject_teardown ;; - start_proxy) - subproject_start_proxy - ;; - examples) subproject_examples ;; + tests) + subproject_tests + ;; + *) echo "Unknown run subcommand '$subcommand'" exit 1