mem.test.js

/*
  MIT License,
  Copyright (c) 2010-2024, Richard Rodger and other contributors.
*/

'use strict'

const Util = require('util')

const Assert = require('assert')
const Seneca = require('seneca')
const Shared = require('seneca-store-test')
const MakePluginValidator = require('seneca-plugin-validator')

const Code = require('@hapi/code')
const { expect } = Code
const Lab = require('@hapi/lab')
const lab = (exports.lab = Lab.script())
const { describe, before, after } = lab
const it = make_it(lab)
const test = it

function makeSenecaForTest(opts = {}) {
  const { seneca_opts = {} } = opts

  const seneca = Seneca(
    Object.assign(
      {
        // log: 'silent',
        default_plugins: { 'mem-store': false },
      },
      seneca_opts,
    ),
  ).test()

  const { mem_store_opts = {} } = opts
  seneca.use('entity', { mem_store: false })
  seneca.use({ name: '..', tag: '1' }, mem_store_opts)

  return seneca
}

const seneca = Seneca({
  legacy: false,
  // log: 'silent',
  default_plugins: { 'mem-store': false },
})
  .test()
  .use('entity', { mem_store: false })
seneca.use({ name: '..', tag: '1' })

const senecaMerge = Seneca({
  legacy: false,
  log: 'silent',
})
  .test()
  .use('entity', { mem_store: false })
senecaMerge.use({ name: '..', tag: '1' }, { merge: false })

const seneca_test = Seneca({ legacy: false }) // ({ require })
  .test()
  .use('promisify')
  .use('entity', { mem_store: false })
//.use('..')

const test_opts = {
  seneca: seneca_test,
  name: 'mem-store',
}

Shared.test.init(lab, test_opts)
Shared.test.keyvalue(lab, test_opts)

describe('mem-store', () => {
  test('load-plugin', async (fin) => {
    const s0 = await Seneca()
      .test()
      .use('promisify')
      .use('entity', { mem_store: false })
      .use('..')
      .ready()
    // console.log(s0.list_plugins())
    // console.log(s0.find_plugin('mem-store'))
    expect(s0.find_plugin('mem-store')).exists()
    await s0.close()
    fin()
  })

  it('is a plugin', (fin) => {
    const validatePlugin = MakePluginValidator(require('..'), module)

    validatePlugin().then(fin).catch(fin)
  })
})

// describe('mem-store tests', function () {
Shared.basictest({
  seneca: seneca,
  senecaMerge: senecaMerge,
  script: lab,
})

Shared.limitstest({
  seneca: seneca,
  script: lab,
})

// TODO: does not seem to include ents that are equvalent for sorting
Shared.sorttest({
  seneca: seneca,
  script: lab,
})

Shared.upserttest({
  seneca: makeSenecaForTest(),
  script: lab,
})

it('export-native', function (fin) {
  Assert.ok(
    seneca.export('mem-store$1/native') || seneca.export('mem-store/1/native'),
  )
  fin()
})

it('custom-test', function (fin) {
  seneca.test(fin)

  var ent = seneca.make('foo', { id$: '0', q: 1 })

  ent.save$(function (err) {
    Assert.ok(null === err)

    seneca.act('role:mem-store, cmd:export', function (err, exported) {
      var expected =
        '{"undefined":{"foo":{"0":{"entity$":"-/-/foo","q":1,"id":"0"}}}}'

      Assert.ok(null === err)
      Assert.equal(exported.json, expected)

      var data = JSON.parse(exported.json)
      data['undefined']['foo']['1'] = { entity$: '-/-/foo', val: 2, id: '1' }

      seneca.act(
        'role:mem-store, cmd:import',
        { json: JSON.stringify(data) },
        function (err) {
          Assert.ok(null === err)

          seneca.make('foo').load$('1', function (err, foo) {
            Assert.ok(null === err)
            Assert.equal(2, foo.val)

            fin()
          })
        },
      )
    })
  })
})

