diff --git a/erisdb/middleware_test.go b/erisdb/middleware_test.go index 2dafe5ec16aa4ddb3aee611d075e2dc813ba8c0a..6afaed01ac48de8a1f7b14080bec715e77bf45d5 100644 --- a/erisdb/middleware_test.go +++ b/erisdb/middleware_test.go @@ -1,239 +1,121 @@ package erisdb import ( - "fmt" "testing" - "reflect" - ep "github.com/androlo/blockchain_rpc/erisdb/pipe" + "github.com/stretchr/testify/assert" + ep "github.com/eris-ltd/erisdb/erisdb/pipe" ) // Test empty query. func TestEmptyQuery(t *testing.T) { arr, err := _parseQuery("") - if err != nil{ - t.Error(err) - } - if arr != nil{ - t.Error(fmt.Errorf("Array should be nil")) - } + assert.NoError(t, err) + assert.Nil(t, arr, "Array should be nil") } // Test no colon separated filter. func TestQueryNoColonSeparator(t *testing.T) { _, err := _parseQuery("test") - if err == nil{ - t.Fatal("Should detect missing colon.") - } + assert.Error(t, err, "Should detect missing colon.") } // Test no colon separated filter and proper filters mixed. func TestQueryNoColonSeparatorMulti(t *testing.T) { _, err := _parseQuery("test + test1:24 + test2") - if err == nil { - t.Fatal("Should detect missing colon.") - } - // fmt.Println("Error: " + err.Error()) + assert.Error(t, err, "Should detect missing colon.") } // Test how it handles a query with op and value empty. func TestQueryOpEmptyValueEmpty(t *testing.T) { - arr, err := _parseQuery("test:") - if err != nil{ - t.Fatal("Caused an error: " + err.Error()) - } - if arr == nil{ - t.Fatal(fmt.Errorf("Array should not be nil")) - } - if len(arr) != 1 { - t.Fatal(fmt.Errorf("Array should have one element in it.")) - } - if !reflect.DeepEqual(arr[0], &ep.FilterData{"test", "==", ""}) { - t.Error("Error: Does not match.") - } + assertFilter(t, "test:", "test", "==", "") } // Test how it handles a query with an empty op but a proper value. func TestQueryOpEmptyValue(t *testing.T) { - arr, err := _parseQuery("test:val") - if err != nil{ - t.Fatal("Caused an error: " + err.Error()) - } - if arr == nil{ - t.Fatal(fmt.Errorf("Array should not be nil")) - } - if len(arr) != 1 { - t.Fatal(fmt.Errorf("Array should have one element in it.")) - } - if !reflect.DeepEqual(arr[0], &ep.FilterData{"test", "==", "val"}) { - t.Error("Error: Does not match.") - } + assertFilter(t, "test:val", "test", "==", "val") } // Test the '>' operator. func TestQueryGT(t *testing.T) { - arr, err := _parseQuery("test:>33") - if err != nil{ - t.Fatal("Caused an error: " + err.Error()) - } - if arr == nil{ - t.Fatal(fmt.Errorf("Array should not be nil")) - } - if len(arr) != 1 { - t.Fatal(fmt.Errorf("Array should have one element in it.")) - } - if !reflect.DeepEqual(arr[0], &ep.FilterData{"test", ">", "33"}) { - t.Error("Error: Does not match.") - } + testOp(">", t) } // Test the '<' operator. func TestQueryLT(t *testing.T) { - arr, err := _parseQuery("test:<33") - if err != nil{ - t.Fatal("Caused an error: " + err.Error()) - } - if arr == nil{ - t.Fatal(fmt.Errorf("Array should not be nil")) - } - if len(arr) != 1 { - t.Fatal(fmt.Errorf("Array should have one element in it.")) - } - if !reflect.DeepEqual(arr[0], &ep.FilterData{"test", "<", "33"}) { - t.Error("Error: Does not match.") - } + testOp("<", t) } // Test the '>=' operator. func TestQueryGTEQ(t *testing.T) { - arr, err := _parseQuery("test:>=33") - if err != nil{ - t.Fatal("Caused an error: " + err.Error()) - } - if arr == nil{ - t.Fatal(fmt.Errorf("Array should not be nil")) - } - if len(arr) != 1 { - t.Fatal(fmt.Errorf("Array should have one element in it.")) - } - if !reflect.DeepEqual(arr[0], &ep.FilterData{"test", ">=", "33"}) { - fmt.Printf("Data: %v\n", arr[0]) - t.Error("Error: Does not match.") - } + testOp(">=", t) } // Test the '<=' operator. func TestQueryLTEQ(t *testing.T) { - arr, err := _parseQuery("test:<=33") - if err != nil{ - t.Fatal("Caused an error: " + err.Error()) - } - if arr == nil{ - t.Fatal(fmt.Errorf("Array should not be nil")) - } - if len(arr) != 1 { - t.Fatal(fmt.Errorf("Array should have one element in it.")) - } - if !reflect.DeepEqual(arr[0], &ep.FilterData{"test", "<=", "33"}) { - t.Error("Error: Does not match.") - } + testOp("<=", t) } // Test the '==' operator. func TestQueryEQ(t *testing.T) { - arr, err := _parseQuery("test:==33") - if err != nil{ - t.Fatal("Caused an error: " + err.Error()) - } - if arr == nil{ - t.Fatal(fmt.Errorf("Array should not be nil")) - } - if len(arr) != 1 { - t.Fatal(fmt.Errorf("Array should have one element in it.")) - } - if !reflect.DeepEqual(arr[0], &ep.FilterData{"test", "==", "33"}) { - t.Error("Error: Does not match.") - } + testOp("==", t) } // Test the '!=' operator. -func TestQueryEQ(t *testing.T) { - arr, err := _parseQuery("test:!=null") - if err != nil{ - t.Fatal("Caused an error: " + err.Error()) - } - if arr == nil{ - t.Fatal(fmt.Errorf("Array should not be nil")) - } - if len(arr) != 1 { - t.Fatal(fmt.Errorf("Array should have one element in it.")) - } - if !reflect.DeepEqual(arr[0], &ep.FilterData{"test", "!=", "null"}) { - t.Error("Error: Does not match.") - } +func TestQueryNEQ(t *testing.T) { + testOp("!=", t) } // Test a working range query. func TestRangeQuery(t *testing.T) { - arr, err := _parseQuery("test:4..66") - if err != nil{ - t.Fatal("Caused an error: " + err.Error()) - } - if arr == nil{ - t.Fatal(fmt.Errorf("Array should not be nil")) - } - if len(arr) != 2 { - t.Fatal(fmt.Errorf("Array should have one element in it.")) - } - fmt.Printf("%v\n", arr[0]) - fmt.Printf("%v\n", arr[1]) - - if !reflect.DeepEqual(arr[0], &ep.FilterData{"test", ">=", "4"}) { - - t.Error("Error: Does not match.") - } - if !reflect.DeepEqual(arr[1], &ep.FilterData{"test", "<=", "66"}) { - t.Error("Error: Does not match.") - } -} - -// Test a working range-query with wildcards. -func TestRangeQueryWildcards(t *testing.T) { - arr, err := _parseQuery("test:*..*") - if err != nil{ - t.Fatal("Caused an error: " + err.Error()) - } - if arr == nil{ - t.Fatal(fmt.Errorf("Array should not be nil")) - } - if len(arr) != 2 { - t.Fatal(fmt.Errorf("Array should have one element in it.")) - } - fmt.Printf("%v\n", arr[0]) - fmt.Printf("%v\n", arr[1]) - - if !reflect.DeepEqual(arr[0], &ep.FilterData{"test", ">=", "min"}) { - - t.Error("Error: Does not match.") - } - if !reflect.DeepEqual(arr[1], &ep.FilterData{"test", "<=", "max"}) { - t.Error("Error: Does not match.") - } + assertRangeFilter(t, "5", "50", "5", "50") +} + +// Test a working range-query with wildcard for lower bound. +func TestRangeQueryWildcardLB(t *testing.T) { + assertRangeFilter(t, "*", "50", "min", "50") +} + +// Test a working range-query with wildcard for upper bound. +func TestRangeQueryWildcardUB(t *testing.T) { + assertRangeFilter(t, "5", "*", "5", "max") +} + +// Test a working range-query with wildcard for upper and lower bound. +func TestRangeQueryWildcardULB(t *testing.T) { + assertRangeFilter(t, "*", "*", "min", "max") } // Test a range query with no upper bounds term. func TestRangeQueryBotchedMax(t *testing.T) { _, err := _parseQuery("test:5..") - if err == nil{ - t.Fatal("Malformed range-query passed") - } - fmt.Println(err) + assert.Error(t, err, "Malformed range-query passed") } // Test a range query with no lower bounds term. func TestRangeQueryBotchedMin(t *testing.T) { _, err := _parseQuery("test:..5") - if err == nil{ - t.Fatal("Malformed range-query passed") - } - fmt.Println(err) + assert.Error(t, err, "Malformed range-query passed") +} + +// Helpers. + +func testOp(op string, t *testing.T) { + assertFilter(t, "test:" + op + "33", "test", op, "33") +} + +func assertFilter(t *testing.T, filter, field, op, val string){ + arr, err := _parseQuery(filter) + assert.NoError(t, err) + assert.NotNil(t, arr) + assert.Len(t, arr, 1) + assert.Equal(t, arr[0], &ep.FilterData{field, op, val}) +} + +func assertRangeFilter(t *testing.T, min, max, res0, res1 string){ + arr, err := _parseQuery("test:"+ min + ".." + max) + assert.NoError(t, err) + assert.NotNil(t, arr) + assert.Len(t, arr, 2) + assert.Equal(t, arr[0], &ep.FilterData{"test", ">=", res0}) + assert.Equal(t, arr[1], &ep.FilterData{"test", "<=", res1}) } \ No newline at end of file diff --git a/files/files_test.go b/files/files_test.go index 869cc8973478c301afdf217d764b6a900a3b133c..124b9fe0f7ce7e3ef06d4de01285ed2c8409db73 100644 --- a/files/files_test.go +++ b/files/files_test.go @@ -2,99 +2,67 @@ package files import ( "bytes" - "fmt" "os" "path" "testing" + "github.com/stretchr/testify/assert" ) -var tempFolder = os.Getenv("TEMP") +var tempFolder = os.TempDir() var fileData = []byte("aaaaaaaaaaaaaaaaa") -func TestWrite(t *testing.T) { +func TestWriteRemove(t *testing.T) { fileName := "testfile" - err := write(fileName) - if err != nil { - t.Fatal(err) - } - remove(fileName) - if !checkGone(fileName){ - t.Error(fmt.Errorf("File not removed: " + fileName)) - } + write(t, fileName) + remove(t, fileName) } -func TestRead(t *testing.T) { +func TestWriteReadRemove(t *testing.T) { fileName := "testfile" - err := write(fileName) - if err != nil { - t.Fatal(err) - } - err2 := readAndCheck(fileName, fileData) - if err2 != nil { - remove(fileName) - t.Fatal(err) - } - remove(fileName) - if !checkGone(fileName){ - t.Error(fmt.Errorf("File not removed: " + fileName)) - } + write(t, fileName) + readAndCheck(t, fileName, fileData) + remove(t, fileName) } -func TestRename(t *testing.T) { +func TestRenameRemove(t *testing.T) { fileName0 := "file0" fileName1 := "file1" - err := write(fileName0) - if err != nil { - t.Fatal(err) - } - err2 := rename(fileName0,fileName1) - if err2 != nil { - t.Fatal(err2) - } - err3 := readAndCheck(fileName1, fileData) - if err3 != nil { - remove(fileName1) - t.Fatal(err) - } - remove(fileName1) - - if !checkGone(fileName0){ - t.Error(fmt.Errorf("File not removed: " + fileName0)) - } - if !checkGone(fileName1){ - t.Error(fmt.Errorf("File not removed: " + fileName1)) - } + write(t, fileName0) + rename(t, fileName0, fileName1) + readAndCheck(t, fileName1, fileData) + remove(t, fileName1) + checkGone(t, fileName0) } +// Helpers + func getName(name string) string { return path.Join(tempFolder, name) } -func write(fileName string) error { - return WriteFile(getName(fileName), fileData, FILE_RW) +func write(t *testing.T, fileName string) { + err := WriteFile(getName(fileName), fileData, FILE_RW) + assert.NoError(t, err) } -func readAndCheck(fileName string, btsIn []byte) error { +func readAndCheck(t *testing.T, fileName string, btsIn []byte) { bts, err := ReadFile(getName(fileName)) - if err != nil { - return err - } - if !bytes.Equal(bts,btsIn) { - return fmt.Errorf("Failed to read file data. Written: %s, Read: %s\n", string(fileData), string(bts)) - } - return nil + assert.NoError(t, err) + assert.True(t, bytes.Equal(bts,btsIn), "Failed to read file data. Written: %s, Read: %s\n", string(fileData), string(bts)) } -func remove(fileName string) error { - return os.Remove(getName(fileName)) +func remove(t *testing.T, fileName string) { + err := os.Remove(getName(fileName)) + assert.NoError(t, err) + checkGone(t, fileName) } -func rename(fileName0, fileName1 string) error { - return Rename(getName(fileName0), getName(fileName1)) +func rename(t *testing.T, fileName0, fileName1 string) { + assert.NoError(t, Rename(getName(fileName0), getName(fileName1))) } -func checkGone(fileName string) bool { +func checkGone(t *testing.T, fileName string) { name := getName(fileName) - _ , err := os.Stat(name) - return os.IsNotExist(err) + _ , err := os.Stat(name) + assert.True(t, os.IsNotExist(err), "File not removed: " + name) } \ No newline at end of file