@drax/identity-back 1.1.1 → 1.3.0

package/test/repository/mongo/role-mongo-repository.test.ts

@@ -1,22 +1,23 @@
 import  {describe,it, beforeAll, afterAll} from "vitest"
 import {equal} from "assert";
 import RoleMongoRepository from "../../../src/repository/mongo/RoleMongoRepository";
-import MongoInMemory from "../../db/MongoInMemory";
+import MongoInMemory from "../../setup/MongoInMemory";
 import {IRole} from "../../../../identity-share/src/interfaces/IRole";
 import {IDraxPaginateResult} from "@drax/crud-share";
 
 describe("RoleRepositoryTest",  function() {
 
+    const mongoInMemory = new MongoInMemory()
     const roleReposirory = new RoleMongoRepository()
 
     beforeAll(async () => {
-        await MongoInMemory.connect()
+        await mongoInMemory.connect()
        // console.log("BEFORE ROLE", MongoInMemory.mongooseStatus, MongoInMemory.serverStatus)
         return
     })
 
     afterAll(async () => {
-        await MongoInMemory.DropAndClose()
+        await mongoInMemory.dropAndClose()
         //console.log("AFTER ROLE", MongoInMemory.status, MongoInMemory.serverStatus)
         return
     })

package/test/repository/mongo/user-apikey-mongo-repository.test.ts

@@ -1,7 +1,7 @@
 import {beforeAll, afterAll, describe, test, expect} from "vitest"
-import assert, {equal} from "assert";
+import  {equal} from "assert";
 import UserApiKeyMongoRepository from "../../../src/repository/mongo/UserApiKeyMongoRepository";
-import MongoInMemory from "../../db/MongoInMemory";
+import MongoInMemory from "../../setup/MongoInMemory";
 import RoleMongoInitializer from "../../initializers/RoleMongoInitializer";
 import UserMongoInitializer from "../../initializers/UserMongoInitializer";
 import {IUserApiKey} from "../../../../identity-share/src/interfaces/IUserApiKey";
@@ -15,9 +15,10 @@ describe("UserApiKeyRepositoryTest", function () {
     let data
     let adminRole
     let rootUser
+    const mongoInMemory = new MongoInMemory()
 
     beforeAll(async () => {
-        await MongoInMemory.connect()
+        await mongoInMemory.connect()
         adminRole = await RoleMongoInitializer.initAdminRole()
         rootUser = await UserMongoInitializer.initRootUser()
 
@@ -26,7 +27,7 @@ describe("UserApiKeyRepositoryTest", function () {
     })
 
     afterAll(async () => {
-        await MongoInMemory.DropAndClose()
+        await mongoInMemory.dropAndClose()
         //console.log("AFTER USER", MongoInMemory.status, MongoInMemory.serverStatus)
         return
     })

package/test/repository/mongo/user-mongo-repository.test.ts

@@ -1,12 +1,10 @@
-import  {beforeAll, afterAll, describe, test, expect} from "vitest"
-import assert, {equal} from "assert";
+import {beforeAll, afterAll, describe, test, expect, assert} from "vitest"
 import UserMongoRepository from "../../../src/repository/mongo/UserMongoRepository";
-import MongoInMemory from "../../db/MongoInMemory";
+import MongoInMemory from "../../setup/MongoInMemory";
 import RoleMongoInitializer from "../../initializers/RoleMongoInitializer";
 import {IUser} from "../../../../identity-share/src/interfaces/IUser";
 import type {IDraxPaginateResult} from "@drax/crud-share";
 import {mongoose, ValidationError} from "@drax/common-back";
-import {object} from "zod";
 
 
 describe("UserRepositoryTest", function () {
@@ -14,9 +12,10 @@ describe("UserRepositoryTest", function () {
     let userRepository = new UserMongoRepository()
     let adminRole
     let userAdminData
+    const mongoInMemory = new MongoInMemory()
 
     beforeAll(async () => {
-        await MongoInMemory.connect()
+        await mongoInMemory.connect()
         adminRole = await RoleMongoInitializer.initAdminRole()
 
         //console.log("BEFORE USER", MongoInMemory.mongooseStatus, MongoInMemory.serverStatus)
@@ -24,7 +23,7 @@ describe("UserRepositoryTest", function () {
     })
 
     afterAll(async () => {
-        await MongoInMemory.DropAndClose()
+        await mongoInMemory.dropAndClose()
         //console.log("AFTER USER", MongoInMemory.status, MongoInMemory.serverStatus)
         return
     })
@@ -32,42 +31,36 @@ describe("UserRepositoryTest", function () {
     test("Create mongo user successfully", async function () {
         userAdminData = (await import("../../data-obj/users/root-mongo-user")).default
         let userCreated = await userRepository.create(userAdminData)
-       equal(userCreated.username, userAdminData.username)
+        expect(userCreated.username).toBe(userAdminData.username)
     })
 
     test("Create mongo user fail same id", async function () {
         userAdminData = (await import("../../data-obj/users/root-mongo-user")).default
         let userData = {...userAdminData, email: "asd123@asd123.com", username: "asd123"}
 
+        await expect(
+            userRepository.create(userData)
+        ).rejects.toThrow(ValidationError)
 
-        await assert.rejects(
-            async () => {
-                await userRepository.create(userData)
-            },
-            (error) => {
-                assert(error instanceof ValidationError, 'Expected error to be instance of ValidationError');
-                assert.strictEqual(error.errors[0].field, '_id');
-                return true;
-            },
-        );
+        try {
+            await userRepository.create(userData)
+        } catch (error) {
+            assert(error instanceof ValidationError)
+            expect(error.errors[0].field).toBe('_id')
+        }
     })
 
     test("Create mongo user fail same username", async function () {
         userAdminData = (await import("../../data-obj/users/root-mongo-user")).default
         let userData = {...userAdminData, _id: new mongoose.Types.ObjectId("646a661e44c93567c23d8d69"),email: "asd123@asd123.com" }
 
-
-        await assert.rejects(
-            async () => {
-                await userRepository.create(userData)
-            },
-            (error) => {
-                assert(error instanceof ValidationError, 'Expected error to be instance of ValidationError');
-                assert.strictEqual(error.errors[0].field, 'username');
-                assert.strictEqual(error.errors[0].reason, 'validation.unique');
-                return true;
-            },
-        );
+        try {
+            await userRepository.create(userData)
+        } catch (error) {
+            assert(error instanceof ValidationError)
+            expect(error.errors[0].field).toBe('username')
+            expect(error.errors[0].reason).toBe('validation.unique')
+        }
     })
 
     test("Create mongo user fail if role doesnt exist", async function () {
@@ -79,46 +72,40 @@ describe("UserRepositoryTest", function () {
             role: "646a661e44c93567c23d8d89"
         }
 
-        await assert.rejects(
-            async () => {
-                await userRepository.create(userData)
-            },
-            (err) => {
-                //console.log("error",err)
-                assert(err instanceof ValidationError, 'Expected error to be instance of ValidationError');
-                assert.strictEqual(err.errors[0].field, 'role');
-                assert.strictEqual(err.errors[0].reason, 'validation.notfound');
-                return true;
-            },
-        );
+        try {
+            await userRepository.create(userData)
+        } catch (error) {
+            assert(error instanceof ValidationError)
+            expect(error.errors[0].field).toBe('role')
+            expect(error.errors[0].reason).toBe('validation.notfound')
+        }
     })
 
     test("Update mongo user successfully.",  async function() {
         let adminData = (await import("../../data-obj/users/root-mongo-user")).default
         adminData.name = "AdminUpdated"
         let userUpdated: IUser = await userRepository.update(adminData._id, adminData)
-        equal(userUpdated.name,userUpdated.name)
+        expect(userUpdated.name).toBe(userUpdated.name)
     })
 
     test("Find mongo user by ID successfully", async function () {
         let adminData = (await import("../../data-obj/users/root-mongo-user")).default
         let userFound = await userRepository.findById(adminData._id)
         console.log("userFound",userFound)
-        equal(userFound.username, userAdminData.username)
+        expect(userFound.username).toBe(userAdminData.username)
         expect(userFound).toBeInstanceOf(Object)
     })
 
     test("Find mongo user by username successfully", async function () {
         let adminData = (await import("../../data-obj/users/root-mongo-user")).default
         let userFound = await userRepository.findByUsername(adminData.username)
-        equal(userFound.username, userAdminData.username)
+        expect(userFound.username).toBe(userAdminData.username)
     })
 
-
     test("Paginate mongo users successfully.",  async function() {
         let paginateUsers: IDraxPaginateResult<IUser> = await userRepository.paginate({page: 1, limit: 5})
-        equal(paginateUsers.items.length,1)
-        equal(paginateUsers.total,1)
-        equal(paginateUsers.page,1)
+        expect(paginateUsers.items.length).toBe(1)
+        expect(paginateUsers.total).toBe(1)
+        expect(paginateUsers.page).toBe(1)
     })
 })

package/test/services/role-service.test.ts

@@ -1,6 +1,6 @@
 import  {describe,it, beforeAll, afterAll, assert} from "vitest"
 import RoleService from "../../src/services/RoleService";
-import MongoInMemory from "../db/MongoInMemory";
+import MongoInMemory from "../setup/MongoInMemory";
 import {IRole} from "../../../identity-share/src/interfaces/IRole";
 import RoleMongoRepository from "../../src/repository/mongo/RoleMongoRepository";
 import {IRoleRepository} from "../../src/interfaces/IRoleRepository";
@@ -8,22 +8,21 @@ import {IRoleRepository} from "../../src/interfaces/IRoleRepository";
 describe("RoleServiceTest",  function() {
     let roleRepository: IRoleRepository = new RoleMongoRepository()
     let roleService = new RoleService(roleRepository)
+    const mongoInMemory = new MongoInMemory()
+
     beforeAll(async () => {
-        await MongoInMemory.connect()
-        console.log("BEFORE ROLE", MongoInMemory.mongooseStatus, MongoInMemory.serverStatus)
+        await mongoInMemory.connect()
         return
     })
 
     afterAll(async () => {
-        await MongoInMemory.DropAndClose()
-        console.log("AFTER ROLE", MongoInMemory.status, MongoInMemory.serverStatus)
+        await mongoInMemory.dropAndClose()
         return
     })
 
     it("should create role",  async function() {
         let roleData = (await import("../data-obj/roles/admin-mongo-role")).default
         let roleCreated: IRole = await roleService.create(roleData)
-
         assert.equal(roleCreated.name,roleData.name)
     })
 })

package/test/services/user-service.test.ts

@@ -22,7 +22,7 @@ describe("UserServiceTest", function () {
     })
 
     afterAll(async () => {
-        await mongoInMemory.DropAndClose()
+        await mongoInMemory.dropAndClose()
         return
     })
 

package/test/setup/MongoInMemory.ts

@@ -1,38 +1,47 @@
 import {mongoose} from '@drax/common-back';
-import { MongoMemoryServer } from 'mongodb-memory-server';
+import {MongoMemoryServer} from 'mongodb-memory-server';
 
-class MongoInMemory{
+class MongoInMemory {
 
-     mongoServer: MongoMemoryServer
+    mongoServer: MongoMemoryServer
 
-     async connect(){
+    async connect() {
         this.mongoServer = await MongoMemoryServer.create();
-        if(this.mongoServer.state == "new"){
+        if (this.mongoServer.state == "new") {
             await this.mongoServer.start()
         }
-        if(!mongoose.connection.readyState){
-            await mongoose.connect(this.mongoServer.getUri(), { dbName: "verifyMASTER" });
+        if (!mongoose.connection.readyState) {
+            await mongoose.connect(this.mongoServer.getUri(), {dbName: "verifyMASTER"});
         }
         return
     }
 
-     get mongooseStatus(){
+    get mongooseStatus() {
         return mongoose.connection.readyState
     }
 
-     get serverStatus(){
+    get serverStatus() {
         return this.mongoServer.state
     }
 
-     get status(){
+    get status() {
         return mongoose.connection.readyState
     }
 
-     async disconnect(){
+    async disconnect() {
         await mongoose.disconnect();
     }
 
-    async DropAndClose(){
+    async dropData() {
+        const collections = await mongoose.connection.listCollections()
+        for (let collection of collections) {
+            console.log(`Dropping collection: ${collection.name}`)
+            await mongoose.connection.dropCollection(collection.name)
+        }
+
+    }
+
+    async dropAndClose() {
         if (this.mongoServer) {
             await mongoose.connection.dropDatabase();
             await mongoose.connection.close();

package/test/setup/TestSetup.ts

@@ -11,8 +11,13 @@ import {
     UserPermissions, RolePermissions, TenantPermissions, UserApiKeyPermissions,
     LoadPermissions
 } from "@drax/identity-back";
-import rootUserData from "./data/root-user";
+
 import adminRoleData from "./data/admin-role";
+import restrictedRoleData from "./data/restricted-role";
+
+import rootUserData from "./data/root-user";
+import basicUserData from "./data/basic-user";
+
 import {IUser, IRole} from "@drax/identity-share";
 import MongoInMemory from "./MongoInMemory";
 
@@ -21,7 +26,9 @@ class TestSetup {
     private _fastifyInstance: FastifyInstance;
     private _mongoInMemory: MongoInMemory;
     private _rootUser: IUser;
+    private _basicUser: IUser;
     private _adminRole: IRole;
+    private _restrictedRole: IRole;
 
     constructor() {
     }
@@ -33,6 +40,7 @@ class TestSetup {
         this.setupFastifyInstance();
         await this.setupMongoInMemoryAndConnect();
         await this.setupRootUserAndAdminRole();
+        await this.setupBasicUserAndRestrictedRole();
     }
 
     setupEnvironmentVariables() {
@@ -81,7 +89,20 @@ class TestSetup {
         this._rootUser = await CreateUserIfNotExist({...rootUserData})
     }
 
-    async login(username: string= rootUserData.username, password: string= rootUserData.password): Promise<{accessToken: string}> {
+    async setupBasicUserAndRestrictedRole() {
+        this._restrictedRole = await CreateOrUpdateRole({...restrictedRoleData})
+        this._basicUser = await CreateUserIfNotExist({...basicUserData})
+    }
+
+    async dropData() {
+        await this._mongoInMemory.dropData()
+    }
+
+    async dropAndClose() {
+        await this._mongoInMemory.dropAndClose()
+    }
+
+    async login(username: string, password: string): Promise<{accessToken: string}> {
 
         const resp = await this._fastifyInstance.inject({
             method: 'POST',
@@ -99,6 +120,46 @@ class TestSetup {
 
     }
 
+    async rootUserLogin(): Promise<{accessToken: string}> {
+
+        const resp = await this._fastifyInstance.inject({
+            method: 'POST',
+            url: '/api/auth/login',
+            payload: {
+                username: rootUserData.username,
+                password: rootUserData.password
+            }
+        });
+
+        let body = resp.json()
+
+        if(resp.statusCode === 200 && body.accessToken){
+            return {accessToken: body.accessToken}
+        }else{
+            throw new Error(`Failed to login. Status Code:  ${resp.statusCode} body:  ${resp.body}`)
+        }
+    }
+
+    async basicUserLogin(): Promise<{accessToken: string}> {
+
+        const resp = await this._fastifyInstance.inject({
+            method: 'POST',
+            url: '/api/auth/login',
+            payload: {
+                username: basicUserData.username,
+                password: basicUserData.password
+            }
+        });
+
+        let body = resp.json()
+
+        if(resp.statusCode === 200 && body.accessToken){
+            return {accessToken: body.accessToken}
+        }else{
+            throw new Error(`Failed to login. Status Code:  ${resp.statusCode} body:  ${resp.body}`)
+        }
+    }
+
     async me(accessToken:string): Promise<IUser> {
 
         const resp = await this._fastifyInstance.inject({
@@ -122,18 +183,34 @@ class TestSetup {
         return {...adminRoleData};
     }
 
+    get restrictedRoleData() {
+        return {...restrictedRoleData};
+    }
+
     get rootUserData() {
         return {...rootUserData};
     }
 
-    get rootUser() {
-        return this._rootUser;
+    get basicUserData() {
+        return {...basicUserData};
     }
 
     get adminRole() {
         return this._adminRole;
     }
 
+    get restrictedRole() {
+        return this._restrictedRole;
+    }
+
+    get rootUser() {
+        return this._rootUser;
+    }
+
+    get basicUser() {
+        return this._basicUser;
+    }
+
     get fastifyInstance() {
         return this._fastifyInstance;
     }

package/test/setup/data/admin-role.ts

@@ -1,10 +1,13 @@
 import {PermissionService} from "@drax/identity-back"
 
-const role = {
+const adminRoleData = {
   name: "Admin",
   permissions: PermissionService.getPermissions(),
   childRoles: [],
   readonly: true
 }
 
-export default role
+export default adminRoleData
+export {
+  adminRoleData
+}

package/test/setup/data/basic-user.ts

@@ -0,0 +1,14 @@
+
+const basicUser = {
+  active: true,
+  groups: [],
+  name: "Basic User",
+  username:  "basicUser",
+  password: "basic.123",
+  email: "basic@example.com",
+  phone: "123456789",
+  role: "Restricted"
+};
+
+export default basicUser
+export {basicUser}

package/test/setup/data/restricted-role.ts

@@ -0,0 +1,10 @@
+
+const restrictedRoleData = {
+  name: "Restricted",
+  permissions: [],
+  childRoles: [],
+  readonly: true
+}
+
+export default restrictedRoleData
+export {restrictedRoleData}

package/test/setup/data/root-user.ts

@@ -1,5 +1,5 @@
 
-const user = {
+const rootUser = {
   active: true,
   groups: [],
   name: "Root",
@@ -10,4 +10,5 @@ const user = {
   role: "Admin"
 };
 
-export default user
+export default rootUser
+export {rootUser}