Merge branch 'main' into refactor/permissions-manager

management/server/networks/manager_test.go

@@ -6,7 +6,6 @@ import (
 
 	"github.com/stretchr/testify/require"
 
-	"github.com/netbirdio/netbird/management/internals/modules/permissions"
 	"github.com/netbirdio/netbird/management/server/groups"
 	"github.com/netbirdio/netbird/management/server/mock_server"
 	"github.com/netbirdio/netbird/management/server/networks/resources"
@@ -26,11 +25,10 @@ func Test_GetAllNetworksReturnsNetworks(t *testing.T) {
 	}
 	t.Cleanup(cleanUp)
 	am := mock_server.MockAccountManager{}
-	permissionsManager := permissions.NewManager(s)
 	groupsManager := groups.NewManagerMock()
 	routerManager := routers.NewManagerMock()
-	resourcesManager := resources.NewManager(s, permissionsManager, groupsManager, &am, nil)
-	manager := NewManager(s, permissionsManager, resourcesManager, routerManager, &am)
+	resourcesManager := resources.NewManager(s, groupsManager, &am, nil)
+	manager := NewManager(s, resourcesManager, routerManager, &am)
 
 	networks, err := manager.GetAllNetworks(ctx, accountID, userID)
 	require.NoError(t, err)
@@ -38,28 +36,6 @@ func Test_GetAllNetworksReturnsNetworks(t *testing.T) {
 	require.Equal(t, "testNetworkId", networks[0].ID)
 }
 
-func Test_GetAllNetworksReturnsPermissionDenied(t *testing.T) {
-	ctx := context.Background()
-	accountID := "testAccountId"
-	userID := "testUserId"
-
-	s, cleanUp, err := store.NewTestStoreFromSQL(context.Background(), "../testdata/networks.sql", t.TempDir())
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(cleanUp)
-	am := mock_server.MockAccountManager{}
-	permissionsManager := permissions.NewManager(s)
-	groupsManager := groups.NewManagerMock()
-	routerManager := routers.NewManagerMock()
-	resourcesManager := resources.NewManager(s, permissionsManager, groupsManager, &am, nil)
-	manager := NewManager(s, permissionsManager, resourcesManager, routerManager, &am)
-
-	networks, err := manager.GetAllNetworks(ctx, accountID, userID)
-	require.Error(t, err)
-	require.Nil(t, networks)
-}
-
 func Test_GetNetworkReturnsNetwork(t *testing.T) {
 	ctx := context.Background()
 	accountID := "testAccountId"
@@ -72,40 +48,16 @@ func Test_GetNetworkReturnsNetwork(t *testing.T) {
 	}
 	t.Cleanup(cleanUp)
 	am := mock_server.MockAccountManager{}
-	permissionsManager := permissions.NewManager(s)
 	groupsManager := groups.NewManagerMock()
 	routerManager := routers.NewManagerMock()
-	resourcesManager := resources.NewManager(s, permissionsManager, groupsManager, &am, nil)
-	manager := NewManager(s, permissionsManager, resourcesManager, routerManager, &am)
+	resourcesManager := resources.NewManager(s, groupsManager, &am, nil)
+	manager := NewManager(s, resourcesManager, routerManager, &am)
 
 	networks, err := manager.GetNetwork(ctx, accountID, userID, networkID)
 	require.NoError(t, err)
 	require.Equal(t, "testNetworkId", networks.ID)
 }
 
-func Test_GetNetworkReturnsPermissionDenied(t *testing.T) {
-	ctx := context.Background()
-	accountID := "testAccountId"
-	userID := "testUserId"
-	networkID := "testNetworkId"
-
-	s, cleanUp, err := store.NewTestStoreFromSQL(context.Background(), "../testdata/networks.sql", t.TempDir())
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(cleanUp)
-	am := mock_server.MockAccountManager{}
-	permissionsManager := permissions.NewManager(s)
-	groupsManager := groups.NewManagerMock()
-	routerManager := routers.NewManagerMock()
-	resourcesManager := resources.NewManager(s, permissionsManager, groupsManager, &am, nil)
-	manager := NewManager(s, permissionsManager, resourcesManager, routerManager, &am)
-
-	network, err := manager.GetNetwork(ctx, accountID, userID, networkID)
-	require.Error(t, err)
-	require.Nil(t, network)
-}
-
 func Test_CreateNetworkSuccessfully(t *testing.T) {
 	ctx := context.Background()
 	userID := "testAdminId"
@@ -120,42 +72,16 @@ func Test_CreateNetworkSuccessfully(t *testing.T) {
 	}
 	t.Cleanup(cleanUp)
 	am := mock_server.MockAccountManager{}
-	permissionsManager := permissions.NewManager(s)
 	groupsManager := groups.NewManagerMock()
 	routerManager := routers.NewManagerMock()
-	resourcesManager := resources.NewManager(s, permissionsManager, groupsManager, &am, nil)
-	manager := NewManager(s, permissionsManager, resourcesManager, routerManager, &am)
+	resourcesManager := resources.NewManager(s, groupsManager, &am, nil)
+	manager := NewManager(s, resourcesManager, routerManager, &am)
 
 	createdNetwork, err := manager.CreateNetwork(ctx, userID, network)
 	require.NoError(t, err)
 	require.Equal(t, network.Name, createdNetwork.Name)
 }
 
-func Test_CreateNetworkFailsWithPermissionDenied(t *testing.T) {
-	ctx := context.Background()
-	userID := "testUserId"
-	network := &types.Network{
-		AccountID: "testAccountId",
-		Name:      "new-network",
-	}
-
-	s, cleanUp, err := store.NewTestStoreFromSQL(context.Background(), "../testdata/networks.sql", t.TempDir())
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(cleanUp)
-	am := mock_server.MockAccountManager{}
-	permissionsManager := permissions.NewManager(s)
-	groupsManager := groups.NewManagerMock()
-	routerManager := routers.NewManagerMock()
-	resourcesManager := resources.NewManager(s, permissionsManager, groupsManager, &am, nil)
-	manager := NewManager(s, permissionsManager, resourcesManager, routerManager, &am)
-
-	createdNetwork, err := manager.CreateNetwork(ctx, userID, network)
-	require.Error(t, err)
-	require.Nil(t, createdNetwork)
-}
-
 func Test_DeleteNetworkSuccessfully(t *testing.T) {
 	ctx := context.Background()
 	accountID := "testAccountId"
@@ -168,38 +94,15 @@ func Test_DeleteNetworkSuccessfully(t *testing.T) {
 	}
 	t.Cleanup(cleanUp)
 	am := mock_server.MockAccountManager{}
-	permissionsManager := permissions.NewManager(s)
 	groupsManager := groups.NewManagerMock()
 	routerManager := routers.NewManagerMock()
-	resourcesManager := resources.NewManager(s, permissionsManager, groupsManager, &am, nil)
-	manager := NewManager(s, permissionsManager, resourcesManager, routerManager, &am)
+	resourcesManager := resources.NewManager(s, groupsManager, &am, nil)
+	manager := NewManager(s, resourcesManager, routerManager, &am)
 
 	err = manager.DeleteNetwork(ctx, accountID, userID, networkID)
 	require.NoError(t, err)
 }
 
-func Test_DeleteNetworkFailsWithPermissionDenied(t *testing.T) {
-	ctx := context.Background()
-	accountID := "testAccountId"
-	userID := "testUserId"
-	networkID := "testNetworkId"
-
-	s, cleanUp, err := store.NewTestStoreFromSQL(context.Background(), "../testdata/networks.sql", t.TempDir())
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(cleanUp)
-	am := mock_server.MockAccountManager{}
-	permissionsManager := permissions.NewManager(s)
-	groupsManager := groups.NewManagerMock()
-	routerManager := routers.NewManagerMock()
-	resourcesManager := resources.NewManager(s, permissionsManager, groupsManager, &am, nil)
-	manager := NewManager(s, permissionsManager, resourcesManager, routerManager, &am)
-
-	err = manager.DeleteNetwork(ctx, accountID, userID, networkID)
-	require.Error(t, err)
-}
-
 func Test_UpdateNetworkSuccessfully(t *testing.T) {
 	ctx := context.Background()
 	userID := "testAdminId"
@@ -215,40 +118,12 @@ func Test_UpdateNetworkSuccessfully(t *testing.T) {
 	}
 	t.Cleanup(cleanUp)
 	am := mock_server.MockAccountManager{}
-	permissionsManager := permissions.NewManager(s)
 	groupsManager := groups.NewManagerMock()
 	routerManager := routers.NewManagerMock()
-	resourcesManager := resources.NewManager(s, permissionsManager, groupsManager, &am, nil)
-	manager := NewManager(s, permissionsManager, resourcesManager, routerManager, &am)
+	resourcesManager := resources.NewManager(s, groupsManager, &am, nil)
+	manager := NewManager(s, resourcesManager, routerManager, &am)
 
 	updatedNetwork, err := manager.UpdateNetwork(ctx, userID, network)
 	require.NoError(t, err)
 	require.Equal(t, network.Name, updatedNetwork.Name)
 }
-
-func Test_UpdateNetworkFailsWithPermissionDenied(t *testing.T) {
-	ctx := context.Background()
-	userID := "testUserId"
-	network := &types.Network{
-		AccountID: "testAccountId",
-		ID:        "testNetworkId",
-		Name:      "new-network",
-	}
-
-	s, cleanUp, err := store.NewTestStoreFromSQL(context.Background(), "../testdata/networks.sql", t.TempDir())
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(cleanUp)
-
-	am := mock_server.MockAccountManager{}
-	permissionsManager := permissions.NewManager(s)
-	groupsManager := groups.NewManagerMock()
-	routerManager := routers.NewManagerMock()
-	resourcesManager := resources.NewManager(s, permissionsManager, groupsManager, &am, nil)
-	manager := NewManager(s, permissionsManager, resourcesManager, routerManager, &am)
-
-	updatedNetwork, err := manager.UpdateNetwork(ctx, userID, network)
-	require.Error(t, err)
-	require.Nil(t, updatedNetwork)
-}

management/server/networks/resources/manager_test.go

@@ -7,13 +7,11 @@ import (
 	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/require"
 
-	"github.com/netbirdio/netbird/management/internals/modules/permissions"
 	reverseproxy "github.com/netbirdio/netbird/management/internals/modules/reverseproxy/service"
 	"github.com/netbirdio/netbird/management/server/groups"
 	"github.com/netbirdio/netbird/management/server/mock_server"
 	"github.com/netbirdio/netbird/management/server/networks/resources/types"
 	"github.com/netbirdio/netbird/management/server/store"
-	"github.com/netbirdio/netbird/shared/management/status"
 )
 
 func Test_GetAllResourcesInNetworkReturnsResources(t *testing.T) {
@@ -27,41 +25,17 @@ func Test_GetAllResourcesInNetworkReturnsResources(t *testing.T) {
 		t.Fatal(err)
 	}
 	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(store)
 	am := mock_server.MockAccountManager{}
 	groupsManager := groups.NewManagerMock()
 	ctrl := gomock.NewController(t)
 	serviceManager := reverseproxy.NewMockManager(ctrl)
-	manager := NewManager(store, permissionsManager, groupsManager, &am, serviceManager)
+	manager := NewManager(store, groupsManager, &am, serviceManager)
 
 	resources, err := manager.GetAllResourcesInNetwork(ctx, accountID, userID, networkID)
 	require.NoError(t, err)
 	require.Len(t, resources, 2)
 }
 
-func Test_GetAllResourcesInNetworkReturnsPermissionDenied(t *testing.T) {
-	ctx := context.Background()
-	accountID := "testAccountId"
-	userID := "testUserId"
-	networkID := "testNetworkId"
-
-	store, cleanUp, err := store.NewTestStoreFromSQL(context.Background(), "../../testdata/networks.sql", t.TempDir())
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(store)
-	am := mock_server.MockAccountManager{}
-	groupsManager := groups.NewManagerMock()
-	ctrl := gomock.NewController(t)
-	serviceManager := reverseproxy.NewMockManager(ctrl)
-	manager := NewManager(store, permissionsManager, groupsManager, &am, serviceManager)
-
-	resources, err := manager.GetAllResourcesInNetwork(ctx, accountID, userID, networkID)
-	require.Error(t, err)
-	require.Equal(t, status.NewPermissionDeniedError(), err)
-	require.Nil(t, resources)
-}
 func Test_GetAllResourcesInAccountReturnsResources(t *testing.T) {
 	ctx := context.Background()
 	accountID := "testAccountId"
@@ -72,41 +46,17 @@ func Test_GetAllResourcesInAccountReturnsResources(t *testing.T) {
 		t.Fatal(err)
 	}
 	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(store)
 	am := mock_server.MockAccountManager{}
 	groupsManager := groups.NewManagerMock()
 	ctrl := gomock.NewController(t)
 	serviceManager := reverseproxy.NewMockManager(ctrl)
-	manager := NewManager(store, permissionsManager, groupsManager, &am, serviceManager)
+	manager := NewManager(store, groupsManager, &am, serviceManager)
 
 	resources, err := manager.GetAllResourcesInAccount(ctx, accountID, userID)
 	require.NoError(t, err)
 	require.Len(t, resources, 2)
 }
 
-func Test_GetAllResourcesInAccountReturnsPermissionDenied(t *testing.T) {
-	ctx := context.Background()
-	accountID := "testAccountId"
-	userID := "testUserId"
-
-	store, cleanUp, err := store.NewTestStoreFromSQL(context.Background(), "../../testdata/networks.sql", t.TempDir())
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(store)
-	am := mock_server.MockAccountManager{}
-	groupsManager := groups.NewManagerMock()
-	ctrl := gomock.NewController(t)
-	serviceManager := reverseproxy.NewMockManager(ctrl)
-	manager := NewManager(store, permissionsManager, groupsManager, &am, serviceManager)
-
-	resources, err := manager.GetAllResourcesInAccount(ctx, accountID, userID)
-	require.Error(t, err)
-	require.Equal(t, status.NewPermissionDeniedError(), err)
-	require.Nil(t, resources)
-}
-
 func Test_GetResourceInNetworkReturnsResources(t *testing.T) {
 	ctx := context.Background()
 	accountID := "testAccountId"
@@ -119,43 +69,17 @@ func Test_GetResourceInNetworkReturnsResources(t *testing.T) {
 		t.Fatal(err)
 	}
 	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(store)
 	am := mock_server.MockAccountManager{}
 	groupsManager := groups.NewManagerMock()
 	ctrl := gomock.NewController(t)
 	serviceManager := reverseproxy.NewMockManager(ctrl)
-	manager := NewManager(store, permissionsManager, groupsManager, &am, serviceManager)
+	manager := NewManager(store, groupsManager, &am, serviceManager)
 
 	resource, err := manager.GetResource(ctx, accountID, userID, networkID, resourceID)
 	require.NoError(t, err)
 	require.Equal(t, resourceID, resource.ID)
 }
 
-func Test_GetResourceInNetworkReturnsPermissionDenied(t *testing.T) {
-	ctx := context.Background()
-	accountID := "testAccountId"
-	userID := "testUserId"
-	networkID := "testNetworkId"
-	resourceID := "testResourceId"
-
-	store, cleanUp, err := store.NewTestStoreFromSQL(context.Background(), "../../testdata/networks.sql", t.TempDir())
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(store)
-	am := mock_server.MockAccountManager{}
-	groupsManager := groups.NewManagerMock()
-	ctrl := gomock.NewController(t)
-	serviceManager := reverseproxy.NewMockManager(ctrl)
-	manager := NewManager(store, permissionsManager, groupsManager, &am, serviceManager)
-
-	resources, err := manager.GetResource(ctx, accountID, userID, networkID, resourceID)
-	require.Error(t, err)
-	require.Equal(t, status.NewPermissionDeniedError(), err)
-	require.Nil(t, resources)
-}
-
 func Test_CreateResourceSuccessfully(t *testing.T) {
 	ctx := context.Background()
 	userID := "testAdminId"
@@ -172,48 +96,18 @@ func Test_CreateResourceSuccessfully(t *testing.T) {
 		t.Fatal(err)
 	}
 	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(store)
 	am := mock_server.MockAccountManager{}
 	groupsManager := groups.NewManagerMock()
 	ctrl := gomock.NewController(t)
 	serviceManager := reverseproxy.NewMockManager(ctrl)
 	serviceManager.EXPECT().ReloadAllServicesForAccount(gomock.Any(), resource.AccountID).Return(nil).AnyTimes()
-	manager := NewManager(store, permissionsManager, groupsManager, &am, serviceManager)
+	manager := NewManager(store, groupsManager, &am, serviceManager)
 
 	createdResource, err := manager.CreateResource(ctx, userID, resource)
 	require.NoError(t, err)
 	require.Equal(t, resource.Name, createdResource.Name)
 }
 
-func Test_CreateResourceFailsWithPermissionDenied(t *testing.T) {
-	ctx := context.Background()
-	userID := "testUserId"
-	resource := &types.NetworkResource{
-		AccountID:   "testAccountId",
-		NetworkID:   "testNetworkId",
-		Name:        "testResourceId",
-		Description: "description",
-		Address:     "192.168.1.1",
-	}
-
-	store, cleanUp, err := store.NewTestStoreFromSQL(context.Background(), "../../testdata/networks.sql", t.TempDir())
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(store)
-	am := mock_server.MockAccountManager{}
-	groupsManager := groups.NewManagerMock()
-	ctrl := gomock.NewController(t)
-	serviceManager := reverseproxy.NewMockManager(ctrl)
-	manager := NewManager(store, permissionsManager, groupsManager, &am, serviceManager)
-
-	createdResource, err := manager.CreateResource(ctx, userID, resource)
-	require.Error(t, err)
-	require.Equal(t, status.NewPermissionDeniedError(), err)
-	require.Nil(t, createdResource)
-}
-
 func Test_CreateResourceFailsWithInvalidAddress(t *testing.T) {
 	ctx := context.Background()
 	userID := "testAdminId"
@@ -230,12 +124,11 @@ func Test_CreateResourceFailsWithInvalidAddress(t *testing.T) {
 		t.Fatal(err)
 	}
 	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(store)
 	am := mock_server.MockAccountManager{}
 	groupsManager := groups.NewManagerMock()
 	ctrl := gomock.NewController(t)
 	serviceManager := reverseproxy.NewMockManager(ctrl)
-	manager := NewManager(store, permissionsManager, groupsManager, &am, serviceManager)
+	manager := NewManager(store, groupsManager, &am, serviceManager)
 
 	createdResource, err := manager.CreateResource(ctx, userID, resource)
 	require.Error(t, err)
@@ -258,12 +151,11 @@ func Test_CreateResourceFailsWithUsedName(t *testing.T) {
 		t.Fatal(err)
 	}
 	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(store)
 	am := mock_server.MockAccountManager{}
 	groupsManager := groups.NewManagerMock()
 	ctrl := gomock.NewController(t)
 	serviceManager := reverseproxy.NewMockManager(ctrl)
-	manager := NewManager(store, permissionsManager, groupsManager, &am, serviceManager)
+	manager := NewManager(store, groupsManager, &am, serviceManager)
 
 	createdResource, err := manager.CreateResource(ctx, userID, resource)
 	require.Error(t, err)
@@ -290,13 +182,12 @@ func Test_UpdateResourceSuccessfully(t *testing.T) {
 		t.Fatal(err)
 	}
 	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(store)
 	am := mock_server.MockAccountManager{}
 	groupsManager := groups.NewManagerMock()
 	ctrl := gomock.NewController(t)
 	serviceManager := reverseproxy.NewMockManager(ctrl)
 	serviceManager.EXPECT().ReloadAllServicesForAccount(gomock.Any(), accountID).Return(nil).AnyTimes()
-	manager := NewManager(store, permissionsManager, groupsManager, &am, serviceManager)
+	manager := NewManager(store, groupsManager, &am, serviceManager)
 
 	updatedResource, err := manager.UpdateResource(ctx, userID, resource)
 	require.NoError(t, err)
@@ -325,12 +216,11 @@ func Test_UpdateResourceFailsWithResourceNotFound(t *testing.T) {
 		t.Fatal(err)
 	}
 	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(store)
 	am := mock_server.MockAccountManager{}
 	groupsManager := groups.NewManagerMock()
 	ctrl := gomock.NewController(t)
 	serviceManager := reverseproxy.NewMockManager(ctrl)
-	manager := NewManager(store, permissionsManager, groupsManager, &am, serviceManager)
+	manager := NewManager(store, groupsManager, &am, serviceManager)
 
 	updatedResource, err := manager.UpdateResource(ctx, userID, resource)
 	require.Error(t, err)
@@ -357,43 +247,11 @@ func Test_UpdateResourceFailsWithNameInUse(t *testing.T) {
 		t.Fatal(err)
 	}
 	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(store)
 	am := mock_server.MockAccountManager{}
 	groupsManager := groups.NewManagerMock()
 	ctrl := gomock.NewController(t)
 	serviceManager := reverseproxy.NewMockManager(ctrl)
-	manager := NewManager(store, permissionsManager, groupsManager, &am, serviceManager)
-
-	updatedResource, err := manager.UpdateResource(ctx, userID, resource)
-	require.Error(t, err)
-	require.Nil(t, updatedResource)
-}
-
-func Test_UpdateResourceFailsWithPermissionDenied(t *testing.T) {
-	ctx := context.Background()
-	accountID := "testAccountId"
-	userID := "testUserId"
-	networkID := "testNetworkId"
-	resourceID := "testResourceId"
-	resource := &types.NetworkResource{
-		AccountID:   accountID,
-		NetworkID:   networkID,
-		Name:        resourceID,
-		Description: "new-description",
-		Address:     "1.2.3.0/24",
-	}
-
-	store, cleanUp, err := store.NewTestStoreFromSQL(context.Background(), "../../testdata/networks.sql", t.TempDir())
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(store)
-	am := mock_server.MockAccountManager{}
-	groupsManager := groups.NewManagerMock()
-	ctrl := gomock.NewController(t)
-	serviceManager := reverseproxy.NewMockManager(ctrl)
-	manager := NewManager(store, permissionsManager, groupsManager, &am, serviceManager)
+	manager := NewManager(store, groupsManager, &am, serviceManager)
 
 	updatedResource, err := manager.UpdateResource(ctx, userID, resource)
 	require.Error(t, err)
@@ -412,37 +270,13 @@ func Test_DeleteResourceSuccessfully(t *testing.T) {
 		t.Fatal(err)
 	}
 	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(store)
 	am := mock_server.MockAccountManager{}
 	groupsManager := groups.NewManagerMock()
 	ctrl := gomock.NewController(t)
 	serviceManager := reverseproxy.NewMockManager(ctrl)
 	serviceManager.EXPECT().GetServiceIDByTargetID(gomock.Any(), accountID, resourceID).Return("", nil).AnyTimes()
-	manager := NewManager(store, permissionsManager, groupsManager, &am, serviceManager)
+	manager := NewManager(store, groupsManager, &am, serviceManager)
 
 	err = manager.DeleteResource(ctx, accountID, userID, networkID, resourceID)
 	require.NoError(t, err)
 }
-
-func Test_DeleteResourceFailsWithPermissionDenied(t *testing.T) {
-	ctx := context.Background()
-	accountID := "testAccountId"
-	userID := "testUserId"
-	networkID := "testNetworkId"
-	resourceID := "testResourceId"
-
-	store, cleanUp, err := store.NewTestStoreFromSQL(context.Background(), "../../testdata/networks.sql", t.TempDir())
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(store)
-	am := mock_server.MockAccountManager{}
-	groupsManager := groups.NewManagerMock()
-	ctrl := gomock.NewController(t)
-	serviceManager := reverseproxy.NewMockManager(ctrl)
-	manager := NewManager(store, permissionsManager, groupsManager, &am, serviceManager)
-
-	err = manager.DeleteResource(ctx, accountID, userID, networkID, resourceID)
-	require.Error(t, err)
-}

management/server/networks/routers/manager_test.go

@@ -6,11 +6,9 @@ import (
 
 	"github.com/stretchr/testify/require"
 
-	"github.com/netbirdio/netbird/management/internals/modules/permissions"
 	"github.com/netbirdio/netbird/management/server/mock_server"
 	"github.com/netbirdio/netbird/management/server/networks/routers/types"
 	"github.com/netbirdio/netbird/management/server/store"
-	"github.com/netbirdio/netbird/shared/management/status"
 )
 
 func Test_GetAllRoutersInNetworkReturnsRouters(t *testing.T) {
@@ -24,9 +22,8 @@ func Test_GetAllRoutersInNetworkReturnsRouters(t *testing.T) {
 		t.Fatal(err)
 	}
 	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(s)
 	am := mock_server.MockAccountManager{}
-	manager := NewManager(s, permissionsManager, &am)
+	manager := NewManager(s, &am)
 
 	routers, err := manager.GetAllRoutersInNetwork(ctx, accountID, userID, networkID)
 	require.NoError(t, err)
@@ -34,27 +31,6 @@ func Test_GetAllRoutersInNetworkReturnsRouters(t *testing.T) {
 	require.Equal(t, "testRouterId", routers[0].ID)
 }
 
-func Test_GetAllRoutersInNetworkReturnsPermissionDenied(t *testing.T) {
-	ctx := context.Background()
-	accountID := "testAccountId"
-	userID := "testUserId"
-	networkID := "testNetworkId"
-
-	s, cleanUp, err := store.NewTestStoreFromSQL(context.Background(), "../../testdata/networks.sql", t.TempDir())
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(s)
-	am := mock_server.MockAccountManager{}
-	manager := NewManager(s, permissionsManager, &am)
-
-	routers, err := manager.GetAllRoutersInNetwork(ctx, accountID, userID, networkID)
-	require.Error(t, err)
-	require.Equal(t, status.NewPermissionDeniedError(), err)
-	require.Nil(t, routers)
-}
-
 func Test_GetRouterReturnsRouter(t *testing.T) {
 	ctx := context.Background()
 	accountID := "testAccountId"
@@ -67,37 +43,14 @@ func Test_GetRouterReturnsRouter(t *testing.T) {
 		t.Fatal(err)
 	}
 	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(s)
 	am := mock_server.MockAccountManager{}
-	manager := NewManager(s, permissionsManager, &am)
+	manager := NewManager(s, &am)
 
 	router, err := manager.GetRouter(ctx, accountID, userID, networkID, resourceID)
 	require.NoError(t, err)
 	require.Equal(t, "testRouterId", router.ID)
 }
 
-func Test_GetRouterReturnsPermissionDenied(t *testing.T) {
-	ctx := context.Background()
-	accountID := "testAccountId"
-	userID := "testUserId"
-	networkID := "testNetworkId"
-	resourceID := "testRouterId"
-
-	s, cleanUp, err := store.NewTestStoreFromSQL(context.Background(), "../../testdata/networks.sql", t.TempDir())
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(s)
-	am := mock_server.MockAccountManager{}
-	manager := NewManager(s, permissionsManager, &am)
-
-	router, err := manager.GetRouter(ctx, accountID, userID, networkID, resourceID)
-	require.Error(t, err)
-	require.Equal(t, status.NewPermissionDeniedError(), err)
-	require.Nil(t, router)
-}
-
 func Test_CreateRouterSuccessfully(t *testing.T) {
 	ctx := context.Background()
 	userID := "testAdminId"
@@ -111,9 +64,8 @@ func Test_CreateRouterSuccessfully(t *testing.T) {
 		t.Fatal(err)
 	}
 	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(s)
 	am := mock_server.MockAccountManager{}
-	manager := NewManager(s, permissionsManager, &am)
+	manager := NewManager(s, &am)
 
 	createdRouter, err := manager.CreateRouter(ctx, userID, router)
 	require.NoError(t, err)
@@ -124,29 +76,6 @@ func Test_CreateRouterSuccessfully(t *testing.T) {
 	require.Equal(t, router.Masquerade, createdRouter.Masquerade)
 }
 
-func Test_CreateRouterFailsWithPermissionDenied(t *testing.T) {
-	ctx := context.Background()
-	userID := "testUserId"
-	router, err := types.NewNetworkRouter("testAccountId", "testNetworkId", "testPeerId", []string{}, false, 9999, true)
-	if err != nil {
-		require.NoError(t, err)
-	}
-
-	s, cleanUp, err := store.NewTestStoreFromSQL(context.Background(), "../../testdata/networks.sql", t.TempDir())
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(s)
-	am := mock_server.MockAccountManager{}
-	manager := NewManager(s, permissionsManager, &am)
-
-	createdRouter, err := manager.CreateRouter(ctx, userID, router)
-	require.Error(t, err)
-	require.Equal(t, status.NewPermissionDeniedError(), err)
-	require.Nil(t, createdRouter)
-}
-
 func Test_DeleteRouterSuccessfully(t *testing.T) {
 	ctx := context.Background()
 	accountID := "testAccountId"
@@ -159,35 +88,13 @@ func Test_DeleteRouterSuccessfully(t *testing.T) {
 		t.Fatal(err)
 	}
 	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(s)
 	am := mock_server.MockAccountManager{}
-	manager := NewManager(s, permissionsManager, &am)
+	manager := NewManager(s, &am)
 
 	err = manager.DeleteRouter(ctx, accountID, userID, networkID, routerID)
 	require.NoError(t, err)
 }
 
-func Test_DeleteRouterFailsWithPermissionDenied(t *testing.T) {
-	ctx := context.Background()
-	accountID := "testAccountId"
-	userID := "testUserId"
-	networkID := "testNetworkId"
-	routerID := "testRouterId"
-
-	s, cleanUp, err := store.NewTestStoreFromSQL(context.Background(), "../../testdata/networks.sql", t.TempDir())
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(s)
-	am := mock_server.MockAccountManager{}
-	manager := NewManager(s, permissionsManager, &am)
-
-	err = manager.DeleteRouter(ctx, accountID, userID, networkID, routerID)
-	require.Error(t, err)
-	require.Equal(t, status.NewPermissionDeniedError(), err)
-}
-
 func Test_UpdateRouterSuccessfully(t *testing.T) {
 	ctx := context.Background()
 	userID := "testAdminId"
@@ -201,34 +108,10 @@ func Test_UpdateRouterSuccessfully(t *testing.T) {
 		t.Fatal(err)
 	}
 	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(s)
 	am := mock_server.MockAccountManager{}
-	manager := NewManager(s, permissionsManager, &am)
+	manager := NewManager(s, &am)
 
 	updatedRouter, err := manager.UpdateRouter(ctx, userID, router)
 	require.NoError(t, err)
 	require.Equal(t, router.Metric, updatedRouter.Metric)
 }
-
-func Test_UpdateRouterFailsWithPermissionDenied(t *testing.T) {
-	ctx := context.Background()
-	userID := "testUserId"
-	router, err := types.NewNetworkRouter("testAccountId", "testNetworkId", "testPeerId", []string{}, false, 1, true)
-	if err != nil {
-		require.NoError(t, err)
-	}
-
-	s, cleanUp, err := store.NewTestStoreFromSQL(context.Background(), "../../testdata/networks.sql", t.TempDir())
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(cleanUp)
-	permissionsManager := permissions.NewManager(s)
-	am := mock_server.MockAccountManager{}
-	manager := NewManager(s, permissionsManager, &am)
-
-	updatedRouter, err := manager.UpdateRouter(ctx, userID, router)
-	require.Error(t, err)
-	require.Equal(t, status.NewPermissionDeniedError(), err)
-	require.Nil(t, updatedRouter)
-}