it('import', function (fin) {
  seneca.test(fin)

  seneca.act(
    'role:mem-store, cmd:import',
    { json: JSON.stringify({ foo: { bar: { aaa: { id: 'aaa', a: 1 } } } }) },
    function (err) {
      seneca.make('foo/bar').load$('aaa', function (err, aaa) {
        Assert.equal('$-/foo/bar;id=aaa;{a:1}', aaa.toString())

        seneca.act(
          'role:mem-store, cmd:import, merge:true',
          {
            json: JSON.stringify({
              foo: {
                bar: {
                  aaa: { id: 'aaa', a: 2 },
                  bbb: { id: 'bbb', a: 3 },
                },
              },
            }),
          },
          function (err) {
            seneca.make('foo/bar').load$('aaa', function (err, aaa) {
              Assert.equal('$-/foo/bar;id=aaa;{a:2}', aaa.toString())

              seneca.make('foo/bar').load$('bbb', function (err, bbb) {
                Assert.equal('$-/foo/bar;id=bbb;{a:3}', bbb.toString())

                seneca.act('role:mem-store, cmd:export', function (err, out) {
                  Assert.equal(
                    JSON.stringify({
                      foo: {
                        bar: {
                          aaa: { id: 'aaa', a: 2 },
                          bbb: { id: 'bbb', a: 3 },
                        },
                      },
                    }),
                    out.json,
                  )
                  fin()
                })
              })
            })
          },
        )
      })
    },
  )
})

it('generate_id', function (fin) {
  seneca.make$('foo', { a: 1 }).save$(function (err, out) {
    if (err) return fin(err)

    Assert(6 === out.id.length)
    fin()
  })
})

it('fields', function (fin) {
  seneca.test(fin)

  var ent = seneca.make('foo', { id$: 'f0', a: 1, b: 2, c: 3 })

  ent.save$(function (err, foo0) {
    foo0.list$({ id: 'f0', fields$: ['a', 'c'] }, function (err, list) {
      expect(list[0].toString()).equal('$-/-/foo;id=f0;{a:1,c:3}')

      foo0.load$(
        { id: 'f0', fields$: ['a', 'not-a-fields'] },
        function (err, out) {
          expect(out.toString()).equal('$-/-/foo;id=f0;{a:1}')
          fin()
        },
      )
    })
  })
})

it('in-query', function (fin) {
  seneca.test(fin)

  seneca.make('zed', { p1: 'a', p2: 10 }).save$()
  seneca.make('zed', { p1: 'b', p2: 20 }).save$()
  seneca.make('zed', { p1: 'c', p2: 30 }).save$()
  seneca.make('zed', { p1: 'a', p2: 40 }).save$()
  seneca.ready(function () {
    seneca.make('zed').list$({ p1: 'a' }, function (err, list) {
      //console.log(err,list)
      expect(list.length).equal(2)

      seneca.make('zed').list$({ p1: ['a'] }, function (err, list) {
        //console.log(err,list)
        expect(list.length).equal(2)

        seneca.make('zed').list$({ p1: ['a', 'b'] }, function (err, list) {
          //console.log(err,list)
          expect(list.length).equal(3)
          fin()
        })
      })
    })
  })
})

