@playpilot/tpi 1.0.0

package/src/tests/lib/api.test.js

@@ -0,0 +1,162 @@
+import { describe, it, expect, vi, afterEach, beforeEach } from 'vitest'
+import { fetchLinkInjections, pollLinkInjections } from '$lib/api'
+import { fakeFetch } from '../helpers'
+import { authorize, isEditorialModeEnabled } from '$lib/auth'
+
+vi.mock('$lib/auth', async importActual => {
+  const actual = await importActual()
+  return {
+    // @ts-ignore
+    ...actual,
+    authorize: vi.fn(() => false),
+    isEditorialModeEnabled: vi.fn(() => false),
+  }
+})
+
+describe('$lib/api', () => {
+  afterEach(() => {
+    vi.resetAllMocks()
+    // @ts-ignore
+    window.PlayPilotLinkInjections = null
+  })
+
+  describe('fetchLinkInjections', () => {
+    beforeEach(() => {
+      // @ts-ignore
+      window.PlayPilotLinkInjections = { token: 'a' }
+    })
+
+    it('Should call fetch with given url and body', async () => {
+      fakeFetch({ response: 'Some response' })
+
+      const response = await fetchLinkInjections('https://some-url', 'some-html', { hash: 'some-hash' })
+
+      expect(response).toBe('Some response')
+      expect(global.fetch).toHaveBeenCalledWith(
+        expect.stringContaining('api-token'),
+        expect.objectContaining({
+          body: JSON.stringify({
+            hash: 'some-hash',
+            url: 'https://some-url',
+            page_text: 'some-html',
+          }),
+          method: 'POST',
+          headers: expect.any(Object),
+        }),
+      )
+    })
+
+    it('Should throw when no api token was given', async () => {
+      // @ts-ignore
+      window.PlayPilotLinkInjections = null
+
+      await expect(async () => await fetchLinkInjections('https://some-url', 'some-html', { hash: 'some-hash' })).rejects.toThrowError('No token was provided')
+    })
+
+    it('Should throw when response was incorrect', async () => {
+      fakeFetch({ ok: false })
+
+      await expect(async () => await fetchLinkInjections('https://some-url', 'some-html', { hash: 'some-hash' })).rejects.toThrowError()
+    })
+
+    it('Should use given api token', async () => {
+      fakeFetch({ response: 'Some response' })
+
+      // @ts-ignore
+      window.PlayPilotLinkInjections = { token: 'token' }
+
+      await fetchLinkInjections('https://some-url', 'some-html', { hash: 'some-hash' })
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        expect.stringContaining('api-token=token'),
+        expect.any(Object),
+      )
+    })
+
+    it('Should throw when no api token was given', async () => {
+      fakeFetch({ response: 'Some response' })
+
+      // @ts-ignore
+      window.PlayPilotLinkInjections = null
+
+      await expect(async () => await fetchLinkInjections('https://some-url', 'some-html', { hash: 'some-hash' })).rejects.toThrowError()
+    })
+
+    it('Should include editorial_mode_enabled=true in url if editorial mode is true', async () => {
+      fakeFetch({ response: 'Some response' })
+
+      vi.mocked(authorize).mockResolvedValueOnce(true)
+      vi.mocked(isEditorialModeEnabled).mockResolvedValueOnce(true)
+
+      const response = await fetchLinkInjections('https://some-url', 'some-html', { hash: 'some-hash' })
+
+      expect(response).toBe('Some response')
+      expect(global.fetch).toHaveBeenCalledWith(
+        expect.stringContaining('editorial_mode_enabled=true'),
+        expect.any(Object),
+      )
+    })
+  })
+
+  describe('pollLinkInjections', () => {
+    it('Should poll endpoint while results are not yet ready', async () => {
+      fakeFetch({ response: { injections_ready: false } })
+
+      pollLinkInjections('https://some-url', 'some-html', 500)
+
+      expect(global.fetch).toHaveBeenCalled()
+
+      await new Promise(res => setTimeout(res, 600)) // Wait for a polling
+      expect(global.fetch).toHaveBeenCalledTimes(2)
+
+      await new Promise(res => setTimeout(res, 600)) // Wait for a polling
+      expect(global.fetch).toHaveBeenCalledTimes(3)
+    })
+
+    it('Should stop polling if replacements are ready', async () => {
+      fakeFetch({ response: { injections_ready: true, link_injections: [{ title: 'value' }] } })
+
+      const result = await pollLinkInjections('https://some-url', 'some-html', 500)
+
+      expect(global.fetch).toHaveBeenCalled()
+      expect(result).toEqual([{ title: 'value', key: expect.any(String) }])
+
+      await new Promise(res => setTimeout(res, 1000)) // Wait for a potential poll
+      expect(global.fetch).toHaveBeenCalledTimes(1)
+    })
+
+    it('Should stop polling if max limit was exceeded', async () => {
+      fakeFetch({ response: { injections_ready: false } })
+
+      await pollLinkInjections('https://some-url', 'some-html', 200, 2)
+
+      await new Promise(res => setTimeout(res, 1000)) // Wait for a potential poll
+      expect(global.fetch).toHaveBeenCalledTimes(2)
+    })
+
+    it('Should continue polling if endpoint throws error', async () => {
+      fakeFetch({ ok: false })
+
+      pollLinkInjections('https://some-url', 'some-html', 500)
+
+      expect(global.fetch).toHaveBeenCalled()
+
+      await new Promise(res => setTimeout(res, 600)) // Wait for a polling
+      expect(global.fetch).toHaveBeenCalledTimes(2)
+    })
+
+    it('Should return empty array if link_injections are null', async () => {
+      fakeFetch({ response: { injections_ready: true, link_injections: null } })
+
+      const result = await pollLinkInjections('https://some-url', 'some-html')
+      expect(result).toEqual([])
+    })
+
+    it('Should return empty array despite actual results if injections_enabled is false', async () => {
+      fakeFetch({ response: { injections_enabled: false, link_injections: [{ title: 'value' }] } })
+
+      const result = await pollLinkInjections('https://some-url', 'some-html')
+      expect(result).toEqual([])
+    })
+  })
+})

