test: update tests with new high value cases

Signed-off-by: Yeganathan S <63534555+skwowet@users.noreply.github.com>

Author: skwowet

services/libs/data-access-layer/src/member-organization-affiliation/index.test.ts

@@ -26,6 +26,9 @@ import {
 } from '@crowd/types'
 
 import { queryActivityRelations } from '../activityRelations'
+import { deleteMemberSegmentAffiliations } from '../member_segment_affiliations'
+import { deleteMemberOrganizations } from '../members/organizations'
+import { insertOrganizationSegments } from '../organizations/segments'
 
 import {
   prepareMemberOrganizationAffiliationTimeline,
@@ -231,18 +234,37 @@ describe('prepareMemberOrganizationAffiliationTimeline', () => {
     ])
 
     const timeline = await prepareMemberOrganizationAffiliationTimeline(qx, member.id)
-    const orgs = baseItems(timeline).map((item) => item.organizationId)
-
-    expect(orgs[0]).toBe(undated.id)
-    expect(orgs).toContain(early.id)
-    expect(orgs).toContain(later.id)
-    // Mid-career hole between early end and later start must also be undated.
-    const gapIdx = orgs.findIndex((id, i) => id === undated.id && i > 0 && orgs[i - 1] === early.id)
-    expect(gapIdx).toBeGreaterThan(0)
-    expect(orgs[gapIdx + 1]).toBe(later.id)
+
+    expectItems(baseItems(timeline), [
+      {
+        organizationId: undated.id,
+        dateStart: EPOCH,
+        dateEnd: '2017-06-30T00:00:00.000Z',
+      },
+      {
+        organizationId: early.id,
+        dateStart: '2017-07-01T00:00:00.000Z',
+        dateEnd: '2020-01-01T00:00:00.000Z',
+      },
+      {
+        organizationId: undated.id,
+        dateStart: '2020-01-02T00:00:00.000Z',
+        dateEnd: '2020-02-29T00:00:00.000Z',
+      },
+      {
+        organizationId: later.id,
+        dateStart: '2020-03-01T00:00:00.000Z',
+        dateEnd: '2021-08-01T00:00:00.000Z',
+      },
+      {
+        organizationId: undated.id,
+        dateStart: '2021-08-02T00:00:00.000Z',
+        dateEnd: null,
+      },
+    ])
   })
 
