mirror of
https://github.com/kevin-DL/services.git
synced 2026-01-13 03:25:32 +00:00
ben-toogood
668
users/handler/handler_test.go
Normal file
668
users/handler/handler_test.go
Normal file
@@ -0,0 +1,668 @@
|
||||
package handler_test
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"google.golang.org/protobuf/types/known/wrapperspb"
|
||||
|
||||
"github.com/micro/services/users/handler"
|
||||
pb "github.com/micro/services/users/proto"
|
||||
"gorm.io/driver/postgres"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
func testHandler(t *testing.T) *handler.Users {
|
||||
// connect to the database
|
||||
db, err := gorm.Open(postgres.Open("postgresql://postgres@localhost:5432/users?sslmode=disable"), &gorm.Config{})
|
||||
if err != nil {
|
||||
t.Fatalf("Error connecting to database: %v", err)
|
||||
}
|
||||
|
||||
// migrate the database
|
||||
if err := db.AutoMigrate(&handler.User{}, &handler.Token{}); err != nil {
|
||||
t.Fatalf("Error migrating database: %v", err)
|
||||
}
|
||||
|
||||
// clean any data from a previous run
|
||||
if err := db.Exec("TRUNCATE TABLE users, tokens CASCADE").Error; err != nil {
|
||||
t.Fatalf("Error cleaning database: %v", err)
|
||||
}
|
||||
|
||||
return &handler.Users{DB: db, Time: time.Now}
|
||||
}
|
||||
|
||||
func TestCreate(t *testing.T) {
|
||||
tt := []struct {
|
||||
Name string
|
||||
FirstName string
|
||||
LastName string
|
||||
Email string
|
||||
Password string
|
||||
Error error
|
||||
}{
|
||||
{
|
||||
Name: "MissingFirstName",
|
||||
LastName: "Doe",
|
||||
Email: "john@doe.com",
|
||||
Password: "password",
|
||||
Error: handler.ErrMissingFirstName,
|
||||
},
|
||||
{
|
||||
Name: "MissingLastName",
|
||||
FirstName: "John",
|
||||
Email: "john@doe.com",
|
||||
Password: "password",
|
||||
Error: handler.ErrMissingLastName,
|
||||
},
|
||||
{
|
||||
Name: "MissingEmail",
|
||||
FirstName: "John",
|
||||
LastName: "Doe",
|
||||
Password: "password",
|
||||
Error: handler.ErrMissingEmail,
|
||||
},
|
||||
{
|
||||
Name: "InvalidEmail",
|
||||
FirstName: "John",
|
||||
LastName: "Doe",
|
||||
Password: "password",
|
||||
Email: "foo.foo.foo",
|
||||
Error: handler.ErrInvalidEmail,
|
||||
},
|
||||
{
|
||||
Name: "InvalidPassword",
|
||||
FirstName: "John",
|
||||
LastName: "Doe",
|
||||
Email: "john@doe.com",
|
||||
Password: "pwd",
|
||||
Error: handler.ErrInvalidPassword,
|
||||
},
|
||||
}
|
||||
|
||||
// test the validations
|
||||
h := testHandler(t)
|
||||
for _, tc := range tt {
|
||||
t.Run(tc.Name, func(t *testing.T) {
|
||||
err := h.Create(context.TODO(), &pb.CreateRequest{
|
||||
FirstName: tc.FirstName,
|
||||
LastName: tc.LastName,
|
||||
Email: tc.Email,
|
||||
Password: tc.Password,
|
||||
}, &pb.CreateResponse{})
|
||||
assert.Equal(t, tc.Error, err)
|
||||
})
|
||||
}
|
||||
|
||||
t.Run("Valid", func(t *testing.T) {
|
||||
var rsp pb.CreateResponse
|
||||
req := pb.CreateRequest{
|
||||
FirstName: "John",
|
||||
LastName: "Doe",
|
||||
Email: "john@doe.com",
|
||||
Password: "passwordabc",
|
||||
}
|
||||
err := h.Create(context.TODO(), &req, &rsp)
|
||||
|
||||
assert.NoError(t, err)
|
||||
u := rsp.User
|
||||
if u == nil {
|
||||
t.Fatalf("No user returned")
|
||||
}
|
||||
assert.NotEmpty(t, u.Id)
|
||||
assert.Equal(t, req.FirstName, u.FirstName)
|
||||
assert.Equal(t, req.LastName, u.LastName)
|
||||
assert.Equal(t, req.Email, u.Email)
|
||||
assert.NotEmpty(t, rsp.Token)
|
||||
})
|
||||
|
||||
t.Run("DuplicateEmail", func(t *testing.T) {
|
||||
var rsp pb.CreateResponse
|
||||
req := pb.CreateRequest{
|
||||
FirstName: "John",
|
||||
LastName: "Doe",
|
||||
Email: "john@doe.com",
|
||||
Password: "passwordabc",
|
||||
}
|
||||
err := h.Create(context.TODO(), &req, &rsp)
|
||||
assert.Equal(t, handler.ErrDuplicateEmail, err)
|
||||
assert.Nil(t, rsp.User)
|
||||
})
|
||||
|
||||
t.Run("DifferentEmail", func(t *testing.T) {
|
||||
var rsp pb.CreateResponse
|
||||
req := pb.CreateRequest{
|
||||
FirstName: "John",
|
||||
LastName: "Doe",
|
||||
Email: "johndoe@gmail.com",
|
||||
Password: "passwordabc",
|
||||
}
|
||||
err := h.Create(context.TODO(), &req, &rsp)
|
||||
|
||||
assert.NoError(t, err)
|
||||
u := rsp.User
|
||||
if u == nil {
|
||||
t.Fatalf("No user returned")
|
||||
}
|
||||
assert.NotEmpty(t, u.Id)
|
||||
assert.Equal(t, req.FirstName, u.FirstName)
|
||||
assert.Equal(t, req.LastName, u.LastName)
|
||||
assert.Equal(t, req.Email, u.Email)
|
||||
})
|
||||
}
|
||||
|
||||
func TestRead(t *testing.T) {
|
||||
h := testHandler(t)
|
||||
|
||||
t.Run("MissingIDs", func(t *testing.T) {
|
||||
var rsp pb.ReadResponse
|
||||
err := h.Read(context.TODO(), &pb.ReadRequest{}, &rsp)
|
||||
assert.Equal(t, handler.ErrMissingIDs, err)
|
||||
assert.Nil(t, rsp.Users)
|
||||
})
|
||||
|
||||
t.Run("NotFound", func(t *testing.T) {
|
||||
var rsp pb.ReadResponse
|
||||
err := h.Read(context.TODO(), &pb.ReadRequest{Ids: []string{"foo"}}, &rsp)
|
||||
assert.Nil(t, err)
|
||||
if rsp.Users == nil {
|
||||
t.Fatal("Expected the users object to not be nil")
|
||||
}
|
||||
assert.Nil(t, rsp.Users["foo"])
|
||||
})
|
||||
|
||||
// create some mock data
|
||||
var rsp1 pb.CreateResponse
|
||||
req1 := pb.CreateRequest{
|
||||
FirstName: "John",
|
||||
LastName: "Doe",
|
||||
Email: "john@doe.com",
|
||||
Password: "passwordabc",
|
||||
}
|
||||
err := h.Create(context.TODO(), &req1, &rsp1)
|
||||
assert.NoError(t, err)
|
||||
if rsp1.User == nil {
|
||||
t.Fatal("No user returned")
|
||||
return
|
||||
}
|
||||
|
||||
var rsp2 pb.CreateResponse
|
||||
req2 := pb.CreateRequest{
|
||||
FirstName: "Apple",
|
||||
LastName: "Tree",
|
||||
Email: "apple@tree.com",
|
||||
Password: "passwordabc",
|
||||
}
|
||||
err = h.Create(context.TODO(), &req2, &rsp2)
|
||||
assert.NoError(t, err)
|
||||
if rsp2.User == nil {
|
||||
t.Fatal("No user returned")
|
||||
return
|
||||
}
|
||||
|
||||
// test the read
|
||||
var rsp pb.ReadResponse
|
||||
err = h.Read(context.TODO(), &pb.ReadRequest{
|
||||
Ids: []string{rsp1.User.Id, rsp2.User.Id},
|
||||
}, &rsp)
|
||||
assert.NoError(t, err)
|
||||
|
||||
if rsp.Users == nil {
|
||||
t.Fatal("Users not returned")
|
||||
return
|
||||
}
|
||||
assert.NotNil(t, rsp.Users[rsp1.User.Id])
|
||||
assert.NotNil(t, rsp.Users[rsp2.User.Id])
|
||||
|
||||
// check the users match
|
||||
if u := rsp.Users[rsp1.User.Id]; u != nil {
|
||||
assert.Equal(t, rsp1.User.Id, u.Id)
|
||||
assert.Equal(t, rsp1.User.FirstName, u.FirstName)
|
||||
assert.Equal(t, rsp1.User.LastName, u.LastName)
|
||||
assert.Equal(t, rsp1.User.Email, u.Email)
|
||||
}
|
||||
if u := rsp.Users[rsp2.User.Id]; u != nil {
|
||||
assert.Equal(t, rsp2.User.Id, u.Id)
|
||||
assert.Equal(t, rsp2.User.FirstName, u.FirstName)
|
||||
assert.Equal(t, rsp2.User.LastName, u.LastName)
|
||||
assert.Equal(t, rsp2.User.Email, u.Email)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUpdate(t *testing.T) {
|
||||
h := testHandler(t)
|
||||
|
||||
t.Run("MissingID", func(t *testing.T) {
|
||||
var rsp pb.UpdateResponse
|
||||
err := h.Update(context.TODO(), &pb.UpdateRequest{}, &rsp)
|
||||
assert.Equal(t, handler.ErrMissingID, err)
|
||||
assert.Nil(t, rsp.User)
|
||||
})
|
||||
|
||||
t.Run("NotFound", func(t *testing.T) {
|
||||
var rsp pb.UpdateResponse
|
||||
err := h.Update(context.TODO(), &pb.UpdateRequest{Id: "foo"}, &rsp)
|
||||
assert.Equal(t, handler.ErrNotFound, err)
|
||||
assert.Nil(t, rsp.User)
|
||||
})
|
||||
|
||||
// create some mock data
|
||||
var cRsp1 pb.CreateResponse
|
||||
cReq1 := pb.CreateRequest{
|
||||
FirstName: "John",
|
||||
LastName: "Doe",
|
||||
Email: "john@doe.com",
|
||||
Password: "passwordabc",
|
||||
}
|
||||
err := h.Create(context.TODO(), &cReq1, &cRsp1)
|
||||
assert.NoError(t, err)
|
||||
if cRsp1.User == nil {
|
||||
t.Fatal("No user returned")
|
||||
return
|
||||
}
|
||||
|
||||
var cRsp2 pb.CreateResponse
|
||||
cReq2 := pb.CreateRequest{
|
||||
FirstName: "John",
|
||||
LastName: "Doe",
|
||||
Email: "johndoe@gmail.com",
|
||||
Password: "passwordabc",
|
||||
}
|
||||
err = h.Create(context.TODO(), &cReq2, &cRsp2)
|
||||
assert.NoError(t, err)
|
||||
if cRsp2.User == nil {
|
||||
t.Fatal("No user returned")
|
||||
return
|
||||
}
|
||||
|
||||
t.Run("BlankFirstName", func(t *testing.T) {
|
||||
var rsp pb.UpdateResponse
|
||||
err := h.Update(context.TODO(), &pb.UpdateRequest{
|
||||
Id: cRsp1.User.Id, FirstName: &wrapperspb.StringValue{},
|
||||
}, &rsp)
|
||||
assert.Equal(t, handler.ErrMissingFirstName, err)
|
||||
assert.Nil(t, rsp.User)
|
||||
})
|
||||
|
||||
t.Run("BlankLastName", func(t *testing.T) {
|
||||
var rsp pb.UpdateResponse
|
||||
err := h.Update(context.TODO(), &pb.UpdateRequest{
|
||||
Id: cRsp1.User.Id, LastName: &wrapperspb.StringValue{},
|
||||
}, &rsp)
|
||||
assert.Equal(t, handler.ErrMissingLastName, err)
|
||||
assert.Nil(t, rsp.User)
|
||||
})
|
||||
|
||||
t.Run("BlankLastName", func(t *testing.T) {
|
||||
var rsp pb.UpdateResponse
|
||||
err := h.Update(context.TODO(), &pb.UpdateRequest{
|
||||
Id: cRsp1.User.Id, LastName: &wrapperspb.StringValue{},
|
||||
}, &rsp)
|
||||
assert.Equal(t, handler.ErrMissingLastName, err)
|
||||
assert.Nil(t, rsp.User)
|
||||
})
|
||||
|
||||
t.Run("BlankEmail", func(t *testing.T) {
|
||||
var rsp pb.UpdateResponse
|
||||
err := h.Update(context.TODO(), &pb.UpdateRequest{
|
||||
Id: cRsp1.User.Id, Email: &wrapperspb.StringValue{},
|
||||
}, &rsp)
|
||||
assert.Equal(t, handler.ErrMissingEmail, err)
|
||||
assert.Nil(t, rsp.User)
|
||||
})
|
||||
|
||||
t.Run("InvalidEmail", func(t *testing.T) {
|
||||
var rsp pb.UpdateResponse
|
||||
err := h.Update(context.TODO(), &pb.UpdateRequest{
|
||||
Id: cRsp1.User.Id, Email: &wrapperspb.StringValue{Value: "foo.bar"},
|
||||
}, &rsp)
|
||||
assert.Equal(t, handler.ErrInvalidEmail, err)
|
||||
assert.Nil(t, rsp.User)
|
||||
})
|
||||
|
||||
t.Run("EmailAlreadyExists", func(t *testing.T) {
|
||||
var rsp pb.UpdateResponse
|
||||
err := h.Update(context.TODO(), &pb.UpdateRequest{
|
||||
Id: cRsp1.User.Id, Email: &wrapperspb.StringValue{Value: cRsp2.User.Email},
|
||||
}, &rsp)
|
||||
assert.Equal(t, handler.ErrDuplicateEmail, err)
|
||||
assert.Nil(t, rsp.User)
|
||||
})
|
||||
|
||||
t.Run("Valid", func(t *testing.T) {
|
||||
uReq := pb.UpdateRequest{
|
||||
Id: cRsp1.User.Id,
|
||||
Email: &wrapperspb.StringValue{Value: "foobar@gmail.com"},
|
||||
FirstName: &wrapperspb.StringValue{Value: "Foo"},
|
||||
LastName: &wrapperspb.StringValue{Value: "Bar"},
|
||||
}
|
||||
var uRsp pb.UpdateResponse
|
||||
err := h.Update(context.TODO(), &uReq, &uRsp)
|
||||
assert.NoError(t, err)
|
||||
if uRsp.User == nil {
|
||||
t.Error("No user returned")
|
||||
return
|
||||
}
|
||||
assert.Equal(t, cRsp1.User.Id, uRsp.User.Id)
|
||||
assert.Equal(t, uReq.Email.Value, uRsp.User.Email)
|
||||
assert.Equal(t, uReq.FirstName.Value, uRsp.User.FirstName)
|
||||
assert.Equal(t, uReq.LastName.Value, uRsp.User.LastName)
|
||||
})
|
||||
}
|
||||
|
||||
func TestDelete(t *testing.T) {
|
||||
h := testHandler(t)
|
||||
|
||||
t.Run("MissingID", func(t *testing.T) {
|
||||
err := h.Delete(context.TODO(), &pb.DeleteRequest{}, &pb.DeleteResponse{})
|
||||
assert.Equal(t, handler.ErrMissingID, err)
|
||||
})
|
||||
|
||||
// create some mock data
|
||||
var cRsp pb.CreateResponse
|
||||
cReq := pb.CreateRequest{
|
||||
FirstName: "John",
|
||||
LastName: "Doe",
|
||||
Email: "john@doe.com",
|
||||
Password: "passwordabc",
|
||||
}
|
||||
err := h.Create(context.TODO(), &cReq, &cRsp)
|
||||
assert.NoError(t, err)
|
||||
if cRsp.User == nil {
|
||||
t.Fatal("No user returned")
|
||||
return
|
||||
}
|
||||
|
||||
t.Run("Valid", func(t *testing.T) {
|
||||
err := h.Delete(context.TODO(), &pb.DeleteRequest{
|
||||
Id: cRsp.User.Id,
|
||||
}, &pb.DeleteResponse{})
|
||||
assert.NoError(t, err)
|
||||
|
||||
// check it was actually deleted
|
||||
var rsp pb.ReadResponse
|
||||
err = h.Read(context.TODO(), &pb.ReadRequest{
|
||||
Ids: []string{cRsp.User.Id},
|
||||
}, &rsp)
|
||||
assert.NoError(t, err)
|
||||
assert.Nil(t, rsp.Users[cRsp.User.Id])
|
||||
})
|
||||
|
||||
t.Run("Retry", func(t *testing.T) {
|
||||
err := h.Delete(context.TODO(), &pb.DeleteRequest{
|
||||
Id: cRsp.User.Id,
|
||||
}, &pb.DeleteResponse{})
|
||||
assert.NoError(t, err)
|
||||
})
|
||||
}
|
||||
|
||||
func TestList(t *testing.T) {
|
||||
h := testHandler(t)
|
||||
|
||||
// create some mock data
|
||||
var cRsp1 pb.CreateResponse
|
||||
cReq1 := pb.CreateRequest{
|
||||
FirstName: "John",
|
||||
LastName: "Doe",
|
||||
Email: "john@doe.com",
|
||||
Password: "passwordabc",
|
||||
}
|
||||
err := h.Create(context.TODO(), &cReq1, &cRsp1)
|
||||
assert.NoError(t, err)
|
||||
if cRsp1.User == nil {
|
||||
t.Fatal("No user returned")
|
||||
return
|
||||
}
|
||||
|
||||
var cRsp2 pb.CreateResponse
|
||||
cReq2 := pb.CreateRequest{
|
||||
FirstName: "John",
|
||||
LastName: "Doe",
|
||||
Email: "johndoe@gmail.com",
|
||||
Password: "passwordabc",
|
||||
}
|
||||
err = h.Create(context.TODO(), &cReq2, &cRsp2)
|
||||
assert.NoError(t, err)
|
||||
if cRsp2.User == nil {
|
||||
t.Fatal("No user returned")
|
||||
return
|
||||
}
|
||||
|
||||
var rsp pb.ListResponse
|
||||
err = h.List(context.TODO(), &pb.ListRequest{}, &rsp)
|
||||
assert.NoError(t, err)
|
||||
if rsp.Users == nil {
|
||||
t.Error("No users returned")
|
||||
return
|
||||
}
|
||||
|
||||
var u1Found, u2Found bool
|
||||
for _, u := range rsp.Users {
|
||||
switch u.Id {
|
||||
case cRsp1.User.Id:
|
||||
assertUsersMatch(t, cRsp1.User, u)
|
||||
u1Found = true
|
||||
case cRsp2.User.Id:
|
||||
assertUsersMatch(t, cRsp2.User, u)
|
||||
u2Found = true
|
||||
default:
|
||||
t.Fatal("Unexpected user returned")
|
||||
return
|
||||
}
|
||||
}
|
||||
assert.True(t, u1Found)
|
||||
assert.True(t, u2Found)
|
||||
}
|
||||
|
||||
func TestLogin(t *testing.T) {
|
||||
h := testHandler(t)
|
||||
|
||||
// create some mock data
|
||||
var cRsp pb.CreateResponse
|
||||
cReq := pb.CreateRequest{
|
||||
FirstName: "John",
|
||||
LastName: "Doe",
|
||||
Email: "john@doe.com",
|
||||
Password: "passwordabc",
|
||||
}
|
||||
err := h.Create(context.TODO(), &cReq, &cRsp)
|
||||
assert.NoError(t, err)
|
||||
if cRsp.User == nil {
|
||||
t.Fatal("No user returned")
|
||||
return
|
||||
}
|
||||
|
||||
tt := []struct {
|
||||
Name string
|
||||
Email string
|
||||
Password string
|
||||
Error error
|
||||
User *pb.User
|
||||
}{
|
||||
{
|
||||
Name: "MissingEmail",
|
||||
Password: "passwordabc",
|
||||
Error: handler.ErrMissingEmail,
|
||||
},
|
||||
{
|
||||
Name: "MissingPassword",
|
||||
Email: "john@doe.com",
|
||||
Error: handler.ErrInvalidPassword,
|
||||
},
|
||||
{
|
||||
Name: "UserNotFound",
|
||||
Email: "foo@bar.com",
|
||||
Password: "passwordabc",
|
||||
Error: handler.ErrNotFound,
|
||||
},
|
||||
{
|
||||
Name: "IncorrectPassword",
|
||||
Email: "john@doe.com",
|
||||
Password: "passwordabcdef",
|
||||
Error: handler.ErrIncorrectPassword,
|
||||
},
|
||||
{
|
||||
Name: "Valid",
|
||||
Email: "john@doe.com",
|
||||
Password: "passwordabc",
|
||||
User: cRsp.User,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range tt {
|
||||
t.Run(tc.Name, func(t *testing.T) {
|
||||
var rsp pb.LoginResponse
|
||||
err := h.Login(context.TODO(), &pb.LoginRequest{
|
||||
Email: tc.Email, Password: tc.Password,
|
||||
}, &rsp)
|
||||
assert.Equal(t, tc.Error, err)
|
||||
|
||||
if tc.User != nil {
|
||||
assertUsersMatch(t, tc.User, rsp.User)
|
||||
assert.NotEmpty(t, rsp.Token)
|
||||
} else {
|
||||
assert.Nil(t, tc.User)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestLogout(t *testing.T) {
|
||||
h := testHandler(t)
|
||||
|
||||
t.Run("MissingUserID", func(t *testing.T) {
|
||||
err := h.Logout(context.TODO(), &pb.LogoutRequest{}, &pb.LogoutResponse{})
|
||||
assert.Equal(t, handler.ErrMissingID, err)
|
||||
})
|
||||
|
||||
t.Run("UserNotFound", func(t *testing.T) {
|
||||
err := h.Logout(context.TODO(), &pb.LogoutRequest{Id: uuid.New().String()}, &pb.LogoutResponse{})
|
||||
assert.Equal(t, handler.ErrNotFound, err)
|
||||
})
|
||||
|
||||
t.Run("Valid", func(t *testing.T) {
|
||||
// create some mock data
|
||||
var cRsp pb.CreateResponse
|
||||
cReq := pb.CreateRequest{
|
||||
FirstName: "John",
|
||||
LastName: "Doe",
|
||||
Email: "john@doe.com",
|
||||
Password: "passwordabc",
|
||||
}
|
||||
err := h.Create(context.TODO(), &cReq, &cRsp)
|
||||
assert.NoError(t, err)
|
||||
if cRsp.User == nil {
|
||||
t.Fatal("No user returned")
|
||||
return
|
||||
}
|
||||
|
||||
err = h.Logout(context.TODO(), &pb.LogoutRequest{Id: cRsp.User.Id}, &pb.LogoutResponse{})
|
||||
assert.NoError(t, err)
|
||||
|
||||
err = h.Validate(context.TODO(), &pb.ValidateRequest{Token: cRsp.Token}, &pb.ValidateResponse{})
|
||||
assert.Error(t, err)
|
||||
})
|
||||
}
|
||||
|
||||
func TestValidate(t *testing.T) {
|
||||
h := testHandler(t)
|
||||
|
||||
// create some mock data
|
||||
var cRsp1 pb.CreateResponse
|
||||
cReq1 := pb.CreateRequest{
|
||||
FirstName: "John",
|
||||
LastName: "Doe",
|
||||
Email: "john@doe.com",
|
||||
Password: "passwordabc",
|
||||
}
|
||||
err := h.Create(context.TODO(), &cReq1, &cRsp1)
|
||||
assert.NoError(t, err)
|
||||
if cRsp1.User == nil {
|
||||
t.Fatal("No user returned")
|
||||
return
|
||||
}
|
||||
|
||||
var cRsp2 pb.CreateResponse
|
||||
cReq2 := pb.CreateRequest{
|
||||
FirstName: "Barry",
|
||||
LastName: "Doe",
|
||||
Email: "barry@doe.com",
|
||||
Password: "passwordabc",
|
||||
}
|
||||
err = h.Create(context.TODO(), &cReq2, &cRsp2)
|
||||
assert.NoError(t, err)
|
||||
if cRsp2.User == nil {
|
||||
t.Fatal("No user returned")
|
||||
return
|
||||
}
|
||||
|
||||
tt := []struct {
|
||||
Name string
|
||||
Token string
|
||||
Time func() time.Time
|
||||
Error error
|
||||
User *pb.User
|
||||
}{
|
||||
{
|
||||
Name: "MissingToken",
|
||||
Error: handler.ErrMissingToken,
|
||||
},
|
||||
{
|
||||
Name: "InvalidToken",
|
||||
Error: handler.ErrInvalidToken,
|
||||
Token: uuid.New().String(),
|
||||
},
|
||||
{
|
||||
Name: "ExpiredToken",
|
||||
Error: handler.ErrTokenExpired,
|
||||
Token: cRsp1.Token,
|
||||
Time: func() time.Time { return time.Now().Add(time.Hour * 24 * 8) },
|
||||
},
|
||||
{
|
||||
Name: "ValidToken",
|
||||
User: cRsp2.User,
|
||||
Token: cRsp2.Token,
|
||||
Time: func() time.Time { return time.Now().Add(time.Hour * 24 * 3) },
|
||||
},
|
||||
{
|
||||
Name: "RefreshedToken",
|
||||
User: cRsp2.User,
|
||||
Token: cRsp2.Token,
|
||||
Time: func() time.Time { return time.Now().Add(time.Hour * 24 * 8) },
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range tt {
|
||||
t.Run(tc.Name, func(t *testing.T) {
|
||||
if tc.Time == nil {
|
||||
h.Time = time.Now
|
||||
} else {
|
||||
h.Time = tc.Time
|
||||
}
|
||||
|
||||
var rsp pb.ValidateResponse
|
||||
err := h.Validate(context.TODO(), &pb.ValidateRequest{Token: tc.Token}, &rsp)
|
||||
assert.Equal(t, tc.Error, err)
|
||||
|
||||
if tc.User != nil {
|
||||
assertUsersMatch(t, tc.User, rsp.User)
|
||||
} else {
|
||||
assert.Nil(t, tc.User)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func assertUsersMatch(t *testing.T, exp, act *pb.User) {
|
||||
if act == nil {
|
||||
t.Error("No user returned")
|
||||
return
|
||||
}
|
||||
assert.Equal(t, exp.Id, act.Id)
|
||||
assert.Equal(t, exp.FirstName, act.FirstName)
|
||||
assert.Equal(t, exp.LastName, act.LastName)
|
||||
assert.Equal(t, exp.Email, act.Email)
|
||||
}
|
||||
Reference in New Issue
Block a user