renamed files for consistency, added util file for api tests, started adding user api tests

controller/api/apiUtil_test.go

+package api
+
+import (
+	rbacImpl "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"}
+
+func clearAndCreateAuthTestSetup() error {
+	//clear setup if changed
+	storedUsers, err := userService.GetAll()
+	if err != nil {
+		return err
+	}
+	for _, u := range storedUsers {
+		err = userService.Delete(u)
+		if err != nil {
+			return err
+		}
+	}
+
+	storedRoles, err := roleService.GetAll()
+	if err != nil {
+		return err
+	}
+	for _, r := range storedRoles {
+		err = roleService.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 := []rbacImpl.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 := userService.Add(rbacImpl.NewUser(u.ID(), u.Name(), u.Roles, u.Password, ""))
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func createTestRoles() error {
+	roles := []rbacImpl.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 := roleService.Add(rbacImpl.NewRole(r.ID(), r.Name(), r.Description, r.Permissions))
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

controller/api/auth_test.go

@@ -6,8 +6,6 @@ import (
 	"testing"
 
 	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"
 )
 
 func TestLogin(t *testing.T) {
@@ -38,12 +36,6 @@ func TestLogin(t *testing.T) {
 		},
 	}
 
-	err := userService.Add(&rbac.User{UserID: uuid.New(), UserName: "testAdmin", Roles: map[string]string{pndID: "admin"}, Password: "admin"})
-	if err != nil {
-		t.Errorf("Login() error = %v", err)
-		return
-	}
-
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			got, err := Login(tt.args.ctx, tt.args.addr, tt.args.username, tt.args.pwd)

controller/api/initialise_test.go

@@ -85,6 +85,7 @@ func bootstrapUnitTest() {
 	sbiStore = nucleus.NewSbiStore(pndUUID)
 	userService = rbacImpl.NewUserService(rbacImpl.NewMemoryUserStore())
 	roleService = rbacImpl.NewRoleService(rbacImpl.NewMemoryRoleStore())
+	clearAndCreateAuthTestSetup()
 
 	previousHostname := "previousHostname"
 	intendedHostname := "intendedHostname"
@@ -142,6 +143,8 @@ func bootstrapUnitTest() {
 	cpb.RegisterCoreServiceServer(s, northbound.Core)
 	ppb.RegisterPndServiceServer(s, northbound.Pnd)
 	apb.RegisterAuthServiceServer(s, northbound.Auth)
+	apb.RegisterUserServiceServer(s, northbound.User)
+	apb.RegisterRoleServiceServer(s, northbound.Role)
 
 	go func() {
 		if err := s.Serve(lis); err != nil {

controller/api/user_test.go

+package api
+
+import (
+	"context"
+	"reflect"
+	"testing"
+
+	apb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/rbac"
+)
+
+func TestCreateUsers(t *testing.T) {
+	type args struct {
+		ctx   context.Context
+		addr  string
+		users []*apb.User
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    apb.Status
+		wantErr bool
+	}{
+		{
+			name: "default create users",
+			args: args{
+				ctx:  context.TODO(),
+				addr: testAPIEndpoint,
+				users: []*apb.User{
+					{
+						Name:     "foo",
+						Roles:    map[string]string{pndID: "s"},
+						Password: "roh",
+						Token:    "da",
+					},
+				},
+			},
+			want:    apb.Status_STATUS_OK,
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := CreateUsers(tt.args.ctx, tt.args.addr, tt.args.users)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("CreateUsers() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got.Status, tt.want) {
+				t.Errorf("CreateUsers() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestGetUser(t *testing.T) {
+	type args struct {
+		ctx  context.Context
+		addr string
+		name string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    *apb.GetUserResponse
+		wantErr bool
+	}{
+		{
+			name: "default get user",
+			args: args{
+				ctx:  context.TODO(),
+				addr: testAPIEndpoint,
+				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(),
+				addr: testAPIEndpoint,
+				name: "foo",
+			},
+			want:    nil,
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := GetUser(tt.args.ctx, tt.args.addr, tt.args.name)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("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("GetUser() = %v, want %v", got, tt.want)
+				}
+			} else {
+				if got != nil {
+					t.Errorf("GetUser() = %v, want %v", got, tt.want)
+				}
+			}
+		})
+	}
+}
+
+func TestGetAllUsers(t *testing.T) {
+	type args struct {
+		ctx  context.Context
+		addr string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    *apb.GetUsersResponse
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := GetAllUsers(tt.args.ctx, tt.args.addr)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("GetAllUsers() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("GetAllUsers() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestUpdateUsers(t *testing.T) {
+	type args struct {
+		ctx   context.Context
+		addr  string
+		users []*apb.User
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    *apb.UpdateUsersResponse
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := UpdateUsers(tt.args.ctx, tt.args.addr, tt.args.users)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("UpdateUsers() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("UpdateUsers() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestDeleteUsers(t *testing.T) {
+	type args struct {
+		ctx       context.Context
+		addr      string
+		userNames []string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    *apb.DeleteUsersResponse
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := DeleteUsers(tt.args.ctx, tt.args.addr, tt.args.userNames)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("DeleteUsers() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("DeleteUsers() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}