it('mongo-style-query', function (fin) {
  seneca.test(fin)

  seneca.make('mongo', { p1: 'a', p2: 10 }).save$()
  seneca.make('mongo', { p1: 'b', p2: 20 }).save$()
  seneca.make('mongo', { p1: 'c', p2: 30 }).save$()
  seneca.make('mongo', { p1: 'a', p2: 40 }).save$()

  seneca.ready(function () {
    let m = seneca.make('mongo')

    m.list$({ p2: { $gte: 20 } }, function (err, list) {
      //console.log(err,list)
      expect(list.length).equal(3)

      m.list$({ p2: { $gt: 20 } }, function (err, list) {
        //console.log(err,list)
        expect(list.length).equal(2)

        m.list$({ p2: { $lt: 20 } }, function (err, list) {
          //console.log(err,list)
          expect(list.length).equal(1)

          m.list$({ p2: { $lte: 20 } }, function (err, list) {
            //console.log(err,list)
            expect(list.length).equal(2)

            m.list$({ p2: { $ne: 20 } }, function (err, list) {
              //console.log(err,list)
              expect(list.length).equal(3)

              m.list$({ p1: { $in: ['a', 'b'] } }, function (err, list) {
                // console.log(err,list)
                expect(list.length).equal(3)

                m.list$({ p1: { $nin: ['a', 'b'] } }, function (err, list) {
                  // console.log(err,list)
                  expect(list.length).equal(1)

                  // ignore unknown constraints
                  m.list$(
                    { p1: { $notaconstraint: 'whatever' } },
                    function (err, list) {
                      // console.log(err,list)
                      expect(list.length).equal(4)

                      fin()
                    },
                  )
                })
              })
            })
          })
        })
      })
    })
  })
})

