Skip to content
Snippets Groups Projects
Commit 5ccb0f64 authored by Fabian Seidl's avatar Fabian Seidl
Browse files

removed user and role stuff from suth.go in northbound/server and updated tests

parent e0714a54
No related branches found
No related tags found
1 merge request!308Improve test coverage of rbac stuff
This commit is part of merge request !308. Comments created here will be created in the context of that merge request.
...@@ -8,9 +8,7 @@ import ( ...@@ -8,9 +8,7 @@ import (
"code.fbi.h-da.de/danet/gosdn/controller/metrics" "code.fbi.h-da.de/danet/gosdn/controller/metrics"
"code.fbi.h-da.de/danet/gosdn/controller/rbac" "code.fbi.h-da.de/danet/gosdn/controller/rbac"
"code.fbi.h-da.de/danet/gosdn/controller/store" "code.fbi.h-da.de/danet/gosdn/controller/store"
"github.com/google/uuid"
"github.com/prometheus/client_golang/prometheus" "github.com/prometheus/client_golang/prometheus"
log "github.com/sirupsen/logrus"
"google.golang.org/grpc/codes" "google.golang.org/grpc/codes"
"google.golang.org/grpc/status" "google.golang.org/grpc/status"
) )
...@@ -87,145 +85,6 @@ func (s Auth) Logout(ctx context.Context, request *apb.LogoutRequest) (*apb.Logo ...@@ -87,145 +85,6 @@ func (s Auth) Logout(ctx context.Context, request *apb.LogoutRequest) (*apb.Logo
}, nil }, nil
} }
// CreateUsers creates new users, can be 1 or more
func (s Auth) CreateUsers(ctx context.Context, request *apb.CreateUsersRequest) (*apb.CreateUsersResponse, error) {
labels := prometheus.Labels{"service": "auth", "rpc": "post"}
start := metrics.StartHook(labels, grpcRequestsTotal)
defer metrics.FinishHook(labels, start, grpcRequestDurationSecondsTotal, grpcRequestDurationSeconds)
// TODO: implement check if user is allowed to create users with this role
// e.g. non-admin shouldn't be allowed to create admin users
for _, u := range request.User {
roles := map[string]string{}
for key, elem := range u.Roles {
_, err := uuid.Parse(key)
if err != nil {
return nil, handleRPCError(labels, err)
}
roles[key] = elem
}
user := rbac.NewUser(uuid.New(), u.Name, roles, u.Password, u.Token)
err := userc.Add(user)
if err != nil {
log.Error(err)
return nil, status.Errorf(codes.Aborted, "%v", err)
}
}
return &apb.CreateUsersResponse{
Timestamp: time.Now().UnixNano(),
Status: apb.Status_STATUS_OK,
}, nil
}
// GetUser returns one user by name.
func (s Auth) GetUser(ctx context.Context, request *apb.GetUserRequest) (*apb.GetUserResponse, error) {
labels := prometheus.Labels{"service": "auth", "rpc": "get"}
start := metrics.StartHook(labels, grpcRequestsTotal)
defer metrics.FinishHook(labels, start, grpcRequestDurationSecondsTotal, grpcRequestDurationSeconds)
// TODO: implement check if user is allowed to get this user data; only their own if not admin
userData, err := userc.Get(store.Query{Name: request.Name})
if err != nil {
return nil, err
}
user := &apb.User{
Id: userData.ID().String(),
Name: userData.Name(),
Roles: userData.GetRoles(),
}
return &apb.GetUserResponse{
Timestamp: time.Now().UnixNano(),
Status: apb.Status_STATUS_OK,
User: user,
}, nil
}
// GetUsers returns all availbale users
func (s Auth) GetUsers(ctx context.Context, request *apb.GetUsersRequest) (*apb.GetUsersResponse, error) {
labels := prometheus.Labels{"service": "auth", "rpc": "get"}
start := metrics.StartHook(labels, grpcRequestsTotal)
defer metrics.FinishHook(labels, start, grpcRequestDurationSecondsTotal, grpcRequestDurationSeconds)
userList, err := userc.GetAll()
if err != nil {
return nil, err
}
users := []*apb.User{}
for _, u := range userList {
users = append(users, &apb.User{
Id: u.ID().String(),
Name: u.Name(),
Roles: u.GetRoles(),
})
}
return &apb.GetUsersResponse{
Timestamp: time.Now().UnixNano(),
Status: apb.Status_STATUS_OK,
User: users,
}, nil
}
// UpdateUsers updates the user data of one or more users provided in the request
func (s Auth) UpdateUsers(ctx context.Context, request *apb.UpdateUsersRequest) (*apb.UpdateUsersResponse, error) {
labels := prometheus.Labels{"service": "auth", "rpc": "post"}
start := metrics.StartHook(labels, grpcRequestsTotal)
defer metrics.FinishHook(labels, start, grpcRequestDurationSecondsTotal, grpcRequestDurationSeconds)
// TODO: check if current user is allowed to update the user they try to update; only their own if not admin
for _, u := range request.User {
uid, err := uuid.Parse(u.Id)
if err != nil {
return nil, handleRPCError(labels, err)
}
_, err = userc.Get(store.Query{ID: uid})
if err != nil {
return nil, status.Errorf(codes.Canceled, "user not found %v", err)
}
userToUpdate := rbac.NewUser(uid, u.Name, u.Roles, u.Password, u.Token)
err = userc.Update(userToUpdate)
if err != nil {
return nil, status.Errorf(codes.Aborted, "could not update user %v", err)
}
}
return &apb.UpdateUsersResponse{
Timestamp: time.Now().UnixNano(),
Status: apb.Status_STATUS_OK,
}, nil
}
// DeleteUsers deletes one or more users provided in the request
func (s Auth) DeleteUsers(ctx context.Context, request *apb.DeleteUsersRequest) (*apb.DeleteUsersResponse, error) {
labels := prometheus.Labels{"service": "auth", "rpc": "delete"}
start := metrics.StartHook(labels, grpcRequestsTotal)
defer metrics.FinishHook(labels, start, grpcRequestDurationSecondsTotal, grpcRequestDurationSeconds)
for _, u := range request.Username {
userToDelete, err := userc.Get(store.Query{Name: u})
if err != nil {
return nil, status.Errorf(codes.Canceled, "user not found %v", err)
}
err = userc.Delete(userToDelete)
if err != nil {
return nil, status.Errorf(codes.Aborted, "error deleting user %v", err)
}
}
return &apb.DeleteUsersResponse{
Timestamp: time.Now().UnixNano(),
Status: apb.Status_STATUS_OK,
}, nil
}
func (s Auth) isValidUser(user rbac.User) (bool, error) { func (s Auth) isValidUser(user rbac.User) (bool, error) {
storedUser, err := userc.Get(store.Query{Name: user.Name()}) storedUser, err := userc.Get(store.Query{Name: user.Name()})
if err != nil { if err != nil {
...@@ -242,175 +101,3 @@ func (s Auth) isValidUser(user rbac.User) (bool, error) { ...@@ -242,175 +101,3 @@ func (s Auth) isValidUser(user rbac.User) (bool, error) {
return false, status.Errorf(codes.Unauthenticated, "incorrect user name or password") return false, status.Errorf(codes.Unauthenticated, "incorrect user name or password")
} }
// CreateRoles creates roles with permissions for the roles used in rbac.
func (s Auth) CreateRoles(ctx context.Context, request *apb.CreateRolesRequest) (*apb.CreateRolesResponse, error) {
labels := prometheus.Labels{"service": "auth", "rpc": "post"}
start := metrics.StartHook(labels, grpcRequestsTotal)
defer metrics.FinishHook(labels, start, grpcRequestDurationSecondsTotal, grpcRequestDurationSeconds)
for _, r := range request.Roles {
role := rbac.NewRole(uuid.New(), r.Name, r.Description, r.Permissions)
err := rolec.Add(role)
if err != nil {
log.Error(err)
return nil, status.Errorf(codes.Aborted, "%v", err)
}
}
return &apb.CreateRolesResponse{
Timestamp: time.Now().UnixNano(),
Status: apb.Status_STATUS_OK,
}, nil
}
// GetRole returns one role with its permissions found by name.
func (s Auth) GetRole(ctx context.Context, request *apb.GetRoleRequest) (*apb.GetRoleResponse, error) {
labels := prometheus.Labels{"service": "auth", "rpc": "get"}
start := metrics.StartHook(labels, grpcRequestsTotal)
defer metrics.FinishHook(labels, start, grpcRequestDurationSecondsTotal, grpcRequestDurationSeconds)
roleData, err := rolec.Get(store.Query{Name: request.RoleName})
if err != nil {
return nil, err
}
role := &apb.Role{
Id: roleData.ID().String(),
Name: roleData.Name(),
Description: roleData.GetDescription(),
Permissions: roleData.GetPermissions(),
}
return &apb.GetRoleResponse{
Timestamp: time.Now().UnixNano(),
Status: apb.Status_STATUS_OK,
Role: role,
}, nil
}
// GetRoles returns all roles with their permissions.
func (s Auth) GetRoles(ctx context.Context, request *apb.GetRolesRequest) (*apb.GetRolesResponse, error) {
labels := prometheus.Labels{"service": "auth", "rpc": "get"}
start := metrics.StartHook(labels, grpcRequestsTotal)
defer metrics.FinishHook(labels, start, grpcRequestDurationSecondsTotal, grpcRequestDurationSeconds)
roleList, err := rolec.GetAll()
if err != nil {
return nil, err
}
roles := []*apb.Role{}
for _, r := range roleList {
roles = append(roles, &apb.Role{
Id: r.ID().String(),
Name: r.Name(),
Description: r.GetDescription(),
Permissions: r.GetPermissions(),
})
}
return &apb.GetRolesResponse{
Timestamp: time.Now().UnixNano(),
Status: apb.Status_STATUS_OK,
Roles: roles,
}, nil
}
// UpdateRoles updates data of the provided roles.
func (s Auth) UpdateRoles(ctx context.Context, request *apb.UpdateRolesRequest) (*apb.UpdateRolesResponse, error) {
labels := prometheus.Labels{"service": "auth", "rpc": "post"}
start := metrics.StartHook(labels, grpcRequestsTotal)
defer metrics.FinishHook(labels, start, grpcRequestDurationSecondsTotal, grpcRequestDurationSeconds)
// TODO: check if current user is allowed to update the role they try to update; only their own if not admin
for _, r := range request.Roles {
rid, err := uuid.Parse(r.Id)
if err != nil {
return nil, handleRPCError(labels, err)
}
_, err = rolec.Get(store.Query{ID: rid})
if err != nil {
return nil, status.Errorf(codes.Canceled, "role not found %v", err)
}
roleToUpdate := rbac.NewRole(rid, r.Name, r.Description, r.Permissions)
err = rolec.Update(roleToUpdate)
if err != nil {
return nil, status.Errorf(codes.Aborted, "could not update role %v", err)
}
}
return &apb.UpdateRolesResponse{
Timestamp: time.Now().UnixNano(),
Status: apb.Status_STATUS_OK,
}, nil
}
// DeletePermissionsForRole deletes the provided permissions from one role found by name.
func (s Auth) DeletePermissionsForRole(ctx context.Context, request *apb.DeletePermissionsForRoleRequest) (*apb.DeletePermissionsForRoleResponse, error) {
labels := prometheus.Labels{"service": "auth", "rpc": "delete"}
start := metrics.StartHook(labels, grpcRequestsTotal)
defer metrics.FinishHook(labels, start, grpcRequestDurationSecondsTotal, grpcRequestDurationSeconds)
roleToUpdate, err := rolec.Get(store.Query{Name: request.RoleName})
if err != nil {
return nil, status.Errorf(codes.Canceled, "role not found %v", err)
}
// checks if there is at least one valid permission to delete
// in the provided set of permissions to delete
nonFound := true
for _, perm := range roleToUpdate.GetPermissions() {
for _, permToDelete := range request.PermissionsToDelete {
if perm == permToDelete {
nonFound = false
break
}
}
if !nonFound {
break
}
}
if nonFound {
return nil, status.Errorf(codes.Canceled, "no fitting permissions")
}
// updates the existing role with the trimmed set of permissions
roleToUpdate.RemovePermissionsFromRole(request.PermissionsToDelete)
err = rolec.Update(roleToUpdate)
if err != nil {
return nil, status.Errorf(codes.Aborted, "could not update role %v", err)
}
return &apb.DeletePermissionsForRoleResponse{
Timestamp: time.Now().UnixNano(),
Status: apb.Status_STATUS_OK,
}, nil
}
// DeleteRoles deletes all the provided roles with their permissions.
func (s Auth) DeleteRoles(ctx context.Context, request *apb.DeleteRolesRequest) (*apb.DeleteRolesResponse, error) {
labels := prometheus.Labels{"service": "auth", "rpc": "delete"}
start := metrics.StartHook(labels, grpcRequestsTotal)
defer metrics.FinishHook(labels, start, grpcRequestDurationSecondsTotal, grpcRequestDurationSeconds)
for _, r := range request.RoleName {
roleToDelete, err := rolec.Get(store.Query{Name: r})
if err != nil {
return nil, status.Errorf(codes.Canceled, "role not found")
}
err = rolec.Delete(roleToDelete)
if err != nil {
return nil, status.Errorf(codes.Aborted, "error deleting role %v", err)
}
}
return &apb.DeleteRolesResponse{
Timestamp: time.Now().UnixNano(),
Status: apb.Status_STATUS_OK,
}, nil
}
package server package server
import ( import (
"bytes"
"context" "context"
"log"
"reflect" "reflect"
"testing" "testing"
apb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/rbac" apb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/rbac"
"code.fbi.h-da.de/danet/gosdn/controller/rbac"
"github.com/google/uuid"
) )
const adminID = "5c248a22-8eb7-48cf-b392-45680a1863a5"
const userID = "57005d13-7a4d-493d-a02b-50ca51c40197"
const adminRoleID = "126683ae-5ff2-43ee-92f7-0e2b936f8c77"
const randomRoleName = "bertram"
var adminRoleMap = map[string]string{pndID: "admin"}
var userRoleMap = map[string]string{pndID: "user"}
var jwt *rbac.JWTManager
func TestAuth_Login(t *testing.T) { func TestAuth_Login(t *testing.T) {
type args struct { type args struct {
ctx context.Context ctx context.Context
...@@ -105,748 +92,3 @@ func TestAuth_Logout(t *testing.T) { ...@@ -105,748 +92,3 @@ func TestAuth_Logout(t *testing.T) {
}) })
} }
} }
func TestAuth_CreateUsers(t *testing.T) {
type args struct {
ctx context.Context
request *apb.CreateUsersRequest
}
tests := []struct {
name string
args args
want apb.Status
wantErr bool
}{
{
name: "default create users",
args: args{ctx: context.TODO(),
request: &apb.CreateUsersRequest{
User: []*apb.User{
{
Name: "asdf",
Roles: map[string]string{pndID: "asdf"},
Password: "asdf",
Token: "",
},
},
},
},
want: apb.Status_STATUS_OK,
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := Auth{}
got, err := s.CreateUsers(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("Auth.CreateUsers() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got.Status, tt.want) {
t.Errorf("Auth.CreateUsers() = %v, want %v", got, tt.want)
}
})
}
}
func TestAuth_GetUser(t *testing.T) {
patchLogger(t)
type args struct {
ctx context.Context
request *apb.GetUserRequest
}
tests := []struct {
name string
args args
want *apb.GetUserResponse
wantErr bool
}{
{
name: "default get user",
args: args{
ctx: context.TODO(),
request: &apb.GetUserRequest{
Name: "testAdmin",
},
},
want: &apb.GetUserResponse{Status: apb.Status_STATUS_OK,
User: &apb.User{Id: adminID,
Name: "testAdmin"}},
wantErr: false,
},
{
name: "fail get user",
args: args{
ctx: context.TODO(),
request: &apb.GetUserRequest{
Name: "nope",
},
},
want: nil,
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := Auth{}
got, err := s.GetUser(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("Auth.GetUser() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != nil && got.Status == tt.want.Status {
if got.User.Name != tt.want.User.Name || got.User.Id != tt.want.User.Id {
t.Errorf("Auth.GetUser() = %v, want %v", got, tt.want)
}
} else {
if got != nil {
t.Errorf("Auth.GetUser() = %v, want %v", got, tt.want)
}
}
})
}
}
func TestAuth_GetUsers(t *testing.T) {
err := clearAndCreateAuthTestSetup()
if err != nil {
t.Fatalf("%v", err)
}
type args struct {
ctx context.Context
request *apb.GetUsersRequest
}
tests := []struct {
name string
args args
want *apb.GetUsersResponse
wantLen int
wantErr bool
}{
{
name: "default get users",
args: args{ctx: context.TODO(),
request: &apb.GetUsersRequest{},
},
want: &apb.GetUsersResponse{Status: apb.Status_STATUS_OK,
User: []*apb.User{
{Name: "testAdmin"},
{Name: "testUser"},
{Name: "testRandom"}},
},
wantLen: 3,
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := Auth{}
got, err := s.GetUsers(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("Auth.GetUsers() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != nil && got.Status == apb.Status_STATUS_OK {
if len(got.User) != tt.wantLen {
t.Errorf("Auth.GetUsers() = %v, want %v", got, tt.want)
}
for _, gotU := range got.User {
containsExpected := false
for _, wantU := range tt.want.User {
if gotU.Name == wantU.Name {
containsExpected = true
break
}
}
if !containsExpected {
t.Errorf("Auth.GetUsers() = %v, want %v", got, tt.want)
}
}
}
})
}
}
func TestAuth_UpdateUsers(t *testing.T) {
type args struct {
ctx context.Context
request *apb.UpdateUsersRequest
}
tests := []struct {
name string
args args
want *apb.UpdateUsersResponse
wantErr bool
}{
{
name: "default update user",
args: args{ctx: context.TODO(),
request: &apb.UpdateUsersRequest{User: []*apb.User{
{Id: adminID,
Name: "sth Else"},
},
},
},
want: &apb.UpdateUsersResponse{
Status: apb.Status_STATUS_OK},
wantErr: false,
},
{
name: "error update user",
args: args{ctx: context.TODO(),
request: &apb.UpdateUsersRequest{User: []*apb.User{
{Id: uuid.NewString(),
Name: "not a user"},
},
},
},
want: nil,
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := Auth{}
got, err := s.UpdateUsers(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("Auth.UpdateUsers() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != nil && got.Status != tt.want.Status {
t.Errorf("Auth.UpdateUsers() = %v, want %v", got, tt.want)
}
})
}
}
func TestAuth_DeleteUsers(t *testing.T) {
type args struct {
ctx context.Context
request *apb.DeleteUsersRequest
}
tests := []struct {
name string
args args
want *apb.DeleteUsersResponse
wantErr bool
}{
{
name: "default delete users",
args: args{ctx: context.TODO(),
request: &apb.DeleteUsersRequest{Username: []string{"testUser"}},
},
want: &apb.DeleteUsersResponse{Status: apb.Status_STATUS_OK},
wantErr: false,
},
{
name: "error delete users",
args: args{ctx: context.TODO(),
request: &apb.DeleteUsersRequest{Username: []string{"no user"}},
},
want: &apb.DeleteUsersResponse{Status: apb.Status_STATUS_OK},
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := Auth{}
got, err := s.DeleteUsers(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("Auth.DeleteUsers() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != nil && got.Status != tt.want.Status {
t.Errorf("Auth.DeleteUsers() = %v, want %v", got, tt.want)
}
})
}
}
func TestAuth_CreateRoles(t *testing.T) {
type args struct {
ctx context.Context
request *apb.CreateRolesRequest
}
tests := []struct {
name string
args args
want *apb.CreateRolesResponse
wantErr bool
}{
{
name: "default create roles",
args: args{ctx: context.TODO(),
request: &apb.CreateRolesRequest{
Roles: []*apb.Role{
{
Name: "new role 1",
Description: "Role 1",
Permissions: []string{"permission 1", "permission 2"},
},
},
},
},
want: &apb.CreateRolesResponse{Status: apb.Status_STATUS_OK},
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := Auth{}
got, err := s.CreateRoles(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("Auth.CreateRoles() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != nil && got.Status != tt.want.Status {
t.Errorf("Auth.CreateRoles() = %v, want %v", got, tt.want)
}
})
}
}
func TestAuth_GetRole(t *testing.T) {
type args struct {
ctx context.Context
request *apb.GetRoleRequest
}
tests := []struct {
name string
args args
want *apb.GetRoleResponse
wantErr bool
}{
{
name: "default get role",
args: args{
ctx: context.TODO(),
request: &apb.GetRoleRequest{
RoleName: "adminTestRole",
},
},
want: &apb.GetRoleResponse{
Role: &apb.Role{
Name: "adminTestRole",
Description: "Admin",
},
Status: apb.Status_STATUS_OK,
},
wantErr: false,
},
{
name: "error get role",
args: args{
ctx: context.TODO(),
request: &apb.GetRoleRequest{
RoleName: "not role",
},
},
want: nil,
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := Auth{}
got, err := s.GetRole(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("Auth.GetRole() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != nil && got.Status == tt.want.Status {
if got.Role.Name != tt.want.Role.Name || got.Role.Description != tt.want.Role.Description {
t.Errorf("Auth.GetRole() = %v, want %v", got, tt.want)
}
} else {
if got != nil {
t.Errorf("Auth.GetRole() = %v, want %v", got, tt.want)
}
}
})
}
}
func TestAuth_GetRoles(t *testing.T) {
err := clearAndCreateAuthTestSetup()
if err != nil {
t.Fatalf("%v", err)
}
type args struct {
ctx context.Context
request *apb.GetRolesRequest
}
tests := []struct {
name string
args args
want *apb.GetRolesResponse
wantLen int
wantErr bool
}{
{
name: "default get roles",
args: args{
ctx: context.TODO(),
request: &apb.GetRolesRequest{},
},
want: &apb.GetRolesResponse{
Status: apb.Status_STATUS_OK,
Roles: []*apb.Role{
{
Name: "adminTestRole",
Description: "Admin",
Permissions: []string{
"/gosdn.core.CoreService/GetPnd",
"/gosdn.core.CoreService/GetPndList",
}},
{
Name: "userTestRole",
Description: "User",
Permissions: []string{
"/gosdn.pnd.PndService/GetChangeList",
}},
{
Name: randomRoleName,
Description: "Not a role",
Permissions: []string{
"nope",
},
},
},
},
wantLen: 3,
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := Auth{}
got, err := s.GetRoles(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("Auth.GetRoles() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != nil && got.Status == tt.want.Status {
if len(got.Roles) != 3 {
t.Errorf("Auth.GetRoles() = %v, want %v", got, tt.want)
}
for _, gotR := range got.Roles {
containsExpected := false
for _, wantR := range tt.want.Roles {
gotPerm := gotR.Permissions
wantPerm := wantR.Permissions
if gotR.Description == wantR.Description && gotR.Name == wantR.Name &&
reflect.DeepEqual(gotPerm, wantPerm) {
containsExpected = true
break
}
}
if !containsExpected {
t.Errorf("Auth.GetRoles() = %v, want %v", got, tt.want)
}
}
}
})
}
}
func TestAuth_UpdateRoles(t *testing.T) {
type args struct {
ctx context.Context
request *apb.UpdateRolesRequest
}
tests := []struct {
name string
args args
want *apb.UpdateRolesResponse
wantErr bool
}{
{
name: "default update roles",
args: args{
ctx: context.TODO(),
request: &apb.UpdateRolesRequest{
Roles: []*apb.Role{
{
Id: adminRoleID,
Name: "New Name",
},
},
},
},
want: &apb.UpdateRolesResponse{
Status: apb.Status_STATUS_OK,
},
wantErr: false,
},
{
name: "error update roles",
args: args{
ctx: context.TODO(),
request: &apb.UpdateRolesRequest{
Roles: []*apb.Role{
{
Id: uuid.NewString(),
Name: "New Name",
},
},
},
},
want: nil,
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := Auth{}
got, err := s.UpdateRoles(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("Auth.UpdateRoles() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != nil && got.Status != tt.want.Status {
t.Errorf("Auth.UpdateRoles() = %v, want %v", got, tt.want)
}
})
}
}
func TestAuth_DeletePermissionsForRole(t *testing.T) {
clearAndCreateAuthTestSetup()
type args struct {
ctx context.Context
request *apb.DeletePermissionsForRoleRequest
}
tests := []struct {
name string
args args
want *apb.DeletePermissionsForRoleResponse
wantErr bool
}{
{
name: "default delete permissions for role",
args: args{
ctx: context.TODO(),
request: &apb.DeletePermissionsForRoleRequest{
RoleName: "adminTestRole",
PermissionsToDelete: []string{
"/gosdn.core.CoreService/GetPnd",
"/gosdn.core.CoreService/GetPndList",
},
},
},
want: &apb.DeletePermissionsForRoleResponse{
Status: apb.Status_STATUS_OK,
},
wantErr: false,
},
{
name: "error delete permissions for role no proper permissions provided",
args: args{
ctx: context.TODO(),
request: &apb.DeletePermissionsForRoleRequest{
RoleName: "adminTestRole",
PermissionsToDelete: []string{
"no",
},
},
},
want: &apb.DeletePermissionsForRoleResponse{
Status: apb.Status_STATUS_OK,
},
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := Auth{}
got, err := s.DeletePermissionsForRole(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("Auth.DeletePermissionsForRole() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != nil && got.Status != tt.want.Status {
t.Errorf("Auth.DeletePermissionsForRole() = %v, want %v", got, tt.want)
}
})
}
}
func TestAuth_DeleteRoles(t *testing.T) {
type args struct {
ctx context.Context
request *apb.DeleteRolesRequest
}
tests := []struct {
name string
args args
want *apb.DeleteRolesResponse
wantErr bool
}{
{
name: "default delete roles",
args: args{
ctx: context.TODO(),
request: &apb.DeleteRolesRequest{
RoleName: []string{
"userTestRole",
},
},
},
want: &apb.DeleteRolesResponse{
Status: apb.Status_STATUS_OK,
},
wantErr: false,
},
{
name: "error delete roles",
args: args{
ctx: context.TODO(),
request: &apb.DeleteRolesRequest{
RoleName: []string{
"no",
},
},
},
want: &apb.DeleteRolesResponse{
Status: apb.Status_STATUS_OK,
},
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := Auth{}
got, err := s.DeleteRoles(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("Auth.DeleteRoles() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != nil && got.Status != tt.want.Status {
t.Errorf("Auth.DeleteRoles() = %v, want %v", got, tt.want)
}
})
}
}
func clearAndCreateAuthTestSetup() error {
//clear setup if changed
storedUsers, err := userc.GetAll()
if err != nil {
return err
}
for _, u := range storedUsers {
err = userc.Delete(u)
if err != nil {
return err
}
}
storedRoles, err := rolec.GetAll()
if err != nil {
return err
}
for _, r := range storedRoles {
err = rolec.Delete(r)
if err != nil {
return err
}
}
// create dataset
err = createTestUsers()
if err != nil {
return err
}
err = createTestRoles()
if err != nil {
return err
}
return nil
}
//TODO(faseid): change password to hashed/encrypted one
func createTestUsers() error {
randomRoleMap := map[string]string{pndID: randomRoleName}
users := []rbac.User{
{UserID: uuid.MustParse(adminID), UserName: "testAdmin", Roles: adminRoleMap, Password: "admin"},
{UserID: uuid.MustParse(userID), UserName: "testUser", Roles: userRoleMap, Password: "user"},
{UserID: uuid.New(), UserName: "testRandom", Roles: randomRoleMap, Password: "aurelius", Token: "wrong token"},
}
for _, u := range users {
err := userc.Add(rbac.NewUser(u.ID(), u.Name(), u.Roles, u.Password, ""))
if err != nil {
return err
}
}
return nil
}
func createTestRoles() error {
roles := []rbac.Role{
{
RoleID: uuid.MustParse(adminRoleID),
RoleName: "adminTestRole",
Description: "Admin",
Permissions: []string{
"/gosdn.core.CoreService/GetPnd",
"/gosdn.core.CoreService/GetPndList",
},
},
{
RoleID: uuid.New(),
RoleName: "userTestRole",
Description: "User",
Permissions: []string{
"/gosdn.pnd.PndService/GetChangeList",
},
},
{
RoleID: uuid.New(),
RoleName: randomRoleName,
Description: "Not a role",
Permissions: []string{
"nope",
},
},
}
for _, r := range roles {
err := rolec.Add(rbac.NewRole(r.ID(), r.Name(), r.Description, r.Permissions))
if err != nil {
return err
}
}
return nil
}
// This is needed as a workaround for a bug where the output of the getUser test falsely was
// that it failed while actually passing. Apparantely, this can happen when loggers write
// the output of test cases.
// Solution found here: https://github.com/gotestyourself/gotestsum/issues/141#issuecomment-686243110
func patchLogger(t *testing.T) {
orig := log.Writer()
buf := new(bytes.Buffer)
log.SetOutput(buf)
t.Cleanup(func() {
// optionally check t.Failed here if you only want to print logs on failure
t.Log(buf.String())
log.SetOutput(orig)
})
}
package server
import (
"context"
"reflect"
"testing"
apb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/rbac"
"github.com/google/uuid"
)
func TestRole_CreateRoles(t *testing.T) {
type args struct {
ctx context.Context
request *apb.CreateRolesRequest
}
tests := []struct {
name string
args args
want *apb.CreateRolesResponse
wantErr bool
}{
{
name: "default create roles",
args: args{ctx: context.TODO(),
request: &apb.CreateRolesRequest{
Roles: []*apb.Role{
{
Name: "new role 1",
Description: "Role 1",
Permissions: []string{"permission 1", "permission 2"},
},
},
},
},
want: &apb.CreateRolesResponse{Status: apb.Status_STATUS_OK},
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := Role{}
got, err := s.CreateRoles(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("Role.CreateRoles() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != nil && got.Status != tt.want.Status {
t.Errorf("Role.CreateRoles() = %v, want %v", got, tt.want)
}
})
}
}
func TestRole_GetRole(t *testing.T) {
type args struct {
ctx context.Context
request *apb.GetRoleRequest
}
tests := []struct {
name string
args args
want *apb.GetRoleResponse
wantErr bool
}{
{
name: "default get role",
args: args{
ctx: context.TODO(),
request: &apb.GetRoleRequest{
RoleName: "adminTestRole",
},
},
want: &apb.GetRoleResponse{
Role: &apb.Role{
Name: "adminTestRole",
Description: "Admin",
},
Status: apb.Status_STATUS_OK,
},
wantErr: false,
},
{
name: "error get role",
args: args{
ctx: context.TODO(),
request: &apb.GetRoleRequest{
RoleName: "not role",
},
},
want: nil,
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := Role{}
got, err := s.GetRole(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("Role.GetRole() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != nil && got.Status == tt.want.Status {
if got.Role.Name != tt.want.Role.Name || got.Role.Description != tt.want.Role.Description {
t.Errorf("Role.GetRole() = %v, want %v", got, tt.want)
}
} else {
if got != nil {
t.Errorf("Role.GetRole() = %v, want %v", got, tt.want)
}
}
})
}
}
func TestRole_GetRoles(t *testing.T) {
err := clearAndCreateAuthTestSetup()
if err != nil {
t.Fatalf("%v", err)
}
type args struct {
ctx context.Context
request *apb.GetRolesRequest
}
tests := []struct {
name string
args args
want *apb.GetRolesResponse
wantLen int
wantErr bool
}{
{
name: "default get roles",
args: args{
ctx: context.TODO(),
request: &apb.GetRolesRequest{},
},
want: &apb.GetRolesResponse{
Status: apb.Status_STATUS_OK,
Roles: []*apb.Role{
{
Name: "adminTestRole",
Description: "Admin",
Permissions: []string{
"/gosdn.core.CoreService/GetPnd",
"/gosdn.core.CoreService/GetPndList",
}},
{
Name: "userTestRole",
Description: "User",
Permissions: []string{
"/gosdn.pnd.PndService/GetChangeList",
}},
{
Name: randomRoleName,
Description: "Not a role",
Permissions: []string{
"nope",
},
},
},
},
wantLen: 3,
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := Role{}
got, err := s.GetRoles(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("Role.GetRoles() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != nil && got.Status == tt.want.Status {
if len(got.Roles) != 3 {
t.Errorf("Role.GetRoles() = %v, want %v", got, tt.want)
}
for _, gotR := range got.Roles {
containsExpected := false
for _, wantR := range tt.want.Roles {
gotPerm := gotR.Permissions
wantPerm := wantR.Permissions
if gotR.Description == wantR.Description && gotR.Name == wantR.Name &&
reflect.DeepEqual(gotPerm, wantPerm) {
containsExpected = true
break
}
}
if !containsExpected {
t.Errorf("Role.GetRoles() = %v, want %v", got, tt.want)
}
}
}
})
}
}
func TestRole_UpdateRoles(t *testing.T) {
type args struct {
ctx context.Context
request *apb.UpdateRolesRequest
}
tests := []struct {
name string
args args
want *apb.UpdateRolesResponse
wantErr bool
}{
{
name: "default update roles",
args: args{
ctx: context.TODO(),
request: &apb.UpdateRolesRequest{
Roles: []*apb.Role{
{
Id: adminRoleID,
Name: "New Name",
},
},
},
},
want: &apb.UpdateRolesResponse{
Status: apb.Status_STATUS_OK,
},
wantErr: false,
},
{
name: "error update roles",
args: args{
ctx: context.TODO(),
request: &apb.UpdateRolesRequest{
Roles: []*apb.Role{
{
Id: uuid.NewString(),
Name: "New Name",
},
},
},
},
want: nil,
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := Role{}
got, err := s.UpdateRoles(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("Role.UpdateRoles() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != nil && got.Status != tt.want.Status {
t.Errorf("Role.UpdateRoles() = %v, want %v", got, tt.want)
}
})
}
}
func TestRole_DeletePermissionsForRole(t *testing.T) {
clearAndCreateAuthTestSetup()
type args struct {
ctx context.Context
request *apb.DeletePermissionsForRoleRequest
}
tests := []struct {
name string
args args
want *apb.DeletePermissionsForRoleResponse
wantErr bool
}{
{
name: "default delete permissions for role",
args: args{
ctx: context.TODO(),
request: &apb.DeletePermissionsForRoleRequest{
RoleName: "adminTestRole",
PermissionsToDelete: []string{
"/gosdn.core.CoreService/GetPnd",
"/gosdn.core.CoreService/GetPndList",
},
},
},
want: &apb.DeletePermissionsForRoleResponse{
Status: apb.Status_STATUS_OK,
},
wantErr: false,
},
{
name: "error delete permissions for role no proper permissions provided",
args: args{
ctx: context.TODO(),
request: &apb.DeletePermissionsForRoleRequest{
RoleName: "adminTestRole",
PermissionsToDelete: []string{
"no",
},
},
},
want: &apb.DeletePermissionsForRoleResponse{
Status: apb.Status_STATUS_OK,
},
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := Role{}
got, err := s.DeletePermissionsForRole(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("Role.DeletePermissionsForRole() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != nil && got.Status != tt.want.Status {
t.Errorf("Role.DeletePermissionsForRole() = %v, want %v", got, tt.want)
}
})
}
}
func TestRole_DeleteRoles(t *testing.T) {
type args struct {
ctx context.Context
request *apb.DeleteRolesRequest
}
tests := []struct {
name string
args args
want *apb.DeleteRolesResponse
wantErr bool
}{
{
name: "default delete roles",
args: args{
ctx: context.TODO(),
request: &apb.DeleteRolesRequest{
RoleName: []string{
"userTestRole",
},
},
},
want: &apb.DeleteRolesResponse{
Status: apb.Status_STATUS_OK,
},
wantErr: false,
},
{
name: "error delete roles",
args: args{
ctx: context.TODO(),
request: &apb.DeleteRolesRequest{
RoleName: []string{
"no",
},
},
},
want: &apb.DeleteRolesResponse{
Status: apb.Status_STATUS_OK,
},
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := Role{}
got, err := s.DeleteRoles(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("Role.DeleteRoles() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != nil && got.Status != tt.want.Status {
t.Errorf("Role.DeleteRoles() = %v, want %v", got, tt.want)
}
})
}
}
package server
import (
"bytes"
"log"
"testing"
"code.fbi.h-da.de/danet/gosdn/controller/rbac"
"github.com/google/uuid"
)
// Name of this file requires _test at the end, because of how the availability of varibales is handled in test files of go packages.
// Does not include actual file tests!
const adminID = "5c248a22-8eb7-48cf-b392-45680a1863a5"
const userID = "57005d13-7a4d-493d-a02b-50ca51c40197"
const adminRoleID = "126683ae-5ff2-43ee-92f7-0e2b936f8c77"
const randomRoleName = "bertram"
var adminRoleMap = map[string]string{pndID: "admin"}
var userRoleMap = map[string]string{pndID: "user"}
var jwt *rbac.JWTManager
func clearAndCreateAuthTestSetup() error {
//clear setup if changed
storedUsers, err := userc.GetAll()
if err != nil {
return err
}
for _, u := range storedUsers {
err = userc.Delete(u)
if err != nil {
return err
}
}
storedRoles, err := rolec.GetAll()
if err != nil {
return err
}
for _, r := range storedRoles {
err = rolec.Delete(r)
if err != nil {
return err
}
}
// create dataset
err = createTestUsers()
if err != nil {
return err
}
err = createTestRoles()
if err != nil {
return err
}
return nil
}
//TODO(faseid): change password to hashed/encrypted one
func createTestUsers() error {
randomRoleMap := map[string]string{pndID: randomRoleName}
users := []rbac.User{
{UserID: uuid.MustParse(adminID), UserName: "testAdmin", Roles: adminRoleMap, Password: "admin"},
{UserID: uuid.MustParse(userID), UserName: "testUser", Roles: userRoleMap, Password: "user"},
{UserID: uuid.New(), UserName: "testRandom", Roles: randomRoleMap, Password: "aurelius", Token: "wrong token"},
}
for _, u := range users {
err := userc.Add(rbac.NewUser(u.ID(), u.Name(), u.Roles, u.Password, ""))
if err != nil {
return err
}
}
return nil
}
func createTestRoles() error {
roles := []rbac.Role{
{
RoleID: uuid.MustParse(adminRoleID),
RoleName: "adminTestRole",
Description: "Admin",
Permissions: []string{
"/gosdn.core.CoreService/GetPnd",
"/gosdn.core.CoreService/GetPndList",
},
},
{
RoleID: uuid.New(),
RoleName: "userTestRole",
Description: "User",
Permissions: []string{
"/gosdn.pnd.PndService/GetChangeList",
},
},
{
RoleID: uuid.New(),
RoleName: randomRoleName,
Description: "Not a role",
Permissions: []string{
"nope",
},
},
}
for _, r := range roles {
err := rolec.Add(rbac.NewRole(r.ID(), r.Name(), r.Description, r.Permissions))
if err != nil {
return err
}
}
return nil
}
// This is needed as a workaround for a bug where the output of the getUser test falsely was
// that it failed while actually passing. Apparantely, this can happen when loggers write
// the output of test cases.
// Solution found here: https://github.com/gotestyourself/gotestsum/issues/141#issuecomment-686243110
func patchLogger(t *testing.T) {
orig := log.Writer()
buf := new(bytes.Buffer)
log.SetOutput(buf)
t.Cleanup(func() {
// optionally check t.Failed here if you only want to print logs on failure
t.Log(buf.String())
log.SetOutput(orig)
})
}
package server
import (
"context"
"reflect"
"testing"
apb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/rbac"
"github.com/google/uuid"
)
func TestUser_CreateUsers(t *testing.T) {
type args struct {
ctx context.Context
request *apb.CreateUsersRequest
}
tests := []struct {
name string
args args
want apb.Status
wantErr bool
}{
{
name: "default create users",
args: args{ctx: context.TODO(),
request: &apb.CreateUsersRequest{
User: []*apb.User{
{
Name: "asdf",
Roles: map[string]string{pndID: "asdf"},
Password: "asdf",
Token: "",
},
},
},
},
want: apb.Status_STATUS_OK,
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := User{}
got, err := s.CreateUsers(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("User.CreateUsers() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got.Status, tt.want) {
t.Errorf("User.CreateUsers() = %v, want %v", got, tt.want)
}
})
}
}
func TestUser_GetUser(t *testing.T) {
patchLogger(t)
type args struct {
ctx context.Context
request *apb.GetUserRequest
}
tests := []struct {
name string
args args
want *apb.GetUserResponse
wantErr bool
}{
{
name: "default get user",
args: args{
ctx: context.TODO(),
request: &apb.GetUserRequest{
Name: "testAdmin",
},
},
want: &apb.GetUserResponse{Status: apb.Status_STATUS_OK,
User: &apb.User{Id: adminID,
Name: "testAdmin"}},
wantErr: false,
},
{
name: "fail get user",
args: args{
ctx: context.TODO(),
request: &apb.GetUserRequest{
Name: "nope",
},
},
want: nil,
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := User{}
got, err := s.GetUser(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("User.GetUser() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != nil && got.Status == tt.want.Status {
if got.User.Name != tt.want.User.Name || got.User.Id != tt.want.User.Id {
t.Errorf("User.GetUser() = %v, want %v", got, tt.want)
}
} else {
if got != nil {
t.Errorf("User.GetUser() = %v, want %v", got, tt.want)
}
}
})
}
}
func TestUser_GetUsers(t *testing.T) {
err := clearAndCreateAuthTestSetup()
if err != nil {
t.Fatalf("%v", err)
}
type args struct {
ctx context.Context
request *apb.GetUsersRequest
}
tests := []struct {
name string
args args
want *apb.GetUsersResponse
wantLen int
wantErr bool
}{
{
name: "default get users",
args: args{ctx: context.TODO(),
request: &apb.GetUsersRequest{},
},
want: &apb.GetUsersResponse{Status: apb.Status_STATUS_OK,
User: []*apb.User{
{Name: "testAdmin"},
{Name: "testUser"},
{Name: "testRandom"}},
},
wantLen: 3,
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := User{}
got, err := s.GetUsers(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("User.GetUsers() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != nil && got.Status == apb.Status_STATUS_OK {
if len(got.User) != tt.wantLen {
t.Errorf("User.GetUsers() = %v, want %v", got, tt.want)
}
for _, gotU := range got.User {
containsExpected := false
for _, wantU := range tt.want.User {
if gotU.Name == wantU.Name {
containsExpected = true
break
}
}
if !containsExpected {
t.Errorf("User.GetUsers() = %v, want %v", got, tt.want)
}
}
}
})
}
}
func TestUser_UpdateUsers(t *testing.T) {
type args struct {
ctx context.Context
request *apb.UpdateUsersRequest
}
tests := []struct {
name string
args args
want *apb.UpdateUsersResponse
wantErr bool
}{
{
name: "default update user",
args: args{ctx: context.TODO(),
request: &apb.UpdateUsersRequest{User: []*apb.User{
{Id: adminID,
Name: "sth Else"},
},
},
},
want: &apb.UpdateUsersResponse{
Status: apb.Status_STATUS_OK},
wantErr: false,
},
{
name: "error update user",
args: args{ctx: context.TODO(),
request: &apb.UpdateUsersRequest{User: []*apb.User{
{Id: uuid.NewString(),
Name: "not a user"},
},
},
},
want: nil,
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := User{}
got, err := s.UpdateUsers(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("User.UpdateUsers() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != nil && got.Status != tt.want.Status {
t.Errorf("User.UpdateUsers() = %v, want %v", got, tt.want)
}
})
}
}
func TestUser_DeleteUsers(t *testing.T) {
type args struct {
ctx context.Context
request *apb.DeleteUsersRequest
}
tests := []struct {
name string
args args
want *apb.DeleteUsersResponse
wantErr bool
}{
{
name: "default delete users",
args: args{ctx: context.TODO(),
request: &apb.DeleteUsersRequest{Username: []string{"testUser"}},
},
want: &apb.DeleteUsersResponse{Status: apb.Status_STATUS_OK},
wantErr: false,
},
{
name: "error delete users",
args: args{ctx: context.TODO(),
request: &apb.DeleteUsersRequest{Username: []string{"no user"}},
},
want: &apb.DeleteUsersResponse{Status: apb.Status_STATUS_OK},
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := User{}
got, err := s.DeleteUsers(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("User.DeleteUsers() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != nil && got.Status != tt.want.Status {
t.Errorf("User.DeleteUsers() = %v, want %v", got, tt.want)
}
})
}
}
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment