dobo 2.38.0 → 2.39.1

package/test/unit/dobo-connection.test.js

@@ -1,37 +1,37 @@
-/* global describe, it, beforeEach */
-
-import { expect } from 'chai'
-import connectionFactory from '../../lib/factory/connection.js'
-import { createAppStub } from './_stub.js'
-
-describe('dobo connection class (unit)', () => {
-  let app
-  let plugin
-
-  beforeEach(async () => {
-    app = createAppStub('/tmp/dobo-connection')
-    app.baseClass.DoboNullAdapter = class DoboNullAdapter {}
-    app.baseClass.DoboAdapter = class DoboAdapter {}
-    plugin = {
-      app,
-      getAdapter: () => ({ sanitizeConnection: async () => {}, connect: async () => ({ client: true }) })
-    }
-    await connectionFactory.call(plugin)
-  })
-
-  it('creates DoboConnection, initializes adapter and connects', async () => {
-    const conn = new app.baseClass.DoboConnection(plugin, { name: 'default', adapter: 'dobo:memory', models: ['User'] })
-    await conn.initAdapter('dobo:memory')
-    expect(conn.adapter).to.be.an('object')
-    await conn.connect(true)
-    expect(conn.connected).to.equal(true)
-    expect(conn.client).to.deep.equal({ client: true })
-  })
-
-  it('dispose clears adapter reference', async () => {
-    const conn = new app.baseClass.DoboConnection(plugin, { name: 'default', adapter: 'dobo:memory' })
-    conn.adapter = { ok: true }
-    await conn.dispose()
-    expect(conn.adapter).to.equal(null)
-  })
-})
+/* global describe, it, beforeEach */
+
+import { expect } from 'chai'
+import connectionFactory from '../../lib/factory/connection.js'
+import { createAppStub } from './_stub.js'
+
+describe('dobo connection class (unit)', () => {
+  let app
+  let plugin
+
+  beforeEach(async () => {
+    app = createAppStub('/tmp/dobo-connection')
+    app.baseClass.DoboNullAdapter = class DoboNullAdapter {}
+    app.baseClass.DoboAdapter = class DoboAdapter {}
+    plugin = {
+      app,
+      getAdapter: () => ({ sanitizeConnection: async () => {}, connect: async () => ({ client: true }) })
+    }
+    await connectionFactory.call(plugin)
+  })
+
+  it('creates DoboConnection, initializes adapter and connects', async () => {
+    const conn = new app.baseClass.DoboConnection(plugin, { name: 'default', adapter: 'dobo:memory', models: ['User'] })
+    await conn.initAdapter('dobo:memory')
+    expect(conn.adapter).to.be.an('object')
+    await conn.connect(true)
+    expect(conn.connected).to.equal(true)
+    expect(conn.client).to.deep.equal({ client: true })
+  })
+
+  it('dispose clears adapter reference', async () => {
+    const conn = new app.baseClass.DoboConnection(plugin, { name: 'default', adapter: 'dobo:memory' })
+    conn.adapter = { ok: true }
+    await conn.dispose()
+    expect(conn.adapter).to.equal(null)
+  })
+})

package/test/unit/dobo-core.test.js

