@bedrockio/model 0.1.0

package/test/load.test.js

@@ -0,0 +1,47 @@
+import mongoose from 'mongoose';
+
+import { loadModel, loadModelDir } from '../src/load';
+
+describe('loadModel', () => {
+  it('should create basic model', async () => {
+    expect(!!mongoose.models.Box).toBe(false);
+    const Box = loadModel(
+      {
+        attributes: {
+          name: {
+            type: 'String',
+            validate: /[a-z]/,
+          },
+        },
+      },
+      'Box'
+    );
+    expect(!!mongoose.models.Box).toBe(true);
+    const box = new Box({ name: 'foo' });
+
+    expect(box.name).toBe('foo');
+
+    await expect(async () => {
+      box.name = 'FOO';
+      await box.save();
+    }).rejects.toThrow();
+  });
+});
+
+describe('loadModelDir', () => {
+  it('should create models from a folder', async () => {
+    expect(!!mongoose.models.SpecialCategory).toBe(false);
+    expect(!!mongoose.models.CustomModel).toBe(false);
+    loadModelDir('test/definitions');
+    expect(!!mongoose.models.SpecialCategory).toBe(true);
+    const { SpecialCategory } = mongoose.models;
+    await SpecialCategory.deleteMany({});
+    const someRef = mongoose.Types.ObjectId();
+    const category = new SpecialCategory({ name: 'foo', someRef, count: 3 });
+    await category.save();
+    const foundCategory = await SpecialCategory.findOne();
+    expect(foundCategory.name).toBe('foo');
+    expect(foundCategory.someRef.toString()).toBe(someRef.toString());
+    expect(foundCategory.count).toBe(3);
+  });
+});

package/test/references.test.js

@@ -0,0 +1,71 @@
+import mongoose from 'mongoose';
+
+import { createTestModel } from '../src/testing';
+
+const User = createTestModel({
+  name: {
+    type: 'String',
+    required: true,
+  },
+});
+const Shop = createTestModel({
+  user: {
+    ref: User.modelName,
+    type: mongoose.Schema.Types.ObjectId,
+  },
+});
+
+describe('assertNoReferences', () => {
+  it('should throw error if document is referenced externally', async () => {
+    const user1 = await User.create({ name: 'foo ' });
+    const user2 = await User.create({ name: 'foo ' });
+    await Shop.create({ user: user1 });
+
+    await expect(async () => {
+      await user1.assertNoReferences();
+    }).rejects.toThrow('Refusing to delete.');
+
+    await expect(
+      user1.assertNoReferences({
+        except: [Shop],
+      })
+    ).resolves.not.toThrow();
+
+    await expect(
+      user1.assertNoReferences({
+        except: [Shop.modelName],
+      })
+    ).resolves.not.toThrow();
+
+    await expect(user2.assertNoReferences()).resolves.not.toThrow();
+  });
+
+  it('should expose references on the error object', async () => {
+    const user1 = await User.create({ name: 'foo ' });
+    await User.create({ name: 'foo ' });
+    const shop = await Shop.create({ user: user1 });
+
+    try {
+      await user1.assertNoReferences();
+    } catch (error) {
+      expect(error.references).toEqual([
+        {
+          model: Shop,
+          count: 1,
+          ids: [shop.id],
+        },
+      ]);
+    }
+  });
+
+  it('should throw error exception is unknown model', async () => {
+    const User = createTestModel();
+    const user = await User.create({});
+
+    await expect(
+      user.assertNoReferences({
+        except: ['BadModelName'],
+      })
+    ).rejects.toThrow('Unknown model "BadModelName".');
+  });
+});