@nocobase/plugin-acl 0.11.1-alpha.5 → 0.12.0-alpha.1

package/src/server/__tests__/own.test.ts

@@ -1,124 +0,0 @@
-import { ACL } from '@nocobase/acl';
-import { Database } from '@nocobase/database';
-import PluginUser from '@nocobase/plugin-users';
-import { MockServer } from '@nocobase/test';
-import { prepareApp } from './prepare';
-
-describe('own test', () => {
-  let app: MockServer;
-  let db: Database;
-  let acl: ACL;
-
-  let pluginUser: PluginUser;
-  let adminToken: string;
-  let userToken: string;
-
-  let admin;
-  let user;
-
-  let role;
-  let agent;
-  let adminAgent;
-  let userAgent;
-
-  afterEach(async () => {
-    await app.destroy();
-  });
-
-  beforeEach(async () => {
-    app = await prepareApp();
-    db = app.db;
-
-    const PostCollection = db.collection({
-      name: 'posts',
-      fields: [
-        { type: 'string', name: 'title' },
-        { type: 'belongsToMany', name: 'tags' },
-      ],
-      createdBy: true,
-    });
-
-    const TagCollection = db.collection({
-      name: 'tags',
-      fields: [
-        { type: 'string', name: 'name' },
-        { type: 'belongsToMany', name: 'posts' },
-      ],
-      createdBy: true,
-    });
-
-    const TestCollection = db.collection({
-      name: 'tests',
-      fields: [{ type: 'string', name: 'name' }],
-    });
-
-    await db.sync();
-
-    agent = app.agent();
-
-    acl = app.acl;
-
-    role = await db.getRepository('roles').findOne({
-      filter: {
-        name: 'admin',
-      },
-    });
-
-    admin = await db.getRepository('users').findOne();
-
-    pluginUser = app.getPlugin('users');
-
-    adminAgent = app.agent().login(admin);
-
-    user = await db.getRepository('users').create({
-      values: {
-        nickname: 'test',
-        roles: ['admin'],
-      },
-    });
-
-    userAgent = app.agent().login(user);
-  });
-
-  it('should list without createBy', async () => {
-    await adminAgent
-      .patch('/roles/admin')
-      .send({
-        strategy: {
-          actions: ['view:own'],
-        },
-      })
-      .set({ Authorization: 'Bearer ' + adminToken });
-
-    const response = await userAgent.get('/tests:list');
-    expect(response.statusCode).toEqual(200);
-  });
-
-  it('should delete with createdBy', async () => {
-    await adminAgent.resource('roles').update({
-      filterByTk: 'admin',
-      values: {
-        strategy: {
-          actions: ['view:own', 'create', 'destroy:own'],
-        },
-      },
-    });
-
-    let response = await userAgent.resource('posts').create({
-      values: {
-        title: 't1',
-      },
-    });
-
-    expect(response.statusCode).toEqual(200);
-
-    const data = response.body;
-    const id = data.data['id'];
-
-    response = await userAgent.resource('posts').destroy({
-      filterByTk: id,
-    });
-    expect(response.statusCode).toEqual(200);
-    expect(await db.getRepository('posts').count()).toEqual(0);
-  });
-});

package/src/server/__tests__/prepare.ts

@@ -1,20 +0,0 @@
-import { mockServer, MockServer } from '@nocobase/test';
-import PluginACL from '../../server';
-
-export async function prepareApp(): Promise<MockServer> {
-  const app = mockServer({
-    registerActions: true,
-    acl: true,
-    plugins: ['error-handler', 'users', 'ui-schema-storage', 'collection-manager', 'auth'],
-  });
-
-  app.plugin(PluginACL, {
-    name: 'acl',
-  });
-
-  await app.loadAndInstall({ clean: true });
-
-  await app.db.sync();
-
-  return app;
-}

package/src/server/__tests__/role-check.test.ts