package/src/tests/lib/array.test.js

@@ -0,0 +1,14 @@
+import { describe, it, expect } from 'vitest'
+import { getLargestValueInArray } from '$lib/array'
+
+describe('array.js', () => {
+  describe('getLargestValueInArray', () => {
+    it('Should return the large given value in an array', () => {
+      expect(getLargestValueInArray([0, 12, 6, 8])).toBe(12)
+    })
+
+    it('Should return 0 when array has no length', () => {
+      expect(getLargestValueInArray([])).toBe(0)
+    })
+  })
+})

package/src/tests/lib/auth.test.js

@@ -0,0 +1,115 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { authorize, getAuthToken, isEditorialModeEnabled } from '$lib/auth'
+
+/**
+ * @param {Object} [options]
+ * @param {any} [options.response]
+ * @param {number} [options.status]
+ * @param {boolean} [options.ok]
+ */
+function fakeFetch({ response = '', status = 200, ok = true } = {}) {
+  // @ts-ignore
+  global.fetch = vi.fn(() =>
+    Promise.resolve({
+      ok,
+      status,
+      json: () => response,
+    }),
+  )
+}
+
+describe('$lib/auth', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+    fakeFetch()
+  })
+
+  describe('authorize', () => {
+    it('Should authorize correctly with url token', async () => {
+      const authorized = await authorize('https://example.com/some-path?articleReplacementEditToken=some-token')
+
+      expect(authorized).toBeTruthy()
+    })
+
+    it('Should authorize correctly with editorial token', async () => {
+      // @ts-ignore
+      window.PlayPilotLinkInjections = { token: 'some-api-token', editorial_token: 'some-token' }
+      const authorized = await authorize('https://example.com/some-path')
+
+      expect(authorized).toBeTruthy()
+    })
+
+    it('Should not authorize if required url param is not present', async () => {
+      const authorized = await authorize('https://example.com/some-path')
+
+      expect(global.fetch).not.toHaveBeenCalled()
+      expect(authorized).not.toBeTruthy()
+    })
+
+    it('Should authorize with cookie if previously authorized with url param', async () => {
+      let authorized = await authorize('https://example.com/some-path?articleReplacementEditToken=some-token')
+      expect(authorized).toBeTruthy()
+
+      authorized = await authorize('https://example.com/some-path')
+      expect(authorized).toBeTruthy()
+    })
+
+    it('Should authorize with cookie if previously authorized with url param and no url is given', async () => {
+      let authorized = await authorize('https://example.com/some-path?articleReplacementEditToken=some-token')
+      expect(authorized).toBeTruthy()
+
+      authorized = await authorize()
+      expect(authorized).toBeTruthy()
+    })
+
+    it('Should not authorize is fetch response was negative', async () => {
+      fakeFetch({ response: '', ok: false, status: 403 })
+      let authorized = await authorize('https://example.com/some-path?articleReplacementEditToken=some-token')
+
+      expect(authorized).not.toBeTruthy()
+    })
+  })
+
+  describe('getAuthToken', () => {
+    it('Should return true if token is set in window object', () => {
+      // @ts-ignore
+      window.PlayPilotLinkInjections = { editorial_token: 'some-token' }
+
+      expect(getAuthToken('https://some-url.com/')).toBeTruthy()
+    })
+
+    it('Should return true if token is set in url', () => {
+      expect(getAuthToken('https://some-url.com/?articleReplacementEditToken=some-token')).toBeTruthy()
+    })
+
+    it('Should return true if token is set as cookie', () => {
+      document.cookie = 'EncryptedToken=some-token'
+      expect(getAuthToken('https://some-url.com/?articleReplacementEditToken=some-token')).toBeTruthy()
+    })
+
+    it('Should return false if no valid token is given', () => {
+      expect(getAuthToken('https://some-url.com/')).not.toBeTruthy()
+    })
+  })
+
+  describe('isEditorialModeEnabled', () => {
+    it('Should return true if both search token and window token are given', async () => {
+      window.location.search = '?playpilot-editorial-mode=false'
+      expect(isEditorialModeEnabled()).toBe(false)
+
+      window.location.search = '?other-param-mode=true'
+      expect(isEditorialModeEnabled()).toBe(false)
+
+      window.location.search = '?playpilot-editorial-mode=true'
+      expect(isEditorialModeEnabled()).toBe(true)
+
+      window.location.search = ''
+      expect(isEditorialModeEnabled()).toBe(false)
+
+      // @ts-ignore
+      window.PlayPilotLinkInjections = { editorial_token: 'some-token' }
+      window.location.search = ''
+      expect(isEditorialModeEnabled()).toBe(true)
+    })
+  })
+})

