checkpoint

go.mod

@@ -0,0 +1,32 @@
+module github.com/gravitl/netmaker
+
+go 1.15
+
+require (
+	github.com/chromedp/cdproto v0.0.0-20210323015217-0942afbea50e
+	github.com/davecgh/go-spew v1.1.1
+	github.com/dgrijalva/jwt-go v3.2.0+incompatible
+	github.com/go-playground/universal-translator v0.17.0 // indirect
+	github.com/golang/protobuf v1.4.3
+	github.com/gorilla/handlers v1.5.1
+	github.com/gorilla/mux v1.8.0
+	github.com/grpc-ecosystem/go-grpc-middleware v1.0.0
+	github.com/leodido/go-urn v1.2.0 // indirect
+	github.com/mitchellh/go-homedir v1.1.0
+	github.com/robfig/cron v1.2.0
+	github.com/spf13/cobra v0.0.3
+	github.com/spf13/viper v1.7.1
+	github.com/stretchr/testify v1.6.1
+	github.com/takama/daemon v1.0.0
+	github.com/vishvananda/netlink v1.1.0
+	go.mongodb.org/mongo-driver v1.4.3
+	golang.org/x/crypto v0.0.0-20200204104054-c9f3fb736b72
+	golang.org/x/net v0.0.0-20210119194325-5f4716e94777 // indirect
+	golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c // indirect
+	golang.org/x/text v0.3.5 // indirect
+	golang.zx2c4.com/wireguard/wgctrl v0.0.0-20200609130330-bd2cb7843e1b
+	google.golang.org/genproto v0.0.0-20210201151548-94839c025ad4 // indirect
+	google.golang.org/grpc v1.35.0
+	gopkg.in/go-playground/validator.v9 v9.31.0
+	gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c
+)

go.sum

@@ -27,6 +27,10 @@ github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kB
 github.com/bketelsen/crypt v0.0.3-0.20200106085610-5cbc8cc4026c/go.mod h1:MKsuJmJgSg28kpZDP6UIiPt0e0Oz0kqKNGyRaWEPv84=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
 github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
+github.com/chromedp/cdproto v0.0.0-20210323015217-0942afbea50e h1:UimnzLuARNkGi2XsNznUoOLFP/noktdUMrr7fcb3D4U=
+github.com/chromedp/cdproto v0.0.0-20210323015217-0942afbea50e/go.mod h1:At5TxYYdxkbQL0TSefRjhLE3Q0lgvqKKMSFUglJ7i1U=
+github.com/chromedp/sysutil v1.0.0 h1:+ZxhTpfpZlmchB58ih/LBHX52ky7w2VhQVKQMucy3Ic=
+github.com/chromedp/sysutil v1.0.0/go.mod h1:kgWmDdq8fTzXYcKIBqIYvRRTnYb9aNS9moAV0xufSww=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
 github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
 github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk=
@@ -163,6 +167,8 @@ github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHW
 github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U=
 github.com/joho/godotenv v1.3.0/go.mod h1:7hK45KPybAkOC6peb+G5yklZfMxEjkZhHbwpqxOKXbg=
 github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
+github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
+github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
 github.com/jsimonetti/rtnetlink v0.0.0-20190606172950-9527aa82566a/go.mod h1:Oz+70psSo5OFh8DBl0Zv2ACw7Esh6pPUphlvZG9x7uw=
 github.com/jsimonetti/rtnetlink v0.0.0-20200117123717-f846d4f6c1f4/go.mod h1:WGuG/smIU4J/54PblvSbh+xvCZmpJnFgr3ds6Z55XMQ=
 github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
@@ -185,6 +191,8 @@ github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y=
 github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
 github.com/magiconair/properties v1.8.1 h1:ZC2Vc7/ZFkGmsVC9KvOjumD+G5lXy2RtTKyzRKO2BQ4=
 github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
+github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
+github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
 github.com/markbates/oncer v0.0.0-20181203154359-bf2de49a0be2/go.mod h1:Ld9puTsIW75CHf65OeIOkyKbteujpZVXDpWK6YGZbxE=
 github.com/markbates/safe v1.0.1/go.mod h1:nAqgmRi7cY2nqMc92/bSEeQA+R4OheNU2T1kNSCBdG0=
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=