@@ -1,46 +0,0 @@
-import { Database } from '@nocobase/database';
-import UsersPlugin from '@nocobase/plugin-users';
-import { MockServer } from '@nocobase/test';
-import { prepareApp } from './prepare';
-
-describe('role check action', () => {
-  let app: MockServer;
-  let db: Database;
-
-  beforeEach(async () => {
-    app = await prepareApp();
-    db = app.db;
-  });
-
-  afterEach(async () => {
-    await app.destroy();
-  });
-
-  it('should return role info', async () => {
-    const role = await db.getRepository('roles').create({
-      values: {
-        name: 'test',
-      },
-    });
-
-    await role.createMenuUiSchema({
-      values: {
-        name: 'test',
-      },
-    });
-
-    const user = await db.getRepository('users').create({
-      values: {
-        roles: ['test'],
-      },
-    });
-
-    const userPlugin = app.getPlugin('users') as UsersPlugin;
-    const agent = app.agent().login(user);
-
-    // @ts-ignore
-    const response = await agent.resource('roles').check();
-
-    expect(response.statusCode).toEqual(200);
-  });
-});

package/src/server/__tests__/role-resource.test.ts

@@ -1,177 +0,0 @@
-import { Database, Model } from '@nocobase/database';
-import { CollectionRepository } from '@nocobase/plugin-collection-manager';
-import UsersPlugin from '@nocobase/plugin-users';
-import { MockServer } from '@nocobase/test';
-import { prepareApp } from './prepare';
-
-describe('role resource api', () => {
-  let app: MockServer;
-  let db: Database;
-  let role: Model;
-  let admin;
-  let adminAgent;
-
-  afterEach(async () => {
-    await app.destroy();
-  });
-
-  beforeEach(async () => {
-    app = await prepareApp();
-    db = app.db;
-
-    role = await db.getRepository('roles').findOne({
-      filter: {
-        name: 'admin',
-      },
-    });
-
-    const UserRepo = db.getCollection('users').repository;
-    admin = await UserRepo.create({
-      values: {
-        roles: ['admin'],
-      },
-    });
-
-    const userPlugin = app.getPlugin('users') as UsersPlugin;
-    adminAgent = app.agent().login(admin);
-  });
-
-  it('should grant resource by createRepository', async () => {
-    const collectionManager = db.getRepository('collections') as CollectionRepository;
-    await collectionManager.create({
-      values: {
-        name: 'c1',
-        title: 'table1',
-      },
-      context: {},
-    });
-
-    await collectionManager.create({
-      values: {
-        name: 'c2',
-        title: 'table2',
-      },
-      context: {},
-    });
-
-    await db.getRepository('roles').create({
-      values: {
-        name: 'testRole',
-        resources: [
-          {
-            name: 'c1',
-            actions: [
-              {
-                name: 'create',
-              },
-            ],
-          },
-        ],
-      },
-    });
-
-    const acl = app.acl;
-    const testRole = acl.getRole('testRole');
-    const resource = testRole.getResource('c1');
-    expect(resource).toBeDefined();
-  });
-
-  it('should grant resource action', async () => {
-    const collectionManager = db.getRepository('collections') as CollectionRepository;
-
-    await collectionManager.create({
-      values: {
-        name: 'c1',
-        title: 'table1',
-      },
-      context: {},
-    });
-
-    await collectionManager.create({
-      values: {
-        name: 'c2',
-        title: 'table2',
-      },
-      context: {},
-    });
-
-    // get collections list
-    let response = await adminAgent.resource('roles.collections', 'admin').list({
-      filter: {
-        $or: [{ name: 'c1' }, { name: 'c2' }],
-      },
-      sort: ['sort'],
-    });
-
-    expect(response.statusCode).toEqual(200);
-
-    expect(response.body.data).toMatchObject([
-      {
-        name: 'c1',
-        title: 'table1',
-        usingConfig: 'strategy',
-        exists: false,
-      },
-      {
-        name: 'c2',
-        title: 'table2',
-        usingConfig: 'strategy',
-        exists: false,
-      },
-    ]);
-
-    // set resource actions
-    response = await adminAgent.resource('roles.resources', 'admin').create({
-      values: {
-        name: 'c1',
-        usingActionsConfig: true,
-        actions: [
-          {
-            name: 'create',
-          },
-        ],
-      },
-    });
-
-    expect(response.statusCode).toEqual(200);
-
-    // get collections list
-    response = await adminAgent.resource('roles.collections').list({
-      associatedIndex: role.get('name') as string,
-      filter: {
-        name: 'c1',
-      },
-    });
-
-    expect(response.body.data[0]['usingConfig']).toEqual('resourceAction');
-
-    response = await adminAgent.resource('roles.resources').list({
-      associatedIndex: role.get('name') as string,
-      appends: 'actions',
-    });
-
-    expect(response.statusCode).toEqual(200);
-    const resources = response.body.data;
-    const resourceAction = resources[0]['actions'][0];
-
-    expect(resourceAction['name']).toEqual('create');
-
-    // update resource actions
-    response = await adminAgent.resource('roles.resources').update({
-      associatedIndex: role.get('name') as string,
-      values: {
-        name: 'c1',
-        usingActionsConfig: true,
-        actions: [
-          {
-            name: 'view',
-          },
-        ],
-      },
-    });
-
-    expect(response.statusCode).toEqual(200);
-    expect(response.body.data[0]['actions'].length).toEqual(1);
-    expect(response.body.data[0]['actions'][0]['name']).toEqual('view');
-  });
-});

