@pbvision/cloud-run-service 0.0.46

package/test/unit-test-analytics.js

@@ -0,0 +1,280 @@
+import crypto from 'node:crypto'
+
+import { mixpanelToken } from '../src/analytics.js'
+
+import { AppTest, runTests } from './base-test.js'
+
+class AnalyticsTest extends AppTest {
+  async beforeEach () {
+    await super.beforeEach()
+    // mock using node-fetch to request the mixpanel APIs
+    this.fetchMock.mockResp(1)
+  }
+
+  async testMixpanelAPIFailure () {
+    this.fetchMock.mockResp(0)
+    await this.sendBasicEvent(null, 551)
+
+    this.fetchMock.mockResp('', 500)
+    await this.sendBasicEvent(null, 551)
+  }
+
+  async testNoAnalyticsLogged () {
+    await this.app.post('/analytics')
+      .send({})
+      .expect(200)
+    expect(this.fetchMock).not.toHaveBeenCalled()
+  }
+
+  async testSendingEvents () {
+    await this.sendBasicEvent()
+    expect(this.fetchMock).toHaveBeenCalledWith(
+      'https://api.mixpanel.com/track',
+      expect.objectContaining({
+        headers: { accept: 'text/plain', 'content-type': 'application/json' },
+        method: 'POST',
+        compress: true
+      }))
+    const calls = this.fetchMock.mock.calls
+    expect(calls.length).toBe(1)
+    const actualBody = JSON.parse(calls[0][1].body)
+    expect(actualBody).toEqual([{
+      event: 'some event',
+      properties: expect.objectContaining({
+        cool: 1,
+        hi: 'world',
+        $user_id: 'some uid',
+        token: mixpanelToken
+      })
+    }])
+    const props = actualBody[0].properties
+    expect(typeof props.ip).toBe('string')
+    expect(new Date().getTime() - props.time).toBeLessThan(5000)
+    expect(props.$insert_id).toMatch(/[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}/)
+  }
+
+  async sendBasicEvent (userAgent, expRespCode = 200) {
+    const req = this.app.post('/analytics')
+    if (userAgent) {
+      req.set('User-Agent', userAgent)
+    }
+    await req.send({
+      eventCalls: [
+        ['some uid', 'some event', { cool: 1, hi: 'world' }]
+      ]
+    }).expect(expRespCode)
+  }
+
+  async testSendInBatches () {
+    await this.app.post('/analytics')
+      .send({
+        eventCalls: [
+          ['xyz', 'some event', { cool: 1, hi: 'world' }]
+        ],
+        moreEventCalls: [
+          ['xyz', 'another event', { x: 2 }]
+        ]
+      }).expect(200)
+    const calls = this.fetchMock.mock.calls
+    expect(calls.length).toBe(2)
+    const actualBody = JSON.parse(calls[0][1].body)
+    expect(actualBody).toEqual([{
+      event: 'some event',
+      properties: expect.objectContaining({
+        cool: 1,
+        hi: 'world',
+        $user_id: 'xyz',
+        token: mixpanelToken
+      })
+    }])
+    const actualBody2 = JSON.parse(calls[1][1].body)
+    expect(actualBody2).toEqual([{
+      event: 'another event',
+      properties: expect.objectContaining({
+        x: 2,
+        $user_id: 'xyz',
+        token: mixpanelToken
+      })
+    }])
+  }
+
+  async testDeviceId () {
+    await this.app.post('/analytics')
+      .send({
+        eventCalls: [
+          ['$device:xyz', 'some event', { cool: 1, hi: 'world' }]
+        ]
+      }).expect(200)
+    const calls = this.fetchMock.mock.calls
+    expect(calls.length).toBe(1)
+    const actualBody = JSON.parse(calls[0][1].body)
+    expect(actualBody).toEqual([{
+      event: 'some event',
+      properties: expect.objectContaining({
+        cool: 1,
+        hi: 'world',
+        distinct_id: '$device:xyz',
+        $device_id: 'xyz',
+        token: mixpanelToken
+      })
+    }])
+  }
+
+  async testDeviceIdWithUserId () {
+    await this.app.post('/analytics')
+      .send({
+        eventCalls: [
+          ['some uid', 'some event', { cool: 1, hi: 'world' }, '$device:xyz']
+        ]
+      }).expect(200)
+    const calls = this.fetchMock.mock.calls
+    expect(calls.length).toBe(1)
+    const actualBody = JSON.parse(calls[0][1].body)
+    expect(actualBody).toEqual([{
+      event: 'some event',
+      properties: expect.objectContaining({
+        cool: 1,
+        hi: 'world',
+        $user_id: 'some uid',
+        distinct_id: 'some uid',
+        $device_id: 'xyz',
+        token: mixpanelToken
+      })
+    }])
+  }
+
+  async testCustomInsertionId () {
+    await this.app.post('/analytics')
+      .send({
+        eventCalls: [
+          ['some uid', 'some event', { cool: 1, hi: 'world' }, null, 'xx']
+        ]
+      }).expect(200)
+    const calls = this.fetchMock.mock.calls
+    expect(calls.length).toBe(1)
+    const actualBody = JSON.parse(calls[0][1].body)
+    expect(actualBody).toEqual([{
+      event: 'some event',
+      properties: expect.objectContaining({
+        cool: 1,
+        hi: 'world',
+        $user_id: 'some uid',
+        token: mixpanelToken,
+        $insert_id: crypto.createHash('md5').update('xx').digest('hex')
+      })
+    }])
+  }
+
+  async testOmittingEventProperties () {
+    await this.app.post('/analytics')
+      .send({
+        eventCalls: [
+          ['some uid', 'some event']
+        ]
+      }).expect(200)
+    const calls = this.fetchMock.mock.calls
+    expect(calls.length).toBe(1)
+    const actualBody = JSON.parse(calls[0][1].body)
+    expect(actualBody).toEqual([{
+      event: 'some event',
+      properties: expect.objectContaining({
+        $user_id: 'some uid',
+        token: mixpanelToken
+      })
+    }])
+  }
+
+  async testUserAgent () {
+    await this.sendBasicEvent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36')
+    const calls = this.fetchMock.mock.calls
+    expect(calls.length).toBe(1)
+    const actualBody = JSON.parse(calls[0][1].body)
+    const props = actualBody[0].properties
+    expect(props.$browser).toBe('Chrome 122.0.0.0')
+    expect(props.$device).toBe(undefined)
+    expect(props.$os).toBe('Windows 10')
+  }
+
+  async testUserAgentWithDevice () {
+    await this.sendBasicEvent('Mozilla/5.0 (PlayBook; U; RIM Tablet OS 1.0.0; en-US) AppleWebKit/534.11 (KHTML, like Gecko) Version/7.1.0.7 Safari/534.11')
+    const calls = this.fetchMock.mock.calls
+    expect(calls.length).toBe(1)
+    const actualBody = JSON.parse(calls[0][1].body)
+    const props = actualBody[0].properties
+    expect(props.$browser).toBe('Safari 7.1.0.7')
+    expect(props.$device).toBe('RIM PlayBook tablet')
+    expect(props.$os).toBe('RIM Tablet OS 1.0.0')
+  }
+
+  async sendUserProfileUpdate (profileUpdates) {
+    const req = this.app.post('/analytics')
+    await req.send({ profileUpdates }).expect(200)
+  }
+
+  async testUserProfileUpdates () {
+    const uids = ['uid0', 'uid1']
+    await this.sendUserProfileUpdate([
+      [uids[0], 'p1', true],
+      [uids[0], 'p2', 5],
+      [uids[1], 'p2', 6],
+      [uids[1], 'p1', 'nope', '$set'],
+      [uids[1], 'p1', 'cool'],
+      [uids[1], 'p1', 'once', '$set_once'],
+      [uids[0], 'p1', false],
+      [uids[0], 'p3', 'hi']
+    ])
+    const calls = this.fetchMock.mock.calls
+    expect(calls.length).toBe(2)
+    const setURL = 'https://api.mixpanel.com/engage#profile-set'
+    const setOnceURL = 'https://api.mixpanel.com/engage#profile-set-once'
+    expect(this.fetchMock).toHaveBeenCalledWith(
+      setURL,
+      expect.objectContaining({
+        headers: { accept: 'text/plain', 'content-type': 'application/json' },
+        method: 'POST',
+        compress: true
+      }))
+    expect(this.fetchMock).toHaveBeenCalledWith(
+      setOnceURL,
+      expect.objectContaining({
+        headers: { accept: 'text/plain', 'content-type': 'application/json' },
+        method: 'POST',
+        compress: true
+      }))
+    // sort $set first, then $set_once (just so we have a consistent order for
+    // the test to check)
+    calls.sort((a, b) => a[0].localeCompare(b[0]))
+
+    // check $set updates
+    const actualSetUpdates = JSON.parse(calls[0][1].body)
+    actualSetUpdates.sort((a, b) => a.$distinct_id.localeCompare(b.$distinct_id))
+    const expectedSets = [
+      { p1: false, p2: 5, p3: 'hi' },
+      { p1: 'cool', p2: 6 }
+    ]
+    for (let i = 0; i < actualSetUpdates.length; i++) {
+      const actualArgs = actualSetUpdates[i]
+      expect(actualArgs).toEqual({
+        $token: mixpanelToken,
+        $distinct_id: uids[i],
+        $set: expectedSets[i]
+      })
+    }
+
+    // check $set_once updates
+    const actualSetOnceUpdates = JSON.parse(calls[1][1].body)
+    const expectedSetOnces = [
+      { p1: 'once' }
+    ]
+    for (let i = 0; i < actualSetOnceUpdates.length; i++) {
+      const actualArgs = actualSetOnceUpdates[i]
+      expect(actualArgs).toEqual({
+        $token: mixpanelToken,
+        $distinct_id: uids[1],
+        $set_once: expectedSetOnces[i]
+      })
+    }
+  }
+}
+
+runTests(AnalyticsTest)

