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