feat: add mock functionality for opportunity-related services (#3380)

Author: idoshamun

.infra/Pulumi.adhoc.yaml

@@ -83,6 +83,7 @@ config:
     pubsubProjectId: local
     redisHost: redis
     redisPort: 6379
+    scraperUrl: http://host.docker.internal:5001
     serviceName: api
     submitArticleThreshold: 250
     typeormDatabase: api
@@ -95,6 +96,7 @@ config:
     resumeBucketName: adhoc-daily-api
     employmentAgreementBucketName: adhoc-daily-api
     brokkrOrigin: http://brokkr-grpc:50051
+    mockExternalServices: true
   api:k8s:
     namespace: local
   api:temporal:

__tests__/schema/opportunity.ts

@@ -4749,6 +4749,61 @@ describe('mutation editOpportunity', () => {
       'Organization with this name already exists',
     );
   });
+
+  it('should generate unique organization name when name is not provided', async () => {
+    loggedUser = '1';
+
+    const MUTATION_WITH_ORG = /* GraphQL */ `
+      mutation EditOpportunityWithOrg(
+        $id: ID!
+        $payload: OpportunityEditInput!
+      ) {
+        editOpportunity(id: $id, payload: $payload) {
+          id
+          organization {
+            id
+            name
+          }
+        }
+      }
+    `;
+
+    const opportunityWithoutOrganization = await con
+      .getRepository(OpportunityJob)
+      .save({
+        ...opportunitiesFixture[0],
+        id: randomUUID(),
+        state: OpportunityState.DRAFT,
+        organizationId: null,
+      });
+
+    await con.getRepository(OpportunityUser).save({
+      opportunityId: opportunityWithoutOrganization.id,
+      userId: loggedUser,
+      type: OpportunityUserType.Recruiter,
+    });
+
+    const res = await client.mutate(MUTATION_WITH_ORG, {
+      variables: {
+        id: opportunityWithoutOrganization.id,
+        payload: {
+          organization: {}, // No name provided - should auto-generate
+        },
+      },
+    });
+
+    expect(res.errors).toBeFalsy();
+    expect(res.data.editOpportunity.organization).toBeDefined();
+    expect(res.data.editOpportunity.organization.name).toMatch(/^Company\d+$/);
+
+    // Verify the organization was created in database with generated name
+    const organization = await con
+      .getRepository(Organization)
+      .findOneBy({ id: res.data.editOpportunity.organization.id });
+
+    expect(organization).not.toBeNull();
+    expect(organization!.name).toMatch(/^Company\d+$/);
+  });
 });
 
 describe('mutation clearOrganizationImage', () => {

src/common/brokkr.ts

@@ -2,8 +2,12 @@ import { env } from 'node:process';
 import { createClient } from '@connectrpc/connect';
 import { createGrpcTransport } from '@connectrpc/connect-node';
 import { BrokkrService } from '@dailydotdev/schema';
-import { GarmrService } from '../integrations/garmr';
+import { GarmrService, GarmrNoopService } from '../integrations/garmr';
 import type { ServiceClient } from '../types';
+import {
+  isMockEnabled,
+  mockBrokkrParseOpportunityResponse,
+} from '../mocks/opportunity/services';
 
 const garmBrokkrService = new GarmrService({
   service: 'brokkr',
@@ -24,10 +28,25 @@ const transport = createGrpcTransport({
 
 export const getBrokkrClient = (
   clientTransport = transport,
-): ServiceClient<typeof BrokkrService> => ({
-  instance: createClient<typeof BrokkrService>(BrokkrService, clientTransport),
-  garmr: garmBrokkrService,
-});
+): ServiceClient<typeof BrokkrService> => {
+  if (isMockEnabled()) {
+    return {
+      instance: {
+        parseOpportunity: async () => mockBrokkrParseOpportunityResponse(),
+        extractMarkdown: async () => ({ markdown: 'Mock CV content' }),
+      } as unknown as ReturnType<typeof createClient<typeof BrokkrService>>,
+      garmr: new GarmrNoopService(),
+    };
+  }
+
+  return {
+    instance: createClient<typeof BrokkrService>(
+      BrokkrService,
+      clientTransport,
+    ),
+    garmr: garmBrokkrService,
+  };
+};
 
 export const extractMarkdownFromCV = async (
   blobName: string,

src/common/gondul.ts

@@ -1,11 +1,17 @@
 import { createGrpcTransport } from '@connectrpc/connect-node';
-import { GarmrService } from '../integrations/garmr';
+import { GarmrService, GarmrNoopService } from '../integrations/garmr';
 import { createClient } from '@connectrpc/connect';
 import {
   ApplicationService as GondulService,
   OpportunityService as GondulOpportunityService,
 } from '@dailydotdev/schema';
 import type { ServiceClient } from '../types';
+import {
+  isMockEnabled,
+  mockGondulScreeningQuestionsResponse,
+  mockPreviewUserIds,
+  mockPreviewTotalCount,
+} from '../mocks/opportunity/services';
 
 const transport = createGrpcTransport({
   baseUrl: process.env.GONDUL_ORIGIN,
@@ -27,6 +33,15 @@ const garmGondulService = new GarmrService({
 export const getGondulClient = (
   clientTransport = transport,
 ): ServiceClient<typeof GondulService> => {
+  if (isMockEnabled()) {
+    return {
+      instance: {
+        screeningQuestions: async () => mockGondulScreeningQuestionsResponse(),
+      } as unknown as ReturnType<typeof createClient<typeof GondulService>>,
+      garmr: new GarmrNoopService(),
+    };
+  }
+
   return {
     instance: createClient<typeof GondulService>(
       GondulService,
@@ -44,6 +59,22 @@ const gondulOpportunityServerTransport = createGrpcTransport({
 export const getGondulOpportunityServiceClient = (
   clientTransport = gondulOpportunityServerTransport,
 ): ServiceClient<typeof GondulOpportunityService> => {
+  if (isMockEnabled()) {
+    return {
+      instance: {
+        // Preview is async - it triggers a background job
+        // For mock, we simulate immediate completion by returning userIds
+        preview: async () => ({
+          userIds: mockPreviewUserIds,
+          totalCount: mockPreviewTotalCount,
+        }),
+      } as unknown as ReturnType<
+        typeof createClient<typeof GondulOpportunityService>
+      >,
+      garmr: new GarmrNoopService(),
+    };
+  }
+
   return {
     instance: createClient<typeof GondulOpportunityService>(
       GondulOpportunityService,

src/common/scraper.ts

@@ -1,6 +1,11 @@
-import { GarmrService } from '../integrations/garmr';
+import { IDefaultPolicyContext, IPolicy, noop } from 'cockatiel';
+import { GarmrService, IGarmrService } from '../integrations/garmr';
+import {
+  isMockEnabled,
+  mockScraperPdfBuffer,
+} from '../mocks/opportunity/services';
 
-export const garmScraperService = new GarmrService({
+const realGarmScraperService = new GarmrService({
   service: 'daily-scraper',
   breakerOpts: {
     halfOpenAfter: 10 * 1000,
@@ -12,3 +17,29 @@ export const garmScraperService = new GarmrService({
     maxAttempts: 3,
   },
 });
+
+/**
+ * Mock scraper service that returns a mock PDF buffer
+ */
+class MockScraperService implements IGarmrService {
+  readonly instance: IPolicy = noop;
+
+  async execute<T>(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _fn: (context: IDefaultPolicyContext) => PromiseLike<T> | T,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _signal?: AbortSignal,
+  ): Promise<T> {
+    // Return a mock Response object with the PDF buffer
+    const buffer = mockScraperPdfBuffer();
+    const response = new Response(new Uint8Array(buffer), {
+      status: 200,
+      headers: { 'content-type': 'application/pdf' },
+    });
+    return response as unknown as T;
+  }
+}
+
+export const garmScraperService: IGarmrService = isMockEnabled()
+  ? new MockScraperService()
+  : realGarmScraperService;

src/integrations/snotra/clients.ts

@@ -3,6 +3,10 @@ import { GarmrNoopService, IGarmrService, GarmrService } from '../garmr';
 import { fetchOptions as globalFetchOptions } from '../../http';
 import { retryFetchParse } from '../retry';
 import { ISnotraClient, ProfileRequest, ProfileResponse } from './types';
+import {
+  isMockEnabled,
+  mockSnotraEngagementProfile,
+} from '../../mocks/opportunity/services';
 
 export class SnotraClient implements ISnotraClient {
   private readonly fetchOptions: RequestInit;
@@ -25,6 +29,11 @@ export class SnotraClient implements ISnotraClient {
   }
 
   getProfile(request: ProfileRequest): Promise<ProfileResponse> {
+    // Mock path: return mock engagement profile
+    if (isMockEnabled()) {
+      return Promise.resolve(mockSnotraEngagementProfile);
+    }
+
     return this.garmr.execute(() => {
       return retryFetchParse<ProfileResponse>(
         `${this.url}/api/v1/memstore/shortprofile`,

src/mocks/opportunity/services.ts

@@ -0,0 +1,125 @@
+/**
+ * Mock service responses for opportunity-related external services.
+ * Only the actual service calls are mocked - all other flow logic remains unchanged.
+ */
+
+import {
+  EmploymentType,
+  OpportunityType,
+  SalaryPeriod,
+  SeniorityLevel,
+} from '@dailydotdev/schema';
+
+/**
+ * Check if external services should be mocked
+ */
+export const isMockEnabled = (): boolean =>
+  process.env.MOCK_EXTERNAL_SERVICES === 'true';
+
+/**
+ * Mock response for Brokkr parseOpportunity service call
+ * Returns plain objects that match the expected protobuf message shape
+ */
+export const mockBrokkrParseOpportunityResponse = () => ({
+  opportunity: {
+    type: OpportunityType.JOB,
+    title: 'Senior Full Stack Developer',
+    tldr: 'Join our team to build cutting-edge developer tools and shape the future of how developers discover content.',
+    content: {
+      overview: {
+        content:
+          'We are looking for a Senior Full Stack Developer to join our growing engineering team. You will work on building and scaling our platform that serves millions of developers worldwide.',
+      },
+      responsibilities: {
+        content:
+          '- Design and implement new features across the full stack\n- Collaborate with product and design teams\n- Mentor junior developers\n- Participate in code reviews and architectural decisions',
+      },
+      requirements: {
+        content:
+          '- 5+ years of experience with modern web technologies\n- Strong proficiency in TypeScript and React\n- Experience with Node.js and PostgreSQL\n- Excellent communication skills',
+      },
+    },
+    meta: {
+      roleType: 0.0,
+      teamSize: 15,
+      seniorityLevel: SeniorityLevel.SENIOR,
+      employmentType: EmploymentType.FULL_TIME,
+      salary: {
+        min: BigInt(120000),
+        max: BigInt(130000),
+        currency: 'USD',
+        period: SalaryPeriod.ANNUAL,
+      },
+      equity: true,
+    },
+    keywords: ['typescript', 'react', 'nodejs', 'postgresql', 'graphql'],
+  },
+});
+
+/**
+ * Mock response for Gondul screeningQuestions service call
+ */
+export const mockGondulScreeningQuestionsResponse = () => ({
+  screening: [
+    'What experience do you have building and scaling applications for millions of users?',
+    'How do you approach mentoring junior developers while maintaining your own productivity?',
+    'Describe your experience with TypeScript and React in production.',
+  ],
+});
+
+/**
+ * Mock user IDs for opportunityPreview (simulates Gondul preview response)
+ * These should be valid user IDs from your local database (from seed data)
+ * Using testuser1-10 which have SourceMember entries for publicsquad
+ */
+export const mockPreviewUserIds = [
+  'testuser',
+  'testuser1',
+  'testuser2',
+  'testuser3',
+  'testuser4',
+  'testuser5',
+  'testuser6',
+  'testuser7',
+  'testuser8',
+  'testuser9',
+];
+export const mockPreviewTotalCount = 4827;
+
+/**
+ * Mock tags for opportunityPreview result
+ * These are used when computing the aggregated tags from user data
+ */
+export const mockPreviewTags = [
+  'react',
+  'typescript',
+  'javascript',
+  'nodejs',
+  'python',
+  'graphql',
+  'nextjs',
+  'aws',
+];
+
+/**
+ * Mock squads for opportunityPreview result
+ * These should match squad IDs from the seed data
+ */
+export const mockPreviewSquadIds = ['publicsquad'];
+
+/**
+ * Mock PDF buffer for scraper service (minimal valid PDF)
+ */
+export const mockScraperPdfBuffer = (): Buffer => {
+  // Minimal PDF structure
+  return Buffer.from('%PDF-1.4\n1 0 obj\n<<>>\nendobj\ntrailer\n<<>>\n%%EOF');
+};
+
+/**
+ * Mock engagement profile returned from Snotra getProfile
+ */
+export const mockSnotraEngagementProfile = {
+  profile_text:
+    'Active developer with strong engagement in React and TypeScript communities. Regular contributor to open source projects and frequent reader of frontend development content. Shows consistent interest in modern web technologies and best practices.',
+  update_at: new Date().toISOString(),
+};