package/test/unit-test-call-service-api.js

@@ -0,0 +1,96 @@
+import { jest } from '@jest/globals'
+import { GoogleAuth } from 'google-auth-library'
+
+import { AppTest, runTests } from './base-test.js'
+
+class TestCallServiceAPI extends AppTest {
+  async beforeAll () {
+    await super.beforeAll()
+
+    // mock GoogleAuth because we can't actually get a token during testing
+    this.fetchIdToken = jest.fn().mockReturnValue('fake-token')
+    jest.spyOn(GoogleAuth.prototype, 'getIdTokenClient').mockImplementation(() => ({
+      idTokenProvider: {
+        fetchIdToken: this.fetchIdToken
+      }
+    }))
+  }
+
+  async beforeEach () {
+    await super.beforeEach()
+    // mock using node-fetch to request an API
+    this.fetchMock.mockResp()
+    this.fetchIdToken.mockClear()
+    GoogleAuth.prototype.getIdTokenClient.mockClear()
+  }
+
+  async afterAll () {
+    await super.afterAll()
+    jest.restoreAllMocks()
+  }
+
+  async check (args, respBody = '', expCode = 200, expPort = 8080) {
+    const result = await this.app.post('/callService').send(args).expect(200)
+    const resp = result.body
+    expect(resp.code).toBe(expCode)
+    expect(resp.body).toEqual(respBody)
+
+    const shouldHaveToken = args.isServiceInternal ?? true
+    const expHeaders = args.headers ?? {}
+    if (shouldHaveToken) {
+      expHeaders.Authorization = 'Bearer fake-token'
+    }
+    expect(this.fetchMock).toHaveBeenCalledWith(
+      `http://localhost:${expPort}${args.path}`, {
+        body: args.body,
+        headers: expHeaders,
+        method: args.method ?? 'POST',
+        compress: true
+      })
+
+    // make sure Google Auth was called with appropriate arguments (or not, if
+    // this wasn't an internal call)
+    if (shouldHaveToken) {
+      const targetAudience = `http://localhost:${expPort}/`
+      expect(GoogleAuth.prototype.getIdTokenClient).toHaveBeenCalledWith(targetAudience)
+      expect(this.fetchIdToken).toHaveBeenCalledWith(targetAudience)
+    } else {
+      expect(GoogleAuth.prototype.getIdTokenClient).not.toHaveBeenCalled()
+    }
+  }
+
+  async testServiceCallingItsOwnInternalAPI () {
+    await this.check({
+      service: process.env.SERVICE,
+      path: '/someAPI',
+      isServiceInternal: true
+    })
+  }
+
+  async testServiceCallingItsOwnPublicAPI () {
+    await this.check({
+      service: process.env.SERVICE,
+      path: '/someAPI',
+      isServiceInternal: false
+    })
+  }
+
+  async testServiceCallingAnotherOneOfItsAPIs () {
+    this.fetchMock.mockResp({ x: 3 })
+    await this.check({
+      service: process.env.SERVICE,
+      path: '/x/y/z'
+    }, JSON.stringify({ x: 3 }))
+  }
+
+  async testServiceCallingAnotherService () {
+    process.env.LOCAL_SERVICE_PORT_MAP = JSON.stringify({ notMe: 9999 })
+    this.fetchMock.mockResp('test resp', 222)
+    await this.check({
+      service: 'notMe',
+      path: '/x'
+    }, 'test resp', 222, 9999)
+  }
+}
+
+runTests(TestCallServiceAPI)