@@ -1,136 +1,136 @@
-/* global describe, it, beforeEach */
-
-import { expect } from 'chai'
-import factory from '../../index.js'
-import { createAppStub } from './_stub.js'
-
-describe('dobo core class (unit)', () => {
-  let app
-  let Dobo
-  let dobo
-
-  beforeEach(async () => {
-    app = createAppStub('/tmp/dobo-unit')
-    Dobo = await factory.call({ app }, 'dobo')
-    dobo = new Dobo()
-  })
-
-  it('creates plugin class with expected static values and defaults', () => {
-    expect(Dobo.aggregateTypes).to.include('count')
-    expect(Dobo.histogramTypes).to.include('yearly')
-    expect(Dobo.idTypes).to.include('string')
-    expect(dobo.config.default.filter.limit).to.equal(25)
-    expect(dobo.adapters).to.deep.equal([])
-    expect(dobo.connections).to.deep.equal([])
-    expect(dobo.features).to.deep.equal([])
-    expect(dobo.models).to.deep.equal([])
-  })
-
-  it('property key helpers include type-specific fields', () => {
-    expect(dobo.getPropertyKeysByType('string')).to.include('maxLength')
-    expect(dobo.getPropertyKeysByType('text')).to.include('textType')
-    expect(dobo.getPropertyKeysByType('smallint')).to.include('autoInc')
-
-    const keys = dobo.getAllPropertyKeys({ constructor: { propertyKeys: ['xFlag'] } })
-    expect(keys).to.include('name')
-    expect(keys).to.include('validator')
-    expect(keys).to.include('xFlag')
-  })
-
-  it('connection, adapter, feature and model lookups work', () => {
-    dobo.connections = [{ name: 'default' }, { name: 'report' }]
-    expect(dobo.getConnection('report').name).to.equal('report')
-    expect(dobo.getConnection('none', true)).to.equal(undefined)
-
-    dobo.adapters = [
-      { name: 'memory', plugin: { ns: 'dobo' } },
-      { name: 'proxy', plugin: { ns: 'ext' } }
-    ]
-    expect(dobo.getAdapter('memory').name).to.equal('memory')
-    expect(dobo.getAdapter('ext:proxy').name).to.equal('proxy')
-    expect(dobo.getAdapter('missing', true)).to.equal(undefined)
-
-    dobo.features = [{ name: 'createdAt', plugin: { ns: 'dobo' } }]
-    expect(dobo.getFeature('createdAt').name).to.equal('createdAt')
-
-    dobo.models = [{ name: 'Order' }, { name: 'Customer' }]
-    expect(dobo.getModel('Order').name).to.equal('Order')
-    expect(dobo.getModel('order').name).to.equal('Order')
-    expect(dobo.getModel('none', true)).to.equal(undefined)
-  })
-
-  it('sanitize helpers and aggregate calculators work', () => {
-    expect(dobo.sanitizeBoolean('true')).to.equal(true)
-    expect(dobo.sanitizeBoolean(false)).to.equal(false)
-    expect(dobo.sanitizeFloat('12.4')).to.equal(12.4)
-    expect(dobo.sanitizeInt('12')).to.equal(12)
-    expect(dobo.sanitizeString(44)).to.equal('44')
-    expect(dobo.sanitizeObject('{"a":1}')).to.deep.equal({ a: 1 })
-
-    const rows = [
-      { grp: 'a', price: 10 },
-      { grp: 'a', price: 30 },
-      { grp: 'b', price: 20 }
-    ]
-    const agg = dobo.calcAggregate({ data: rows, group: 'grp', field: 'price', aggregates: ['count', 'avg', 'min', 'max'] })
-    expect(agg).to.have.length(2)
-    const itemA = agg.find(i => i.grp === 'a')
-    expect(itemA.count).to.equal(2)
-    expect(itemA.max).to.equal(30)
-  })
-
-  it('histogram and query parsers work with valid input', () => {
-    const rows = [
-      { createdAt: '2026-01-01T00:00:00Z', score: 5 },
-      { createdAt: '2026-01-01T12:00:00Z', score: 7 },
-      { createdAt: '2026-01-02T00:00:00Z', score: 10 }
-    ]
-    const hist = dobo.calcHistogram({ data: rows, type: 'daily', group: 'createdAt', field: 'score', aggregates: ['count'] })
-    expect(hist).to.have.length(2)
-    expect(hist[0]).to.have.property('date')
-
-    const model = {
-      scanables: ['name'],
-      sortables: ['name'],
-      properties: [{ name: 'name', type: 'string' }],
-      adapter: { idField: { name: '_id' } }
-    }
-    const parsed = dobo.parseQuery('name:~\'john\'', model)
-    expect(parsed).to.be.an('object')
-
-    const parsedAny = dobo.parseQuery('john*', model)
-    expect(parsedAny).to.be.an('object')
-  })
-
-  it('regex json helpers and model hooks work', async () => {
-    const input = { n: /abc/gi }
-    const text = dobo.replaceRegexInJson(input, true)
-    const revived = dobo.reviveRegexInJson(text, true)
-    expect(revived.n).to.be.instanceOf(RegExp)
-    expect(revived.n.flags).to.include('g')
-
-    const calls = []
-    const model = {
-      hooks: [
-        { name: 'beforeCreateRecord', level: 2, handler: async () => calls.push(2) },
-        { name: 'beforeCreateRecord', level: 1, handler: async () => calls.push(1) }
-      ]
-    }
-    await dobo.runModelHook(model, 'beforeCreateRecord', {})
-    expect(calls).to.deep.equal([1, 2])
-  })
-
-  it('default values and hard-cap last page handler work', () => {
-    dobo.config.default.filter = { limit: 10, maxLimit: 50, maxPage: 30, sort: [] }
-    dobo.config.default.hardCap = 100
-    dobo.config.default.warnings = true
-
-    const def = dobo.getDefaultValues()
-    expect(def.limit).to.equal(10)
-    expect(def.hardCap).to.equal(100)
-
-    const result = dobo.handleLastPage({ count: 300, limit: 10, page: 25 })
-    expect(result.count).to.equal(100)
-    expect(result.data).to.deep.equal([])
-  })
-})
+/* global describe, it, beforeEach */
+
+import { expect } from 'chai'
+import factory from '../../index.js'
+import { createAppStub } from './_stub.js'
+
+describe('dobo core class (unit)', () => {
+  let app
+  let Dobo
+  let dobo
+
+  beforeEach(async () => {
+    app = createAppStub('/tmp/dobo-unit')
+    Dobo = await factory.call({ app }, 'dobo')
+    dobo = new Dobo()
+  })
+
+  it('creates plugin class with expected static values and defaults', () => {
+    expect(Dobo.aggregateTypes).to.include('count')
+    expect(Dobo.histogramTypes).to.include('yearly')
+    expect(Dobo.idTypes).to.include('string')
+    expect(dobo.config.default.filter.limit).to.equal(25)
+    expect(dobo.adapters).to.deep.equal([])
+    expect(dobo.connections).to.deep.equal([])
+    expect(dobo.features).to.deep.equal([])
+    expect(dobo.models).to.deep.equal([])
+  })
+
+  it('property key helpers include type-specific fields', () => {
+    expect(dobo.getPropertyKeysByType('string')).to.include('maxLength')
+    expect(dobo.getPropertyKeysByType('text')).to.include('textType')
+    expect(dobo.getPropertyKeysByType('smallint')).to.include('autoInc')
+
+    const keys = dobo.getAllPropertyKeys({ constructor: { propertyKeys: ['xFlag'] } })
+    expect(keys).to.include('name')
+    expect(keys).to.include('validator')
+    expect(keys).to.include('xFlag')
+  })
+
+  it('connection, adapter, feature and model lookups work', () => {
+    dobo.connections = [{ name: 'default' }, { name: 'report' }]
+    expect(dobo.getConnection('report').name).to.equal('report')
+    expect(dobo.getConnection('none', true)).to.equal(undefined)
+
+    dobo.adapters = [
+      { name: 'memory', plugin: { ns: 'dobo' } },
+      { name: 'proxy', plugin: { ns: 'ext' } }
+    ]
+    expect(dobo.getAdapter('memory').name).to.equal('memory')
+    expect(dobo.getAdapter('ext:proxy').name).to.equal('proxy')
+    expect(dobo.getAdapter('missing', true)).to.equal(undefined)
+
+    dobo.features = [{ name: 'createdAt', plugin: { ns: 'dobo' } }]
+    expect(dobo.getFeature('createdAt').name).to.equal('createdAt')
+
+    dobo.models = [{ name: 'Order' }, { name: 'Customer' }]
+    expect(dobo.getModel('Order').name).to.equal('Order')
+    expect(dobo.getModel('order').name).to.equal('Order')
+    expect(dobo.getModel('none', true)).to.equal(undefined)
+  })
+
+  it('sanitize helpers and aggregate calculators work', () => {
+    expect(dobo.sanitizeBoolean('true')).to.equal(true)
+    expect(dobo.sanitizeBoolean(false)).to.equal(false)
+    expect(dobo.sanitizeFloat('12.4')).to.equal(12.4)
+    expect(dobo.sanitizeInt('12')).to.equal(12)
+    expect(dobo.sanitizeString(44)).to.equal('44')
+    expect(dobo.sanitizeObject('{"a":1}')).to.deep.equal({ a: 1 })
+
+    const rows = [
+      { grp: 'a', price: 10 },
+      { grp: 'a', price: 30 },
+      { grp: 'b', price: 20 }
+    ]
+    const agg = dobo.calcAggregate({ data: rows, group: 'grp', field: 'price', aggregates: ['count', 'avg', 'min', 'max'] })
+    expect(agg).to.have.length(2)
+    const itemA = agg.find(i => i.grp === 'a')
+    expect(itemA.count).to.equal(2)
+    expect(itemA.max).to.equal(30)
+  })
+
+  it('histogram and query parsers work with valid input', () => {
+    const rows = [
+      { createdAt: '2026-01-01T00:00:00Z', score: 5 },
+      { createdAt: '2026-01-01T12:00:00Z', score: 7 },
+      { createdAt: '2026-01-02T00:00:00Z', score: 10 }
+    ]
+    const hist = dobo.calcHistogram({ data: rows, type: 'daily', group: 'createdAt', field: 'score', aggregates: ['count'] })
+    expect(hist).to.have.length(2)
+    expect(hist[0]).to.have.property('date')
+
+    const model = {
+      scanables: ['name'],
+      sortables: ['name'],
+      properties: [{ name: 'name', type: 'string' }],
+      adapter: { idField: { name: '_id' } }
+    }
+    const parsed = dobo.parseQuery('name:~\'john\'', model)
+    expect(parsed).to.be.an('object')
+
+    const parsedAny = dobo.parseQuery('john*', model)
+    expect(parsedAny).to.be.an('object')
+  })
+
+  it('regex json helpers and model hooks work', async () => {
+    const input = { n: /abc/gi }
+    const text = dobo.replaceRegexInJson(input, true)
+    const revived = dobo.reviveRegexInJson(text, true)
+    expect(revived.n).to.be.instanceOf(RegExp)
+    expect(revived.n.flags).to.include('g')
+
+    const calls = []
+    const model = {
+      hooks: [
+        { name: 'beforeCreateRecord', level: 2, handler: async () => calls.push(2) },
+        { name: 'beforeCreateRecord', level: 1, handler: async () => calls.push(1) }
+      ]
+    }
+    await dobo.runModelHook(model, 'beforeCreateRecord', {})
+    expect(calls).to.deep.equal([1, 2])
+  })
+
+  it('default values and hard-cap last page handler work', () => {
+    dobo.config.default.filter = { limit: 10, maxLimit: 50, maxPage: 30, sort: [] }
+    dobo.config.default.hardCap = 100
+    dobo.config.default.warnings = true
+
+    const def = dobo.getDefaultValues()
+    expect(def.limit).to.equal(10)
+    expect(def.hardCap).to.equal(100)
+
+    const result = dobo.handleLastPage({ count: 300, limit: 10, page: 25 })
+    expect(result.count).to.equal(100)
+    expect(result.data).to.deep.equal([])
+  })
+})