describe('internal utilities', () => {
  const mem_store = seneca.export('mem-store')
  const { intern } = mem_store.init

  describe('find_mement', () => {
    const ent_base = 'sys'
    const ent_name = 'product'

    describe('no such entities exist', () => {
      let entmap

      before(async () => {
        entmap = {}
      })

      it('cannot match', (fin) => {
        const ent = seneca.make('sys', 'product')
        const filter = { label: 'lorem ipsum' }
        const result = intern.find_mement(entmap, ent, filter)

        expect(result).to.equal(null)

        return fin()
      })
    })

    describe('same entity base, different entity name', () => {
      let entmap

      before(async () => {
        entmap = {
          [ent_base]: {
            artist: {
              foo: {
                id: 'foo',
                label: 'lorem ipsum',
              },
            },
          },
        }
      })

      it('cannot match', (fin) => {
        const ent = seneca.make(ent_base, 'product')
        const filter = { label: 'lorem ipsum' }
        const result = intern.find_mement(entmap, ent, filter)

        expect(result).to.equal(null)

        return fin()
      })
    })

    describe('filter has more fields than the entity', () => {
      let entmap

      before(async () => {
        entmap = {
          [ent_base]: {
            [ent_name]: {
              foo: {
                id: 'foo',
                label: 'lorem ipsum',
              },
            },
          },
        }
      })

      it('cannot match', (fin) => {
        const ent = seneca.make(ent_base, ent_name)
        const filter = { label: 'lorem ipsum', bar: 'baz' }
        const result = intern.find_mement(entmap, ent, filter)

        expect(result).to.equal(null)

        return fin()
      })
    })

    describe('some field mismatches', () => {
      let entmap

      before(async () => {
        entmap = {
          [ent_base]: {
            [ent_name]: {
              foo: {
                id: 'foo',
                label: 'lorem ipsum',
                price: '2.34',
              },
            },
          },
        }
      })

      it('cannot match', (fin) => {
        const ent = seneca.make(ent_base, ent_name)
        const filter = { label: 'lorem ipsum', price: '0.95' }
        const result = intern.find_mement(entmap, ent, filter)

        expect(result).to.equal(null)

        return fin()
      })
    })

    describe('all fields and values match', () => {
      const some_product = {
        id: 'foo',
        label: 'lorem ipsum',
        price: '2.34',
      }

      let entmap

      before(async () => {
        entmap = {
          sys: {
            product: {
              foo: some_product,
            },
          },
        }
      })

      it('returns the match', (fin) => {
        const ent = seneca.make(ent_base, ent_name)
        const filter = { label: 'lorem ipsum', price: '2.34' }
        const result = intern.find_mement(entmap, ent, filter)

        expect(result).to.equal(some_product)

        return fin()
      })
    })

    describe('when the filter is empty', () => {
      const some_product = {
        id: 'foo',
        label: 'lorem ipsum',
        price: '2.34',
      }

      let entmap

      before(async () => {
        entmap = {
          sys: {
            product: {
              foo: some_product,
            },
          },
        }
      })

      it('returns the first document it comes across', (fin) => {
        const ent = seneca.make(ent_base, ent_name)
        const result = intern.find_mement(entmap, ent, {})

        expect(result).to.equal(some_product)

        return fin()
      })
    })
  })

  describe('is_new', () => {
    describe('passed a null', () => {
      it('returns a correct value', (fin) => {
        const result = intern.is_new(null)
        expect(result).to.equal(false)

        fin()
      })
    })

    describe('passed an entity that has not been saved yet', () => {
      let product

      before(() => {
        product = seneca.make('product').data$({ label: 'Legions of Rome' })
      })

      it('returns a correct value', (fin) => {
        const result = intern.is_new(product)
        expect(result).to.equal(true)

        fin()
      })
    })

    describe('passed an entity that has been saved before', () => {
      let product

      before(() => {
        return new Promise((resolve, reject) => {
          seneca
            .make('product')
            .data$({ label: 'Legions of Rome' })
            .save$((err, out) => {
              if (err) {
                return reject(err)
              }

              product = out

              return resolve()
            })
        })
      })

      it('returns a correct value', (fin) => {
        const result = intern.is_new(product)
        expect(result).to.equal(false)

        fin()
      })
    })

    describe('passed a new entity, but also an id arg', () => {
      let product

      before(() => {
        product = seneca
          .make('product')
          .data$({ id: 'my_precious', label: 'Legions of Rome' })
      })

      it('returns a correct value', (fin) => {
        const result = intern.is_new(product)
        expect(result).to.equal(false)

        fin()
      })
    })
  })

  describe('listents', () => {
    describe('when the query argument is a string', () => {
      const ent_base = 'sys'
      const ent_name = 'product'

      const product_id = 'foobaz'

      const product = {
        id: product_id,
        label: 'lorem ipsum',
        price: '2.34',
      }

      describe('when an entity with the same base, name, id exists', () => {
        let entmap

        before(async () => {
          entmap = {
            [ent_base]: {
              [ent_name]: {
                [product_id]: product,
              },
            },
          }
        })

        const product_ent = seneca.make(ent_base, ent_name)

        it('fetches the entity with the matching id', (fin) => {
          intern.listents(
            seneca,
            entmap,
            product_ent,
            product_id,
            (err, out) => {
              if (err) {
                return fin(err)
              }

              expect(out).to.equal([product])

              return fin()
            },
          )
        })
      })

      describe('entity with the same base, name, but not id exists', () => {
        const product_id = 'foobaz'

        const product = {
          id: product_id,
          label: 'lorem ipsum',
          price: '2.34',
        }

        let entmap

        before(async () => {
          entmap = {
            [ent_base]: {
              [ent_name]: {
                [product_id]: product,
              },
            },
          }
        })

        const product_ent = seneca.make(ent_base, ent_name)

        it('cannot match the entity', (fin) => {
          intern.listents(seneca, entmap, product_ent, 'quix', (err, out) => {
            if (err) {
              return fin(err)
            }

            expect(out).to.equal([])

            return fin()
          })
        })
      })
    })

    describe('when the query argument is an array', () => {
      const ent_base = 'sys'
      const ent_name = 'product'

      const product_id = 'foobaz'

      const product = {
        id: product_id,
        label: 'lorem ipsum',
        price: '2.34',
      }

      describe('when an item in the array is null', () => {
        let entmap

        before(async () => {
          entmap = {
            [ent_base]: {
              [ent_name]: {
                [product_id]: product,
              },
            },
          }
        })

        const product_ent = seneca.make(ent_base, ent_name)

        it('ignores the null', (fin) => {
          intern.listents(seneca, entmap, product_ent, [null], (err, out) => {
            if (err) {
              return fin(err)
            }

            expect(out).to.equal([])

            return fin()
          })
        })
      })
    })

    describe('when the query argument is null', () => {
      const product_id = 'aaaa'

      const product = {
        id: product_id,
        label: 'lorem ipsum',
        price: '2.34',
      }

      const ent_base = 'sys'
      const ent_name = 'product'

      let entmap

      before(async () => {
        entmap = {
          [ent_base]: {
            [ent_name]: {
              [product_id]: product,
            },
          },
        }
      })

      const product_ent = seneca.make(ent_base, ent_name)

      it('returns an empty list', (fin) => {
        intern.listents(seneca, entmap, product_ent, null, (err, out) => {
          if (err) {
            return fin(err)
          }

          expect(out).to.equal([])

          return fin()
        })
      })
    })
  })
})

