@playpilot/tpi 1.4.3 → 2.0.0

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

@@ -1,9 +1,9 @@
 import { fireEvent  } from '@testing-library/svelte'
 import { describe, expect, it, vi, beforeEach } from 'vitest'
 
-import { injectLinksInDocument, clearLinkInjections, clearLinkInjection, getLinkInjectionElements, insertAfterArticlePlaylinks, getLinkInjectionsParentElement, sortLinkInjectionsByRange } from '$lib/linkInjection'
-import { title } from '$lib/fakeData'
+import { injectLinksInDocument, clearLinkInjections, clearLinkInjection, getLinkInjectionElements, insertAfterArticlePlaylinks, getLinkInjectionsParentElement, sortLinkInjectionsByRange, isAvailableAsManualInjection, filterRemovedInjections, isEquivalentInjection, filterInvalidInTextInjections, filterInvalidAfterArticleInjections, isValidInjection } from '$lib/linkInjection'
 import { mount, unmount } from 'svelte'
+import { generateInjection } from '../helpers'
 
 vi.mock('svelte', () => ({
   mount: vi.fn(),
@@ -31,98 +31,102 @@ describe('linkInjection.js', () => {
 
   describe('injectLinksInDocument', () => {
     it('Should replace given words with injections', () => {
-      document.body.innerHTML = '<p>This is a sentence with an injection.</p>'
+      const injection = generateInjection('This is a sentence with an injection.', 'an injection')
+      const linkInjections = [injection]
 
-      const elements = Array.from(document.querySelectorAll('p'))
+      document.body.innerHTML = `<p>${injection.sentence}</p>`
 
-      const linkInjections = [{
-        sid: '1',
-        title: 'an injection',
-        sentence: 'This is a sentence with an injection.',
-        playpilot_url: 'https://some-link.com/',
-        poster: 'some-poster',
-        key: 'some-key',
-      }]
+      const elements = Array.from(document.querySelectorAll('p'))
 
-      injectLinksInDocument(elements, linkInjections, () => null)
+      injectLinksInDocument(elements, () => null, { aiInjections: linkInjections, manualInjections: [] })
 
       const link = /** @type {HTMLAnchorElement} */ (document.querySelector('a'))
 
-      expect(link.innerText).toBe('an injection')
-      expect(link.href).toBe('https://some-link.com/')
+      expect(link.innerText).toBe(injection.title)
+      expect(link.href).toBe(injection.playpilot_url)
     })
 
     it('Should replace given words as expected when more than 1 injection per sentence is present', () => {
-      document.body.innerHTML = '<p>This is a sentence with an injection.</p>'
+      const sentence = 'This is a sentence with an injection.'
+      const linkInjections = [
+        generateInjection(sentence, 'a sentence'),
+        generateInjection(sentence, 'an injection'),
+      ]
+
+      document.body.innerHTML = `<p>${sentence}</p>`
 
       const elements = Array.from(document.body.querySelectorAll('p'))
 
-      const linkInjections = [{
-        sid: '1',
-        title: 'a sentence',
-        sentence: 'This is a sentence with an injection.',
-        playpilot_url: 'https://some-link.com/',
-        poster: 'some-poster',
-        key: 'some-key-1',
-        title_details: title,
-      }, {
-        sid: '2',
-        title: 'an injection',
-        sentence: 'This is a sentence with an injection.',
-        playpilot_url: 'https://some-link.com/',
-        poster: 'some-poster',
-        key: 'some-key-1',
-        title_details: title,
-      }]
-
-      injectLinksInDocument(elements, linkInjections, () => null)
+      injectLinksInDocument(elements, () => null, { aiInjections: linkInjections, manualInjections: [] })
 
       const links = /** @type {HTMLAnchorElement[]} */ (Array.from(document.querySelectorAll('a')))
 
-      expect(links[0].innerText).toBe('a sentence')
-      expect(links[0].href).toBe('https://some-link.com/')
-      expect(links[0].dataset.playpilotOriginalTitle).toBe(title.original_title)
+      expect(links[0].innerText).toBe(linkInjections[0].title)
+      expect(links[0].href).toBe(linkInjections[0].playpilot_url)
+      /** @ts-ignore It is defined */
+      expect(links[0].dataset.playpilotOriginalTitle).toBe(linkInjections[0].title_details.original_title)
 
-      expect(links[1].innerText).toBe('an injection')
-      expect(links[1].href).toBe('https://some-link.com/')
-      expect(links[1].dataset.playpilotOriginalTitle).toBe(title.original_title)
+      expect(links[1].innerText).toBe(linkInjections[1].title)
+      expect(links[1].href).toBe(linkInjections[1].playpilot_url)
+      /** @ts-ignore It is defined */
+      expect(links[1].dataset.playpilotOriginalTitle).toBe(linkInjections[1].title_details.original_title)
     })
 
     it('Should ignore injections that are marked as inactive', () => {
-      document.body.innerHTML = '<p>This is a sentence with an injection.</p>'
+      const sentence = 'This is a sentence with an injection.'
+      const injection = generateInjection(sentence, 'an injection')
+      const linkInjections = [{ ...injection, inactive: true }]
+
+      document.body.innerHTML = `<p>${sentence}</p>`
 
       const elements = Array.from(document.body.querySelectorAll('p'))
 
-      const linkInjections = [{
-        sid: '1',
-        title: 'an injection',
-        sentence: 'This is a sentence with an injection.',
-        playpilot_url: '',
-        poster: 'some-poster',
-        key: 'some-key',
-        inactive: true,
-      }]
+      injectLinksInDocument(elements, () => null, { aiInjections: linkInjections, manualInjections: [] })
 
-      injectLinksInDocument(elements, linkInjections, () => null)
+      expect(document.body.innerHTML).toBe(`<p>${sentence}</p>`)
+    })
+
+    it('Should ignore injections that are marked as removed', () => {
+      const sentence = 'This is a sentence with an injection.'
+      const injection = generateInjection(sentence, 'an injection')
+      const linkInjections = [{ ...injection, removed: true }]
 
-      expect(document.body.innerHTML).toBe('<p>This is a sentence with an injection.</p>')
+      document.body.innerHTML = `<p>${sentence}</p>`
+
+      const elements = Array.from(document.body.querySelectorAll('p'))
+
+      injectLinksInDocument(elements, () => null, { aiInjections: linkInjections, manualInjections: [] })
+
+      expect(document.body.innerHTML).toBe(`<p>${sentence}</p>`)
+    })
+
+    it('Should ignore AI injections that are marked as removed as a matching manual injections', () => {
+      const sentence = 'This is a sentence with an injection.'
+      const injection = generateInjection(sentence, 'an injection')
+
+      document.body.innerHTML = `<p>${sentence}</p>`
+
+      const elements = Array.from(document.body.querySelectorAll('p'))
+
+      const injections = {
+        aiInjections: [injection],
+        manualInjections: [{ ...injection, manual: true, removed: true }],
+      }
+
+      injectLinksInDocument(elements, () => null, injections)
+
+      expect(document.body.innerHTML).toBe(`<p>${sentence}</p>`)
     })
 
     it('Should keep existing HTML elements intact', () => {
+      const injection = generateInjection('This is a sentence with an injection.', 'an injection')
+      const linkInjections = [injection]
+
       document.body.innerHTML = '<p>This is a <button>sentence</button> with an injection.</p>'
 
       const elements = Array.from(document.body.querySelectorAll('p'))
 
-      const linkInjections = [{
-        sid: '1',
-        title: 'an injection',
-        sentence: 'This is a sentence with an injection.',
-        playpilot_url: '',
-        poster: 'some-poster',
-        key: 'some-key',
-      }]
-
-      injectLinksInDocument(elements, linkInjections, () => null)
+      injectLinksInDocument(elements, () => null, { aiInjections: linkInjections, manualInjections: [] })
 
       const button = /** @type {HTMLButtonElement} */ (document.querySelector('button'))
 
@@ -133,56 +137,43 @@ describe('linkInjection.js', () => {
       document.body.innerHTML = '<h1>I am a title</h1><p>This is a sentence with an injection.</p>'
 
       const elements = Array.from(document.body.querySelectorAll('p'))
+      const injection = generateInjection('I am a title', 'a title')
 
-      const linkInjections = [{
-        sid: '1',
-        title: 'a title',
-        sentence: 'I am a title',
-        playpilot_url: '',
-        poster: 'some-poster',
-        key: 'some-key',
-      }]
+      injectLinksInDocument(elements, () => null, { aiInjections: [injection], manualInjections: [] })
 
-      injectLinksInDocument(elements, linkInjections, () => null)
-
-      expect(document.body.innerHTML.includes('I am a title')).toBeTruthy()
+      expect(document.body.innerHTML.includes(injection.sentence)).toBeTruthy()
     })
 
     it('Should ignore partial matches due to interfering elements', () => {
       document.body.innerHTML = '<p>This is a sentence with <strong>an</strong> injection.</p>'
 
       const elements = Array.from(document.body.querySelectorAll('p'))
+      const injection = generateInjection('This is a sentence with an injection.', 'an injection')
 
-      const linkInjections = [{
-        sid: '1',
-        title: 'an injection',
-        sentence: 'This is a sentence with an injection.',
-        playpilot_url: '',
-        poster: 'some-poster',
-        key: 'some-key',
-      }]
-
-      injectLinksInDocument(elements, linkInjections, () => null)
+      injectLinksInDocument(elements, () => null, { aiInjections: [injection], manualInjections: [] })
 
       expect(document.body.innerHTML.includes('an injection')).not.toBeTruthy()
       expect(document.body.innerHTML.includes('an')).toBeTruthy()
     })
 
+    it('Should ignore encoded characters in given sentences', () => {
+      document.body.innerHTML = '<p>This is a sentence & an injection.</p>'
+
+      const elements = Array.from(document.body.querySelectorAll('p'))
+      const injection = generateInjection('This is a sentence &amp; an injection.', 'an injection')
+
+      injectLinksInDocument(elements, () => null, { aiInjections: [injection], manualInjections: [] })
+
+      expect(document.querySelectorAll('a')).toHaveLength(1)
+    })
+
     it('Should ignore matches due to parent links', () => {
       document.body.innerHTML = '<p>This is <a>a sentence</a> with an injection.</p>'
 
       const elements = Array.from(document.body.querySelectorAll('p'))
+      const injection = generateInjection('This is a sentence with an injection.', 'a sentence')
 
-      const linkInjections = [{
-        sid: '1',
-        title: 'a sentence',
-        sentence: 'This is a sentence with an injection.',
-        playpilot_url: 'https://some-link.com/',
-        poster: 'some-poster',
-        key: 'some-key-1',
-      }]
-
-      injectLinksInDocument(elements, linkInjections, () => null)
+      injectLinksInDocument(elements, () => null, { aiInjections: [injection], manualInjections: [] })
 
       expect(document.querySelector('[data-playpilot-injection-key]')).not.toBeTruthy()
     })
@@ -191,17 +182,9 @@ describe('linkInjection.js', () => {
       document.body.innerHTML = '<p>This is <a data-thing="some word">a sentence</a> with an injection.</p>'
 
       const elements = Array.from(document.body.querySelectorAll('p'))
+      const injection = generateInjection('This is a sentence with an injection.', 'some word')
 
-      const linkInjections = [{
-        sid: '1',
-        title: 'some word',
-        sentence: 'This is a sentence with an injection.',
-        playpilot_url: 'https://some-link.com/',
-        poster: 'some-poster',
-        key: 'some-key-1',
-      }]
-
-      injectLinksInDocument(elements, linkInjections, () => null)
+      injectLinksInDocument(elements, () => null, { aiInjections: [injection], manualInjections: [] })
 
       expect(document.querySelector('[data-playpilot-injection-key]')).not.toBeTruthy()
     })
@@ -210,17 +193,9 @@ describe('linkInjection.js', () => {
       document.body.innerHTML = '<p>This is <a>a word</a> with a word.</p>'
 
       const elements = Array.from(document.body.querySelectorAll('p'))
+      const injection = generateInjection('This is a word with a word.', 'a word')
 
-      const linkInjections = [{
-        sid: '1',
-        title: 'a word',
-        sentence: 'This is a word with a word.',
-        playpilot_url: 'https://some-link.com/',
-        poster: 'some-poster',
-        key: 'some-key-1',
-      }]
-
-      injectLinksInDocument(elements, linkInjections, () => null)
+      injectLinksInDocument(elements, () => null, { aiInjections: [injection], manualInjections: [] })
 
       expect(document.querySelectorAll('a')).toHaveLength(2)
     })
@@ -229,17 +204,9 @@ describe('linkInjection.js', () => {
       document.body.innerHTML = '<p>This is <a>a sentence</a> with an injection.</p>'
 
       const elements = Array.from(document.body.querySelectorAll('p'))
+      const injection = generateInjection('This is a sentence with an injection.', 'an injection')
 
-      const linkInjections = [{
-        sid: '1',
-        title: 'an injection',
-        sentence: 'This is a sentence with an injection.',
-        playpilot_url: 'https://some-link.com/',
-        poster: 'some-poster',
-        key: 'some-key-1',
-      }]
-
-      injectLinksInDocument(elements, linkInjections, () => null)
+      injectLinksInDocument(elements, () => null, { aiInjections: [injection], manualInjections: [] })
 
       expect(document.querySelector('[data-playpilot-injection-key]')).toBeTruthy()
     })
@@ -252,7 +219,7 @@ describe('linkInjection.js', () => {
       /** @type {LinkInjection[]} */
       const linkInjections = []
 
-      injectLinksInDocument(elements, linkInjections, () => null)
+      injectLinksInDocument(elements, () => null, { aiInjections: linkInjections, manualInjections: [] })
 
       expect(document.body.innerHTML.includes('This is a sentence with an injection.')).toBeTruthy()
     })
@@ -264,55 +231,37 @@ describe('linkInjection.js', () => {
       /** @type {LinkInjection[]} */
       const linkInjections = []
 
-      expect(() => injectLinksInDocument(elements, linkInjections, () => null)).not.toThrow()
+      expect(() => injectLinksInDocument(elements, () => null, { aiInjections: linkInjections, manualInjections: [] })).not.toThrow()
     })
 
     it('Should fire given onclick function when clicked', async () => {
       document.body.innerHTML = '<p>This is a sentence with an injection.</p>'
 
       const elements = Array.from(document.body.querySelectorAll('p'))
-
-      const linkInjections = [{
-        sid: '1',
-        title: 'an injection',
-        sentence: 'This is a sentence with an injection.',
-        playpilot_url: 'https://some-link.com/',
-        poster: 'some-poster',
-        key: 'some-key',
-      }]
+      const injection = generateInjection('This is a sentence with an injection.', 'an injection')
 
       const mock = vi.fn()
-      injectLinksInDocument(elements, linkInjections, mock)
+      injectLinksInDocument(elements, mock, { aiInjections: [injection], manualInjections: [] })
 
       const link = /** @type {HTMLAnchorElement} */ (document.querySelector('a'))
       await fireEvent.click(link)
 
-      expect(mock).toHaveBeenCalledWith(linkInjections[0])
+      expect(mock).toHaveBeenCalledWith(injection)
     })
 
     it('Should fire given onclick function when clicked for each link in a sentence if more than 1 injection is present', async () => {
-      document.body.innerHTML = '<p>This is a sentence with an injection.</p>'
+      const sentence = 'This is a sentence with an injection.'
+      document.body.innerHTML = `<p>${sentence}</p>`
 
       const elements = Array.from(document.body.querySelectorAll('p'))
 
-      const linkInjections = [{
-        sid: '1',
-        title: 'a sentence',
-        sentence: 'This is a sentence with an injection.',
-        playpilot_url: 'https://some-link.com/',
-        poster: 'some-poster',
-        key: 'some-key-1',
-      }, {
-        sid: '2',
-        title: 'an injection',
-        sentence: 'This is a sentence with an injection.',
-        playpilot_url: 'https://some-link.com/',
-        poster: 'some-poster',
-        key: 'some-key-2',
-      }]
+      const linkInjections = [
+        generateInjection(sentence, 'a sentence'),
+        generateInjection(sentence, 'an injection'),
+      ]
 
       const mock = vi.fn()
-      injectLinksInDocument(elements, linkInjections, mock)
+      injectLinksInDocument(elements, mock, { aiInjections: linkInjections, manualInjections: [] })
 
       const links = document.querySelectorAll('a')
       await fireEvent.click(links[0])
@@ -325,18 +274,10 @@ describe('linkInjection.js', () => {
       document.body.innerHTML = '<p>This is a sentence with an injection.</p>'
 
       const elements = Array.from(document.body.querySelectorAll('p'))
-
-      const linkInjections = [{
-        sid: '1',
-        title: 'an injection',
-        sentence: 'This is a sentence with an injection.',
-        playpilot_url: 'https://some-link.com/',
-        poster: 'some-poster',
-        key: 'some-key',
-      }]
+      const injection = generateInjection('This is a sentence with an injection.', 'an injection')
 
       const mock = vi.fn()
-      injectLinksInDocument(elements, linkInjections, mock)
+      injectLinksInDocument(elements, mock, { aiInjections: [injection], manualInjections: [] })
 
       const link = /** @type {HTMLAnchorElement} */ (document.querySelector('a'))
 
@@ -349,48 +290,30 @@ describe('linkInjection.js', () => {
     })
 
     it('Should return array with failed injections marked as such', () => {
-      document.body.innerHTML = '<p>This is a sentence with an injection.</p>'
+      const sentence = 'This is a sentence with an injection.'
+      document.body.innerHTML = `<p>${sentence}</p>`
 
       const elements = Array.from(document.body.querySelectorAll('p'))
 
-      const linkInjections = [{
-        sid: '1',
-        title: 'a sentence',
-        sentence: 'This is a sentence with an injection.',
-        playpilot_url: 'https://some-link.com/',
-        poster: 'some-poster',
-        key: 'some-key-1',
-      }, {
-        sid: '2',
-        title: 'not an injection',
-        sentence: 'This is a sentence with an injection.',
-        playpilot_url: 'https://some-link.com/',
-        poster: 'some-poster',
-        key: 'some-key-2',
-      }]
-
-      const results = injectLinksInDocument(elements, linkInjections, () => null)
+      const linkInjections = [
+        generateInjection(sentence, 'a sentence'),
+        generateInjection(sentence, 'not an injection'),
+      ]
+
+      const results = injectLinksInDocument(elements, () => null, { aiInjections: linkInjections, manualInjections: [] })
 
-      expect(results[1].failed).toBe(true)
       expect(results[0].failed).toBe(false)
+      expect(results[1].failed).toBe(true)
     })
 
     it('Should mount popover component when link is hovered and unmount when link is blurred', async () => {
       document.body.innerHTML = '<p>This is a sentence with an injection.</p>'
 
       const elements = Array.from(document.body.querySelectorAll('p'))
-
-      const linkInjections = [{
-        sid: '1',
-        title: 'an injection',
-        sentence: 'This is a sentence with an injection.',
-        playpilot_url: 'https://some-link.com/',
-        poster: 'some-poster',
-        key: 'some-key',
-      }]
+      const injection = generateInjection('This is a sentence with an injection.', 'an injection')
 
       const mock = vi.fn()
-      injectLinksInDocument(elements, linkInjections, mock)
+      injectLinksInDocument(elements, mock, { aiInjections: [injection], manualInjections: [] })
 
       const link = /** @type {HTMLAnchorElement} */ (document.querySelector('[data-playpilot-injection-key]'))
 
@@ -406,75 +329,66 @@ describe('linkInjection.js', () => {
 
       const elements = Array.from(document.querySelectorAll('p'))
 
-      const linkInjections = [{
-        sid: '1',
-        title: 'injection',
-        sentence: 'This is a sentence with an injection and another injection',
-        playpilot_url: 'https://some-link.com/',
-        poster: 'some-poster',
-        key: 'some-key',
-      }, {
-        sid: '2',
-        title: 'injection',
-        sentence: 'This is a sentence with an injection and another injection',
-        playpilot_url: 'https://some-link-2.com/',
-        poster: 'some-poster',
-        key: 'some-key-2',
-      }]
-
-      injectLinksInDocument(elements, linkInjections, () => null)
+      const sentence = 'This is a sentence with an injection and another injection'
+      const linkInjections = [
+        generateInjection(sentence, 'injection'),
+        generateInjection(sentence, 'injection'),
+      ]
+
+      injectLinksInDocument(elements, () => null, { aiInjections: linkInjections, manualInjections: [] })
 
       const links = /** @type {HTMLAnchorElement[]} */ (Array.from(document.querySelectorAll('[data-playpilot-injection-key]')))
 
       expect(links).toHaveLength(2)
-      expect(links[0].dataset.playpilotInjectionKey).toBe('some-key')
-      expect(links[1].dataset.playpilotInjectionKey).toBe('some-key-2')
+      expect(links[0].dataset.playpilotInjectionKey).toBe(linkInjections[0].key)
+      expect(links[1].dataset.playpilotInjectionKey).toBe(linkInjections[1].key)
     })
 
     it('Should not inject injections with in_text set to false', () => {
       document.body.innerHTML = '<p>This is a sentence with an injection.</p>'
 
       const elements = Array.from(document.querySelectorAll('p'))
+      const injection = { ...generateInjection('This is a sentence with an injection.', 'an injection'), in_text: false }
 
-      const linkInjections = [{
-        sid: '1',
-        title: 'an injection',
-        sentence: 'This is a sentence with an injection.',
-        playpilot_url: 'https://some-link.com/',
-        poster: 'some-poster',
-        key: 'some-key',
-        in_text: false,
-      }]
-
-      injectLinksInDocument(elements, linkInjections, () => null)
+      injectLinksInDocument(elements, () => null, { aiInjections: [injection], manualInjections: [] })
 
       expect(document.querySelector('a')).not.toBeTruthy()
     })
-  })
 
-  it('Should not mount popover if user uses touch', async () => {
-    mockMatchMedia(true)
+    it('Should not mount popover if user uses touch', async () => {
+      mockMatchMedia(true)
 
-    document.body.innerHTML = '<p>This is a sentence with an injection.</p>'
+      document.body.innerHTML = '<p>This is a sentence with an injection.</p>'
+
+      const elements = Array.from(document.body.querySelectorAll('p'))
+      const injection = generateInjection('This is a sentence with an injection.', 'an injection')
+
+      const mock = vi.fn()
+      injectLinksInDocument(elements, mock, { aiInjections: [injection], manualInjections: [] })
+
+      const link = /** @type {HTMLAnchorElement} */ (document.querySelector('a'))
 
-    const elements = Array.from(document.body.querySelectorAll('p'))
+      await fireEvent.mouseEnter(link)
+      expect(mount).not.toHaveBeenCalled()
+    })
 
-    const linkInjections = [{
-      sid: '1',
-      title: 'an injection',
-      sentence: 'This is a sentence with an injection.',
-      playpilot_url: 'https://some-link.com/',
-      poster: 'some-poster',
-      key: 'some-key',
-    }]
+    it('Should not call insertAfterArticlePlaylinks if injections only contain inactive or removed items', () => {
+      document.body.innerHTML = `<section>
+          <div>Some text</div>
+          <div>Some other text</div>
+        </section>
+      `
 
-    const mock = vi.fn()
-    injectLinksInDocument(elements, linkInjections, mock)
+      const elements = Array.from(document.body.querySelectorAll('div'))
+      const injection = generateInjection('Some sentence', 'an injection')
+      const linkInjections = [{ ...injection, after_article: true, inactive: true }, { ...injection, after_article: true, removed: true }]
 
-    const link = /** @type {HTMLAnchorElement} */ (document.querySelector('a'))
+      const mock = vi.fn()
+      injectLinksInDocument(elements, mock, { aiInjections: [], manualInjections: linkInjections })
 
-    await fireEvent.mouseEnter(link)
-    expect(mount).not.toHaveBeenCalled()
+      expect(mount).not.toHaveBeenCalled()
+      expect(document.querySelector('[data-playpilot-after-article-playlinks]')).not.toBeTruthy()
+    })
   })
 
   describe('clearLinkInjections', () => {
@@ -679,17 +593,10 @@ describe('linkInjection.js', () => {
         </section>
       `
 
-      const linkInjections = [{
-        sid: '1',
-        title: 'an injection',
-        sentence: 'This is a sentence with an injection.',
-        playpilot_url: 'https://some-link.com/',
-        poster: 'some-poster',
-        key: 'some-key',
-      }]
+      const injection = generateInjection('This is a sentence with an injection.', 'an injection')
 
       const elements = getLinkInjectionElements(document.body)
-      insertAfterArticlePlaylinks(elements, linkInjections, () => null)
+      insertAfterArticlePlaylinks(elements, [injection], () => null)
 
       expect(mount).toHaveBeenCalled()
       expect(document.querySelector('[data-playpilot-after-article-playlinks]')).toBeTruthy()
@@ -754,4 +661,106 @@ describe('linkInjection.js', () => {
       expect(sortedInjections[2].key).toBe('a')
     })
   })
+
+  describe('isAvailableAsManualInjection', () => {
+    it('Should return true if the ai injection has a matching manual injection', () => {
+      const aiInjection = generateInjection('Some sentence', 'Some title')
+      const manualInjection = { ...aiInjection, manual: true }
+
+      expect(isAvailableAsManualInjection(aiInjection, 0, [aiInjection, manualInjection]))
+    })
+
+    it('Should return false if the ai injection has no matching manual injection', () => {
+      const aiInjection = generateInjection('Some sentence', 'Some title')
+
+      expect(isAvailableAsManualInjection(aiInjection, 0, [aiInjection]))
+    })
+
+    it('Should return false if the ai injection has a matching ai injection', () => {
+      const aiInjection = generateInjection('Some sentence', 'Some title')
+
+      expect(isAvailableAsManualInjection(aiInjection, 0, [aiInjection, aiInjection]))
+    })
+  })
+
+  describe('filterRemovedInjections', () => {
+    it('Should not return injections that are removed or have an removed manual equivalent', () => {
+      const aiInjection = generateInjection('Some sentence', 'Some title')
+      const manualInjection = { ...aiInjection, manual: true, removed: true }
+
+      expect(filterRemovedInjections([aiInjection, manualInjection])).toEqual([])
+    })
+
+    it('Should return ai injections that have no matching manual injection', () => {
+      const aiInjection = generateInjection('Some sentence', 'Some title')
+      const manualInjection = { ...generateInjection('Some other sentence', 'Some other title'), manual: true }
+
+      expect(filterRemovedInjections([aiInjection, manualInjection])).toEqual([aiInjection, manualInjection])
+    })
+
+    it('Should return manual injections that have been removed at one point, but a new injection for the same title was created', () => {
+      const manualInjection = { ...generateInjection('Some other sentence', 'Some other title'), manual: true }
+      const removedManualInjection = { ...manualInjection, removed: true }
+
+      expect(filterRemovedInjections([manualInjection, removedManualInjection])).toEqual([manualInjection])
+    })
+  })
+
+  describe('isEquivalentInjection', () => {
+    it('Should return true if injections have the same title and sentence', () => {
+      expect(isEquivalentInjection(generateInjection('a', 'b'), generateInjection('a', 'b'))).toBe(true)
+    })
+
+    it('Should return false if injections have different titles', () => {
+      expect(isEquivalentInjection(generateInjection('a', 'b'), generateInjection('a', 'c'))).toBe(false)
+    })
+
+    it('Should return false if injections have different sentences', () => {
+      expect(isEquivalentInjection(generateInjection('a', 'b'), generateInjection('b', 'b'))).toBe(false)
+    })
+
+    it('Should return false if injections have both different titles and sentences', () => {
+      expect(isEquivalentInjection(generateInjection('a', 'b'), generateInjection('c', 'd'))).toBe(false)
+    })
+  })
+
+  describe('isValidInjection', () => {
+    it('Should only return true when the injection is valid', () => {
+      expect(isValidInjection({ ...generateInjection('a', 'b') })).toBe(true)
+      expect(isValidInjection({ ...generateInjection('a', 'b'), inactive: true })).toBe(false)
+      expect(isValidInjection({ ...generateInjection('a', 'b'), removed: true })).toBe(false)
+      expect(isValidInjection({ ...generateInjection('a', 'b'), duplicate: true })).toBe(false)
+      expect(isValidInjection({ ...generateInjection('a', 'b'), title_details: undefined })).toBe(false)
+    })
+  })
+
+  describe('filterInvalidInTextInjections', () => {
+    it('Should return injections that are valid', () => {
+      expect(filterInvalidInTextInjections([generateInjection('a', 'b')])).toHaveLength(1)
+    })
+
+    it('Should return not injections that inactive, removed, duplicate, have no title_details, or are not in_text', () => {
+      expect(filterInvalidInTextInjections([{ ...generateInjection('a', 'b'), inactive: true }])).toHaveLength(0)
+      expect(filterInvalidInTextInjections([{ ...generateInjection('a', 'b'), removed: true }])).toHaveLength(0)
+      expect(filterInvalidInTextInjections([{ ...generateInjection('a', 'b'), duplicate: true }])).toHaveLength(0)
+      expect(filterInvalidInTextInjections([{ ...generateInjection('a', 'b'), title_details: undefined }])).toHaveLength(0)
+      expect(filterInvalidInTextInjections([{ ...generateInjection('a', 'b'), in_text: false }])).toHaveLength(0)
+
+      expect(filterInvalidInTextInjections([{ ...generateInjection('a', 'b'), in_text: undefined }])).toHaveLength(1)
+      expect(filterInvalidInTextInjections([{ ...generateInjection('a', 'b'), in_text: true }])).toHaveLength(1)
+    })
+  })
+
+  describe('filterInvalidAfterArticleInjections', () => {
+    it('Should return not injections that inactive, removed, duplicate, have no title_details, or are not after_article', () => {
+      expect(filterInvalidAfterArticleInjections([{ ...generateInjection('a', 'b'), inactive: true }])).toHaveLength(0)
+      expect(filterInvalidAfterArticleInjections([{ ...generateInjection('a', 'b'), removed: true }])).toHaveLength(0)
+      expect(filterInvalidAfterArticleInjections([{ ...generateInjection('a', 'b'), duplicate: true }])).toHaveLength(0)
+      expect(filterInvalidAfterArticleInjections([{ ...generateInjection('a', 'b'), title_details: undefined }])).toHaveLength(0)
+      expect(filterInvalidAfterArticleInjections([{ ...generateInjection('a', 'b'), after_article: false }])).toHaveLength(0)
+      expect(filterInvalidAfterArticleInjections([{ ...generateInjection('a', 'b'), after_article: undefined }])).toHaveLength(0)
+
+      expect(filterInvalidAfterArticleInjections([{ ...generateInjection('a', 'b'), after_article: true }])).toHaveLength(1)
+    })
+  })
 })