update_metric_in_google_sheet.test.js

import assert from 'node:assert/strict'
import { randomUUID } from 'node:crypto'
import { loadEnvFile } from 'node:process'
import { describe, it } from 'node:test'

try {
  loadEnvFile('.env')
} catch (error) {
  if (error.code === 'ENOENT') {
    console.log('No env file found, proceeding without it')
  } else {
    throw error
  }
}

const {
  default: component,
  calculateUniqueRunID,
} = await import('./update_metric_in_google_sheet.js')

describe(component.name, () => {
  describe('run', () => {
    it('should add a column if no column is found for that record type', async (testContext) => {
      const googleServiceAccountKey = process.env.TEST_GOOGLE_SERVICE_ACCOUNT_KEY
      if (!googleServiceAccountKey) {
        testContext.skip('Lacking GOOGLE_SERVICE_ACCOUNT_KEY, skipping test')
        return
      }
      const googleSheetId = process.env.TEST_GOOGLE_SHEET_ID
      assert.ok(googleSheetId, 'No GOOGLE_SHEET_ID provided')

      component.run_id = 'abcd1234'
      component.source_file_name = 'test.csv'
      component.record_type = Math.random() + ' Lines'
      component.number_of_items = 1
      component.google_sheet_id = googleSheetId
      component.google_service_account_key = googleServiceAccountKey

      const response = await component.run({
        steps: { trigger: {} },
        $: {}
      })

      console.debug(response)
      assert.equal(response.error, undefined)
      assert.ok(
        String(response.warnings?.join("\n")).includes('No column found for'),
        'Expected a warning that no column was found for that record type'
      )
      assert.ok(response.insertedNewColumn)
      assert.equal(response.newCount, 1)
    })

    it('should report an error if not given a Run ID (nor told to generate a new one)', async (testContext) => {
      const googleServiceAccountKey = process.env.TEST_GOOGLE_SERVICE_ACCOUNT_KEY
      if (!googleServiceAccountKey) {
        testContext.skip('Lacking GOOGLE_SERVICE_ACCOUNT_KEY, skipping test')
        return
      }
      const googleSheetId = process.env.TEST_GOOGLE_SHEET_ID
      assert.ok(googleSheetId, 'No GOOGLE_SHEET_ID provided')

      component.run_id = ''
      component.source_file_name = 'test.csv'
      component.record_type = 'ICJEs'
      component.number_of_items = 1
      component.google_sheet_id = googleSheetId
      component.google_service_account_key = googleServiceAccountKey

      const response = await component.run({
        steps: { trigger: {} },
        $: {}
      })

      console.debug(response)
      assert.ok(
        String(response.error).includes('Run ID'),
        'Expected an error about the Run ID'
      )
    })

    it('should report an error if given a Record Type when generating a new row', async (testContext) => {
      const googleServiceAccountKey = process.env.TEST_GOOGLE_SERVICE_ACCOUNT_KEY
      if (!googleServiceAccountKey) {
        testContext.skip('Lacking GOOGLE_SERVICE_ACCOUNT_KEY, skipping test')
        return
      }
      const googleSheetId = process.env.TEST_GOOGLE_SHEET_ID
      assert.ok(googleSheetId, 'No GOOGLE_SHEET_ID provided')

      component.run_id = 'NEW'
      component.source_file_name = 'test.csv'
      component.record_type = 'ICJE Lines'
      component.number_of_items = 1
      component.google_sheet_id = googleSheetId
      component.google_service_account_key = googleServiceAccountKey

      const response = await component.run({
        steps: { trigger: {} },
        $: {}
      })

      console.debug(response)
      const errorMessage = String(response.error)
      assert.ok(
        errorMessage.includes('Record Type') && errorMessage.includes('new'),
        'Expected an error about providing a Record Type when generating a new Run ID'
      )
    })

    it('should return an error if no row has the given the File Name and Run ID', async (testContext) => {
      const googleServiceAccountKey = process.env.TEST_GOOGLE_SERVICE_ACCOUNT_KEY
      if (!googleServiceAccountKey) {
        testContext.skip('Lacking GOOGLE_SERVICE_ACCOUNT_KEY, skipping test')
        return
      }
      const googleSheetId = process.env.TEST_GOOGLE_SHEET_ID
      assert.ok(googleSheetId, 'No GOOGLE_SHEET_ID provided')

      component.run_id = 'zzzzzzzz'
      component.source_file_name = 'test.csv'
      component.record_type = 'ICJE Lines'
      component.number_of_items = 1
      component.google_sheet_id = googleSheetId
      component.google_service_account_key = googleServiceAccountKey

      const response = await component.run({
        steps: { trigger: {} },
        $: {}
      })

      console.debug(response)
      assert.ok(
        String(response.error).includes('No row found for'),
        'Expected an error that no row was found for that run id'
      )
    })

    it('should add a row (and use the Event ID as the actual Run ID) if given a Run ID of "NEW"', async (testContext) => {
      const googleServiceAccountKey = process.env.TEST_GOOGLE_SERVICE_ACCOUNT_KEY
      if (!googleServiceAccountKey) {
        testContext.skip('Lacking GOOGLE_SERVICE_ACCOUNT_KEY, skipping test')
        return
      }
      const googleSheetId = process.env.TEST_GOOGLE_SHEET_ID
      assert.ok(googleSheetId, 'No GOOGLE_SHEET_ID provided')
      const exampleEventId = randomUUID()

      component.run_id = 'NEW'
      component.source_file_name = 'test.csv'
      component.record_type = ''
      component.number_of_items = 1
      component.google_sheet_id = googleSheetId
      component.google_service_account_key = googleServiceAccountKey
      component.event_id = exampleEventId

      const response = await component.run()

      console.debug(response)
      assert.equal(response.error, undefined)
      assert.ok(response.insertedNewRow)
      assert.equal(response.runID, exampleEventId)
      assert.notEqual(response.runID, 'NEW')
      assert.equal(response.newCount, undefined)
    })

    it('should indicate that it was a dry run (when adding a new row during a dry run)', async (testContext) => {
      const googleServiceAccountKey = process.env.TEST_GOOGLE_SERVICE_ACCOUNT_KEY
      if (!googleServiceAccountKey) {
        testContext.skip('Lacking GOOGLE_SERVICE_ACCOUNT_KEY, skipping test')
        return
      }
      const googleSheetId = process.env.TEST_GOOGLE_SHEET_ID
      assert.ok(googleSheetId, 'No GOOGLE_SHEET_ID provided')
      const exampleEventId = randomUUID()

      component.run_id = 'NEW'
      component.was_dry_run = true
      component.source_file_name = 'test.csv'
      component.record_type = ''
      component.number_of_items = 1
      component.google_sheet_id = googleSheetId
      component.google_service_account_key = googleServiceAccountKey
      component.event_id = exampleEventId

      const response = await component.run()

      console.debug(response)
      assert.equal(response.error, undefined)
      assert.ok(response.insertedNewRow)
      assert.equal(response.dryRun, 'Yes')
    })

    it('should indicate that it was not a dry run (when adding a new row during a non-dry-run)', async (testContext) => {
      const googleServiceAccountKey = process.env.TEST_GOOGLE_SERVICE_ACCOUNT_KEY
      if (!googleServiceAccountKey) {
        testContext.skip('Lacking GOOGLE_SERVICE_ACCOUNT_KEY, skipping test')
        return
      }
      const googleSheetId = process.env.TEST_GOOGLE_SHEET_ID
      assert.ok(googleSheetId, 'No GOOGLE_SHEET_ID provided')
      const exampleEventId = randomUUID()

      component.run_id = 'NEW'
      component.was_dry_run = false
      component.source_file_name = 'test.csv'
      component.record_type = ''
      component.number_of_items = 1
      component.google_sheet_id = googleSheetId
      component.google_service_account_key = googleServiceAccountKey
      component.event_id = exampleEventId

      const response = await component.run()

      console.debug(response)
      assert.equal(response.error, undefined)
      assert.ok(response.insertedNewRow)
      assert.equal(response.dryRun, 'No')
    })

    it('should add a row and calculate a unique Run ID if given an existing Run ID when adding a row', async (testContext) => {
      const googleServiceAccountKey = process.env.TEST_GOOGLE_SERVICE_ACCOUNT_KEY
      if (!googleServiceAccountKey) {
        testContext.skip('Lacking GOOGLE_SERVICE_ACCOUNT_KEY, skipping test')
        return
      }
      const googleSheetId = process.env.TEST_GOOGLE_SHEET_ID
      assert.ok(googleSheetId, 'No GOOGLE_SHEET_ID provided')
      const existingEventId = 'abcd1234'

      component.run_id = 'NEW'
      component.source_file_name = 'test.csv'
      component.record_type = ''
      component.number_of_items = 1
      component.google_sheet_id = googleSheetId
      component.google_service_account_key = googleServiceAccountKey
      component.event_id = existingEventId

      const response = await component.run()

      console.debug(response)
      assert.equal(response.error, undefined)
      assert.ok(response.insertedNewRow)
      assert.ok(response.runID.startsWith(existingEventId))
      assert.notEqual(response.runID, existingEventId)
      assert.notEqual(response.runID, 'NEW')
      assert.equal(response.newCount, undefined)
    })

    it('should update the existing row if one matches the File Name and Run ID', async (testContext) => {
      const googleServiceAccountKey = process.env.TEST_GOOGLE_SERVICE_ACCOUNT_KEY
      if (!googleServiceAccountKey) {
        testContext.skip('Lacking GOOGLE_SERVICE_ACCOUNT_KEY, skipping test')
        return
      }
      const googleSheetId = process.env.TEST_GOOGLE_SHEET_ID
      assert.ok(googleSheetId, 'No GOOGLE_SHEET_ID provided')

      component.run_id = 'abcd1234'
      component.source_file_name = 'test.csv'
      component.record_type = 'ICJE Lines'
      component.number_of_items = 1
      component.google_sheet_id = googleSheetId
      component.google_service_account_key = googleServiceAccountKey

      const response = await component.run({
        steps: { trigger: {} },
        $: {}
      })

      console.debug(response)
      assert.equal(response.error, undefined)
      assert.equal(response.insertedNewRow, false)
      assert.equal(response.runID, component.run_id)
      assert.ok(response.newCount > 0)
    })

    it('should update by the specified amount', async (testContext) => {
      const googleServiceAccountKey = process.env.TEST_GOOGLE_SERVICE_ACCOUNT_KEY
      if (!googleServiceAccountKey) {
        testContext.skip('Lacking GOOGLE_SERVICE_ACCOUNT_KEY, skipping test')
        return
      }
      const googleSheetId = process.env.TEST_GOOGLE_SHEET_ID
      assert.ok(googleSheetId, 'No GOOGLE_SHEET_ID provided')

      component.run_id = 'abcd1234'
      component.source_file_name = 'test.csv'
      component.record_type = 'Invoice Lines'
      component.number_of_items = 3
      component.google_sheet_id = googleSheetId
      component.google_service_account_key = googleServiceAccountKey

      const response = await component.run({
        steps: { trigger: {} },
        $: {}
      })

      console.debug(response)
      assert.equal(response.error, undefined)
      assert.equal(response.insertedNewRow, false)
      assert.equal(response.runID, component.run_id)
      assert.notEqual(response.previousCount, undefined, 'Did not return previous count')
      assert.equal(
        response.newCount - response.previousCount,
        component.number_of_items
      )
    })

    it('should gracefully handle any Errors thrown', async () => {
      component.google_service_account_key = 'NOT a valid JSON string, to trigger an error'

      const response = await component.run()

      console.debug(response)
      assert.notEqual(response.error, undefined)
    })
  })

  describe('calculateUniqueRunID', () => {
    it('should return the given Run ID if it is not in the list of existing Run IDs', async () => {
      const givenRunID = 'abcd1234'
      const existingRunIDs = []
      const result = calculateUniqueRunID(givenRunID, existingRunIDs)

      assert.equal(result, givenRunID)
    })

    it('should return a modified Run ID if the given one is in the list of existing Run IDs', async () => {
      const givenRunID = 'abcd1234'
      const existingRunIDs = ['abcd1234']

      const result = calculateUniqueRunID(givenRunID, existingRunIDs)

      assert.notEqual(result, givenRunID)
    })

    it('should return a unique Run ID even if the given one and what it would change it to are in the list of existing Run IDs', async () => {
      const givenRunID = 'abcd1234'
      const existingRunIDs = ['abcd1234']
      const nextRunID = calculateUniqueRunID(givenRunID, existingRunIDs)
      existingRunIDs.push(nextRunID)

      const result = calculateUniqueRunID(givenRunID, existingRunIDs)

      assert.notEqual(result, givenRunID)
      for (const existingRunID of existingRunIDs) {
        assert.notEqual(result, existingRunID)
      }
    })
  })
})