dobo 2.38.0 → 2.39.1

package/test/unit/helper-sanitize-all.test.js

@@ -1,40 +1,40 @@
-/* global describe, it, beforeEach */
-
-import { expect } from 'chai'
-import factory from '../../index.js'
-import { sanitizeAll } from '../../lib/helper.js'
-import { createAppStub } from './_stub.js'
-
-describe('helper sanitizeAll (unit)', () => {
-  let app
-  let dobo
-
-  beforeEach(async () => {
-    app = createAppStub('/tmp/dobo-helper-all')
-    const Dobo = await factory.call({ app }, 'dobo')
-    dobo = new Dobo()
-    app.dobo = dobo
-    dobo.fatal = (msg, ...args) => { throw new Error(`${msg}:${args.join(',')}`) }
-  })
-
-  it('normalizes properties, indexes, sortables and hidden fields', async () => {
-    const schema = {
-      name: 'Order',
-      properties: [
-        { name: 'id', type: 'string', index: 'primary' },
-        { name: 'name', type: 'string', minLength: '0', maxLength: '20' },
-        { name: 'amount', type: 'double' }
-      ],
-      indexes: [{ name: 'idx_name', type: 'index', fields: ['name'] }],
-      hidden: ['name', 'ghost']
-    }
-
-    await sanitizeAll.call(dobo, schema)
-
-    expect(schema.sortables).to.include('name')
-    expect(schema.hidden).to.deep.equal(['name'])
-    const nameProp = schema.properties.find(p => p.name === 'name')
-    expect(nameProp.maxLength).to.equal(20)
-    expect(nameProp.minLength).to.equal(undefined)
-  })
-})
+/* global describe, it, beforeEach */
+
+import { expect } from 'chai'
+import factory from '../../index.js'
+import { sanitizeAll } from '../../lib/helper.js'
+import { createAppStub } from './_stub.js'
+
+describe('helper sanitizeAll (unit)', () => {
+  let app
+  let dobo
+
+  beforeEach(async () => {
+    app = createAppStub('/tmp/dobo-helper-all')
+    const Dobo = await factory.call({ app }, 'dobo')
+    dobo = new Dobo()
+    app.dobo = dobo
+    dobo.fatal = (msg, ...args) => { throw new Error(`${msg}:${args.join(',')}`) }
+  })
+
+  it('normalizes properties, indexes, sortables and hidden fields', async () => {
+    const schema = {
+      name: 'Order',
+      properties: [
+        { name: 'id', type: 'string', index: 'primary' },
+        { name: 'name', type: 'string', minLength: '0', maxLength: '20' },
+        { name: 'amount', type: 'double' }
+      ],
+      indexes: [{ name: 'idx_name', type: 'index', fields: ['name'] }],
+      hidden: ['name', 'ghost']
+    }
+
+    await sanitizeAll.call(dobo, schema)
+
+    expect(schema.sortables).to.include('name')
+    expect(schema.hidden).to.deep.equal(['name'])
+    const nameProp = schema.properties.find(p => p.name === 'name')
+    expect(nameProp.maxLength).to.equal(20)
+    expect(nameProp.minLength).to.equal(undefined)
+  })
+})

package/test/unit/helper-sanitize-ref.test.js

@@ -1,64 +1,64 @@
-/* global describe, it, beforeEach */
-
-import { expect } from 'chai'
-import factory from '../../index.js'
-import { sanitizeRef } from '../../lib/helper.js'
-import { createAppStub } from './_stub.js'
-
-describe('helper sanitizeRef (unit)', () => {
-  let app
-  let dobo
-
-  beforeEach(async () => {
-    app = createAppStub('/tmp/dobo-helper-ref')
-    const Dobo = await factory.call({ app }, 'dobo')
-    dobo = new Dobo()
-    app.dobo = dobo
-    dobo.fatal = (msg, ...args) => { throw new Error(`${msg}:${args.join(',')}`) }
-  })
-
-  it('normalizes reference fields and filters unknown refs', async () => {
-    const user = {
-      name: 'User',
-      properties: [{ name: 'id' }, { name: 'name' }]
-    }
-    const order = {
-      name: 'Order',
-      properties: [
-        {
-          name: 'userId',
-          ref: {
-            user: { model: 'User', field: 'id', fields: ['name'] },
-            missing: { model: 'Unknown', field: 'id' }
-          }
-        }
-      ]
-    }
-
-    await sanitizeRef.call(dobo, order, [user, order])
-
-    expect(order.properties[0].ref.user.type).to.equal('1:1')
-    expect(order.properties[0].ref.user.searchField).to.equal('id')
-    expect(order.properties[0].ref.user.labelField).to.equal('id')
-    expect(order.properties[0].ref.user.fields).to.include('id')
-    expect(order.properties[0].ref.missing).to.equal(undefined)
-  })
-
-  it('throws when duplicate ref keys exist across properties', async () => {
-    const schema = {
-      name: 'Order',
-      properties: [
-        { name: 'a', ref: { rel: { model: 'User' } } },
-        { name: 'b', ref: { rel: { model: 'User' } } }
-      ]
-    }
-    const user = { name: 'User', properties: [{ name: 'id' }] }
-
-    let err
-    try {
-      await sanitizeRef.call(dobo, schema, [schema, user])
-    } catch (e) { err = e }
-    expect(err).to.be.instanceOf(Error)
-    expect(err.message).to.include('duplicateRefKeys')
-  })
-})
+/* global describe, it, beforeEach */
+
+import { expect } from 'chai'
+import factory from '../../index.js'
+import { sanitizeRef } from '../../lib/helper.js'
+import { createAppStub } from './_stub.js'
+
+describe('helper sanitizeRef (unit)', () => {
+  let app
+  let dobo
+
+  beforeEach(async () => {
+    app = createAppStub('/tmp/dobo-helper-ref')
+    const Dobo = await factory.call({ app }, 'dobo')
+    dobo = new Dobo()
+    app.dobo = dobo
+    dobo.fatal = (msg, ...args) => { throw new Error(`${msg}:${args.join(',')}`) }
+  })
+
+  it('normalizes reference fields and filters unknown refs', async () => {
+    const user = {
+      name: 'User',
+      properties: [{ name: 'id' }, { name: 'name' }]
+    }
+    const order = {
+      name: 'Order',
+      properties: [
+        {
+          name: 'userId',
+          ref: {
+            user: { model: 'User', field: 'id', fields: ['name'] },
+            missing: { model: 'Unknown', field: 'id' }
+          }
+        }
+      ]
+    }
+
+    await sanitizeRef.call(dobo, order, [user, order])
+
+    expect(order.properties[0].ref.user.type).to.equal('1:1')
+    expect(order.properties[0].ref.user.searchField).to.equal('id')
+    expect(order.properties[0].ref.user.labelField).to.equal('id')
+    expect(order.properties[0].ref.user.fields).to.include('id')
+    expect(order.properties[0].ref.missing).to.equal(undefined)
+  })
+
+  it('throws when duplicate ref keys exist across properties', async () => {
+    const schema = {
+      name: 'Order',
+      properties: [
+        { name: 'a', ref: { rel: { model: 'User' } } },
+        { name: 'b', ref: { rel: { model: 'User' } } }
+      ]
+    }
+    const user = { name: 'User', properties: [{ name: 'id' }] }
+
+    let err
+    try {
+      await sanitizeRef.call(dobo, schema, [schema, user])
+    } catch (e) { err = e }
+    expect(err).to.be.instanceOf(Error)
+    expect(err.message).to.include('duplicateRefKeys')
+  })
+})