package/test/unit/dobo-feature.test.js

@@ -1,25 +1,25 @@
-/* global describe, it, beforeEach */
-
-import { expect } from 'chai'
-import featureFactory from '../../lib/factory/feature.js'
-import { createAppStub } from './_stub.js'
-
-describe('dobo feature class (unit)', () => {
-  let app
-  let plugin
-
-  beforeEach(async () => {
-    app = createAppStub('/tmp/dobo-feature')
-    plugin = { app }
-    await featureFactory.call(plugin)
-  })
-
-  it('creates DoboFeature and disposes cleanly', async () => {
-    const feat = new app.baseClass.DoboFeature(plugin, { name: 'createdAt', handler: async () => ({}) })
-    expect(feat.name).to.equal('createdAt')
-    expect(feat.handler).to.be.a('function')
-    await feat.dispose()
-    expect(feat.name).to.equal(null)
-    expect(feat.handler).to.equal(null)
-  })
-})
+/* global describe, it, beforeEach */
+
+import { expect } from 'chai'
+import featureFactory from '../../lib/factory/feature.js'
+import { createAppStub } from './_stub.js'
+
+describe('dobo feature class (unit)', () => {
+  let app
+  let plugin
+
+  beforeEach(async () => {
+    app = createAppStub('/tmp/dobo-feature')
+    plugin = { app }
+    await featureFactory.call(plugin)
+  })
+
+  it('creates DoboFeature and disposes cleanly', async () => {
+    const feat = new app.baseClass.DoboFeature(plugin, { name: 'createdAt', handler: async () => ({}) })
+    expect(feat.name).to.equal('createdAt')
+    expect(feat.handler).to.be.a('function')
+    await feat.dispose()
+    expect(feat.name).to.equal(null)
+    expect(feat.handler).to.equal(null)
+  })
+})

