feat: add snjs package

packages/snjs/mocha/auth-fringe-cases.test.js

@@ -0,0 +1,111 @@
+/* eslint-disable no-unused-expressions */
+/* eslint-disable no-undef */
+import * as Factory from './lib/factory.js'
+chai.use(chaiAsPromised)
+const expect = chai.expect
+
+describe('auth fringe cases', () => {
+  const BASE_ITEM_COUNT = ['default items key', 'user prefs'].length
+
+  const createContext = async () => {
+    const application = await Factory.createInitAppWithFakeCrypto()
+    return {
+      expectedItemCount: BASE_ITEM_COUNT,
+      application: application,
+      email: UuidGenerator.GenerateUuid(),
+      password: UuidGenerator.GenerateUuid(),
+      deinit: async () => {
+        await Factory.safeDeinit(application)
+      },
+    }
+  }
+
+  beforeEach(async function () {
+    localStorage.clear()
+  })
+
+  afterEach(async function () {
+    localStorage.clear()
+  })
+
+  const clearApplicationLocalStorage = function () {
+    const keys = Object.keys(localStorage)
+    for (const key of keys) {
+      if (!key.toLowerCase().includes('item')) {
+        localStorage.removeItem(key)
+      }
+    }
+  }
+
+  const awaitSync = true
+
+  describe('localStorage improperly cleared with 1 item', function () {
+    it('item should be errored', async function () {
+      const context = await createContext()
+      await context.application.register(context.email, context.password)
+      const note = await Factory.createSyncedNote(context.application)
+      clearApplicationLocalStorage()
+
+      console.warn("Expecting errors 'Unable to find operator for version undefined'")
+
+      const restartedApplication = await Factory.restartApplication(context.application)
+      const refreshedNote = restartedApplication.payloadManager.findOne(note.uuid)
+      expect(refreshedNote.errorDecrypting).to.equal(true)
+
+      await Factory.safeDeinit(restartedApplication)
+    })
+
+    it('signing in again should decrypt item', async function () {
+      const context = await createContext()
+      await context.application.register(context.email, context.password)
+      const note = await Factory.createSyncedNote(context.application)
+      clearApplicationLocalStorage()
+      const restartedApplication = await Factory.restartApplication(context.application)
+
+      console.warn(
+        "Expecting errors 'No associated key found for item encrypted with latest protocol version.'",
+        "and 'Unable to find operator for version undefined'",
+      )
+
+      await restartedApplication.signIn(context.email, context.password, undefined, undefined, undefined, awaitSync)
+      const refreshedNote = restartedApplication.itemManager.findItem(note.uuid)
+      expect(isDecryptedItem(refreshedNote)).to.equal(true)
+      expect(restartedApplication.itemManager.getDisplayableNotes().length).to.equal(1)
+      await Factory.safeDeinit(restartedApplication)
+    }).timeout(10000)
+  })
+
+  describe('having offline item matching remote item uuid', function () {
+    it('offline item should not overwrite recently updated server item and conflict should be created', async function () {
+      const context = await createContext()
+      await context.application.register(context.email, context.password)
+
+      const staleText = 'stale text'
+
+      const firstVersionOfNote = await Factory.createSyncedNote(context.application, undefined, staleText)
+
+      const serverText = 'server text'
+
+      await context.application.mutator.changeAndSaveItem(firstVersionOfNote, (mutator) => {
+        mutator.text = serverText
+      })
+
+      const newApplication = await Factory.signOutApplicationAndReturnNew(context.application)
+
+      /** Create same note but now offline */
+      await newApplication.itemManager.emitItemFromPayload(firstVersionOfNote.payload)
+
+      /** Sign in and merge local data */
+      await newApplication.signIn(context.email, context.password, undefined, undefined, true, true)
+
+      expect(newApplication.itemManager.getDisplayableNotes().length).to.equal(2)
+
+      expect(newApplication.itemManager.getDisplayableNotes().find((n) => n.uuid === firstVersionOfNote.uuid).text).to.equal(staleText)
+
+      const conflictedCopy = newApplication.itemManager.getDisplayableNotes().find((n) => n.uuid !== firstVersionOfNote.uuid)
+      expect(conflictedCopy.text).to.equal(serverText)
+      expect(conflictedCopy.duplicate_of).to.equal(firstVersionOfNote.uuid)
+      await Factory.safeDeinit(newApplication)
+    }).timeout(10000)
+  })
+})