@atproto/api 0.12.25 → 0.12.26

package/tests/bsky-agent.test.ts

@@ -1751,14 +1751,6 @@ describe('agent', () => {
 
     describe('muted words', () => {
       let agent: BskyAgent
-      const mutedWords = [
-        { value: 'both', targets: ['content', 'tag'] },
-        { value: 'content', targets: ['content'] },
-        { value: 'tag', targets: ['tag'] },
-        { value: 'tag_then_both', targets: ['tag'] },
-        { value: 'tag_then_content', targets: ['tag'] },
-        { value: 'tag_then_none', targets: ['tag'] },
-      ]
 
       beforeAll(async () => {
         agent = new BskyAgent({ service: network.pds.url })
@@ -1769,214 +1761,591 @@ describe('agent', () => {
         })
       })
 
-      it('upsertMutedWords', async () => {
-        await agent.upsertMutedWords(mutedWords)
-        await agent.upsertMutedWords(mutedWords) // double
-        await expect(agent.getPreferences()).resolves.toHaveProperty(
-          'moderationPrefs.mutedWords',
-          mutedWords,
-        )
+      afterEach(async () => {
+        const { moderationPrefs } = await agent.getPreferences()
+        await agent.removeMutedWords(moderationPrefs.mutedWords)
       })
 
-      it('upsertMutedWords with #', async () => {
-        await agent.upsertMutedWords([
-          { value: 'hashtag', targets: ['content'] },
-        ])
-        // is sanitized to `hashtag`
-        await agent.upsertMutedWords([{ value: '#hashtag', targets: ['tag'] }])
+      describe('addMutedWord', () => {
+        it('inserts', async () => {
+          const expiresAt = new Date(Date.now() + 6e3).toISOString()
+          await agent.addMutedWord({
+            value: 'word',
+            targets: ['content'],
+            actorTarget: 'all',
+            expiresAt,
+          })
 
-        const { mutedWords } = (await agent.getPreferences()).moderationPrefs
+          const { moderationPrefs } = await agent.getPreferences()
+          const word = moderationPrefs.mutedWords.find(
+            (m) => m.value === 'word',
+          )
 
-        expect(mutedWords.find((m) => m.value === '#hashtag')).toBeFalsy()
-        // merged with existing
-        expect(mutedWords.find((m) => m.value === 'hashtag')).toStrictEqual({
-          value: 'hashtag',
-          targets: ['content', 'tag'],
+          expect(word!.id).toBeTruthy()
+          expect(word!.targets).toEqual(['content'])
+          expect(word!.actorTarget).toEqual('all')
+          expect(word!.expiresAt).toEqual(expiresAt)
         })
-        // only one added
-        expect(mutedWords.filter((m) => m.value === 'hashtag').length).toBe(1)
-      })
 
-      it('updateMutedWord', async () => {
-        await agent.updateMutedWord({
-          value: 'tag_then_content',
-          targets: ['content'],
+        it('single-hash #, no insert', async () => {
+          await agent.addMutedWord({
+            value: '#',
+            targets: [],
+            actorTarget: 'all',
+          })
+          const { moderationPrefs } = await agent.getPreferences()
+
+          // sanitized to empty string, not inserted
+          expect(moderationPrefs.mutedWords.length).toEqual(0)
         })
-        await agent.updateMutedWord({
-          value: 'tag_then_both',
-          targets: ['content', 'tag'],
+
+        it('multi-hash ##, inserts #', async () => {
+          await agent.addMutedWord({
+            value: '##',
+            targets: [],
+            actorTarget: 'all',
+          })
+          const { moderationPrefs } = await agent.getPreferences()
+          expect(
+            moderationPrefs.mutedWords.find((m) => m.value === '#'),
+          ).toBeTruthy()
         })
-        await agent.updateMutedWord({ value: 'tag_then_none', targets: [] })
-        await agent.updateMutedWord({ value: 'no_exist', targets: ['tag'] })
-        const { mutedWords } = (await agent.getPreferences()).moderationPrefs
 
-        expect(
-          mutedWords.find((m) => m.value === 'tag_then_content'),
-        ).toHaveProperty('targets', ['content'])
-        expect(
-          mutedWords.find((m) => m.value === 'tag_then_both'),
-        ).toHaveProperty('targets', ['content', 'tag'])
-        expect(
-          mutedWords.find((m) => m.value === 'tag_then_none'),
-        ).toHaveProperty('targets', [])
-        expect(mutedWords.find((m) => m.value === 'no_exist')).toBeFalsy()
-      })
+        it('multi-hash ##hashtag, inserts #hashtag', async () => {
+          await agent.addMutedWord({
+            value: '##hashtag',
+            targets: [],
+            actorTarget: 'all',
+          })
+          const { moderationPrefs } = await agent.getPreferences()
+          expect(
+            moderationPrefs.mutedWords.find((w) => w.value === '#hashtag'),
+          ).toBeTruthy()
+        })
 
-      it('updateMutedWord with #, does not update', async () => {
-        await agent.upsertMutedWords([
-          {
-            value: '#just_a_tag',
-            targets: ['tag'],
-          },
-        ])
-        await agent.updateMutedWord({
-          value: '#just_a_tag',
-          targets: ['tag', 'content'],
+        it('hash emoji #️⃣, inserts #️⃣', async () => {
+          await agent.addMutedWord({
+            value: '#️⃣',
+            targets: [],
+            actorTarget: 'all',
+          })
+          const { moderationPrefs } = await agent.getPreferences()
+          expect(
+            moderationPrefs.mutedWords.find((m) => m.value === '#️⃣'),
+          ).toBeTruthy()
         })
-        const { mutedWords } = (await agent.getPreferences()).moderationPrefs
-        expect(mutedWords.find((m) => m.value === 'just_a_tag')).toStrictEqual({
-          value: 'just_a_tag',
-          targets: ['tag'],
+
+        it('hash emoji w/leading hash ##️⃣, inserts #️⃣', async () => {
+          await agent.addMutedWord({
+            value: '##️⃣',
+            targets: [],
+            actorTarget: 'all',
+          })
+          const { moderationPrefs } = await agent.getPreferences()
+          expect(
+            moderationPrefs.mutedWords.find((m) => m.value === '#️⃣'),
+          ).toBeTruthy()
         })
-      })
 
-      it('removeMutedWord', async () => {
-        await agent.removeMutedWord({ value: 'tag_then_content', targets: [] })
-        await agent.removeMutedWord({ value: 'tag_then_both', targets: [] })
-        await agent.removeMutedWord({ value: 'tag_then_none', targets: [] })
-        const { mutedWords } = (await agent.getPreferences()).moderationPrefs
+        it('hash emoji with double leading hash ###️⃣, inserts ##️⃣', async () => {
+          await agent.addMutedWord({
+            value: '###️⃣',
+            targets: [],
+            actorTarget: 'all',
+          })
+          const { moderationPrefs } = await agent.getPreferences()
+          expect(
+            moderationPrefs.mutedWords.find((m) => m.value === '##️⃣'),
+          ).toBeTruthy()
+        })
 
-        expect(
-          mutedWords.find((m) => m.value === 'tag_then_content'),
-        ).toBeFalsy()
-        expect(mutedWords.find((m) => m.value === 'tag_then_both')).toBeFalsy()
-        expect(mutedWords.find((m) => m.value === 'tag_then_none')).toBeFalsy()
-      })
+        it(`includes apostrophes e.g. Bluesky's`, async () => {
+          await agent.addMutedWord({
+            value: `Bluesky's`,
+            targets: [],
+            actorTarget: 'all',
+          })
+          const { mutedWords } = (await agent.getPreferences()).moderationPrefs
+
+          expect(mutedWords.find((m) => m.value === `Bluesky's`)).toBeTruthy()
+        })
 
-      it('removeMutedWord with #, no match, no removal', async () => {
-        await agent.removeMutedWord({ value: '#hashtag', targets: [] })
-        const { mutedWords } = (await agent.getPreferences()).moderationPrefs
+        describe(`invalid characters`, () => {
+          it('#<zws>, no insert', async () => {
+            await agent.addMutedWord({
+              value: '#​',
+              targets: [],
+              actorTarget: 'all',
+            })
+            const { moderationPrefs } = await agent.getPreferences()
+            expect(moderationPrefs.mutedWords.length).toEqual(0)
+          })
 
-        // was inserted with #hashtag, but we don't sanitize on remove
-        expect(mutedWords.find((m) => m.value === 'hashtag')).toBeTruthy()
+          it('#<zws>ab, inserts ab', async () => {
+            await agent.addMutedWord({
+              value: '#​ab',
+              targets: [],
+              actorTarget: 'all',
+            })
+            const { moderationPrefs } = await agent.getPreferences()
+            expect(moderationPrefs.mutedWords.length).toEqual(1)
+          })
+
+          it('phrase with newline, inserts phrase without newline', async () => {
+            await agent.addMutedWord({
+              value: 'test value\n with newline',
+              targets: [],
+              actorTarget: 'all',
+            })
+            const { moderationPrefs } = await agent.getPreferences()
+            expect(
+              moderationPrefs.mutedWords.find(
+                (m) => m.value === 'test value with newline',
+              ),
+            ).toBeTruthy()
+          })
+
+          it('phrase with newlines, inserts phrase without newlines', async () => {
+            await agent.addMutedWord({
+              value: 'test value\n\r with newline',
+              targets: [],
+              actorTarget: 'all',
+            })
+            const { moderationPrefs } = await agent.getPreferences()
+            expect(
+              moderationPrefs.mutedWords.find(
+                (m) => m.value === 'test value with newline',
+              ),
+            ).toBeTruthy()
+          })
+
+          it('empty space, no insert', async () => {
+            await agent.addMutedWord({
+              value: ' ',
+              targets: [],
+              actorTarget: 'all',
+            })
+            const { moderationPrefs } = await agent.getPreferences()
+            expect(moderationPrefs.mutedWords.length).toEqual(0)
+          })
+
+          it(`' trim ', inserts 'trim'`, async () => {
+            await agent.addMutedWord({
+              value: ' trim ',
+              targets: [],
+              actorTarget: 'all',
+            })
+            const { moderationPrefs } = await agent.getPreferences()
+            expect(
+              moderationPrefs.mutedWords.find((m) => m.value === 'trim'),
+            ).toBeTruthy()
+          })
+        })
       })
 
-      it('single-hash #', async () => {
-        const prev = (await agent.getPreferences()).moderationPrefs
-        const length = prev.mutedWords.length
-        await agent.upsertMutedWords([{ value: '#', targets: [] }])
-        const end = (await agent.getPreferences()).moderationPrefs
+      describe('addMutedWords', () => {
+        it('inserts happen sequentially, no clobbering', async () => {
+          await agent.addMutedWords([
+            { value: 'a', targets: ['content'], actorTarget: 'all' },
+            { value: 'b', targets: ['content'], actorTarget: 'all' },
+            { value: 'c', targets: ['content'], actorTarget: 'all' },
+          ])
+
+          const { moderationPrefs } = await agent.getPreferences()
 
-        // sanitized to empty string, not inserted
-        expect(end.mutedWords.length).toEqual(length)
+          expect(moderationPrefs.mutedWords.length).toEqual(3)
+        })
       })
 
-      it('multi-hash ##', async () => {
-        await agent.upsertMutedWords([{ value: '##', targets: [] }])
-        const { mutedWords } = (await agent.getPreferences()).moderationPrefs
+      describe('upsertMutedWords (deprecated)', () => {
+        it('no longer upserts, calls addMutedWords', async () => {
+          await agent.upsertMutedWords([
+            { value: 'both', targets: ['content'], actorTarget: 'all' },
+          ])
+          await agent.upsertMutedWords([
+            { value: 'both', targets: ['tag'], actorTarget: 'all' },
+          ])
+
+          const { moderationPrefs } = await agent.getPreferences()
 
-        expect(mutedWords.find((m) => m.value === '#')).toBeTruthy()
+          expect(moderationPrefs.mutedWords.length).toEqual(2)
+        })
       })
 
-      it('multi-hash ##hashtag', async () => {
-        await agent.upsertMutedWords([{ value: '##hashtag', targets: [] }])
-        const a = (await agent.getPreferences()).moderationPrefs
+      describe('updateMutedWord', () => {
+        it(`word doesn't exist, no update or insert`, async () => {
+          await agent.updateMutedWord({
+            value: 'word',
+            targets: ['tag', 'content'],
+            actorTarget: 'all',
+          })
+          const { moderationPrefs } = await agent.getPreferences()
+          expect(moderationPrefs.mutedWords.length).toEqual(0)
+        })
 
-        expect(a.mutedWords.find((w) => w.value === '#hashtag')).toBeTruthy()
+        it('updates and sanitizes new value', async () => {
+          await agent.addMutedWord({
+            value: 'value',
+            targets: ['content'],
+            actorTarget: 'all',
+          })
 
-        await agent.removeMutedWord({ value: '#hashtag', targets: [] })
-        const b = (await agent.getPreferences()).moderationPrefs
+          const a = await agent.getPreferences()
+          const word = a.moderationPrefs.mutedWords.find(
+            (m) => m.value === 'value',
+          )
 
-        expect(b.mutedWords.find((w) => w.value === '#hashtag')).toBeFalsy()
-      })
+          await agent.updateMutedWord({
+            ...word!,
+            value: '#new value',
+          })
 
-      it('hash emoji #️⃣', async () => {
-        await agent.upsertMutedWords([{ value: '#️⃣', targets: [] }])
-        const { mutedWords } = (await agent.getPreferences()).moderationPrefs
+          const b = await agent.getPreferences()
+          const updatedWord = b.moderationPrefs.mutedWords.find(
+            (m) => m.id === word!.id,
+          )
 
-        expect(mutedWords.find((m) => m.value === '#️⃣')).toBeTruthy()
+          expect(updatedWord!.value).toEqual('new value')
+          expect(updatedWord).toHaveProperty('targets', ['content'])
+        })
 
-        await agent.removeMutedWord({ value: '#️⃣', targets: [] })
-        const end = (await agent.getPreferences()).moderationPrefs
+        it('updates targets', async () => {
+          await agent.addMutedWord({
+            value: 'word',
+            targets: ['tag'],
+            actorTarget: 'all',
+          })
 
-        expect(end.mutedWords.find((m) => m.value === '#️⃣')).toBeFalsy()
-      })
+          const a = await agent.getPreferences()
+          const word = a.moderationPrefs.mutedWords.find(
+            (m) => m.value === 'word',
+          )
 
-      it('hash emoji ##️⃣', async () => {
-        await agent.upsertMutedWords([{ value: '##️⃣', targets: [] }])
-        const { mutedWords } = (await agent.getPreferences()).moderationPrefs
+          await agent.updateMutedWord({
+            ...word!,
+            targets: ['content'],
+          })
 
-        expect(mutedWords.find((m) => m.value === '#️⃣')).toBeTruthy()
+          const b = await agent.getPreferences()
 
-        await agent.removeMutedWord({ value: '#️⃣', targets: [] })
-        const end = (await agent.getPreferences()).moderationPrefs
+          expect(
+            b.moderationPrefs.mutedWords.find((m) => m.id === word!.id),
+          ).toHaveProperty('targets', ['content'])
+        })
 
-        expect(end.mutedWords.find((m) => m.value === '#️⃣')).toBeFalsy()
-      })
+        it('updates actorTarget', async () => {
+          await agent.addMutedWord({
+            value: 'value',
+            targets: ['content'],
+            actorTarget: 'all',
+          })
 
-      it('hash emoji ###️⃣', async () => {
-        await agent.upsertMutedWords([{ value: '###️⃣', targets: [] }])
-        const { mutedWords } = (await agent.getPreferences()).moderationPrefs
+          const a = await agent.getPreferences()
+          const word = a.moderationPrefs.mutedWords.find(
+            (m) => m.value === 'value',
+          )
 
-        expect(mutedWords.find((m) => m.value === '##️⃣')).toBeTruthy()
+          await agent.updateMutedWord({
+            ...word!,
+            actorTarget: 'exclude-following',
+          })
 
-        await agent.removeMutedWord({ value: '##️⃣', targets: [] })
-        const end = (await agent.getPreferences()).moderationPrefs
+          const b = await agent.getPreferences()
 
-        expect(end.mutedWords.find((m) => m.value === '##️⃣')).toBeFalsy()
-      })
+          expect(
+            b.moderationPrefs.mutedWords.find((m) => m.id === word!.id),
+          ).toHaveProperty('actorTarget', 'exclude-following')
+        })
+
+        it('updates expiresAt', async () => {
+          const expiresAt = new Date(Date.now() + 6e3).toISOString()
+          const expiresAt2 = new Date(Date.now() + 10e3).toISOString()
+          await agent.addMutedWord({
+            value: 'value',
+            targets: ['content'],
+            expiresAt,
+            actorTarget: 'all',
+          })
+
+          const a = await agent.getPreferences()
+          const word = a.moderationPrefs.mutedWords.find(
+            (m) => m.value === 'value',
+          )
+
+          await agent.updateMutedWord({
+            ...word!,
+            expiresAt: expiresAt2,
+          })
 
-      it(`apostrophe: Bluesky's`, async () => {
-        await agent.upsertMutedWords([{ value: `Bluesky's`, targets: [] }])
-        const { mutedWords } = (await agent.getPreferences()).moderationPrefs
+          const b = await agent.getPreferences()
 
-        expect(mutedWords.find((m) => m.value === `Bluesky's`)).toBeTruthy()
+          expect(
+            b.moderationPrefs.mutedWords.find((m) => m.id === word!.id),
+          ).toHaveProperty('expiresAt', expiresAt2)
+        })
+
+        it(`doesn't update if value is sanitized to be falsy`, async () => {
+          await agent.addMutedWord({
+            value: 'rug',
+            targets: ['content'],
+            actorTarget: 'all',
+          })
+
+          const a = await agent.getPreferences()
+          const word = a.moderationPrefs.mutedWords.find(
+            (m) => m.value === 'rug',
+          )
+
+          await agent.updateMutedWord({
+            ...word!,
+            value: '',
+          })
+
+          const b = await agent.getPreferences()
+
+          expect(
+            b.moderationPrefs.mutedWords.find((m) => m.id === word!.id),
+          ).toHaveProperty('value', 'rug')
+        })
       })
 
-      describe(`invalid characters`, () => {
-        it('zero width space', async () => {
-          const prev = (await agent.getPreferences()).moderationPrefs
-          const length = prev.mutedWords.length
-          await agent.upsertMutedWords([{ value: '#​', targets: [] }])
-          const { mutedWords } = (await agent.getPreferences()).moderationPrefs
+      describe('removeMutedWord', () => {
+        it('removes word', async () => {
+          await agent.addMutedWord({
+            value: 'word',
+            targets: ['tag'],
+            actorTarget: 'all',
+          })
+          const a = await agent.getPreferences()
+          const word = a.moderationPrefs.mutedWords.find(
+            (m) => m.value === 'word',
+          )
+
+          await agent.removeMutedWord(word!)
 
-          expect(mutedWords.length).toEqual(length)
+          const b = await agent.getPreferences()
+
+          expect(
+            b.moderationPrefs.mutedWords.find((m) => m.id === word!.id),
+          ).toBeFalsy()
         })
 
-        it('newline', async () => {
-          await agent.upsertMutedWords([
-            { value: 'test value\n with newline', targets: [] },
-          ])
-          const { mutedWords } = (await agent.getPreferences()).moderationPrefs
+        it(`word doesn't exist, no action`, async () => {
+          await agent.addMutedWord({
+            value: 'word',
+            targets: ['tag'],
+            actorTarget: 'all',
+          })
+          const a = await agent.getPreferences()
+          const word = a.moderationPrefs.mutedWords.find(
+            (m) => m.value === 'word',
+          )
+
+          await agent.removeMutedWord({
+            value: 'another',
+            targets: [],
+            actorTarget: 'all',
+          })
+
+          const b = await agent.getPreferences()
 
           expect(
-            mutedWords.find((m) => m.value === 'test value with newline'),
+            b.moderationPrefs.mutedWords.find((m) => m.id === word!.id),
           ).toBeTruthy()
         })
+      })
+
+      describe('removeMutedWords', () => {
+        it(`removes sequentially, no clobbering`, async () => {
+          await agent.addMutedWords([
+            { value: 'a', targets: ['content'], actorTarget: 'all ' },
+            { value: 'b', targets: ['content'], actorTarget: 'all ' },
+            { value: 'c', targets: ['content'], actorTarget: 'all ' },
+          ])
+
+          const a = await agent.getPreferences()
+          await agent.removeMutedWords(a.moderationPrefs.mutedWords)
+          const b = await agent.getPreferences()
+
+          expect(b.moderationPrefs.mutedWords.length).toEqual(0)
+        })
+      })
+    })
+
+    describe('legacy muted words', () => {
+      let agent: BskyAgent
+
+      async function updatePreferences(
+        agent: BskyAgent,
+        cb: (
+          prefs: AppBskyActorDefs.Preferences,
+        ) => AppBskyActorDefs.Preferences | false,
+      ) {
+        const res = await agent.app.bsky.actor.getPreferences({})
+        const newPrefs = cb(res.data.preferences)
+        if (newPrefs === false) {
+          return
+        }
+        await agent.app.bsky.actor.putPreferences({
+          preferences: newPrefs,
+        })
+      }
+
+      async function addLegacyMutedWord(mutedWord: AppBskyActorDefs.MutedWord) {
+        await updatePreferences(agent, (prefs) => {
+          let mutedWordsPref = prefs.findLast(
+            (pref) =>
+              AppBskyActorDefs.isMutedWordsPref(pref) &&
+              AppBskyActorDefs.validateMutedWordsPref(pref).success,
+          )
+
+          const newMutedWord: AppBskyActorDefs.MutedWord = {
+            value: mutedWord.value,
+            targets: mutedWord.targets,
+            actorTarget: 'all',
+          }
+
+          if (
+            mutedWordsPref &&
+            AppBskyActorDefs.isMutedWordsPref(mutedWordsPref)
+          ) {
+            mutedWordsPref.items.push(newMutedWord)
+          } else {
+            // if the pref doesn't exist, create it
+            mutedWordsPref = {
+              items: [newMutedWord],
+            }
+          }
+
+          return prefs
+            .filter((p) => !AppBskyActorDefs.isMutedWordsPref(p))
+            .concat([
+              {
+                ...mutedWordsPref,
+                $type: 'app.bsky.actor.defs#mutedWordsPref',
+              },
+            ])
+        })
+      }
+
+      beforeAll(async () => {
+        agent = new BskyAgent({ service: network.pds.url })
+        await agent.createAccount({
+          handle: 'user7-1.test',
+          email: 'user7-1@test.com',
+          password: 'password',
+        })
+      })
+
+      afterEach(async () => {
+        const { moderationPrefs } = await agent.getPreferences()
+        await agent.removeMutedWords(moderationPrefs.mutedWords)
+      })
+
+      describe(`upsertMutedWords (and addMutedWord)`, () => {
+        it(`adds new word, migrates old words`, async () => {
+          await addLegacyMutedWord({
+            value: 'word',
+            targets: ['content'],
+            actorTarget: 'all',
+          })
+
+          {
+            const { moderationPrefs } = await agent.getPreferences()
+            const word = moderationPrefs.mutedWords.find(
+              (w) => w.value === 'word',
+            )
+            expect(word).toBeTruthy()
+            expect(word!.id).toBeFalsy()
+          }
 
-        it('newline(s)', async () => {
           await agent.upsertMutedWords([
-            { value: 'test value\n\r with newline', targets: [] },
+            { value: 'word2', targets: ['tag'], actorTarget: 'all' },
           ])
-          const { mutedWords } = (await agent.getPreferences()).moderationPrefs
 
-          expect(
-            mutedWords.find((m) => m.value === 'test value with newline'),
-          ).toBeTruthy()
+          {
+            const { moderationPrefs } = await agent.getPreferences()
+            const word = moderationPrefs.mutedWords.find(
+              (w) => w.value === 'word',
+            )
+            const word2 = moderationPrefs.mutedWords.find(
+              (w) => w.value === 'word2',
+            )
+
+            expect(word!.id).toBeTruthy()
+            expect(word2!.id).toBeTruthy()
+          }
         })
+      })
 
-        it('empty space', async () => {
-          await agent.upsertMutedWords([{ value: ' ', targets: [] }])
-          const { mutedWords } = (await agent.getPreferences()).moderationPrefs
+      describe(`updateMutedWord`, () => {
+        it(`updates legacy word, migrates old words`, async () => {
+          await addLegacyMutedWord({
+            value: 'word',
+            targets: ['content'],
+            actorTarget: 'all',
+          })
+          await addLegacyMutedWord({
+            value: 'word2',
+            targets: ['tag'],
+            actorTarget: 'all',
+          })
 
-          expect(mutedWords.find((m) => m.value === ' ')).toBeFalsy()
+          await agent.updateMutedWord({
+            value: 'word',
+            targets: ['tag'],
+            actorTarget: 'all',
+          })
+
+          {
+            const { moderationPrefs } = await agent.getPreferences()
+            const word = moderationPrefs.mutedWords.find(
+              (w) => w.value === 'word',
+            )
+            const word2 = moderationPrefs.mutedWords.find(
+              (w) => w.value === 'word2',
+            )
+
+            expect(moderationPrefs.mutedWords.length).toEqual(2)
+            expect(word!.id).toBeTruthy()
+            expect(word!.targets).toEqual(['tag'])
+            expect(word2!.id).toBeTruthy()
+          }
         })
+      })
 
-        it('leading/trailing space', async () => {
-          await agent.upsertMutedWords([{ value: ' trim ', targets: [] }])
-          const { mutedWords } = (await agent.getPreferences()).moderationPrefs
+      describe(`removeMutedWord`, () => {
+        it(`removes legacy word, migrates old words`, async () => {
+          await addLegacyMutedWord({
+            value: 'word',
+            targets: ['content'],
+            actorTarget: 'all',
+          })
+          await addLegacyMutedWord({
+            value: 'word2',
+            targets: ['tag'],
+            actorTarget: 'all',
+          })
+
+          await agent.removeMutedWord({
+            value: 'word',
+            targets: ['tag'],
+            actorTarget: 'all',
+          })
 
-          expect(mutedWords.find((m) => m.value === 'trim')).toBeTruthy()
+          {
+            const { moderationPrefs } = await agent.getPreferences()
+            const word = moderationPrefs.mutedWords.find(
+              (w) => w.value === 'word',
+            )
+            const word2 = moderationPrefs.mutedWords.find(
+              (w) => w.value === 'word2',
+            )
+
+            expect(moderationPrefs.mutedWords.length).toEqual(1)
+            expect(word).toBeFalsy()
+            expect(word2!.id).toBeTruthy()
+          }
         })
       })
     })