package/src/server/__tests__/role-user.test.ts

@@ -1,127 +0,0 @@
-import Database, { BelongsToManyRepository } from '@nocobase/database';
-import AuthPlugin from '@nocobase/plugin-auth';
-import UsersPlugin from '@nocobase/plugin-users';
-import { MockServer, mockServer } from '@nocobase/test';
-import jwt from 'jsonwebtoken';
-import PluginACL from '../index';
-
-describe('role', () => {
-  let api: MockServer;
-  let db: Database;
-
-  let usersPlugin: UsersPlugin;
-
-  beforeEach(async () => {
-    api = mockServer();
-    await api.cleanDb();
-    api.plugin(UsersPlugin, { name: 'users' });
-    api.plugin(PluginACL, { name: 'acl' });
-    api.plugin(AuthPlugin, { name: 'auth' });
-    await api.loadAndInstall();
-
-    db = api.db;
-    usersPlugin = api.getPlugin('users');
-  });
-
-  afterEach(async () => {
-    await api.destroy();
-  });
-
-  it('should set default role', async () => {
-    await db.getRepository('roles').create({
-      values: {
-        name: 'test1',
-        title: 'Admin User',
-        allowConfigure: true,
-        default: true,
-      },
-    });
-
-    const user = await db.getRepository('users').create({});
-
-    // @ts-ignore
-    const roles = await user.getRoles();
-
-    expect(roles.length).toEqual(1);
-    expect(roles[0].get('name')).toEqual('test1');
-  });
-
-  it('should not add role when user has role', async () => {
-    await db.getRepository('roles').create({
-      values: {
-        name: 'test1',
-        default: true,
-      },
-    });
-
-    await db.getRepository('roles').create({
-      values: {
-        name: 'test2',
-      },
-    });
-
-    const user = await db.getRepository('users').create({
-      values: {
-        roles: [
-          {
-            name: 'test2',
-          },
-        ],
-      },
-    });
-
-    // @ts-ignore
-    const roles = await user.getRoles();
-
-    expect(roles.length).toEqual(1);
-    expect(roles[0].get('name')).toEqual('test2');
-  });
-
-  it('should set users default role', async () => {
-    await db.getRepository('roles').create({
-      values: {
-        name: 'test1',
-        title: 'Admin User',
-        allowConfigure: true,
-        default: true,
-      },
-    });
-
-    await db.getRepository('roles').create({
-      values: {
-        name: 'test2',
-        title: 'test2 user',
-        allowConfigure: true,
-      },
-    });
-
-    const user = await db.getRepository('users').create({
-      values: {
-        token: '123',
-      },
-    });
-
-    const userRolesRepo = db.getRepository<BelongsToManyRepository>('users.roles', user.get('id') as string);
-    await userRolesRepo.add('test1');
-    await userRolesRepo.add('test2');
-
-    const userToken = jwt.sign({ userId: user.get('id') }, 'test-key');
-    const response = await api
-      .agent()
-      .post('/users:setDefaultRole')
-      .send({
-        roleName: 'test2',
-      })
-      .set({
-        Authorization: `Bearer ${userToken}`,
-        'X-Authenticator': 'basic',
-      });
-
-    expect(response.statusCode).toEqual(200);
-
-    const userRoles = await userRolesRepo.find();
-    const defaultRole = userRoles.find((userRole) => userRole.get('rolesUsers').default);
-
-    expect(defaultRole['name']).toEqual('test2');
-  });
-});

package/src/server/__tests__/role.test.ts