package/test/unit/dobo-model.test.js

@@ -1,115 +1,115 @@
-/* global describe, it, beforeEach */
-
-import { expect } from 'chai'
-import modelFactory from '../../lib/factory/model.js'
-import { createAppStub, Base } from './_stub.js'
-
-describe('dobo model class (unit)', () => {
-  let app
-  let plugin
-  let model
-
-  beforeEach(async () => {
-    app = createAppStub('/tmp/dobo-model-unit')
-    app.dobo = {
-      models: [],
-      sanitizeDate: (v) => v,
-      sanitizeByType: (v) => v,
-      checkAggregateParams: () => {},
-      checkHistogramParams: () => {},
-      runModelHook: async () => {},
-      parseQuery: (q) => q
-    }
-    app.baseClass.DoboAction = class DoboAction {
-      constructor (m, name, ...args) {
-        this.model = m
-        this.name = name
-        this.args = args
-      }
-    }
-
-    plugin = new Base('dobo', app)
-    await modelFactory.call(plugin)
-
-    const options = {
-      name: 'Order',
-      baseName: 'order',
-      connection: {
-        name: 'default',
-        adapter: { idField: { name: '_id', type: 'string', maxLength: 50 } }
-      },
-      properties: [
-        { name: 'id', type: 'string', maxLength: 50 },
-        { name: 'title', type: 'string', maxLength: 50 },
-        { name: 'total', type: 'double' },
-        { name: 'virtualTitle', type: 'string', virtual: true }
-      ],
-      indexes: [{ name: 'idx_title', type: 'index', fields: ['title'] }],
-      hooks: []
-    }
-    model = new app.baseClass.DoboModel(plugin, options)
-    app.dobo.models.push(model)
-  })
-
-  it('builds aliases, action and property getters correctly', () => {
-    const act = model.action('getRecord', 'id-1')
-    expect(act.name).to.equal('getRecord')
-    expect(model.getProperty('title').type).to.equal('string')
-    expect(model.getField('title').name).to.equal('title')
-    expect(model.hasProperty('title')).to.equal(true)
-    expect(model.hasField('ghost')).to.equal(false)
-    expect(model.getIndexes()).to.have.length(1)
-  })
-
-  it('returns filtered property lists (all, virtual, non-virtual)', () => {
-    expect(model.getProperties().length).to.equal(4)
-    expect(model.getProperties({ noVirtual: true }).length).to.equal(3)
-    expect(model.getProperties({ noVirtual: true, namesOnly: true })).to.include('title')
-    expect(model.getVirtualProperties(true)).to.deep.equal(['virtualTitle'])
-    expect(model.getNonVirtualProperties(true)).to.include('id')
-  })
-
-  it('sanitizes and syncs id field', () => {
-    model.properties[0].type = 'integer'
-    expect(model.sanitizeId('12')).to.equal(12)
-
-    model.syncIdField({ name: 'id', type: 'string', maxLength: 20 })
-    expect(model.properties[0].maxLength).to.equal(20)
-  })
-
-  it('buildPropValues supports array and req translation hooks', async () => {
-    const prop = {
-      name: 'status',
-      values: ['draft', { value: 'done', text: 'done' }]
-    }
-    const req = {
-      te: (k) => k === 'statusDone',
-      t: () => 'Selesai'
-    }
-    const vals = await model.buildPropValues(prop, { req })
-    expect(vals).to.have.length(2)
-    expect(vals[1].text).to.equal('Selesai')
-  })
-
-  it('_simpleLookup handles string/object/array definitions', async () => {
-    const userModel = {
-      findOneRecord: async () => ({ id: 'u1', username: 'john' })
-    }
-    app.dobo.getModel = () => userModel
-
-    const a = await model._simpleLookup('User:username:id=u1', {})
-    expect(a).to.equal('john')
-
-    const b = await model._simpleLookup({ model: 'User', field: 'id', query: 'id={id}' }, { id: 'u9' })
-    expect(b).to.equal('u1')
-
-    const c = await model._simpleLookup(['User', 'id', 'id=u5'], {})
-    expect(c).to.equal('u1')
-  })
-
-  it('dispose clears connection and adapter references', async () => {
-    await model.dispose()
-    expect(model.connection).to.equal(null)
-    expect(model.adapter).to.equal(null)
-  })
-})
+/* global describe, it, beforeEach */
+
+import { expect } from 'chai'
+import modelFactory from '../../lib/factory/model.js'
+import { createAppStub, Base } from './_stub.js'
+
+describe('dobo model class (unit)', () => {
+  let app
+  let plugin
+  let model
+
+  beforeEach(async () => {
+    app = createAppStub('/tmp/dobo-model-unit')
+    app.dobo = {
+      models: [],
+      sanitizeDate: (v) => v,
+      sanitizeByType: (v) => v,
+      checkAggregateParams: () => {},
+      checkHistogramParams: () => {},
+      runModelHook: async () => {},
+      parseQuery: (q) => q
+    }
+    app.baseClass.DoboAction = class DoboAction {
+      constructor (m, name, ...args) {
+        this.model = m
+        this.name = name
+        this.args = args
+      }
+    }
+
+    plugin = new Base('dobo', app)
+    await modelFactory.call(plugin)
+
+    const options = {
+      name: 'Order',
+      baseName: 'order',
+      connection: {
+        name: 'default',
+        adapter: { idField: { name: '_id', type: 'string', maxLength: 50 } }
+      },
+      properties: [
+        { name: 'id', type: 'string', maxLength: 50 },
+        { name: 'title', type: 'string', maxLength: 50 },
+        { name: 'total', type: 'double' },
+        { name: 'virtualTitle', type: 'string', virtual: true }
+      ],
+      indexes: [{ name: 'idx_title', type: 'index', fields: ['title'] }],
+      hooks: []
+    }
+    model = new app.baseClass.DoboModel(plugin, options)
+    app.dobo.models.push(model)
+  })
+
+  it('builds aliases, action and property getters correctly', () => {
+    const act = model.action('getRecord', 'id-1')
+    expect(act.name).to.equal('getRecord')
+    expect(model.getProperty('title').type).to.equal('string')
+    expect(model.getField('title').name).to.equal('title')
+    expect(model.hasProperty('title')).to.equal(true)
+    expect(model.hasField('ghost')).to.equal(false)
+    expect(model.getIndexes()).to.have.length(1)
+  })
+
+  it('returns filtered property lists (all, virtual, non-virtual)', () => {
+    expect(model.getProperties().length).to.equal(4)
+    expect(model.getProperties({ noVirtual: true }).length).to.equal(3)
+    expect(model.getProperties({ noVirtual: true, namesOnly: true })).to.include('title')
+    expect(model.getVirtualProperties(true)).to.deep.equal(['virtualTitle'])
+    expect(model.getNonVirtualProperties(true)).to.include('id')
+  })
+
+  it('sanitizes and syncs id field', () => {
+    model.properties[0].type = 'integer'
+    expect(model.sanitizeId('12')).to.equal(12)
+
+    model.syncIdField({ name: 'id', type: 'string', maxLength: 20 })
+    expect(model.properties[0].maxLength).to.equal(20)
+  })
+
+  it('buildPropValues supports array and req translation hooks', async () => {
+    const prop = {
+      name: 'status',
+      values: ['draft', { value: 'done', text: 'done' }]
+    }
+    const req = {
+      te: (k) => k === 'statusDone',
+      t: () => 'Selesai'
+    }
+    const vals = await model.buildPropValues(prop, { req })
+    expect(vals).to.have.length(2)
+    expect(vals[1].text).to.equal('Selesai')
+  })
+
+  it('_simpleLookup handles string/object/array definitions', async () => {
+    const userModel = {
+      findOneRecord: async () => ({ id: 'u1', username: 'john' })
+    }
+    app.dobo.getModel = () => userModel
+
+    const a = await model._simpleLookup('User:username:id=u1', {})
+    expect(a).to.equal('john')
+
+    const b = await model._simpleLookup({ model: 'User', field: 'id', query: 'id={id}' }, { id: 'u9' })
+    expect(b).to.equal('u1')
+
+    const c = await model._simpleLookup(['User', 'id', 'id=u5'], {})
+    expect(c).to.equal('u1')
+  })
+
+  it('dispose clears connection and adapter references', async () => {
+    await model.dispose()
+    expect(model.connection).to.equal(null)
+    expect(model.adapter).to.equal(null)
+  })
+})