eintopf.info@v0.13.16/service/group/authorizer_test.go

// Copyright (C) 2022 The Eintopf authors
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

package group_test

import (
	"context"
	"testing"

	"github.com/petergtz/pegomock"

	"eintopf.info/internal/mock"
	"eintopf.info/service/auth"
	"eintopf.info/service/group"
)

var (
	roleAdmin    = auth.RoleAdmin
	roleModertor = auth.RoleModerator
	roleNormal   = auth.RoleNormal
)

func TestAuthorizerCreate(t *testing.T) {
	for _, test := range []struct {
		name      string
		userID    string
		group     *group.NewGroup
		wantError error
	}{
		{
			name:      "UnauthorizedWithNoUserID",
			userID:    "",
			group:     &group.NewGroup{},
			wantError: auth.ErrUnauthorized,
		}, {
			name:      "AuthorizedWithUserID",
			userID:    "foo",
			group:     &group.NewGroup{},
			wantError: nil,
		},
	} {
		t.Run(test.name, func(tt *testing.T) {
			pegomock.RegisterMockTestingT(tt)
			ctx := auth.ContextWithID(context.Background(), test.userID)

			mockedService := mock.NewGroupService()
			authorizer := group.NewAuthorizer(mockedService)

			_, err := authorizer.Create(ctx, test.group)
			if err != test.wantError {
				tt.Errorf("err != test.wantError: %s != %s", err, test.wantError)
			}

			if test.wantError == nil {
				mockedService.VerifyWasCalledOnce().Create(ctx, test.group)
			}
		})
	}
}

func TestAuthorizerUpdate(t *testing.T) {
	for _, test := range []struct {
		name      string
		userID    string
		role      *auth.Role
		group     *group.Group
		wantError error
	}{
		{
			name:      "UnauthorizedWithNoUserIDAndRole",
			userID:    "",
			role:      nil,
			group:     &group.Group{},
			wantError: auth.ErrUnauthorized,
		}, {
			name:      "AuthorizedWithAdminRole",
			userID:    "foo",
			role:      &roleAdmin,
			group:     &group.Group{OwnedBy: []string{"bar"}},
			wantError: nil,
		}, {
			name:      "AuthorizedWithModeratorRole",
			userID:    "foo",
			role:      &roleModertor,
			group:     &group.Group{OwnedBy: []string{"bar"}},
			wantError: nil,
		}, {
			name:      "UnauthorizedWithNormalRoleNotOwned",
			userID:    "foo",
			role:      &roleNormal,
			group:     &group.Group{OwnedBy: []string{"bar"}},
			wantError: auth.ErrUnauthorized,
		}, {
			name:      "AuthorizedWithNormalRoleOwned",
			userID:    "bar",
			role:      &roleNormal,
			group:     &group.Group{OwnedBy: []string{"bar"}},
			wantError: nil,
		},
	} {
		t.Run(test.name, func(tt *testing.T) {
			pegomock.RegisterMockTestingT(tt)
			ctx := auth.ContextWithID(context.Background(), test.userID)
			if test.role != nil {
				ctx = auth.ContextWithRole(ctx, *test.role)
			}

			mockedService := mock.NewGroupService()
			pegomock.When(mockedService.FindByID(ctx, test.group.ID)).
				ThenReturn(test.group, nil)
			authorizer := group.NewAuthorizer(mockedService)

			_, err := authorizer.Update(ctx, test.group)
			if err != test.wantError {
				tt.Errorf("err != test.wantError: %s != %s", err, test.wantError)
			}

			if test.wantError == nil {
				mockedService.VerifyWasCalledOnce().Update(ctx, test.group)
			}
		})
	}
}

func TestAuthorizerDelete(t *testing.T) {
	for _, test := range []struct {
		name      string
		userID    string
		role      *auth.Role
		group     *group.Group
		wantError error
	}{
		{
			name:      "UnauthorizedWithNoUserIDAndRole",
			userID:    "",
			role:      nil,
			wantError: auth.ErrUnauthorized,
		}, {
			name:      "AuthorizedWithAdminRole",
			userID:    "foo",
			role:      &roleAdmin,
			wantError: nil,
		}, {
			name:      "UnauthorizedWithModeratorRoleNotOwned",
			userID:    "foo",
			role:      &roleModertor,
			wantError: auth.ErrUnauthorized,
		}, {
			name:      "AuthorizedWithModeratorRoleOwned",
			userID:    "bar",
			role:      &roleModertor,
			wantError: nil,
		}, {
			name:      "UnauthorizedWithNormalRoleNotOwned",
			userID:    "foo",
			role:      &roleNormal,
			wantError: auth.ErrUnauthorized,
		}, {
			name:      "AuthorizedWithNormalRoleOwned",
			userID:    "bar",
			role:      &roleNormal,
			wantError: nil,
		},
	} {
		t.Run(test.name, func(tt *testing.T) {
			pegomock.RegisterMockTestingT(tt)
			ctx := auth.ContextWithID(context.Background(), test.userID)
			if test.role != nil {
				ctx = auth.ContextWithRole(ctx, *test.role)
			}

			mockedService := mock.NewGroupService()
			pegomock.When(mockedService.FindByID(ctx, "foobar")).
				ThenReturn(&group.Group{OwnedBy: []string{"bar"}}, nil)
			authorizer := group.NewAuthorizer(mockedService)

			err := authorizer.Delete(ctx, "foobar")
			if err != test.wantError {
				tt.Errorf("err != test.wantError: %s != %s", err, test.wantError)
			}

			if test.wantError == nil {
				mockedService.VerifyWasCalledOnce().Delete(ctx, "foobar")
			}
		})
	}
}

func TestAuthorizerFind(t *testing.T) {
	for _, test := range []struct {
		name      string
		userID    string
		role      *auth.Role
		group     *group.Group
		wantError error
	}{
		{
			name:      "AuthorizedAll",
			userID:    "",
			role:      nil,
			wantError: nil,
		},
	} {
		t.Run(test.name, func(tt *testing.T) {
			pegomock.RegisterMockTestingT(tt)
			ctx := auth.ContextWithID(context.Background(), test.userID)
			if test.role != nil {
				ctx = auth.ContextWithRole(ctx, *test.role)
			}

			mockedService := mock.NewGroupService()
			authorizer := group.NewAuthorizer(mockedService)

			_, _, err := authorizer.Find(ctx, nil)
			if err != test.wantError {
				tt.Errorf("err != test.wantError: %s != %s", err, test.wantError)
			}

			if test.wantError == nil {
				mockedService.VerifyWasCalledOnce().Find(ctx, nil)
			}
		})
	}
}

func TestAuthorizerFindByID(t *testing.T) {
	for _, test := range []struct {
		name      string
		userID    string
		role      *auth.Role
		group     *group.Group
		wantError error
	}{
		{
			name:      "AuthorizedAll",
			userID:    "",
			role:      nil,
			wantError: nil,
		},
	} {
		t.Run(test.name, func(tt *testing.T) {
			pegomock.RegisterMockTestingT(tt)
			ctx := auth.ContextWithID(context.Background(), test.userID)
			if test.role != nil {
				ctx = auth.ContextWithRole(ctx, *test.role)
			}

			mockedService := mock.NewGroupService()
			authorizer := group.NewAuthorizer(mockedService)

			_, err := authorizer.FindByID(ctx, "")
			if err != test.wantError {
				tt.Errorf("err != test.wantError: %s != %s", err, test.wantError)
			}

			if test.wantError == nil {
				mockedService.VerifyWasCalledOnce().FindByID(ctx, "")
			}
		})
	}
}