package/test/unit-test-placeholder.js

@@ -0,0 +1,10 @@
+import { AppTest, runTests } from './base-test.js'
+
+class PlaceholderTest extends AppTest {
+  async testTime () {
+    const ret = await this.app.get('/time').expect(200)
+    expect(Object.keys(ret.body)).toEqual(['epoch'])
+  }
+}
+
+runTests(PlaceholderTest)

package/test/unit-test-tasks.js

@@ -0,0 +1,133 @@
+import crypto from 'node:crypto'
+
+import { CloudTasksClient } from '@google-cloud/tasks'
+import { expect, jest } from '@jest/globals'
+
+import { enqueueCloudTask } from '../src/tasks.js'
+
+import { BaseTest, runTests } from './base-test.js'
+
+class TestTasks extends BaseTest {
+  async beforeAll () {
+    await super.beforeAll()
+
+    process.env.LOCAL_SERVICE_PORT_MAP = JSON.stringify({ internal: 8888 })
+
+    // mock GoogleAuth because we can't actually get a token during testing
+    this.createTaskReturnValue = new Promise(resolve => resolve())
+    jest.spyOn(CloudTasksClient.prototype, 'createTask').mockImplementation(
+      () => this.createTaskReturnValue)
+  }
+
+  async beforeEach () {
+    await super.beforeEach()
+    CloudTasksClient.prototype.createTask.mockClear()
+  }
+
+  async afterAll () {
+    await super.afterAll()
+    jest.restoreAllMocks()
+  }
+
+  async check (args, taskExpectations = {}, expRejectionMsg = null) {
+    const promise = enqueueCloudTask({
+      queue: 'test-queue',
+      ...args
+    })
+    if (expRejectionMsg) {
+      await expect(promise).rejects.toThrow(expRejectionMsg)
+    } else {
+      await promise
+    }
+    expect(CloudTasksClient.prototype.createTask).toHaveBeenCalledWith({
+      // assuming values for project (localhost-emulator) and region (us-central1) and
+      // service (tbd)
+      parent: 'projects/localhost-emulator/locations/us-central1/queues/test-queue',
+      task: {
+        httpRequest: {
+          body: Buffer.from(JSON.stringify(args.payload)).toString('base64'),
+          headers: { 'Content-Type': 'application/json' },
+          httpMethod: 'POST',
+          oidcToken: {
+            serviceAccountEmail: 'cr-tbd@localhost-emulator.iam.gserviceaccount.com'
+          },
+          url: 'http://localhost:8888/test_queue'
+        },
+        ...taskExpectations
+      }
+    })
+  }
+
+  async testEnqueueTask () {
+    await this.check({ payload: { x: 3 } })
+  }
+
+  async testEnqueueTaskWithDelay () {
+    const now = new Date().getTime() / 1000
+    await this.check(
+      { payload: { x: 3 }, delaySecs: 10 },
+      { scheduleTime: { seconds: expect.closeTo(now + 10, -0.7) } })
+  }
+
+  async testEnqueueTaskWithSchedule () {
+    const target = 100 + Math.floor(new Date().getTime() / 1000)
+    await this.check(
+      { payload: { x: 3 }, scheduledEpoch: target },
+      { scheduleTime: { seconds: target } })
+  }
+
+  async testEnqueueTaskWithName () {
+    await this.check(
+      { name: 'x', payload: { x: 3 } },
+      { name: 'projects/localhost-emulator/locations/us-central1/queues/test-queue/tasks/x' })
+  }
+
+  async testEnqueueTaskWithHashName () {
+    const partsToCheck = [
+      [], ['x'], ['x', 'yyy', '']
+    ]
+    for (const hashNameParts of partsToCheck) {
+      const expName = crypto.createHash('md5').update(
+        ['test-queue'].concat(hashNameParts).join('|')).digest('hex')
+      await this.check(
+        { hashNameParts, payload: { x: 3 } },
+        { name: 'projects/localhost-emulator/locations/us-central1/queues/test-queue/tasks/' + expName })
+    }
+  }
+
+  async testEnqueueTaskWithNameThatWasRecentlyUsedNOTOkay () {
+    this.createTaskReturnValue = new Promise((resolve, reject) => {
+      const err = new Error('6 ALREADY_EXISTS and other random details')
+      err.code = 6
+      reject(err)
+    })
+    await this.check(
+      { name: 'x', payload: { x: 3 }, ignoreNameAlreadyUsedError: true },
+      { name: 'projects/localhost-emulator/locations/us-central1/queues/test-queue/tasks/x' })
+  }
+
+  async testEnqueueTaskWithNameThatWasRecentlyUsedAndThatsOkay () {
+    this.createTaskReturnValue = new Promise((resolve, reject) => {
+      const err = new Error('6 ALREADY_EXISTS and other random details')
+      err.code = 6
+      reject(err)
+    })
+    await this.check(
+      { name: 'x', payload: { x: 3 } },
+      { name: 'projects/localhost-emulator/locations/us-central1/queues/test-queue/tasks/x' },
+      'task name already used recently: x')
+  }
+
+  async testEnqueueTaskThrowsUnknownExceptions () {
+    this.createTaskReturnValue = new Promise((resolve, reject) => {
+      const err = new Error('ALREADY_EXISTS but not in right format')
+      reject(err)
+    })
+    await this.check(
+      { name: 'x', payload: { x: 3 } },
+      { name: 'projects/localhost-emulator/locations/us-central1/queues/test-queue/tasks/x' },
+      'not in right format')
+  }
+}
+
+runTests(TestTasks)