user_test.go

@@ -10,6 +10,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/chromedp/cdproto/database"
 	controller "github.com/gravitl/netmaker/controllers"
 	"github.com/gravitl/netmaker/models"
 	"github.com/gravitl/netmaker/mongoconn"
@@ -22,6 +23,11 @@ type AuthorizationResponse struct {
 	AuthToken string
 }
 
+type databaseError struct {
+	Inner  *int
+	Errors int
+}
+
 type goodResponse struct {
 	Code     int
 	Message  string
@@ -58,218 +64,265 @@ func TestUsers(t *testing.T) {
 	//		response := checkAdminExists(t)
 	//		assert.Equal(t, false, response)
 	//	})
-
-	t.Run("Admin Creation", func(t *testing.T) {
-		var admin, user models.User
-		admin.UserName = "admin"
-		admin.Password = "password"
-		if !adminExists(t) {
-			t.Run("AdminCreationValid", func(t *testing.T) {
-				response, err := api(admin, http.MethodPost, "http://localhost:8081/users/createadmin", "")
-				if err != nil {
-					t.Error("error calling createadmin", err)
-				}
-				defer response.Body.Close()
-				json.NewDecoder(response.Body).Decode(&user)
-				assert.Equal(t, admin.UserName, user.UserName)
-				assert.Equal(t, true, user.IsAdmin)
-				assert.Equal(t, http.StatusOK, response.StatusCode)
-				assert.True(t, adminExists(t), "Admin creation failed")
-			})
-			t.Run("AdminCreationInvalid", func(t *testing.T) {
-				response, err := api(admin, http.MethodPost, "http://localhost:8081/users/createadmin", "")
-				if err != nil {
-					t.Error("error calling createadmin", err)
-				}
-				defer response.Body.Close()
-				var message badResponse
-				json.NewDecoder(response.Body).Decode(&message)
-				assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
-				assert.Equal(t, http.StatusUnauthorized, message.Code)
-				assert.Equal(t, "W1R3: Admin already exists! ", message.Message)
-			})
-		} else {
-			t.Run("AdminCreationInvalid", func(t *testing.T) {
-				response, err := api(admin, http.MethodPost, "http://localhost:8081/users/createadmin", "")
-
-				if err != nil {
-					t.Error("error calling createadmin", err)
-				}
-				defer response.Body.Close()
-				var message badResponse
-				json.NewDecoder(response.Body).Decode(&message)
-				assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
-				assert.Equal(t, http.StatusUnauthorized, message.Code)
-				assert.Equal(t, "W1R3: Admin already exists! ", message.Message)
-			})
-			//deleteAdmin()
-			t.Run("Admin Creation - Valid", func(t *testing.T) {
-				t.Skip()
-				response, err := api(admin, http.MethodPost, "http://localhost:8081/users/createadmin", "")
-				if err != nil {
-					t.Error("error calling createadmin", err)
-				}
-				defer response.Body.Close()
-				json.NewDecoder(response.Body).Decode(&user)
-				assert.Equal(t, admin.UserName, user.UserName)
-				assert.Equal(t, true, user.IsAdmin)
-				assert.Equal(t, http.StatusOK, response.StatusCode)
-				assert.True(t, adminExists(t), "Admin creation failed")
-			})
-		}
-	})
-
-	t.Run("GetUser", func(t *testing.T) {
-		//ensure admin exists
-		if !adminExists(t) {
-			t.Error("admin account does not exist")
-			return
-		}
-		//authenticate
-		t.Run("GetUser ValidToken", func(t *testing.T) {
-			token, err := authenticate()
-			if err != nil {
-				t.Error("could not authenticate")
-			}
-			response, err := api("", http.MethodGet, "http://localhost:8081/users/admin", token)
+}
+func TestAdminCreation(t *testing.T) {
+	t.Skip()
+	var admin, user models.User
+	admin.UserName = "admin"
+	admin.Password = "password"
+	if !adminExists(t) {
+		t.Run("AdminCreationValid", func(t *testing.T) {
+			response, err := api(t, admin, http.MethodPost, "http://localhost:8081/users/createadmin", "")
+			assert.NotNil(t, err, "create admin")
 			if err != nil {
-				t.Error("could not get user")
+				t.Fatal("....")
 			}
 			defer response.Body.Close()
-			var user models.User
 			json.NewDecoder(response.Body).Decode(&user)
-			assert.Equal(t, http.StatusOK, response.StatusCode)
-			assert.Equal(t, "admin", user.UserName)
+			assert.Equal(t, admin.UserName, user.UserName)
 			assert.Equal(t, true, user.IsAdmin)
+			assert.Equal(t, http.StatusOK, response.StatusCode)
+			assert.True(t, adminExists(t), "Admin creation failed")
+		})
+		t.Run("AdminCreationInvalid", func(t *testing.T) {
+			response, err := api(t, admin, http.MethodPost, "http://localhost:8081/users/createadmin", "")
+			if err != nil {
+				t.Error("error calling createadmin", err)
+			}
+			defer response.Body.Close()
+			var message badResponse
+			json.NewDecoder(response.Body).Decode(&message)
+			assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
+			assert.Equal(t, http.StatusUnauthorized, message.Code)
+			assert.Equal(t, "W1R3: Admin already exists! ", message.Message)
 		})
-		t.Run("GetUser InvalidToken", func(t *testing.T) {
-			//skip until sort out what should be returned
+	} else {
+		t.Run("AdminCreationInvalid", func(t *testing.T) {
+			response, err := api(t, admin, http.MethodPost, "http://localhost:8081/users/createadmin", "")
+			assert.NotNil(t, err, "createadmin")
+			defer response.Body.Close()
+			var message badResponse
+			json.NewDecoder(response.Body).Decode(&message)
+			assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
+			assert.Equal(t, http.StatusUnauthorized, message.Code)
+			assert.Equal(t, "W1R3: Admin already exists! ", message.Message)
+		})
+		//deleteAdmin()
+		t.Run("Admin Creation - Valid", func(t *testing.T) {
 			t.Skip()
-			response, err := api("", http.MethodGet, "http://localhost:8081/users/admin", "xxxx")
+			response, err := api(t, admin, http.MethodPost, "http://localhost:8081/users/createadmin", "")
 			if err != nil {
-				t.Error("error getting user")
+				t.Error("error calling createadmin", err)
 			}
 			defer response.Body.Close()
-			///not sure what this should be
-			var something string
-			json.NewDecoder(response.Body).Decode(something)
-			assert.Equal(t, "Some error message", something)
+			json.NewDecoder(response.Body).Decode(&user)
+			assert.Equal(t, admin.UserName, user.UserName)
+			assert.Equal(t, true, user.IsAdmin)
+			assert.Equal(t, http.StatusOK, response.StatusCode)
+			assert.True(t, adminExists(t), "Admin creation failed")
 		})
-	})
+	}
+}
+
+func TestGetUser(t *testing.T) {
 
-	t.Run("Update User", func(t *testing.T) {
+	t.Skip()
+	//ensure admin exists
+	if !adminExists(t) {
+		t.Error("admin account does not exist")
+		return
+	}
+	//authenticate
+	t.Run("GetUser ValidToken", func(t *testing.T) {
+		token, err := authenticate(t)
+		if err != nil {
+			t.Error("could not authenticate")
+		}
+		response, err := api(t, "", http.MethodGet, "http://localhost:8081/users/admin", token)
+		if err != nil {
+			t.Error("could not get user")
+		}
+		defer response.Body.Close()
+		var user models.User
+		json.NewDecoder(response.Body).Decode(&user)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		assert.Equal(t, "admin", user.UserName)
+		assert.Equal(t, true, user.IsAdmin)
+	})
+	t.Run("GetUser InvalidToken", func(t *testing.T) {
+		//skip until sort out what should be returned
 		t.Skip()
-		if !adminExists(t) {
-			addAdmin(t)
+		response, err := api(t, "", http.MethodGet, "http://localhost:8081/users/admin", "xxxx")
+		if err != nil {
+			t.Error("error getting user")
 		}
-		//token, err := authenticate()
-		//if err != nil {
-		//	t.Error("could not authenticate")
-		//}
+		defer response.Body.Close()
+		///not sure what this should be
+		var something string
+		json.NewDecoder(response.Body).Decode(something)
+		assert.Equal(t, "Some error message", something)
+	})
+}
+
+func TestUpdateUser(t *testing.T) {
+	t.Skip()
+	if !adminExists(t) {
+		addAdmin(t)
+	}
+	//token, err := authenticate(t)
+	//if err != nil {
+	//	t.Error("could not authenticate")
+	//}
 
-		var admin, user models.User
-		admin.UserName = "admin"
-		admin.Password = "admin"
+	var admin, user models.User
+	admin.UserName = "admin"
+	admin.Password = "admin"
 
-		//payload := map[string]string{"username": "admin", "password": "admin"}
-		payload, _ := json.Marshal(admin)
-		request, err := http.NewRequest(http.MethodPut, "http://localhost:8081/users/admin", bytes.NewBuffer(payload))
+	//payload := map[string]string{"username": "admin", "password": "admin"}
+	payload, _ := json.Marshal(admin)
+	request, err := http.NewRequest(http.MethodPut, "http://localhost:8081/users/admin", bytes.NewBuffer(payload))
+	if err != nil {
+		t.Error(err)
+	}
+	request.Header.Set("Authorization", "Bearer secretkey")
+	request.Header.Set("Content-Type", "application/json")
+	client := &http.Client{}
+	response, err := client.Do(request)
+	if err != nil {
+		t.Error("error calling createadmin", err)
+	}
+	defer response.Body.Close()
+	body, _ := ioutil.ReadAll(response.Body)
+	t.Log(string(body))
+	_ = json.Unmarshal(body, &user)
+	assert.Equal(t, admin.UserName, user.UserName)
+	assert.Equal(t, true, user.IsAdmin)
+	assert.Equal(t, http.StatusOK, response.StatusCode)
+}
+
+func TestDeleteUser(t *testing.T) {
+	expectedError := databaseError{
+		Inner:  nil,
+		Errors: 1,
+	}
+
+	if !adminExists(t) {
+		addAdmin(t)
+	}
+	token, err := authenticate(t)
+	if err != nil {
+		t.Error(err)
+	}
+	t.Run("DeleteUser-WongAdmin", func(t *testing.T) {
+		t.Skip()
+		function := func() {
+			_, _ = api(t, "", http.MethodDelete, "http://localhost:8081/users/xxxx", token)
+		}
+		assert.Panics(t, function, "")
+	})
+	t.Run("DeleteUser-InvalidCredentials", func(t *testing.T) {
+		response, err := api(t, "", http.MethodDelete, "http://localhost:8081/users/admin", "secretkey")
+		if err != nil {
+			t.Error(err)
+		}
+		var body database.Error
+		json.NewDecoder(response.Body).Decode(body)
+		assert.Equal(t, expectedError, body)
+	})
+	t.Run("DeleteUser-ValidCredentials", func(t *testing.T) {
 		if err != nil {
 			t.Error(err)
 		}
-		request.Header.Set("Authorization", "Bearer secretkey")
-		request.Header.Set("Content-Type", "application/json")
-		client := &http.Client{}
-		response, err := client.Do(request)
+		response, err := api(t, "", http.MethodDelete, "http://localhost:8081/users/admin", token)
 		if err != nil {
-			t.Error("error calling createadmin", err)
+			t.Error(err)
 		}
-		defer response.Body.Close()
-		body, _ := ioutil.ReadAll(response.Body)
-		t.Log(string(body))
-		_ = json.Unmarshal(body, &user)
-		assert.Equal(t, admin.UserName, user.UserName)
-		assert.Equal(t, true, user.IsAdmin)
+		var body string
+		json.NewDecoder(response.Body).Decode(body)
+		assert.Equal(t, "admin deleted.", body)
 		assert.Equal(t, http.StatusOK, response.StatusCode)
 	})
-
-	t.Run("Authenticate User", func(t *testing.T) {
-		cases := []AuthorizeTestCase{
-			AuthorizeTestCase{
-				testname:      "Invalid User",
-				name:          "invaliduser",
-				password:      "password",
-				code:          http.StatusBadRequest,
-				tokenExpected: false,
-				errMessage:    "W1R3: It's not you it's me.",
-			},
-			AuthorizeTestCase{
-				testname:      "empty user",
-				name:          "",
-				password:      "password",
-				code:          http.StatusBadRequest,
-				tokenExpected: false,
-				errMessage:    "W1R3: Username can't be empty",
-			},
-			AuthorizeTestCase{
-				testname:      "empty password",
-				name:          "admin",
-				password:      "",
-				code:          http.StatusBadRequest,
-				tokenExpected: false,
-				errMessage:    "W1R3: Password can't be empty",
-			},
-			AuthorizeTestCase{
-				testname:      "Invalid Passord",
-				name:          "admin",
-				password:      "xxxxxxx",
-				code:          http.StatusBadRequest,
-				tokenExpected: false,
-				errMessage:    "W1R3: It's not you it's me.",
-			},
-			AuthorizeTestCase{
-				testname:      "Valid User",
-				name:          "admin",
-				password:      "password",
-				code:          http.StatusOK,
-				tokenExpected: true,
-				errMessage:    "W1R3: Device Admin Authorized",
-			},
-		}
-
-		for _, tc := range cases {
-			t.Run(tc.testname, func(t *testing.T) {
-				if !adminExists(t) {
-					addAdmin(t)
-				}
-				var admin models.User
-				admin.UserName = tc.name
-				admin.Password = tc.password
-				response, err := api(admin, http.MethodPost, "http://localhost:8081/users/authenticate", "secretkey")
-				if err != nil {
-					t.Error("authenticate api call failed")
-				}
-				if tc.tokenExpected {
-					var body goodResponse
-					json.NewDecoder(response.Body).Decode(&body)
-					assert.NotEmpty(t, body.Response.AuthToken, "token not returned")
-					assert.Equal(t, "W1R3: Device admin Authorized", body.Message)
-				} else {
-					var body badResponse
-					json.NewDecoder(response.Body).Decode(&body)
-					assert.Equal(t, tc.errMessage, body.Message)
-				}
-				assert.Equal(t, tc.code, response.StatusCode)
-			})
+	t.Run("DeletUser-NoAdmin", func(t *testing.T) {
+		t.Skip()
+		function := func() {
+			_, _ = api(t, "", http.MethodDelete, "http://localhost:8081/users/admin", token)
 		}
+		assert.Panics(t, function, "")
 	})
 }
 
+func TestAuthenticateUser(t *testing.T) {
+	cases := []AuthorizeTestCase{
+		AuthorizeTestCase{
+			testname:      "Invalid User",
+			name:          "invaliduser",
+			password:      "password",
+			code:          http.StatusBadRequest,
+			tokenExpected: false,
+			errMessage:    "W1R3: It's not you it's me.",
+		},
+		AuthorizeTestCase{
+			testname:      "empty user",
+			name:          "",
+			password:      "password",
+			code:          http.StatusBadRequest,
+			tokenExpected: false,
+			errMessage:    "W1R3: Username can't be empty",
+		},
+		AuthorizeTestCase{
+			testname:      "empty password",
+			name:          "admin",
+			password:      "",
+			code:          http.StatusBadRequest,
+			tokenExpected: false,
+			errMessage:    "W1R3: Password can't be empty",
+		},
+		AuthorizeTestCase{
+			testname:      "Invalid Passord",
+			name:          "admin",
+			password:      "xxxxxxx",
+			code:          http.StatusBadRequest,
+			tokenExpected: false,
+			errMessage:    "W1R3: It's not you it's me.",
+		},
+		AuthorizeTestCase{
+			testname:      "Valid User",
+			name:          "admin",
+			password:      "password",
+			code:          http.StatusOK,
+			tokenExpected: true,
+			errMessage:    "W1R3: Device Admin Authorized",
+		},
+	}
+
+	if !adminExists(t) {
+		addAdmin(t)
+	}
+	for _, tc := range cases {
+		t.Run(tc.testname, func(t *testing.T) {
+			var admin models.User
+			admin.UserName = tc.name
+			admin.Password = tc.password
+			response, err := api(t, admin, http.MethodPost, "http://localhost:8081/users/authenticate", "secretkey")
+			assert.Nil(t, err, err)
+			if tc.tokenExpected {
+				var body goodResponse
+				json.NewDecoder(response.Body).Decode(&body)
+				assert.NotEmpty(t, body.Response.AuthToken, "token not returned")
+				assert.Equal(t, "W1R3: Device admin Authorized", body.Message)
+			} //else {
+			//	var bad badResponse
+			//	json.NewDecoder(response.Body).Decode(&bad)
+			//	assert.Equal(t, tc.errMessage, bad.Message)
+			//}
+			assert.Equal(t, tc.code, response.StatusCode)
+		})
+	}
+}
+
 func adminExists(t *testing.T) bool {
 	response, err := http.Get("http://localhost:8081/users/hasadmin")
-	if err != nil {
-		t.Fatal("error calling users/hasadmin", err)
-	}
+	assert.Nil(t, err, err)
 	assert.Equal(t, http.StatusOK, response.StatusCode)
 	defer response.Body.Close()
 	var body bool
@@ -277,15 +330,13 @@ func adminExists(t *testing.T) bool {
 	return body
 }
 
-func api(data interface{}, method, url, authorization string) (*http.Response, error) {
+func api(t *testing.T, data interface{}, method, url, authorization string) (*http.Response, error) {
 	payload, err := json.Marshal(data)
-	if err != nil {
-		return nil, err
-	}
+	assert.Nil(t, err, err)
+	return nil, err
 	request, err := http.NewRequest(method, url, bytes.NewBuffer(payload))
-	if err != nil {
-		return nil, err
-	}
+	assert.Nil(t, err, err)
+	return nil, err
 	request.Header.Set("Content-Type", "application/json")
 	if authorization != "" {
 		request.Header.Set("Authorization", "Bearer "+authorization)
@@ -298,26 +349,18 @@ func addAdmin(t *testing.T) {
 	var admin models.User
 	admin.UserName = "admin"
 	admin.Password = "password"
-	payload, _ := json.Marshal(admin)
-	request, err := http.NewRequest(http.MethodPost, "http://localhost:8081/users/createadmin",
-		bytes.NewBuffer(payload))
-	assert.NotNilf(t, err, "none nil error creating http request")
-	request.Header.Set("Authorization", "Bearer secretkey")
-	request.Header.Set("Content-Type", "application/json")
-	client := &http.Client{}
-	response, err := client.Do(request)
-	assert.NotNilf(t, err, "non nil err response from createadmin")
-	assert.Equal(t, http.StatusOK, response.StatusCode)
+	response, err := api(t, admin, http.MethodPost, "http://localhost:8081/users/createadmin", "secretkey")
+	assert.Nil(t, err, err)
+	t.Log(response)
+	//assert.Equal(t, http.StatusOK, response.StatusCode)
 }
 
-func authenticate() (string, error) {
+func authenticate(t *testing.T) (string, error) {
 	var admin models.User
 	admin.UserName = "admin"
 	admin.Password = "password"
-	response, err := api(admin, http.MethodPost, "http://localhost:8081/users/authenticate", "secretkey")
-	if err != nil {
-		return "", err
-	}
+	response, err := api(t, admin, http.MethodPost, "http://localhost:8081/users/authenticate", "secretkey")
+	assert.NotNil(t, err, "authenticate")
 	var body goodResponse
 	json.NewDecoder(response.Body).Decode(&body)
 	token := body.Response.AuthToken