-  test('primary open-ended employer wins over overlapping blocked stints', async ({ qx }) => {
+  test('allowAffiliation false drops overlapping stints from the timeline', async ({ qx }) => {
     const [employer, internship, foundation, undated] = await createOrganizations(
       qx,
       withOrganizationDefaults([
@@ -290,12 +312,6 @@ describe('prepareMemberOrganizationAffiliationTimeline', () => {
     ])
 
     await createMemberOrganizationAffiliationOverrides(qx, [
-      {
-        memberId: member.id,
-        memberOrganizationId: mos[0].id,
-        allowAffiliation: true,
-        isPrimaryWorkExperience: true,
-      },
       {
         memberId: member.id,
         memberOrganizationId: mos[1].id,
@@ -390,12 +406,15 @@ describe('prepareMemberOrganizationAffiliationTimeline', () => {
     expect(baseItems(timeline).every((item) => item.organizationId !== orgA.id)).toBe(true)
   })
 
-  test('blacklisted titles like Investor and Mentor are excluded', async ({ qx }) => {
-    const [investorOrg, mentorOrg, engOrg] = await createOrganizations(
+  test('blacklisted titles like Investor, Mentor, and Board Member are excluded', async ({
+    qx,
+  }) => {
+    const [investorOrg, mentorOrg, boardOrg, engOrg] = await createOrganizations(
       qx,
       withOrganizationDefaults([
         { displayName: 'Various Startups' },
         { displayName: 'Google' },
+        { displayName: 'Acme Board' },
         { displayName: 'Red Hat' },
       ]),
     )
@@ -418,6 +437,14 @@ describe('prepareMemberOrganizationAffiliationTimeline', () => {
         title: 'Mentor',
         source: OrganizationSource.ENRICHMENT_CRUSTDATA,
       },
+      {
+        memberId: member.id,
+        organizationId: boardOrg.id,
+        dateStart: '2018-01-01T00:00:00.000Z',
+        dateEnd: '2020-01-01T00:00:00.000Z',
+        title: 'Board Member',
+        source: OrganizationSource.ENRICHMENT_CRUSTDATA,
+      },
       {
         memberId: member.id,
         organizationId: engOrg.id,
@@ -433,9 +460,81 @@ describe('prepareMemberOrganizationAffiliationTimeline', () => {
 
     expect(orgIds).not.toContain(investorOrg.id)
     expect(orgIds).not.toContain(mentorOrg.id)
+    expect(orgIds).not.toContain(boardOrg.id)
     expect(orgIds).toContain(engOrg.id)
   })
 
+  test('soft-deleted MO is ignored', async ({ qx }) => {
+    const [activeOrg, deletedOrg] = await createOrganizations(
+      qx,
+      withOrganizationDefaults([{ displayName: 'Red Hat' }, { displayName: 'Gone Co' }]),
+    )
+    const [member] = await createMembers(qx, withMemberDefaults([{}]))
+
+    const [, deletedMo] = await createMemberOrganizations(qx, [
+      {
+        memberId: member.id,
+        organizationId: activeOrg.id,
+        dateStart: '2022-01-01T00:00:00.000Z',
+        dateEnd: null,
+        source: OrganizationSource.UI,
+      },
+      {
+        memberId: member.id,
+        organizationId: deletedOrg.id,
+        dateStart: '2020-01-01T00:00:00.000Z',
+        dateEnd: '2021-01-01T00:00:00.000Z',
+        source: OrganizationSource.UI,
+      },
+    ])
+
+    await deleteMemberOrganizations(qx, member.id, [deletedMo.id])
+
+    const timeline = await prepareMemberOrganizationAffiliationTimeline(qx, member.id)
+    const orgIds = baseItems(timeline).map((item) => item.organizationId)
+
+    expect(orgIds).toContain(activeOrg.id)
+    expect(orgIds).not.toContain(deletedOrg.id)
+  })
+
+  test('soft-deleted MSA is ignored', async ({ qx }) => {
+    const [employer, sponsor] = await createOrganizations(
+      qx,
+      withOrganizationDefaults([{ displayName: 'Akuity Inc' }, { displayName: 'Red Hat' }]),
+    )
+    const [member] = await createMembers(qx, withMemberDefaults([{}]))
+    const { kubernetes } = await createLeafSegments(qx)
+
+    await createMemberOrganizations(qx, [
+      {
+        memberId: member.id,
+        organizationId: employer.id,
+        dateStart: '2021-08-01T00:00:00.000Z',
+        dateEnd: null,
+        source: OrganizationSource.UI,
+      },
+    ])
+
+    const [msa] = await createMemberSegmentAffiliations(qx, [
+      {
+        memberId: member.id,
+        segmentId: kubernetes.id,
+        organizationId: sponsor.id,
+        dateStart: null,
+        dateEnd: null,
+      },
+    ])
+
+    await deleteMemberSegmentAffiliations(qx, { ids: [msa.id] })
+
+    const timeline = await prepareMemberOrganizationAffiliationTimeline(qx, member.id)
+
+    expect(manualItems(timeline)).toHaveLength(0)
+    expect(baseItems(timeline).every((item) => item.skipManualAffiliationSegments === false)).toBe(
+      true,
+    )
+  })
+
   test('undated MSA is a 1970 catch-all; base timeline skips that segment', async ({ qx }) => {
     const [employer, sponsor] = await createOrganizations(
       qx,
@@ -475,6 +574,28 @@ describe('prepareMemberOrganizationAffiliationTimeline', () => {
     )
   })
 
+  test('without MSA, base timeline does not skip manual affiliation segments', async ({ qx }) => {
+    const [org] = await createOrganizations(qx, withOrganizationDefaults([{ displayName: 'Meta' }]))
+    const [member] = await createMembers(qx, withMemberDefaults([{}]))
+
+    await createMemberOrganizations(qx, [
+      {
+        memberId: member.id,
+        organizationId: org.id,
+        dateStart: '2019-06-01T00:00:00.000Z',
+        dateEnd: null,
+        source: OrganizationSource.UI,
+      },
+    ])
+
+    const timeline = await prepareMemberOrganizationAffiliationTimeline(qx, member.id)
+
+    expect(manualItems(timeline)).toHaveLength(0)
+    expect(baseItems(timeline).every((item) => item.skipManualAffiliationSegments === false)).toBe(
+      true,
+    )
+  })
+
   test('dated MSA keeps its date range on the segment timeline', async ({ qx }) => {
     const [org] = await createOrganizations(
       qx,
@@ -584,6 +705,110 @@ describe('prepareMemberOrganizationAffiliationTimeline', () => {
     expect(duringOverlap).toBeDefined()
   })
 
+  test('longer stint wins when overlapping dated MOs share source and memberCount', async ({
+    qx,
+  }) => {
+    const [longer, shorter] = await createOrganizations(
+      qx,
+      withOrganizationDefaults([{ displayName: 'Long Co' }, { displayName: 'Short Co' }]),
+    )
+    const [member] = await createMembers(qx, withMemberDefaults([{}]))
+
+    await createMemberOrganizations(qx, [
+      {
+        memberId: member.id,
+        organizationId: longer.id,
+        dateStart: '2020-01-01T00:00:00.000Z',
+        dateEnd: '2023-01-01T00:00:00.000Z',
+        source: OrganizationSource.ENRICHMENT_CRUSTDATA,
+      },
+      {
+        memberId: member.id,
+        organizationId: shorter.id,
+        dateStart: '2021-01-01T00:00:00.000Z',
+        dateEnd: '2022-01-01T00:00:00.000Z',
+        source: OrganizationSource.ENRICHMENT_CRUSTDATA,
+      },
+    ])
+
+    const timeline = await prepareMemberOrganizationAffiliationTimeline(qx, member.id)
+    const duringOverlap = baseItems(timeline).find(
+      (item) => item.organizationId === longer.id && item.dateStart === '2020-01-01T00:00:00.000Z',
+    )
+
+    expect(duringOverlap).toBeDefined()
+    expect(
+      baseItems(timeline).some(
+        (item) =>
+          item.organizationId === shorter.id && item.dateStart === '2021-01-01T00:00:00.000Z',
+      ),
+    ).toBe(false)
+  })
+
+  test('higher memberCount wins when overlapping dated MOs share source', async ({ qx }) => {
+    const [popular, niche] = await createOrganizations(
+      qx,
+      withOrganizationDefaults([{ displayName: 'Popular Co' }, { displayName: 'Niche Co' }]),
+    )
+    const [member] = await createMembers(qx, withMemberDefaults([{}]))
+    const { kubernetes } = await createLeafSegments(qx)
+
+    // Niche stint is longer; popular must win via memberCount, not longest-range.
+    await createMemberOrganizations(qx, [
+      {
+        memberId: member.id,
+        organizationId: popular.id,
+        dateStart: '2021-01-01T00:00:00.000Z',
+        dateEnd: '2022-01-01T00:00:00.000Z',
+        source: OrganizationSource.ENRICHMENT_CRUSTDATA,
+      },
+      {
+        memberId: member.id,
+        organizationId: niche.id,
+        dateStart: '2020-01-01T00:00:00.000Z',
+        dateEnd: '2023-01-01T00:00:00.000Z',
+        source: OrganizationSource.ENRICHMENT_CRUSTDATA,
+      },
+    ])
+
+    await insertOrganizationSegments(qx, [
+      {
+        organizationId: popular.id,
+        segmentId: kubernetes.id,
+        memberCount: 10_000,
+        activityCount: 1,
+        activeOn: ['github'],
+        joinedAt: '2020-01-01T00:00:00.000Z',
+        lastActive: '2024-01-01T00:00:00.000Z',
+        avgContributorEngagement: 0,
+      },
+      {
+        organizationId: niche.id,
+        segmentId: kubernetes.id,
+        memberCount: 10,
+        activityCount: 1,
+        activeOn: ['github'],
+        joinedAt: '2020-01-01T00:00:00.000Z',
+        lastActive: '2024-01-01T00:00:00.000Z',
+        avgContributorEngagement: 0,
+      },
+    ])
+
+    const timeline = await prepareMemberOrganizationAffiliationTimeline(qx, member.id)
+
+    expect(
+      baseItems(timeline).some(
+        (item) =>
+          item.organizationId === popular.id && item.dateStart === '2021-01-01T00:00:00.000Z',
+      ),
+    ).toBe(true)
+    expect(
+      baseItems(timeline).some(
+        (item) => item.organizationId === niche.id && item.dateStart === '2021-01-01T00:00:00.000Z',
+      ),
+    ).toBe(false)
+  })
+
   test('company is preferred over university when dated stints overlap', async ({ qx }) => {
     const [company, university] = await createOrganizations(
       qx,
@@ -823,6 +1048,57 @@ describe('refreshMemberOrganizationAffiliations', () => {
     expect(await countByOrg(qx, member.id, kubernetes.id, employer.id)).toBe(0)
   })
 
+  test('dated MSA applies only inside its window; MO covers activities outside', async ({ qx }) => {
+    const [employer, sponsor] = await createOrganizations(
+      qx,
+      withOrganizationDefaults([{ displayName: 'Akuity Inc' }, { displayName: 'Red Hat' }]),
+    )
+    const { member, identities } = await createMemberWithIdentity(qx, { value: 'contributor' })
+    const { kubernetes } = await createLeafSegments(qx)
+
+    await createMemberOrganizations(qx, [
+      {
+        memberId: member.id,
+        organizationId: employer.id,
+        dateStart: '2020-01-01T00:00:00.000Z',
+        dateEnd: null,
+        source: OrganizationSource.UI,
+      },
+    ])
+
+    await createMemberSegmentAffiliations(qx, [
+      {
+        memberId: member.id,
+        segmentId: kubernetes.id,
+        organizationId: sponsor.id,
+        dateStart: '2021-01-01T00:00:00.000Z',
+        dateEnd: '2021-06-01T00:00:00.000Z',
+      },
+    ])
+
+    await createActivityRelations(qx, [
+      ...generateActivityRelations({
+        memberId: member.id,
+        segmentId: kubernetes.id,
+        identities,
+        count: 40,
+        timestamp: { from: '2021-02-01T00:00:00.000Z', to: '2021-05-01T00:00:00.000Z' },
+      }),
+      ...generateActivityRelations({
+        memberId: member.id,
+        segmentId: kubernetes.id,
+        identities,
+        count: 30,
+        timestamp: { from: '2022-01-01T00:00:00.000Z', to: '2022-06-01T00:00:00.000Z' },
+      }),
+    ])
+
+    await refreshMemberOrganizationAffiliations(qx, member.id)
+
+    expect(await countByOrg(qx, member.id, kubernetes.id, sponsor.id)).toBe(40)
+    expect(await countByOrg(qx, member.id, kubernetes.id, employer.id)).toBe(30)
+  })
+
   test('email-domain activities route to matching org over the date timeline', async ({ qx }) => {
     const [emailOrg, datedOrg] = await createOrganizations(
       qx,