package/test/unit-test-utils.js

@@ -0,0 +1,44 @@
+import { jest } from '@jest/globals'
+
+import { BaseTest, runTests } from '../node_modules/@pbvision/fastify-firestore-service/test/base-test.js'
+import { port } from '../src/port.js'
+import { getServiceHost, isCloud, isDev, isLocalhost, isProd, usingEmulator } from '../src/utils.js'
+
+const ORIG_ENV = process.env
+
+class TestUtils extends BaseTest {
+  beforeEach () {
+    jest.resetModules()
+    process.env = { ...ORIG_ENV }
+  }
+
+  afterEach () {
+    process.env = ORIG_ENV
+  }
+
+  testEnv () {
+    expect(process.env.GIT_HASH).toBe(undefined)
+    expect(process.env.K_REVISION).toBe('unittest')
+    expect(process.env.NODE_ENV).toBe('localhost')
+    expect(isLocalhost).toBe(true)
+    expect(isCloud).toBe(false)
+    expect(isProd).toBe(false)
+    expect(isDev).toBe(false)
+    expect(usingEmulator).toBe(true)
+  }
+
+  testGetServiceHost () {
+    expect(getServiceHost(process.env.SERVICE)).toBe(`localhost:${port}`)
+    expect(() => getServiceHost('unknown')).toThrow()
+    process.env.LOCAL_SERVICE_PORT_MAP = JSON.stringify({ unknown: 8088 })
+    expect(getServiceHost('unknown')).toBe('localhost:8088')
+    expect(() => getServiceHost('actually_unknown')).toThrow()
+
+    process.env.NODE_ENV = 'dev'
+    const testSuffix = '-tbd-uc.a.run.app'
+    process.env.CLOUD_RUN_HOSTNAME_SUFFIX = testSuffix
+    expect(getServiceHost('unknown')).toBe('unknown' + testSuffix)
+  }
+}
+
+runTests(TestUtils)