Fix tests

server/src/user/user.repository.ts

@@ -1,6 +1,6 @@
 import { Injectable } from '@nestjs/common';
 import { Prisma, WorkspaceMember } from '@prisma/client';
-import { PrismaService } from 'src/database/prisma.service';
+import { PrismaService } from '../database/prisma.service';
 
 @Injectable()
 export class UserRepository {
@@ -8,7 +8,8 @@ export class UserRepository {
 
     async upsertWorkspaceMember(params: { data: Prisma.WorkspaceMemberCreateInput }): Promise<WorkspaceMember> {
       const { data } = params;
-      return this.prisma.workspaceMember.upsert({
+
+      return await this.prisma.workspaceMember.upsert({
         where: {
             user_id: data.user_id,
         },

server/src/user/user.service.spec.ts

@@ -1,18 +1,104 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { UserService } from './user.service';
+import { UserRepository } from './user.repository';
+import { WorkspaceRepository } from './workspace.repository';
+import { PrismaService } from '../database/prisma.service';
+import {
+  MockContext,
+  createMockContext,
+} from '../database/client-mock/context';
+import { DeepMockProxy } from 'jest-mock-extended';
 
 describe('UserService', () => {
+  let mockCtx: MockContext;
   let service: UserService;
+  let mockedPrismaService: DeepMockProxy<PrismaService>;
 
   beforeEach(async () => {
+    mockCtx = createMockContext();
+
     const module: TestingModule = await Test.createTestingModule({
-      providers: [UserService],
-    }).compile();
+      providers: [
+        UserService,
+        UserRepository,
+        WorkspaceRepository,
+        PrismaService,
+      ],
+    })
+      .overrideProvider(PrismaService)
+      .useValue(mockCtx.prisma)
+      .compile();
 
     service = module.get<UserService>(UserService);
+    mockedPrismaService =
+      module.get<DeepMockProxy<PrismaService>>(PrismaService);
   });
 
   it('should be defined', () => {
     expect(service).toBeDefined();
   });
+
+  it('upsertWorkspaceMember should not upsert if email is absent', () => {
+    service.handleUserCreated({
+      event: {
+        data: { new: { id: 1, email: ''}, old: null },
+        session_variables: {},
+        op: 'INSERT'
+      },
+      id: '1',
+      table: { schema: 'auth', name: 'users' },
+      trigger: { name: 'user-created' },
+      delivery_info: { current_retry: 0, max_retries: 0},
+      created_at: '2021-03-01T00:00:00.000Z',
+    });
+    expect(mockedPrismaService.workspace.findUnique).toHaveBeenCalledTimes(0);
+  });
+
+  it('upsertWorkspaceMember should upsert if domain name is found from email', async () => {
+    mockedPrismaService.workspace.findUnique.mockResolvedValue({
+      id: 2,
+      display_name: 'test',
+      domain_name: 'domain.namexxx',
+      created_at: new Date(),
+      updated_at: new Date(),
+      deleted_at: null,
+    });
+
+    mockedPrismaService.workspaceMember.upsert.mockResolvedValue({
+      id: 1,
+      user_id: '1',
+      workspace_id: 1,
+      created_at: new Date(),
+      updated_at: new Date(),
+      deleted_at: null,
+    });
+
+    await service.handleUserCreated({
+      event: {
+        data: { new: { id: 1, email: 'test@domain.name' }, old: null },
+        session_variables: {},
+        op: 'INSERT',
+      },
+      id: '1',
+      table: { schema: 'auth', name: 'users' },
+      trigger: { name: 'user-created' },
+      delivery_info: { current_retry: 0, max_retries: 0 },
+      created_at: '2021-03-01T00:00:00.000Z',
+    });
+    expect(mockedPrismaService.workspace.findUnique).toHaveBeenCalledWith({
+      where: { domain_name: 'domain.name' },
+    });
+    expect(mockedPrismaService.workspaceMember.upsert).toHaveBeenCalledWith(
+      {
+        where: {
+          user_id: '1',
+        },
+        create: {
+          user_id: '1',
+          workspace_id: 2,
+        },
+        update: {},
+      },
+    );
+  });
 });

server/src/user/user.service.ts

@@ -1,5 +1,8 @@
-import { HasuraInsertEvent, TrackedHasuraEventHandler } from '@golevelup/nestjs-hasura';
-import { UserRepository} from "./user.repository"
+import {
+  HasuraInsertEvent,
+  TrackedHasuraEventHandler,
+} from '@golevelup/nestjs-hasura';
+import { UserRepository } from './user.repository';
 import { Injectable, Response } from '@nestjs/common';
 import { WorkspaceRepository } from './workspace.repository';
 import { response } from 'express';
@@ -11,7 +14,10 @@ interface User {
 
 @Injectable()
 export class UserService {
-  constructor(private repository: UserRepository, private workspaceRepository: WorkspaceRepository) {}
+  constructor(
+    private repository: UserRepository,
+    private workspaceRepository: WorkspaceRepository,
+  ) {}
 
   @TrackedHasuraEventHandler({
     triggerName: 'user-created',
@@ -20,11 +26,15 @@ export class UserService {
     definition: { type: 'insert' },
   })
   async handleUserCreated(evt: HasuraInsertEvent<User>) {
-    const workspace = await this.workspaceRepository.findWorkspaceByDomainName(
-      { where: { domain_name:evt.event.data.new.email.split('@')[1] }
-    });
+    const emailDomain = evt.event.data.new.email.split('@')[1];
 
-    console.log(workspace)
+    if (!emailDomain) {
+      return;
+    }
+
+    const workspace = await this.workspaceRepository.findWorkspaceByDomainName({
+      where: { domain_name: emailDomain },
+    });
 
     if (!workspace) {
       return;
@@ -37,4 +47,4 @@ export class UserService {
       },
     });
   }
-}
+}

server/src/user/workspace.repository.ts

@@ -1,12 +1,14 @@
 import { Injectable } from '@nestjs/common';
 import { Prisma, Workspace } from '@prisma/client';
-import { PrismaService } from 'src/database/prisma.service';
+import { PrismaService } from '../database/prisma.service';
 
 @Injectable()
 export class WorkspaceRepository {
-    constructor(private prisma: PrismaService) {}
+  constructor(private prisma: PrismaService) {}
 
-    async findWorkspaceByDomainName(data: Prisma.WorkspaceFindUniqueArgs): Promise<Workspace> {
-      return this.prisma.workspace.findUnique(data);
-    }
-}
+  async findWorkspaceByDomainName(
+    data: Prisma.WorkspaceFindUniqueArgs,
+  ): Promise<Workspace | null> {
+    return await this.prisma.workspace.findUnique(data);
+  }
+}