feat: add snjs package

packages/snjs/mocha/model_tests/items.test.js

@@ -0,0 +1,220 @@
+/* eslint-disable no-unused-expressions */
+/* eslint-disable no-undef */
+import * as Factory from '../lib/factory.js'
+chai.use(chaiAsPromised)
+const expect = chai.expect
+
+describe('items', () => {
+  const BASE_ITEM_COUNT = 2 /** Default items key, user preferences */
+
+  const syncOptions = {
+    checkIntegrity: true,
+    awaitAll: true,
+  }
+
+  beforeEach(async function () {
+    this.expectedItemCount = BASE_ITEM_COUNT
+    this.application = await Factory.createInitAppWithFakeCrypto()
+  })
+
+  afterEach(async function () {
+    await Factory.safeDeinit(this.application)
+  })
+
+  it('setting an item as dirty should update its client updated at', async function () {
+    const params = Factory.createNotePayload()
+    await this.application.itemManager.emitItemsFromPayloads([params], PayloadEmitSource.LocalChanged)
+    const item = this.application.itemManager.items[0]
+    const prevDate = item.userModifiedDate.getTime()
+    await Factory.sleep(0.1)
+    await this.application.itemManager.setItemDirty(item, true)
+    const refreshedItem = this.application.itemManager.findItem(item.uuid)
+    const newDate = refreshedItem.userModifiedDate.getTime()
+    expect(prevDate).to.not.equal(newDate)
+  })
+
+  it('setting an item as dirty with option to skip client updated at', async function () {
+    const params = Factory.createNotePayload()
+    await this.application.itemManager.emitItemsFromPayloads([params], PayloadEmitSource.LocalChanged)
+    const item = this.application.itemManager.items[0]
+    const prevDate = item.userModifiedDate.getTime()
+    await Factory.sleep(0.1)
+    await this.application.itemManager.setItemDirty(item)
+    const newDate = item.userModifiedDate.getTime()
+    expect(prevDate).to.equal(newDate)
+  })
+
+  it('properly pins, archives, and locks', async function () {
+    const params = Factory.createNotePayload()
+    await this.application.itemManager.emitItemsFromPayloads([params], PayloadEmitSource.LocalChanged)
+
+    const item = this.application.itemManager.items[0]
+    expect(item.pinned).to.not.be.ok
+
+    const refreshedItem = await this.application.mutator.changeAndSaveItem(
+      item,
+      (mutator) => {
+        mutator.pinned = true
+        mutator.archived = true
+        mutator.locked = true
+      },
+      undefined,
+      undefined,
+      syncOptions,
+    )
+    expect(refreshedItem.pinned).to.equal(true)
+    expect(refreshedItem.archived).to.equal(true)
+    expect(refreshedItem.locked).to.equal(true)
+  })
+
+  it('properly compares item equality', async function () {
+    const params1 = Factory.createNotePayload()
+    const params2 = Factory.createNotePayload()
+    await this.application.itemManager.emitItemsFromPayloads([params1, params2], PayloadEmitSource.LocalChanged)
+
+    let item1 = this.application.itemManager.getDisplayableNotes()[0]
+    let item2 = this.application.itemManager.getDisplayableNotes()[1]
+
+    expect(item1.isItemContentEqualWith(item2)).to.equal(true)
+
+    // items should ignore this field when checking for equality
+    item1 = await this.application.mutator.changeAndSaveItem(
+      item1,
+      (mutator) => {
+        mutator.userModifiedDate = new Date()
+      },
+      undefined,
+      undefined,
+      syncOptions,
+    )
+    item2 = await this.application.mutator.changeAndSaveItem(
+      item2,
+      (mutator) => {
+        mutator.userModifiedDate = undefined
+      },
+      undefined,
+      undefined,
+      syncOptions,
+    )
+
+    expect(item1.isItemContentEqualWith(item2)).to.equal(true)
+
+    item1 = await this.application.mutator.changeAndSaveItem(
+      item1,
+      (mutator) => {
+        mutator.mutableContent.foo = 'bar'
+      },
+      undefined,
+      undefined,
+      syncOptions,
+    )
+
+    expect(item1.isItemContentEqualWith(item2)).to.equal(false)
+
+    item2 = await this.application.mutator.changeAndSaveItem(
+      item2,
+      (mutator) => {
+        mutator.mutableContent.foo = 'bar'
+      },
+      undefined,
+      undefined,
+      syncOptions,
+    )
+
+    expect(item1.isItemContentEqualWith(item2)).to.equal(true)
+    expect(item2.isItemContentEqualWith(item1)).to.equal(true)
+
+    item1 = await this.application.mutator.changeAndSaveItem(
+      item1,
+      (mutator) => {
+        mutator.e2ePendingRefactor_addItemAsRelationship(item2)
+      },
+      undefined,
+      undefined,
+      syncOptions,
+    )
+    item2 = await this.application.mutator.changeAndSaveItem(
+      item2,
+      (mutator) => {
+        mutator.e2ePendingRefactor_addItemAsRelationship(item1)
+      },
+      undefined,
+      undefined,
+      syncOptions,
+    )
+
+    expect(item1.content.references.length).to.equal(1)
+    expect(item2.content.references.length).to.equal(1)
+
+    expect(item1.isItemContentEqualWith(item2)).to.equal(false)
+
+    item1 = await this.application.mutator.changeAndSaveItem(
+      item1,
+      (mutator) => {
+        mutator.removeItemAsRelationship(item2)
+      },
+      undefined,
+      undefined,
+      syncOptions,
+    )
+    item2 = await this.application.mutator.changeAndSaveItem(
+      item2,
+      (mutator) => {
+        mutator.removeItemAsRelationship(item1)
+      },
+      undefined,
+      undefined,
+      syncOptions,
+    )
+
+    expect(item1.isItemContentEqualWith(item2)).to.equal(true)
+    expect(item1.content.references.length).to.equal(0)
+    expect(item2.content.references.length).to.equal(0)
+  })
+
+  it('content equality should not have side effects', async function () {
+    const params1 = Factory.createNotePayload()
+    const params2 = Factory.createNotePayload()
+    await this.application.itemManager.emitItemsFromPayloads([params1, params2], PayloadEmitSource.LocalChanged)
+
+    let item1 = this.application.itemManager.getDisplayableNotes()[0]
+    const item2 = this.application.itemManager.getDisplayableNotes()[1]
+
+    item1 = await this.application.mutator.changeAndSaveItem(
+      item1,
+      (mutator) => {
+        mutator.mutableContent.foo = 'bar'
+      },
+      undefined,
+      undefined,
+      syncOptions,
+    )
+
+    expect(item1.content.foo).to.equal('bar')
+
+    item1.contentKeysToIgnoreWhenCheckingEquality = () => {
+      return ['foo']
+    }
+
+    item2.contentKeysToIgnoreWhenCheckingEquality = () => {
+      return ['foo']
+    }
+
+    // calling isItemContentEqualWith should not have side effects
+    // There was an issue where calling that function would modify values directly to omit keys
+    // in contentKeysToIgnoreWhenCheckingEquality.
+
+    await this.application.itemManager.setItemsDirty([item1, item2])
+
+    expect(item1.userModifiedDate).to.be.ok
+    expect(item2.userModifiedDate).to.be.ok
+
+    expect(item1.isItemContentEqualWith(item2)).to.equal(true)
+    expect(item2.isItemContentEqualWith(item1)).to.equal(true)
+
+    expect(item1.userModifiedDate).to.be.ok
+    expect(item2.userModifiedDate).to.be.ok
+
+    expect(item1.content.foo).to.equal('bar')
+  })
+})