@@ -1,118 +0,0 @@
-import { ArrayFieldRepository, Database, Model } from '@nocobase/database';
-import UsersPlugin from '@nocobase/plugin-users';
-import { MockServer } from '@nocobase/test';
-import { prepareApp } from './prepare';
-
-describe('role api', () => {
-  let app: MockServer;
-  let db: Database;
-
-  afterEach(async () => {
-    await app.destroy();
-  });
-
-  beforeEach(async () => {
-    app = await prepareApp();
-    db = app.db;
-  });
-
-  describe('grant', () => {
-    let role: Model;
-    let admin: Model;
-    let adminAgent;
-
-    beforeEach(async () => {
-      role = await db.getRepository('roles').findOne({
-        filter: {
-          name: 'admin',
-        },
-      });
-
-      const UserRepo = db.getCollection('users').repository;
-      admin = await UserRepo.create({
-        values: {
-          roles: ['admin'],
-        },
-      });
-
-      const userPlugin = app.getPlugin('users') as UsersPlugin;
-      adminAgent = app.agent().login(admin);
-    });
-
-    it('should list actions', async () => {
-      const response = await adminAgent.resource('availableActions').list();
-      expect(response.statusCode).toEqual(200);
-    });
-
-    it('should grant universal role actions', async () => {
-      // grant role actions
-      const response = await adminAgent.resource('roles').update({
-        forceUpdate: true,
-        values: {
-          strategy: {
-            actions: ['create:all', 'view:own'],
-          },
-        },
-      });
-
-      expect(response.statusCode).toEqual(200);
-
-      await role.reload();
-
-      expect(role.get('strategy')).toMatchObject({
-        actions: ['create:all', 'view:own'],
-      });
-    });
-  });
-
-  it('should works with default option', async () => {
-    await db.getRepository('roles').create({
-      values: {
-        name: 'role1',
-        title: 'admin 1',
-        default: true,
-      },
-    });
-
-    await db.getRepository('roles').create({
-      values: {
-        name: 'role2',
-        default: true,
-      },
-    });
-
-    const defaultRole = await db.getRepository('roles').find({
-      filter: {
-        default: true,
-      },
-    });
-
-    expect(defaultRole.length).toEqual(1);
-    expect(defaultRole[0].get('name')).toEqual('role2');
-  });
-
-  it('should sync snippet patterns', async () => {
-    app.acl.registerSnippet({
-      name: 'collections',
-      actions: ['collection:*'],
-    });
-
-    await db.getRepository('roles').create({
-      values: {
-        name: 'role1',
-      },
-    });
-
-    await db.getRepository<ArrayFieldRepository>('roles.snippets', 'role1').set({
-      values: ['collections'],
-    });
-
-    const role1Instance = await db.getRepository('roles').findOne({
-      filterByTk: 'role1',
-    });
-
-    const role1 = app.acl.getRole('role1');
-
-    expect(role1.toJSON()['snippets']).toEqual(['collections']);
-  });
-});

package/src/server/__tests__/scope.test.ts

@@ -1,55 +0,0 @@
-import { Database } from '@nocobase/database';
-import UsersPlugin from '@nocobase/plugin-users';
-import { MockServer } from '@nocobase/test';
-import { prepareApp } from './prepare';
-
-describe('scope api', () => {
-  let app: MockServer;
-  let db: Database;
-
-  let admin;
-  let adminAgent;
-
-  afterEach(async () => {
-    await app.destroy();
-  });
-
-  beforeEach(async () => {
-    app = await prepareApp();
-    db = app.db;
-
-    const UserRepo = db.getCollection('users').repository;
-    admin = await UserRepo.create({
-      values: {
-        roles: ['admin'],
-      },
-    });
-
-    const userPlugin = app.getPlugin('users') as UsersPlugin;
-    adminAgent = app.agent().login(admin);
-  });
-
-  it('should create scope of resource', async () => {
-    const response = await adminAgent.resource('rolesResourcesScopes').create({
-      values: {
-        resourceName: 'posts',
-        name: 'published posts',
-        scope: {
-          published: true,
-        },
-      },
-    });
-
-    expect(response.statusCode).toEqual(200);
-
-    const scope = await db.getRepository('rolesResourcesScopes').findOne({
-      filter: {
-        name: 'published posts',
-      },
-    });
-
-    expect(scope.get('scope')).toMatchObject({
-      published: true,
-    });
-  });
-});