mirror of
https://github.com/raseels-repos/golang-saas-starter-kit.git
synced 2025-06-06 23:46:29 +02:00
316 lines
8.6 KiB
Go
316 lines
8.6 KiB
Go
package tests
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"geeks-accelerator/oss/saas-starter-kit/example-project/cmd/web-api/handlers"
|
|
"geeks-accelerator/oss/saas-starter-kit/example-project/internal/account"
|
|
"geeks-accelerator/oss/saas-starter-kit/example-project/internal/platform/auth"
|
|
"geeks-accelerator/oss/saas-starter-kit/example-project/internal/platform/tests"
|
|
"geeks-accelerator/oss/saas-starter-kit/example-project/internal/platform/web"
|
|
"geeks-accelerator/oss/saas-starter-kit/example-project/internal/signup"
|
|
"geeks-accelerator/oss/saas-starter-kit/example-project/internal/user"
|
|
"geeks-accelerator/oss/saas-starter-kit/example-project/internal/user_account"
|
|
"github.com/google/go-cmp/cmp"
|
|
"github.com/iancoleman/strcase"
|
|
"github.com/pborman/uuid"
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
var a http.Handler
|
|
var test *tests.Test
|
|
var authenticator *auth.Authenticator
|
|
|
|
// Information about the users we have created for testing.
|
|
type roleTest struct {
|
|
Role string
|
|
Token user.Token
|
|
Claims auth.Claims
|
|
User mockUser
|
|
Account *account.Account
|
|
ForbiddenUser mockUser
|
|
ForbiddenAccount *account.Account
|
|
}
|
|
|
|
type requestTest struct {
|
|
name string
|
|
method string
|
|
url string
|
|
request interface{}
|
|
token user.Token
|
|
claims auth.Claims
|
|
statusCode int
|
|
error interface{}
|
|
}
|
|
|
|
var roleTests map[string]roleTest
|
|
|
|
func init() {
|
|
roleTests = make(map[string]roleTest)
|
|
}
|
|
|
|
// TestMain is the entry point for testing.
|
|
func TestMain(m *testing.M) {
|
|
os.Exit(testMain(m))
|
|
}
|
|
|
|
func testMain(m *testing.M) int {
|
|
test = tests.New()
|
|
defer test.TearDown()
|
|
|
|
now := time.Date(2018, time.October, 1, 0, 0, 0, 0, time.UTC)
|
|
|
|
var err error
|
|
authenticator, err = auth.NewAuthenticatorMemory(now)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
shutdown := make(chan os.Signal, 1)
|
|
|
|
log := test.Log
|
|
log.SetOutput(ioutil.Discard)
|
|
a = handlers.API(shutdown, log, test.MasterDB, nil, authenticator)
|
|
|
|
// Create a new account directly business logic. This creates an
|
|
// initial account and user that we will use for admin validated endpoints.
|
|
signupReq1 := mockSignupRequest()
|
|
signup1, err := signup.Signup(tests.Context(), auth.Claims{}, test.MasterDB, signupReq1, now)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
expires := time.Now().UTC().Sub(signup1.User.CreatedAt) + time.Hour
|
|
adminTkn, err := user.Authenticate(tests.Context(), test.MasterDB, authenticator, signupReq1.User.Email, signupReq1.User.Password, expires, now)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
adminClaims, err := authenticator.ParseClaims(adminTkn.AccessToken)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
// Create a second account that the first account user should not have access to.
|
|
signupReq2 := mockSignupRequest()
|
|
signup2, err := signup.Signup(tests.Context(), auth.Claims{}, test.MasterDB, signupReq2, now)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
// First test will be for role Admin
|
|
roleTests[auth.RoleAdmin] = roleTest{
|
|
Role: auth.RoleAdmin,
|
|
Token: adminTkn,
|
|
Claims: adminClaims,
|
|
User: mockUser{signup1.User, signupReq1.User.Password},
|
|
Account: signup1.Account,
|
|
ForbiddenUser: mockUser{signup2.User, signupReq2.User.Password},
|
|
ForbiddenAccount: signup2.Account,
|
|
}
|
|
|
|
// Create a regular user to use when calling regular validated endpoints.
|
|
userReq := user.UserCreateRequest{
|
|
Name: "Lucas Brown",
|
|
Email: uuid.NewRandom().String() + "@geeksinthewoods.com",
|
|
Password: "akTechFr0n!ier",
|
|
PasswordConfirm: "akTechFr0n!ier",
|
|
}
|
|
usr, err := user.Create(tests.Context(), adminClaims, test.MasterDB, userReq, now)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
_, err = user_account.Create(tests.Context(), adminClaims, test.MasterDB, user_account.UserAccountCreateRequest{
|
|
UserID: usr.ID,
|
|
AccountID: signup1.Account.ID,
|
|
Roles: []user_account.UserAccountRole{user_account.UserAccountRole_User},
|
|
// Status: use default value
|
|
}, now)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
userTkn, err := user.Authenticate(tests.Context(), test.MasterDB, authenticator, usr.Email, userReq.Password, expires, now)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
userClaims, err := authenticator.ParseClaims(userTkn.AccessToken)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
// Second test will be for role User
|
|
roleTests[auth.RoleUser] = roleTest{
|
|
Role: auth.RoleUser,
|
|
Token: userTkn,
|
|
Claims: userClaims,
|
|
Account: signup1.Account,
|
|
User: mockUser{usr, userReq.Password},
|
|
ForbiddenUser: mockUser{signup2.User, signupReq2.User.Password},
|
|
ForbiddenAccount: signup2.Account,
|
|
}
|
|
|
|
return m.Run()
|
|
}
|
|
|
|
// executeRequestTest provides request execution and basic response validation
|
|
func executeRequestTest(t *testing.T, tt requestTest, ctx context.Context) (*httptest.ResponseRecorder, bool) {
|
|
var req []byte
|
|
var rr io.Reader
|
|
if tt.request != nil {
|
|
var ok bool
|
|
req, ok = tt.request.([]byte)
|
|
if !ok {
|
|
var err error
|
|
req, err = json.Marshal(tt.request)
|
|
if err != nil {
|
|
t.Logf("\t\tGot err : %+v", err)
|
|
t.Logf("\t\tEncode request failed.")
|
|
return nil, false
|
|
}
|
|
}
|
|
rr = bytes.NewReader(req)
|
|
}
|
|
|
|
r := httptest.NewRequest(tt.method, tt.url, rr).WithContext(ctx)
|
|
|
|
w := httptest.NewRecorder()
|
|
|
|
r.Header.Set("Content-Type", web.MIMEApplicationJSONCharsetUTF8)
|
|
if tt.token.AccessToken != "" {
|
|
r.Header.Set("Authorization", tt.token.AuthorizationHeader())
|
|
}
|
|
|
|
a.ServeHTTP(w, r)
|
|
|
|
if w.Code != tt.statusCode {
|
|
t.Logf("\t\tRequest : %s\n", string(req))
|
|
t.Logf("\t\tBody : %s\n", w.Body.String())
|
|
t.Logf("\t\tShould receive a status code of %d for the response : %v", tt.statusCode, w.Code)
|
|
return w, false
|
|
}
|
|
|
|
if tt.error != nil {
|
|
var actual web.ErrorResponse
|
|
if err := json.Unmarshal(w.Body.Bytes(), &actual); err != nil {
|
|
t.Logf("\t\tBody : %s\n", w.Body.String())
|
|
t.Logf("\t\tGot error : %+v", err)
|
|
t.Logf("\t\tShould get the expected error.")
|
|
return w, false
|
|
}
|
|
|
|
if diff := cmp.Diff(actual, tt.error); diff != "" {
|
|
t.Logf("\t\tDiff : %s\n", diff)
|
|
t.Logf("\t\tShould get the expected error.")
|
|
return w, false
|
|
}
|
|
}
|
|
|
|
return w, true
|
|
}
|
|
|
|
// decodeMapToStruct used to covert map to json struct so don't have a bunch of raw json strings running around test files.
|
|
func decodeMapToStruct(expectedMap map[string]interface{}, expected interface{}) error {
|
|
expectedJson, err := json.Marshal(expectedMap)
|
|
if err != nil {
|
|
return errors.WithStack(err)
|
|
}
|
|
|
|
if err := json.Unmarshal([]byte(expectedJson), &expected); err != nil {
|
|
return errors.WithStack(err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// cmpDiff prints out the raw json to help with debugging.
|
|
func cmpDiff(t *testing.T, actual, expected interface{}) bool {
|
|
if actual == nil && expected == nil {
|
|
return false
|
|
}
|
|
if diff := cmp.Diff(actual, expected); diff != "" {
|
|
actualJSON, err := json.MarshalIndent(actual, "", " ")
|
|
if err != nil {
|
|
t.Fatalf("\t%s\tGot error : %+v", tests.Failed, err)
|
|
}
|
|
t.Logf("\t\tGot : %s\n", actualJSON)
|
|
|
|
expectedJSON, err := json.MarshalIndent(expected, "", " ")
|
|
if err != nil {
|
|
t.Fatalf("\t%s\tGot error : %+v", tests.Failed, err)
|
|
}
|
|
t.Logf("\t\tExpected : %s\n", expectedJSON)
|
|
|
|
t.Logf("\t\tDiff : %s\n", diff)
|
|
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func printResultMap(ctx context.Context, result []byte) {
|
|
var m map[string]interface{}
|
|
if err := json.Unmarshal(result, &m); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
fmt.Println(`map[string]interface{}{`)
|
|
printResultMapKeys(ctx, m, 1)
|
|
fmt.Println(`}`)
|
|
}
|
|
|
|
func printResultMapKeys(ctx context.Context, m map[string]interface{}, depth int) {
|
|
var isEnum bool
|
|
if m["value"] != nil && m["title"] != nil && m["options"] != nil {
|
|
isEnum = true
|
|
}
|
|
|
|
for k, kv := range m {
|
|
fn := strcase.ToCamel(k)
|
|
|
|
switch k {
|
|
case "created_at", "updated_at", "archived_at":
|
|
pv := fmt.Sprintf("web.NewTimeResponse(ctx, actual.%s)", fn)
|
|
fmt.Printf("%s\"%s\": %s,\n", strings.Repeat("\t", depth), k, pv)
|
|
continue
|
|
}
|
|
|
|
if sm, ok := kv.([]map[string]interface{}); ok {
|
|
fmt.Printf("%s\"%s\": []map[string]interface{}{\n", strings.Repeat("\t", depth), k)
|
|
|
|
for _, smv := range sm {
|
|
printResultMapKeys(ctx, smv, depth+1)
|
|
}
|
|
|
|
fmt.Printf("%s},\n", strings.Repeat("\t", depth))
|
|
} else if sm, ok := kv.(map[string]interface{}); ok {
|
|
fmt.Printf("%s\"%s\": map[string]interface{}{\n", strings.Repeat("\t", depth), k)
|
|
printResultMapKeys(ctx, sm, depth+1)
|
|
fmt.Printf("%s},\n", strings.Repeat("\t", depth))
|
|
} else {
|
|
var pv string
|
|
if isEnum {
|
|
jv, _ := json.Marshal(kv)
|
|
pv = string(jv)
|
|
} else {
|
|
pv = fmt.Sprintf("req.%s", fn)
|
|
}
|
|
|
|
fmt.Printf("%s\"%s\": %s,\n", strings.Repeat("\t", depth), k, pv)
|
|
}
|
|
}
|
|
}
|