@drax/identity-back 1.0.0 → 1.1.0

package/test/{service → services}/user-service.test.ts

@@ -1,6 +1,6 @@
 import { beforeAll, afterAll, describe, it, expect } from "vitest"
 import UserService from "../../src/services/UserService";
-import MongoInMemory from "../db/MongoInMemory";
+import MongoInMemory from "../setup/MongoInMemory";
 import RoleMongoInitializer from "../initializers/RoleMongoInitializer";
 import {IRole} from "../../../identity-share/src/interfaces/IRole";
 import UserMongoRepository from "../../src/repository/mongo/UserMongoRepository";
@@ -12,34 +12,38 @@ describe("UserServiceTest", function () {
     let userService = new UserService(userRepository)
     let adminRole: IRole
     let userAdminData: any
+    let mongoInMemory: MongoInMemory = new MongoInMemory()
 
     beforeAll(async () => {
-        await MongoInMemory.connect()
+        await mongoInMemory.connect()
         adminRole = await RoleMongoInitializer.initAdminRole()
         userAdminData = (await import("../data-obj/users/root-mongo-user")).default
-        console.log("BEFORE USER", MongoInMemory.mongooseStatus, MongoInMemory.serverStatus)
         return
     })
 
     afterAll(async () => {
-        await MongoInMemory.DropAndClose()
-        console.log("AFTER USER", MongoInMemory.status, MongoInMemory.serverStatus)
+        await mongoInMemory.DropAndClose()
         return
     })
 
     it("should create user", async function () {
-        const user = {...userAdminData}
-        let userCreated = await userService.create(user)
+        const userData = {...userAdminData}
+        let userCreated = await userService.create(userData)
         expect(userCreated.username).toBe(userAdminData.username)
     })
 
 
+    it("should find one user", async function () {
+        let user = await userService.findById(userAdminData._id)
+        expect(user.username).toBe(userAdminData.username)
+    })
 
-    it("should changeUserPassword user", async function () {
-        const userId = userAdminData._id
-        const newPassword = "123"
-        let userPasswordChanged = await userService.changeUserPassword(userId, newPassword)
-        expect(userPasswordChanged._id.toString()).toBe(userId)
+    it("should modify user", async function () {
+        const userData = {...userAdminData}
+        const newName = "AdminUpdated"
+        userData.name = newName
+        let userUpdated = await userService.update(userAdminData._id, userData)
+        expect(userUpdated.name).toBe(newName)
     })
 
     it("should fail create user with short password", async function () {
@@ -55,8 +59,14 @@ describe("UserServiceTest", function () {
         });
     })
 
-    it("should find one user", async function () {
-        let user = await userService.findById(userAdminData._id)
-        expect(user.username).toBe(userAdminData.username)
+
+    it("should changeUserPassword user", async function () {
+        const userId = userAdminData._id
+        const newPassword = "123"
+        let userPasswordChanged = await userService.changeUserPassword(userId, newPassword)
+        expect(userPasswordChanged._id.toString()).toBe(userId)
     })
+
+
+
 })

package/test/setup/MongoInMemory.ts

@@ -0,0 +1,44 @@
+import {mongoose} from '@drax/common-back';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+
+class MongoInMemory{
+
+     mongoServer: MongoMemoryServer
+
+     async connect(){
+        this.mongoServer = await MongoMemoryServer.create();
+        if(this.mongoServer.state == "new"){
+            await this.mongoServer.start()
+        }
+        if(!mongoose.connection.readyState){
+            await mongoose.connect(this.mongoServer.getUri(), { dbName: "verifyMASTER" });
+        }
+        return
+    }
+
+     get mongooseStatus(){
+        return mongoose.connection.readyState
+    }
+
+     get serverStatus(){
+        return this.mongoServer.state
+    }
+
+     get status(){
+        return mongoose.connection.readyState
+    }
+
+     async disconnect(){
+        await mongoose.disconnect();
+    }
+
+    async DropAndClose(){
+        if (this.mongoServer) {
+            await mongoose.connection.dropDatabase();
+            await mongoose.connection.close();
+            await this.mongoServer.stop();
+        }
+    }
+}
+
+export default MongoInMemory

package/test/setup/TestSetup.ts

@@ -0,0 +1,153 @@
+import Fastify, {FastifyInstance} from "fastify";
+import {LoadCommonConfigFromEnv} from "@drax/common-back";
+import {
+    LoadIdentityConfigFromEnv,
+    CreateOrUpdateRole,
+    CreateUserIfNotExist,
+    jwtMiddleware,
+    rbacMiddleware,
+    apiKeyMiddleware,
+    UserRoutes, RoleRoutes, TenantRoutes, UserApiKeyRoutes,
+    UserPermissions, RolePermissions, TenantPermissions, UserApiKeyPermissions,
+    LoadPermissions
+} from "@drax/identity-back";
+import rootUserData from "./data/root-user";
+import adminRoleData from "./data/admin-role";
+import {IUser, IRole} from "@drax/identity-share";
+import MongoInMemory from "./MongoInMemory";
+
+class TestSetup {
+
+    private _fastifyInstance: FastifyInstance;
+    private _mongoInMemory: MongoInMemory;
+    private _rootUser: IUser;
+    private _adminRole: IRole;
+
+    constructor() {
+    }
+
+    async setup() {
+        this.setupEnvironmentVariables();
+        this.setupConfig();
+        this.setupPermissions();
+        this.setupFastifyInstance();
+        await this.setupMongoInMemoryAndConnect();
+        await this.setupRootUserAndAdminRole();
+    }
+
+    setupEnvironmentVariables() {
+        // Define environment variables
+        process.env.DRAX_DB_ENGINE = "mongo";
+        process.env.DRAX_JWT_SECRET = "xxx";
+    }
+
+    setupConfig() {
+        LoadCommonConfigFromEnv();
+        LoadIdentityConfigFromEnv();
+    }
+
+    setupPermissions() {
+        //Merge All Permissions
+        const permissions = [
+            ...Object.values(UserPermissions),
+            ...Object.values(RolePermissions),
+            ...Object.values(TenantPermissions),
+            ...Object.values(UserApiKeyPermissions),
+        ]
+
+        //Load All Permissions
+        LoadPermissions(permissions)
+    }
+
+    setupFastifyInstance() {
+        this._fastifyInstance = Fastify()
+        this._fastifyInstance.setValidatorCompiler(() => () => true)
+        this._fastifyInstance.addHook('onRequest', jwtMiddleware)
+        this._fastifyInstance.addHook('onRequest', rbacMiddleware)
+        this._fastifyInstance.addHook('onRequest', apiKeyMiddleware)
+        this._fastifyInstance.register(UserRoutes)
+        this._fastifyInstance.register(RoleRoutes)
+        this._fastifyInstance.register(TenantRoutes)
+        this._fastifyInstance.register(UserApiKeyRoutes)
+    }
+
+    async setupMongoInMemoryAndConnect() {
+        this._mongoInMemory = new MongoInMemory();
+        await this._mongoInMemory.connect();
+    }
+
+    async setupRootUserAndAdminRole() {
+        this._adminRole = await CreateOrUpdateRole({...adminRoleData})
+        this._rootUser = await CreateUserIfNotExist({...rootUserData})
+    }
+
+    async login(username: string= rootUserData.username, password: string= rootUserData.password): Promise<{accessToken: string}> {
+
+        const resp = await this._fastifyInstance.inject({
+            method: 'POST',
+            url: '/api/auth/login',
+            payload: {username: username, password: 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({
+            method: 'GET',
+            url: '/api/auth/me',
+            headers: {Authorization: `Bearer ${accessToken}`}
+        });
+
+        if(resp.statusCode === 200){
+            let user : IUser = resp.json() as IUser
+            return user
+        }else{
+            throw new Error(`Failed to get me. Status Code:  ${resp.statusCode} body:  ${resp.body}`)
+        }
+
+
+    }
+
+
+    get adminRoleData() {
+        return {...adminRoleData};
+    }
+
+    get rootUserData() {
+        return {...rootUserData};
+    }
+
+    get rootUser() {
+        return this._rootUser;
+    }
+
+    get adminRole() {
+        return this._adminRole;
+    }
+
+    get fastifyInstance() {
+        return this._fastifyInstance;
+    }
+
+    get mongoInMemory() {
+        return this._mongoInMemory;
+    }
+
+
+}
+
+
+export default TestSetup
+
+export {
+    TestSetup
+}

package/test/{routes → setup}/data/admin-role.ts

@@ -1,4 +1,4 @@
-import {PermissionService} from "../../../src/services/PermissionService.js"
+import {PermissionService} from "@drax/identity-back"
 
 const role = {
   name: "Admin",