package/src/tests/lib/hash.test.js

@@ -0,0 +1,28 @@
+import { describe, it, expect } from 'vitest'
+import { stringToHash } from '$lib/hash'
+
+describe('$lib/hash', () => {
+  describe('stringToHash', () => {
+    it('Should return the same hash for the same string', () => {
+      expect(stringToHash('Some string')).toBe(stringToHash('Some string'))
+    })
+
+    it('Should return different hashes for different strings', () => {
+      expect(stringToHash('Some')).not.toBe(stringToHash('String'))
+    })
+
+    it('Should handle an empty string correctly', () => {
+      const result = stringToHash('')
+      expect(result).toBe('0')
+    })
+
+    it('Should be case-sensitive', () => {
+      expect(stringToHash('Some string')).not.toBe(stringToHash('some string'))
+    })
+
+    it('Should handle long strings without throwing errors', () => {
+      const longString = 'a'.repeat(10000)
+      expect(() => stringToHash(longString)).not.toThrow()
+    })
+  })
+})

package/src/tests/lib/html.test.js

@@ -0,0 +1,16 @@
+import { describe, it, expect } from 'vitest'
+import { encodeHtmlEntities, decodeHtmlEntities } from '$lib/html'
+
+describe('html.js', () => {
+  describe('encodeHtmlEntities', () => {
+    it('Should encode given characters', () => {
+      expect(encodeHtmlEntities('Some & word')).toBe('Some & word')
+    })
+  })
+
+  describe('decodeHtmlEntities', () => {
+    it('Should deencode given characters', () => {
+      expect(decodeHtmlEntities('Some & word')).toBe('Some & word')
+    })
+  })
+})