describe('additional mem-store tests', () => {
  describe('#save', () => {
    describe('when trying to create the entity with the same id', () => {
      const seneca = makeSenecaForTest()

      it('crashes', (fin) => {
        seneca.test(fin)

        seneca.fail = function (...args) {
          expect(0 < args.length).to.equal(true)
          expect(args[0]).to.equal('entity-id-exists')

          return fin()
        }

        const my_product_id = 'MyPreciousId'

        seneca
          .make('sys', 'product')
          .data$({ id: my_product_id, label: 'lorem ipsum' })
          .save$((err, _out) => {
            if (err) {
              return fin(err)
            }

            seneca
              .make('sys', 'product')
              .data$({ id$: my_product_id, label: 'nauta sagittas portat' })
              .save$((err, _out) => {
                if (err) {
                  return fin(err)
                }

                return fin(new Error('Expected an error to be thrown'))
              })
          })
      })
    })

    it('when data.id$ is null generates an id and creates a new entity', (fin) => {
      const seneca = makeSenecaForTest()
      seneca.test(fin)

      seneca
        .make('sys', 'product')
        .data$({ id$: null, label: 'lorem ipsum' })
        .save$()

      seneca.make('sys', 'product').load$(null, (err, out) => {
        if (err) {
          return fin(err)
        }

        expect(out).to.be.null()

        return seneca.make('sys', 'product').list$((err, products) => {
          if (err) {
            return fin(err)
          }

          expect(products.length).to.equal(1)

          expect(typeof products[0].id).to.equal('string')
          expect(products[0].label).to.equal('lorem ipsum')

          return fin()
        })
      })
    })

    it('when data.id$ is null generate_id-null', (fin) => {
      const seneca = makeSenecaForTest({
        mem_store_opts: {
          generate_id(_ent) {
            return null
          },
        },
      })

      seneca.quiet().ready(() => {
        // console.log(seneca.list())

        seneca
          .make('sys', 'product')
          .data$({ label: 'lorem ipsum' })
          .save$(function (err, out) {
            expect(err.code).equal('generate-invalid-entity-id')
            fin()
          })
      })
    })

    describe('the "entity$" field when saving an entity', () => {
      const seneca = makeSenecaForTest()

      it('stores the "entity$" field with each entity', (fin) => {
        const product_ent = seneca.entity('default_zone', 'sys', 'product')

        product_ent.data$({}).save$((err, saved_product) => {
          if (err) {
            return fin(err)
          }

          if (null == saved_product) {
            return fin(new Error('Expected the product to be saved'))
          }

          if (null == saved_product.id) {
            return fin(new Error('Expected the saved product to have an id'))
          }

          try {
            expect(saved_product.entity$).to.equal('default_zone/sys/product')
          } catch (err) {
            return fin(err)
          }

          const { id: product_id } = saved_product

          product_ent.load$(product_id, (err, product) => {
            if (err) {
              return fin(err)
            }

            try {
              expect(product.entity$).to.equal('default_zone/sys/product')
            } catch (err) {
              return fin(err)
            }

            return fin()
          })
        })
      })
    })
  })

  describe('#load by date', () => {
    const millenium = new Date(2000, 0, 1)
    const elvis_bday = new Date(1935, 0, 8)

    let seneca

    async function setupTest() {
      seneca = makeSenecaForTest()

      await saveEnt(seneca.make('products').data$({ created_at: elvis_bday }))
      await saveEnt(seneca.make('products').data$({ created_at: millenium }))
    }

    it('can query by date', async (fin) => {
      await setupTest()

      return seneca
        .make('products')
        .load$({ created_at: makeDateSimilarTo(millenium) }, (err, out) => {
          if (err) {
            return fin(err)
          }

          expect(out).to.contain({
            created_at: millenium,
          })

          return fin()
        })
    })

    it('can query by date', async (fin) => {
      await setupTest()

      return seneca
        .make('products')
        .load$({ created_at: makeDateSimilarTo(elvis_bday) }, (err, out) => {
          if (err) {
            return fin(err)
          }

          expect(out).to.contain({
            created_at: elvis_bday,
          })

          return fin()
        })
    })

    it('fails when trying to compare a date field to anything else', (fin) => {
      return seneca.make('products').load$({ created_at: 123 }, (err, out) => {
        if (err) {
          return fin(err)
        }

        expect(out).to.equal(null)

        return fin()
      })
    })
  })

  describe('#list by date', () => {
    const millenium = new Date(2000, 0, 1)
    const elvis_bday = new Date(1935, 0, 8)

    let seneca

    async function setupTest() {
      seneca = makeSenecaForTest()

      await saveEnt(seneca.make('products').data$({ created_at: elvis_bday }))
      await saveEnt(seneca.make('products').data$({ created_at: millenium }))
    }

    it('can query by date', async (fin) => {
      await setupTest()

      return seneca
        .make('products')
        .list$({ created_at: makeDateSimilarTo(millenium) }, (err, out) => {
          if (err) {
            return fin(err)
          }

          expect(out.length).to.equal(1)

          expect(out[0]).to.contain({
            created_at: millenium,
          })

          return fin()
        })
    })

    it('can query by date', async (fin) => {
      await setupTest()

      return seneca
        .make('products')
        .list$({ created_at: makeDateSimilarTo(elvis_bday) }, (err, out) => {
          if (err) {
            return fin(err)
          }

          expect(out.length).to.equal(1)

          expect(out[0]).to.contain({
            created_at: elvis_bday,
          })

          return fin()
        })
    })
  })

  describe('#remove by date', () => {
    const millenium = new Date(2000, 0, 1)
    const elvis_bday = new Date(1935, 0, 8)

    let seneca

    async function setupTest() {
      seneca = makeSenecaForTest()

      await saveEnt(seneca.make('products').data$({ created_at: elvis_bday }))
      await saveEnt(seneca.make('products').data$({ created_at: millenium }))
    }

    it('can query by date', async (fin) => {
      await setupTest()

      return seneca
        .make('products')
        .remove$({ created_at: makeDateSimilarTo(millenium) }, (err) => {
          if (err) {
            return fin(err)
          }

          return seneca.make('products').list$({}, (err, out) => {
            expect(out.length).to.equal(1)

            expect(out[0]).to.contain({
              created_at: elvis_bday,
            })

            return fin()
          })
        })
    })

    it('can query by date', async (fin) => {
      await setupTest()

      return seneca
        .make('products')
        .remove$({ created_at: makeDateSimilarTo(elvis_bday) }, (err, out) => {
          if (err) {
            return fin(err)
          }

          return seneca.make('products').list$({}, (err, out) => {
            expect(out.length).to.equal(1)

            expect(out[0]).to.contain({
              created_at: millenium,
            })

            return fin()
          })
        })
    })
  })
})

function make_it(lab) {
  return function it(name, opts, func) {
    if ('function' === typeof opts) {
      func = opts
      opts = {}
    }

    lab.it(
      name,
      opts,
      Util.promisify(function (x, fin) {
        func(fin)
      }),
    )
  }
}

function saveEnt(ent, save_opts = {}) {
  return Util.promisify(ent.save$).call(ent, save_opts)
}

function makeDateSimilarTo(date) {
  return new Date(date)
}