@laboratoria/sdk-js 1.0.0 → 1.1.0

package/lib/core.js

@@ -1,6 +1,4 @@
 import md5 from 'blueimp-md5';
-import currencies from './currencies';
-import roles from './roles';
 import { createModels, extendSchemaDefinitions } from './model';
 import schema from '../schemas/core.json';
 
@@ -135,9 +133,6 @@ const extended = {
       countryCode: {
         enum: ['BR', 'CL', 'CO', 'MX', 'PE'],
       },
-      currency: {
-        enum: currencies,
-      },
     },
   },
   Gig: {
@@ -150,11 +145,6 @@ const extended = {
       'start',
       'end',
     ],
-    properties: {
-      role: {
-        enum: roles,
-      },
-    },
   },
 };
 
@@ -162,8 +152,3 @@ export const createAPI = (url, state) => createModels(url, state, {
   ...schema,
   definitions: extendSchemaDefinitions(schema, extended),
 });
-
-// const {
-//   delete: _,
-//   ...userAPI,
-// } = createModel(coreApiUrl, state, 'users', schemas.user);

package/lib/model.js

@@ -1,6 +1,38 @@
 import { createClient } from './client.js';
 
 
+const isRequiredOneToOneRelation = (schema, key) => (
+  !!schema.properties
+  && !!schema.properties[key]
+  && !!schema.properties[key].$ref
+);
+
+const isOptionalOneToOneRelation = (schema, key) => (
+  !!schema.properties
+  && !!schema.properties[key]
+  && Array.isArray(schema.properties[key].anyOf)
+  && !!schema.properties[key].anyOf[0]?.$ref
+  && schema.properties[key].anyOf[1]?.type === 'null'
+);
+
+const isOneToOneRelation = (schema, key) => (
+  isRequiredOneToOneRelation(schema, key)
+  || isOptionalOneToOneRelation(schema, key)
+);
+
+const isOneToManyRelation = (schema, key) => (
+  schema.properties
+  && schema.properties[key]
+  && schema.properties[key].type === 'array'
+  && !!schema.properties[key].items.$ref
+);
+
+// const isRelation = (schema, key) => (
+//   isOneToOneRelation(schema, key)
+//   || isOneToManyRelation(schema, key)
+// );
+
+
 const createValidator = (schema) => {
   const properties = schema.properties || {};
   const inputProps = schema.inputProps || Object.keys(properties);
@@ -78,15 +110,7 @@ const serializeData = (data, schema) => {
       if (hasInputProps && !schema.inputProps.includes(key)) {
         return memo;
       }
-      const prop = (schema.properties || {})[key];
-      const isOptionalRelation = (
-        prop
-        && Array.isArray(prop.anyOf)
-        && prop.anyOf[0].$ref
-        && prop.anyOf[1]
-        && prop.anyOf[1].type === 'null'
-      );
-      if (isOptionalRelation && data[key] === null) {
+      if (isOptionalOneToOneRelation(schema, key) && data[key] === null) {
         return memo;
       }
       return {
@@ -144,10 +168,43 @@ export const createModel = (baseUrl, state, collectionName, schema = {}) => {
     );
   };
 
+  const relations = Object.keys(schema.properties || {}).reduce(
+    (memo, key) => (
+      isRequiredOneToOneRelation(schema, key)
+        ? Object.assign(memo, {
+          all: memo.all.concat(key),
+          oneToOne: memo.oneToOne.concat(key),
+          requiredOneToOne: memo.requiredOneToOne.concat(key),
+        })
+        : isOptionalOneToOneRelation(schema, key)
+          ? Object.assign(memo, {
+            all: memo.all.concat(key),
+            oneToOne: memo.oneToOne.concat(key),
+            optionalOneToOne: memo.optionalOneToOne.concat(key),
+          })
+          : isOneToManyRelation(schema, key)
+            ? Object.assign(memo, {
+              all: memo.all.concat(key),
+              oneToMany: memo.oneToMany.concat(key),
+            })
+            : memo
+    ),
+    {
+      all: [],
+      oneToOne: [],
+      requiredOneToOne: [],
+      optionalOneToOne: [],
+      oneToMany: [],
+    },
+  );
+
   return {
     get schema() {
       return schema;
     },
+    get relations() {
+      return relations;
+    },
     validateAttr: validator.validateAttr,
     validate: validator.validate,
     findMany: q => req(buildURL(null, q))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@laboratoria/sdk-js",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Laboratoria JavaScript (browser) SDK",
   "scripts": {
     "test": "jest --verbose --coverage",
@@ -9,25 +9,25 @@
   "license": "MIT",
   "dependencies": {
     "blueimp-md5": "^2.19.0",
-    "firebase": "^9.6.4"
+    "firebase": "^9.6.5"
   },
   "devDependencies": {
     "@babel/core": "^7.16.12",
     "@babel/plugin-transform-modules-commonjs": "^7.16.8",
     "babel-jest": "^27.4.6",
     "jest": "^27.4.7",
-    "webpack": "^5.67.0",
+    "webpack": "^5.68.0",
     "webpack-cli": "^4.9.2"
   },
   "jest": {
     "testEnvironment": "jsdom",
     "coverageThreshold": {
       "global": {
-        "statements": 96,
-        "branches": 91,
+        "statements": 97,
+        "branches": 92,
         "functions": 98,
-        "lines": 96
+        "lines": 97
       }
     }
   }
-}
+}

package/.github/workflows/node.js.yml

@@ -1,31 +0,0 @@
-# This workflow will do a clean install of node dependencies, cache/restore them, build the source code and run tests across different versions of node
-# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
-
-name: Node.js CI
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [14.x, 16.x]
-        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v2
-      with:
-        node-version: ${{ matrix.node-version }}
-        cache: 'npm'
-    - run: npm ci
-    - run: npm run build --if-present
-    - run: npm test

package/index.spec.js

@@ -1,112 +0,0 @@
-import { initializeApp } from 'firebase/app';
-import {
-  getAuth,
-  onAuthStateChanged,
-  signInWithEmailAndPassword,
-  signOut,
-} from 'firebase/auth';
-import { createAPI as createCoreAPI } from './lib/core';
-import { createApp } from './index.js';
-
-jest.mock('./lib/core.js', () => ({
-  createAPI: jest.fn().mockReturnValue({
-    user: {
-      findById: jest.fn().mockResolvedValue({}),
-    },
-  }),
-}));
-
-beforeEach(() => {
-  initializeApp.mockClear();
-  onAuthStateChanged.mockClear();
-  signInWithEmailAndPassword.mockClear();
-});
-
-describe('createApp', () => {
-  it('should invoke firebase\'s initializaApp', () => {
-    createApp();
-    expect(initializeApp).toHaveBeenCalledTimes(1);
-    expect(initializeApp.mock.calls[0]).toMatchSnapshot();
-  });
-});
-
-describe('app.auth.onChange', () => {
-  it('should listen to firebase\'s onAuthStateChanged and notify subscribers when not authenticated', (done) => {
-    const { auth } = createApp();
-
-    onAuthStateChanged.mockImplementationOnce((_, cb) => {
-      cb();
-      return () => { };
-    });
-
-    auth.onChange(({ authUser, user }) => {
-      expect(authUser).toBeNull();
-      expect(user).toBeNull();
-      done();
-    });
-  });
-
-  it('should fetch user from db when authenticated using coreAPI', (done) => {
-    const { auth } = createApp();
-    const mockAuthUser = { uid: 'xxx', getIdToken: () => 'token' };
-    const userMock = { uid: 'xxx', email: 'foo@bar.baz' };
-
-    onAuthStateChanged.mockImplementationOnce((_, cb) => {
-      cb(mockAuthUser);
-      return () => { };
-    });
-
-    createCoreAPI().user.findById.mockResolvedValue(userMock);
-
-    auth.onChange(({ authUser, user }) => {
-      expect(authUser).toEqual(mockAuthUser);
-      expect(user).toEqual(userMock);
-      done();
-    });
-  });
-
-  it('should log error and reset state (authUser = null, user = null) when fetch user from db fails', (done) => {
-    const { auth } = createApp();
-    const mockAuthUser = { uid: 'xxx', getIdToken: () => 'token' };
-    const spy = jest.spyOn(console, 'error').mockImplementationOnce(() => { })
-    const error = new Error('OMG');
-
-    onAuthStateChanged.mockImplementationOnce((_, cb) => {
-      cb(mockAuthUser);
-      return () => { };
-    });
-
-    createCoreAPI().user.findById.mockRejectedValueOnce(error);
-
-    auth.onChange(({ authUser, user }) => {
-      expect(authUser).toBeNull();
-      expect(user).toBeNull();
-      expect(spy).toHaveBeenCalledWith(error);
-      spy.mockRestore();
-      done();
-    });
-  });
-});
-
-describe('app.auth.signIn', () => {
-  it('should delegate to firebase\'s signInWithEmailAndPassword', async () => {
-    const { auth } = createApp();
-    const email = 'foo@bar.baz';
-    const pass = 'secret';
-
-    await auth.signIn(email, pass);
-
-    expect(signInWithEmailAndPassword).toHaveBeenCalledTimes(1);
-    expect(signInWithEmailAndPassword).toHaveBeenCalledWith({}, email, pass);
-  });
-});
-
-describe('app.auth.signOut', () => {
-  it('should delegate to firebase\'s signOut', async () => {
-    const { auth } = createApp();
-
-    await auth.signOut();
-
-    expect(signOut).toHaveBeenCalledTimes(1);
-  });
-});

package/lib/client.spec.js

@@ -1,77 +0,0 @@
-import { createClient } from './client.js';
-
-describe('client', () => {
-
-  beforeAll(() => window.fetch = jest.fn());
-
-  afterEach(() => {
-    window.fetch.mockClear();
-    jest.restoreAllMocks();
-  });
-
-  it('should delegate to global fetch and add mode:cors and parse JSON resp when OK', async () => {
-    window.fetch.mockResolvedValue({
-      json: jest.fn().mockResolvedValue({ ok: true }),
-    });
-    const baseUrl = 'http://foo.bar';
-    const client = createClient(baseUrl);
-    expect(await client('/')).toEqual({ ok: true });
-    expect(window.fetch).toHaveBeenCalledTimes(1);
-    expect(window.fetch).toHaveBeenCalledWith(`${baseUrl}/`, {
-      mode: 'cors',
-      headers: {},
-    });
-  });
-
-  it('should reject when response.status > 202', async () => {
-    window.fetch.mockResolvedValue({
-      status: 400,
-      json: jest.fn().mockResolvedValue({ ok: false }),
-    });
-    const baseUrl = 'http://foo.bar';
-    const client = createClient(baseUrl);
-    await expect(client('/')).rejects.toThrow('HTTP Error 400');
-    expect(window.fetch).toHaveBeenCalledTimes(1);
-    expect(window.fetch).toHaveBeenCalledWith(`${baseUrl}/`, {
-      mode: 'cors',
-      headers: {},
-    });
-  });
-
-  it('should add token when authUser present', async () => {
-    window.fetch.mockResolvedValue({
-      json: jest.fn().mockResolvedValue({ ok: true }),
-    });
-    const baseUrl = 'http://foo.bar';
-    const user = { getIdToken: jest.fn().mockReturnValueOnce('xxx') };
-    const client = createClient(baseUrl, user);
-    expect(await client('/')).toEqual({ ok: true });
-    expect(window.fetch).toHaveBeenCalledTimes(1);
-    expect(window.fetch).toHaveBeenCalledWith(`${baseUrl}/`, {
-      mode: 'cors',
-      headers: {
-        authorization: 'Bearer xxx',
-      },
-    });
-    expect(user.getIdToken).toHaveBeenCalledTimes(1);
-  });
-
-  it('should add content-type header and stringify body when necessary', async () => {
-    window.fetch.mockResolvedValue({
-      json: jest.fn().mockResolvedValue({ ok: true }),
-    });
-    const baseUrl = 'http://foo.bar';
-    const client = createClient(baseUrl);
-    const body = { foo: 'bar' };
-    expect(await client('/', { method: 'POST', body })).toEqual({ ok: true });
-    expect(window.fetch).toHaveBeenCalledTimes(1);
-    expect(window.fetch).toHaveBeenCalledWith(`${baseUrl}/`, {
-      mode: 'cors',
-      headers: {
-        'content-type': 'application/json',
-      },
-      method: 'POST',
-      body: JSON.stringify(body),
-    });
-  });
-});

package/lib/currencies.js

@@ -1,3 +0,0 @@
-const currencies = ['BRL', 'CLP', 'COP', 'MXN', 'PEN', 'USD'];
-
-export default currencies;

package/lib/curriculum.spec.js

@@ -1,194 +0,0 @@
-import { createAPI } from './curriculum';
-
-describe('projects', () => {
-  describe('findMany', () => {
-    // TODO: errores HTTP, GitHub caido, repo borrado, etc...
-
-    it('sends request to get latest version and then corresponding json', () => {
-      global.fetch = jest.fn().mockImplementation(async url => ({
-        status: 200,
-        json: jest.fn().mockResolvedValue(
-          url.startsWith('https://api.')
-            ? { tag_name: 'v4.0.0' }
-            : []
-        ),
-      }));
-
-      return createAPI().projects.findMany()
-        .then((projects) => {
-          expect(projects).toEqual([]);
-          expect(global.fetch).toHaveBeenCalledTimes(2);
-          expect(global.fetch).toHaveBeenNthCalledWith(
-            1,
-            'https://api.github.com/repos/Laboratoria/bootcamp/releases/latest',
-          );
-          expect(global.fetch).toHaveBeenNthCalledWith(
-            2,
-            'https://raw.githubusercontent.com/Laboratoria/bootcamp/v4.0.0/dist/projects.json',
-          );
-        });
-    });
-
-    it('gets projects in specific tag when passed as option', () => {
-      global.fetch = jest.fn().mockImplementation(async url => ({
-        status: 200,
-        json: jest.fn().mockResolvedValue(
-          url.startsWith('https://api.')
-            ? { tag_name: 'v4.0.0' }
-            : []
-        ),
-      }));
-
-      return createAPI().projects.findMany({ tag: 'v3.0.0' })
-        .then((projects) => {
-          expect(projects).toEqual([]);
-          expect(global.fetch).toHaveBeenCalledTimes(1);
-          expect(global.fetch).toHaveBeenCalledWith(
-            'https://raw.githubusercontent.com/Laboratoria/bootcamp/v3.0.0/dist/projects.json',
-          );
-        });
-    });
-
-    it('gets projects in specific tag when passed as option', () => {
-      global.fetch = jest.fn().mockImplementation(async url => ({
-        status: 200,
-        json: jest.fn().mockResolvedValue(
-          url.startsWith('https://api.')
-            ? { tag_name: 'v4.0.0' }
-            : [
-              { locale: 'es-ES', track: 'ux' },
-              { locale: 'es-ES', track: 'js' },
-              { locale: 'pt-BR', track: 'ux' },
-            ]
-        ),
-      }));
-
-      return createAPI().projects.findMany({
-        tag: 'v3.0.0',
-        locale: 'es-ES',
-        track: 'ux',
-      })
-        .then((projects) => {
-          expect(projects).toEqual([{ locale: 'es-ES', track: 'ux' }]);
-          expect(global.fetch).toHaveBeenCalledTimes(1);
-          expect(global.fetch).toHaveBeenCalledWith(
-            'https://raw.githubusercontent.com/Laboratoria/bootcamp/v3.0.0/dist/projects.json',
-          );
-        });
-    });
-
-    // it should filter by tag, locale and track...
-  });
-
-  describe('findById', () => {
-    it('sends request to get latest version and then corresponding json', () => {
-      global.fetch = jest.fn().mockImplementation(async url => ({
-        status: 200,
-        json: jest.fn().mockResolvedValue(
-          url.startsWith('https://api.')
-            ? { tag_name: 'v4.0.0' }
-            : {}
-        ),
-      }));
-
-      return createAPI().projects.findById('cipher')
-        .then((project) => {
-          expect(project).toEqual({});
-          expect(global.fetch).toHaveBeenCalledTimes(2);
-          expect(global.fetch).toHaveBeenNthCalledWith(
-            1,
-            'https://api.github.com/repos/Laboratoria/bootcamp/releases/latest',
-          );
-          expect(global.fetch).toHaveBeenNthCalledWith(
-            2,
-            'https://raw.githubusercontent.com/Laboratoria/bootcamp/v4.0.0/dist/projects/cipher.json',
-          );
-        });
-    });
-  });
-});
-
-describe('topics', () => {
-  describe('findMany', () => {
-    it('sends request to get latest version and then corresponding json', () => {
-      global.fetch = jest.fn().mockImplementation(async url => ({
-        status: 200,
-        json: jest.fn().mockResolvedValue(
-          url.startsWith('https://api.')
-            ? { tag_name: 'v4.0.0' }
-            : []
-        ),
-      }));
-
-      return createAPI().topics.findMany()
-        .then((topics) => {
-          expect(topics).toEqual([]);
-          expect(global.fetch).toHaveBeenCalledTimes(2);
-          expect(global.fetch).toHaveBeenNthCalledWith(
-            1,
-            'https://api.github.com/repos/Laboratoria/bootcamp/releases/latest',
-          );
-          expect(global.fetch).toHaveBeenNthCalledWith(
-            2,
-            'https://raw.githubusercontent.com/Laboratoria/bootcamp/v4.0.0/dist/topics.json',
-          );
-        });
-    });
-  });
-
-  describe('findById', () => {
-    it('sends request to get latest version and then corresponding json', () => {
-      global.fetch = jest.fn().mockImplementation(async url => ({
-        status: 200,
-        json: jest.fn().mockResolvedValue(
-          url.startsWith('https://api.')
-            ? { tag_name: 'v4.0.0' }
-            : {}
-        ),
-      }));
-
-      return createAPI().topics.findById('javascript')
-        .then((topic) => {
-          expect(topic).toEqual({});
-          expect(global.fetch).toHaveBeenCalledTimes(2);
-          expect(global.fetch).toHaveBeenNthCalledWith(
-            1,
-            'https://api.github.com/repos/Laboratoria/bootcamp/releases/latest',
-          );
-          expect(global.fetch).toHaveBeenNthCalledWith(
-            2,
-            'https://raw.githubusercontent.com/Laboratoria/bootcamp/v4.0.0/dist/topics/javascript.json',
-          );
-        });
-    });
-  });
-});
-
-describe('learningObjectives', () => {
-  describe('findMany', () => {
-    it('sends request to get latest version and then corresponding json', () => {
-      global.fetch = jest.fn().mockImplementation(async url => ({
-        status: 200,
-        json: jest.fn().mockResolvedValue(
-          url.startsWith('https://api.')
-            ? { tag_name: 'v4.0.0' }
-            : []
-        ),
-      }));
-
-      return createAPI().learningObjectives.findMany()
-        .then((learningObjectives) => {
-          expect(learningObjectives).toEqual([]);
-          expect(global.fetch).toHaveBeenCalledTimes(2);
-          expect(global.fetch).toHaveBeenNthCalledWith(
-            1,
-            'https://api.github.com/repos/Laboratoria/bootcamp/releases/latest',
-          );
-          expect(global.fetch).toHaveBeenNthCalledWith(
-            2,
-            'https://raw.githubusercontent.com/Laboratoria/bootcamp/v4.0.0/dist/learning-objectives.json',
-          );
-        });
-    });
-  });
-});

package/lib/model.spec.js

@@ -1,242 +0,0 @@
-import { createModel } from './model.js';
-import { createClient } from './client.js';
-
-jest.mock('./client.js');
-
-beforeEach(() => createClient().mockClear());
-
-describe('model.schema', () => {
-  it('should be empty object by default', () => {
-    const model = createModel('http://1.2.3.4', {}, 'foo');
-    expect(model.schema).toEqual({});
-  });
-
-  it('should get the model\'s schema', () => {
-    const schema = {
-      properties: {
-        a: { type: 'string' },
-      },
-    };
-    const model = createModel('http://1.2.3.4', {}, 'foo', schema);
-    expect(model.schema).toEqual(schema);
-  });
-});
-
-describe('model.findMany(options)', () => {
-  it('should send GET request', async () => {
-    const schema = {
-      properties: {
-        id: { type: 'integer' },
-        createdAt: { type: 'string', format: 'date-time' },
-      },
-    };
-    const now = new Date();
-    const client = createClient().mockResolvedValue([{
-      id: 1,
-      createdAt: now.toISOString(),
-    }]);
-    const model = createModel('http://1.2.3.4', {}, 'foo', schema);
-    const results = await model.findMany();
-    expect(results).toEqual([{ id: 1, createdAt: now }]);
-    expect(results[0].createdAt instanceof Date).toBe(true);
-    expect(client).toHaveBeenCalledTimes(1);
-    expect(client).toHaveBeenCalledWith('/foo');
-  });
-});
-
-describe('model.findById(id, options)', () => {
-  it('should send GET request', async () => {
-    const client = createClient().mockResolvedValue({});
-    const model = createModel('http://1.2.3.4', {}, 'foo');
-    expect(await model.findById(1)).toEqual({});
-    expect(client).toHaveBeenCalledTimes(1);
-    expect(client).toHaveBeenCalledWith('/foo/1');
-  });
-});
-
-describe('model.create(options)', () => {
-  it('should send POST request', async () => {
-    const client = createClient().mockResolvedValue({});
-    const model = createModel('http://1.2.3.4', {}, 'foo');
-    expect(await model.create({ data: { ok: true } })).toEqual({});
-    expect(client).toHaveBeenCalledTimes(1);
-    expect(client).toHaveBeenCalledWith('/foo', {
-      body: { data: { ok: true } },
-      method: 'POST',
-    });
-  });
-});
-
-describe('model.update(options)', () => {
-  it('should send POST request', async () => {
-    const client = createClient().mockResolvedValue({});
-    const model = createModel('http://1.2.3.4', {}, 'foo');
-    expect(await model.update({ where: { id: 1 }, data: { ok: true } })).toEqual({});
-    expect(client).toHaveBeenCalledTimes(1);
-    expect(client).toHaveBeenCalledWith('/foo/1', {
-      body: { where: { id: 1 }, data: { ok: true } },
-      method: 'PUT',
-    });
-  });
-
-  it('should exclude null values for optional relation props', async () => {
-    const client = createClient().mockResolvedValue({});
-    const schema = {
-      properties: {
-        signupCohort: {
-          anyOf: [
-            { '$ref': '#/definitions/Cohort' },
-            { type: 'null' },
-          ],
-        },
-      },
-    };
-    const model = createModel('http://1.2.3.4', {}, 'foo', schema);
-    expect(await model.update({
-      where: { id: 1 },
-      data: { signupCohort: null },
-    })).toEqual({});
-    expect(client).toHaveBeenCalledTimes(1);
-    expect(client).toHaveBeenCalledWith('/foo/1', {
-      body: {
-        where: { id: 1 },
-        data: {},
-      },
-      method: 'PUT',
-    });
-  });
-});
-
-describe('model.upsert(options)', () => {
-  it('should send POST request when new row', async () => {
-    const client = createClient().mockResolvedValue({});
-    const model = createModel('http://1.2.3.4', {}, 'foo');
-    const result = await model.upsert({
-      where: {},
-      create: { ok: true },
-    });
-    expect(result).toEqual({});
-    expect(client).toHaveBeenCalledTimes(1);
-    expect(client).toHaveBeenCalledWith('/foo', {
-      body: { data: { ok: true } },
-      method: 'POST',
-    });
-  });
-
-  it('should send PUT request when existing row', async () => {
-    const client = createClient().mockResolvedValue({});
-    const model = createModel('http://1.2.3.4', {}, 'foo');
-    const result = await model.upsert({
-      where: { id: 1 },
-      update: { ok: true },
-    });
-    expect(result).toEqual({});
-    expect(client).toHaveBeenCalledTimes(1);
-    expect(client).toHaveBeenCalledWith('/foo/1', {
-      body: {
-        where: { id: 1 },
-        data: { ok: true },
-      },
-      method: 'PUT',
-    });
-  });
-});
-
-describe('model.delete(id)', () => {
-  it('should send POST request', async () => {
-    const client = createClient().mockResolvedValue({});
-    const model = createModel('http://1.2.3.4', {}, 'foo');
-    expect(await model.delete(1)).toEqual({});
-    expect(client).toHaveBeenCalledTimes(1);
-    expect(client).toHaveBeenCalledWith('/foo/1', {
-      method: 'DELETE',
-    });
-  });
-});
-
-describe('model.validateAttr(key, value)', () => {
-  it('should not validate when no schema', () => {
-    const model = createModel('http://1.2.3.4', {}, 'foo');
-    expect(model.validateAttr('a', 1)).toBeUndefined();
-  });
-
-  it('should validate text when required', () => {
-    const schema = {
-      properties: {
-        a: { type: 'string' },
-      },
-    };
-    const model = createModel('http://1.2.3.4', {}, 'foo', schema);
-    expect(model.validateAttr('a', '')).toBe('Field is required');
-  });
-
-  it('should validate number when required', () => {
-    const schema = {
-      properties: {
-        a: { type: 'integer', required: true },
-      },
-    };
-    const model = createModel('http://1.2.3.4', {}, 'foo', schema);
-    expect(model.validateAttr('a', 'foo')).toBe('Invalid number format');
-  });
-
-  it('should validate enum', () => {
-    const schema = {
-      properties: {
-        a: { type: 'integer', enum: [1, 2, 3] },
-      },
-    };
-    const model = createModel('http://1.2.3.4', {}, 'foo', schema);
-    expect(model.validateAttr('a', 'foo')).toBe('foo is not one of: 1,2,3');
-  });
-
-  it('should allow empty enum when not required', () => {
-    const schema = {
-      properties: {
-        a: { type: ['integer', 'null'], enum: [1, 2, 3] },
-      },
-    };
-    const model = createModel('http://1.2.3.4', {}, 'foo', schema);
-    expect(model.validateAttr('a', null)).toBeUndefined();
-    expect(model.validateAttr('a', undefined)).toBeUndefined();
-    expect(model.validateAttr('a', '')).toBeUndefined();
-  });
-});
-
-describe('model.validate(attributes)', () => {
-  it('should not validate when no schema', () => {
-    const model = createModel('http://1.2.3.4', {}, 'foo');
-    expect(model.validate({ a: 1 })).toEqual({});
-  });
-
-  it('should validate when schema present', () => {
-    const schema = {
-      properties: {
-        a: { type: 'string' },
-        b: { type: 'integer' },
-      },
-    };
-    const model = createModel('http://1.2.3.4', {}, 'foo', schema);
-    expect(model.validate({ a: '', b: 1 })).toEqual({ a: 'Field is required' });
-  });
-
-  it('should validate number when required', () => {
-    const schema = {
-      properties: {
-        a: { type: 'integer' },
-      },
-    };
-    const model = createModel('http://1.2.3.4', {}, 'foo', schema);
-    expect(model.validateAttr('a', 'foo')).toBe('Invalid number format');
-  });
-
-  it('should validate enum', () => {
-    const schema = {
-      properties: {
-        a: { type: 'integer', enum: [1, 2, 3] },
-      },
-    };
-    const model = createModel('http://1.2.3.4', {}, 'foo', schema);
-    expect(model.validateAttr('a', 'foo')).toBe('foo is not one of: 1,2,3');
-  });
-});