@projectcaluma/ember-testing 9.1.0 → 10.2.0-beta.2

package/addon/mirage-graphql/filters/answer.js

@@ -0,0 +1,13 @@
+import BaseFilter from "@projectcaluma/ember-testing/mirage-graphql/filters/base";
+
+export default class extends BaseFilter {
+  questions(records, value, { invert = false }) {
+    return records.filter(
+      (record) => invert !== value.includes(record.questionId)
+    );
+  }
+
+  question(records, value, { invert = false }) {
+    return this.questions(records, [value], { invert });
+  }
+}

package/addon/mirage-graphql/filters/base.js

@@ -1,39 +1,66 @@
+import { camelize } from "@ember/string";
+
 export default class {
-  constructor(type, collection, db) {
+  constructor(type) {
     this.type = type;
-    this.collection = collection;
-    this.db = db;
   }
 
-  _getFilterFns(filters) {
-    return Object.entries(filters).map(([name, value]) => {
-      const fn = this[name];
+  _getFilterFns(rawFilters) {
+    const filters = Array.isArray(rawFilters)
+      ? // new format
+        rawFilters
+          .filter((filter) => Object.keys(filter).length !== 0) // filter out empty filters
+          .map((filter) => {
+            const entries = Object.entries(filter);
+            const key = entries[0][0];
+            const value = entries[0][1];
+            const options = entries
+              .slice(1)
+              .reduce((opts, [k, v]) => ({ ...opts, [k]: v }), {});
+
+            return { key, value, options };
+          })
+      : // old format
+        Object.entries(rawFilters).map(([key, value]) => ({
+          key,
+          value,
+        }));
+
+    return filters.map(({ key, value, options = {} }) => {
+      const fn = this[key];
 
       return typeof fn === "function"
-        ? (records) => fn.call(this, records, value)
+        ? (records) => fn.call(this, records, value, options)
         : (records) => records;
     });
   }
 
+  sort(records, order) {
+    if (!order) return records;
+
+    return records.sort((a, b) => {
+      return (
+        order
+          .map((o) => {
+            const attr = camelize(o.attribute.toLowerCase());
+            const direction = o.direction === "ASC" ? -1 : 1;
+
+            return (b[attr] - a[attr]) * direction;
+          })
+          .find((result) => result !== 0) ?? 0
+      );
+    });
+  }
+
   filter(records, filters) {
-    // flatten array of filters to find filter functions
-    const filterObj = Array.isArray(filters)
-      ? filters.length
-        ? Object.assign(...filters)
-        : {}
-      : filters;
-
-    return this._getFilterFns(filterObj).reduce(
+    return this._getFilterFns(filters.filter ?? filters).reduce(
       (recs, fn) => fn(recs),
-      records
+      this.sort(records, filters?.order)
     );
   }
 
   find(records, filters) {
-    return (
-      this._getFilterFns(filters).reduce((recs, fn) => fn(recs), records)[0] ||
-      null
-    );
+    return this.filter(records, filters)[0] || null;
   }
 
   slug(records, value) {

package/addon/mirage-graphql/filters/question.js

@@ -12,10 +12,8 @@ export default class extends BaseFilter {
   }
 
   excludeForms(records, value) {
-    const forms = this.db.forms.filter(({ slug }) => value.includes(slug));
-
     return records.filter(
-      ({ formIds }) => !forms.some(({ id }) => (formIds || []).includes(id))
+      ({ formIds }) => !value.some((id) => (formIds || []).includes(id))
     );
   }
 }

package/addon/mirage-graphql/filters/work-item.js

@@ -1,7 +1,27 @@
 import BaseFilter from "@projectcaluma/ember-testing/mirage-graphql/filters/base";
 
 export default class extends BaseFilter {
-  status(records, value) {
-    return records.filter(({ status }) => status === value);
+  status(records, value, { invert = false }) {
+    return records.filter(({ status }) => invert !== (status === value));
+  }
+
+  tasks(records, value, { invert = false }) {
+    return records.filter((record) => invert !== value.includes(record.taskId));
+  }
+
+  task(records, value, { invert = false }) {
+    return this.tasks(records, [value], { invert });
+  }
+
+  controllingGroups(records, value, { invert = false }) {
+    return records.filter((record) =>
+      value.every((g) => invert !== record.controllingGroups?.includes(g))
+    );
+  }
+
+  addressedGroups(records, value, { invert = false }) {
+    return records.filter((record) =>
+      value.every((g) => invert !== record.addressedGroups?.includes(g))
+    );
   }
 }

package/addon/mirage-graphql/handler.js

@@ -1,25 +1,35 @@
 import { classify } from "@ember/string";
 import { singularize } from "ember-inflector";
 import { graphql } from "graphql";
+import {
+  GraphQLDate as Date,
+  GraphQLDateTime as DateTime,
+} from "graphql-iso-date";
 import { addMockFunctionsToSchema, makeExecutableSchema } from "graphql-tools";
-import moment from "moment";
 
 import { Mock } from "@projectcaluma/ember-testing/mirage-graphql";
-import resolvers from "@projectcaluma/ember-testing/mirage-graphql/resolvers";
-import rawSchema from "@projectcaluma/ember-testing/mirage-graphql/schema.graphql";
+import typeDefs from "@projectcaluma/ember-testing/mirage-graphql/schema.graphql";
 
 export default function (server) {
   return function ({ db }, request) {
     const mocks = db._collections.reduce((m, { name }) => {
       const cls = classify(singularize(name));
-      const mock = new Mock(cls, db[name], db, server);
+      const mock = new Mock(cls, server);
 
       return { ...m, ...mock.getHandlers() };
     }, {});
 
     const schema = makeExecutableSchema({
-      typeDefs: rawSchema,
-      resolvers,
+      typeDefs,
+      resolvers: {
+        Date,
+        DateTime,
+        GenericScalar: {
+          serialize(value) {
+            return typeof value === "string" ? JSON.parse(value) : value;
+          },
+        },
+      },
       resolverValidationOptions: { requireResolversForResolveType: false },
     });
 
@@ -29,10 +39,18 @@ export default function (server) {
       schema,
       mocks: {
         ...mocks,
-        Date: () => moment().format(moment.HTML5_FMT.DATE),
         JSONString: () => JSON.stringify({}),
         GenericScalar: () => ({}),
         Node: (_, { id }) => ({ __typename: atob(id).split(":")[0] }),
+        SelectedOption: ({ value }) => {
+          const option = server.schema.options.findBy({ slug: value });
+
+          return {
+            slug: value,
+            label: option.label,
+            __typename: "SelectedOption",
+          };
+        },
       },
       preserveResolvers: false,
     });

package/addon/mirage-graphql/index.js

@@ -1,4 +1,4 @@
-import { dasherize } from "@ember/string";
+import { dasherize, classify } from "@ember/string";
 import require from "require";
 
 const importTypeOrBase = (path, type) => {
@@ -28,8 +28,29 @@ export const register = (tpl) => (target, name, descriptor) => {
   return descriptor;
 };
 
-export const Serializer = function (type, ...args) {
-  return new (importTypeOrBase("./serializers", type))(type, ...args);
+export const serialize = (deserialized = {}, type) => {
+  const __typename = [deserialized.type?.toLowerCase(), type]
+    .filter(Boolean)
+    .map(classify)
+    .join("");
+
+  return {
+    ...deserialized,
+    id: btoa(`${__typename}:${deserialized.id}`),
+    __typename,
+  };
+};
+
+export const deserialize = (serialized) => {
+  let decodedId = serialized.id;
+
+  try {
+    decodedId = atob(serialized.id).split(":")[1] || serialized.id;
+  } catch (e) {
+    // this is expected most times
+  }
+
+  return { ...serialized, ...(decodedId ? { id: decodedId } : {}) };
 };
 
 export const Filter = function (type, ...args) {

package/addon/mirage-graphql/mocks/answer.js

@@ -4,46 +4,21 @@ import { register } from "@projectcaluma/ember-testing/mirage-graphql";
 import BaseMock from "@projectcaluma/ember-testing/mirage-graphql/mocks/base";
 
 export default class extends BaseMock {
-  @register("Answer")
-  handleAnswer({ __typename }) {
-    return { __typename };
-  }
-
   _handleSaveDocumentAnswer(
     _,
-    {
-      question: questionSlug,
-      document: documentId,
-      clientMutationId,
-      value,
-      type,
-    }
+    { question: questionId, document: documentId, value, type }
   ) {
-    const questionId = this.db.questions.findBy({ slug: questionSlug }).id;
-
     const answer = this.collection.findBy({ questionId, documentId });
 
-    const res = this.handleSavePayload.fn.call(this, _, {
+    return this.handleSavePayload.fn.call(this, _, {
       input: {
-        id: answer && answer.id,
+        id: answer?.id,
         type,
         value,
         documentId,
         questionId,
-        clientMutationId,
       },
     });
-
-    // Default answers don't have a document.
-    if (res.answer.documentId) {
-      const doc = this.db.documents.findBy({ id: res.answer.documentId });
-
-      this.db.documents.update(doc.id, {
-        answerIds: [...new Set([...(doc.answerIds || []), res.answer.id])],
-      });
-    }
-
-    return res;
   }
 
   @register("SaveDocumentStringAnswerPayload")
@@ -51,7 +26,7 @@ export default class extends BaseMock {
   handleSaveDocumentStringAnswer(_, { input }) {
     return this._handleSaveDocumentAnswer(_, {
       ...input,
-      value: String(input.value),
+      value: input.value ? String(input.value) : null,
       type: "STRING",
     });
   }
@@ -61,7 +36,7 @@ export default class extends BaseMock {
   handleSaveIntegerAnswer(_, { input }) {
     return this._handleSaveDocumentAnswer(_, {
       ...input,
-      value: parseInt(input.value),
+      value: input.value ? parseInt(input.value) : null,
       type: "INTEGER",
     });
   }
@@ -71,7 +46,7 @@ export default class extends BaseMock {
   handleSaveFloatAnswer(_, { input }) {
     return this._handleSaveDocumentAnswer(_, {
       ...input,
-      value: parseFloat(input.value),
+      value: input.value ? parseFloat(input.value) : null,
       type: "FLOAT",
     });
   }
@@ -81,7 +56,7 @@ export default class extends BaseMock {
   handleSaveListAnswer(_, { input }) {
     return this._handleSaveDocumentAnswer(_, {
       ...input,
-      value: [...input.value].map(String),
+      value: input.value ? [...input.value].map(String) : null,
       type: "LIST",
     });
   }
@@ -90,7 +65,7 @@ export default class extends BaseMock {
   handleSaveFileAnswer(_, { input }) {
     return this._handleSaveDocumentAnswer(_, {
       ...input,
-      value: { metadata: { object_name: input.value } },
+      value: input.value ? { metadata: { object_name: input.value } } : null,
       type: "FILE",
     });
   }

package/addon/mirage-graphql/mocks/base.js

@@ -1,24 +1,70 @@
-import { camelize, dasherize } from "@ember/string";
+import { camelize, dasherize, classify } from "@ember/string";
+import faker from "@faker-js/faker";
+import { singularize, pluralize } from "ember-inflector";
 import { MockList } from "graphql-tools";
 
 import {
   Filter,
-  Serializer,
   register,
+  serialize,
+  deserialize,
 } from "@projectcaluma/ember-testing/mirage-graphql";
 
+export const ANSWER_TYPES = [
+  "DATE",
+  "FILE",
+  "FLOAT",
+  "INTEGER",
+  "LIST",
+  "STRING",
+  "TABLE",
+];
+
+export const QUESTION_TYPES = [
+  "ACTION_BUTTON",
+  "CALCULATED_FLOAT",
+  "CHOICE",
+  "DATE",
+  "DYNAMIC_CHOICE",
+  "DYNAMIC_MULTIPLE_CHOICE",
+  "FILE",
+  "FLOAT",
+  "FORM",
+  "INTEGER",
+  "MULTIPLE_CHOICE",
+  "STATIC",
+  "TABLE",
+  "TEXT",
+  "TEXTAREA",
+];
+
+export const TASK_TYPES = [
+  "SIMPLE",
+  "COMPLETE_WORKFLOW_FORM",
+  "COMPLETE_TASK_FORM",
+];
+
+export const TYPE_MAPPING = {
+  Answer: ANSWER_TYPES,
+  Question: QUESTION_TYPES,
+  Task: TASK_TYPES,
+};
+
 export default class {
-  constructor(type, collection, db, server, ...args) {
+  constructor(type, server) {
     this.type = type;
-    this.collection = collection;
-    this.db = db;
     this.server = server;
+    this.schema = server.schema;
+
+    this.filter = new Filter(type);
+  }
 
-    this.filter = new Filter(type, collection, db, server, ...args);
-    this.serializer = new Serializer(type, collection, db, server, ...args);
+  get collection() {
+    return this.schema[pluralize(camelize(this.type))];
   }
 
   getHandlers() {
+    const types = TYPE_MAPPING[this.type];
     const handlers = (target) => {
       const proto = Reflect.getPrototypeOf(target);
       const res = Object.values(proto);
@@ -37,10 +83,26 @@ export default class {
           ...handlers,
           // Mocks can have multiple handlers per type.
           ...handler.__handlerFor.reduce((targets, target) => {
+            const handlerName = target.replace(/\{type\}/, this.type);
+            const baseHandlerName = handlerName.replace(/\{subtype\}/, "");
+            const fn = (...args) => handler.fn.apply(this, args);
+
+            const newHandlers = types
+              ? types.reduce(
+                  (typeHandlers, type) => ({
+                    ...typeHandlers,
+                    [handlerName.replace(
+                      /\{subtype\}/,
+                      classify(type.toLowerCase())
+                    )]: fn,
+                  }),
+                  {}
+                )
+              : { [baseHandlerName]: fn };
+
             return {
               ...targets,
-              [target.replace(/\{type\}/, this.type)]: (...args) =>
-                handler.fn.apply(this, args),
+              ...newHandlers,
             };
           }, {}),
         };
@@ -51,21 +113,23 @@ export default class {
   }
 
   @register("{type}Connection")
-  handleConnection(root, vars) {
+  handleConnection(root, vars, _, { fieldName }) {
     let records = this.filter.filter(
-      this.collection,
-      this.serializer.deserialize(vars)
+      this.collection.all().models,
+      deserialize(vars)
     );
 
-    const relKey = `${camelize(this.type)}Ids`;
+    const relKey = `${singularize(fieldName)}Ids`;
     if (root && Object.prototype.hasOwnProperty.call(root, relKey)) {
       const ids = root[relKey];
-      records = records.filter(({ id }) => ids && ids.includes(id));
+      records = records
+        .filter(({ id }) => ids && ids.includes(id))
+        .sort((a, b) => ids.indexOf(a.id) - ids.indexOf(b.id));
     }
 
     // add base64 encoded index as cursor to records
     records = records.map((record, index) => ({
-      ...record,
+      ...record.toJSON(),
       _cursor: btoa(index),
     }));
 
@@ -91,46 +155,47 @@ export default class {
       edges: () =>
         new MockList(records.length, () => ({
           node: (r, v, _, meta) =>
-            this.serializer.serialize(records[meta.path.prev.key]),
+            serialize(records[meta.path.prev.key], this.type),
         })),
     };
   }
 
-  @register("{type}")
-  handle(root, vars) {
+  @register("{subtype}{type}")
+  handle(root, vars, _, { fieldName }) {
     // If the parent node already resolved this branch in the graph, return it
     // directly without mocking it
     if (
       root &&
-      Object.prototype.hasOwnProperty.call(root, camelize(this.type))
+      fieldName !== "node" &&
+      Object.prototype.hasOwnProperty.call(root, fieldName)
     ) {
-      return root[camelize(this.type)];
+      return root[fieldName];
     }
 
     // If the parent node provides an ID for this relation, filter our mock data
     // with that given ID
+    const relKey = `${fieldName}Id`;
     if (
       root &&
-      Object.prototype.hasOwnProperty.call(root, `${camelize(this.type)}Id`)
+      fieldName !== "node" &&
+      Object.prototype.hasOwnProperty.call(root, relKey)
     ) {
-      vars = { id: root[`${camelize(this.type)}Id`] };
+      vars = { id: root[relKey] };
     }
 
-    const record = this.filter.find(
-      this.collection,
-      this.serializer.deserialize(vars)
-    );
+    const record = this.collection.findBy(deserialize(vars));
 
-    return record && this.serializer.serialize(record);
+    return record && serialize(record.toJSON(), this.type);
   }
 
-  @register("Save{type}Payload")
-  handleSavePayload(_, { input: { clientMutationId, slug, id, ...args } }) {
+  @register("Save{subtype}{type}Payload")
+  handleSavePayload(
+    _,
+    { input: { clientMutationId = faker.datatype.uuid(), slug, id, ...args } }
+  ) {
     const identifier = slug ? { slug } : { id };
 
-    const relKeys = this.server.schema.modelFor(
-      this.type.toLowerCase()
-    ).foreignKeys;
+    const relKeys = this.schema.modelFor(camelize(this.type)).foreignKeys;
 
     const parsedArgs = Object.entries(args).reduce((parsed, [key, value]) => {
       const re = new RegExp(`${camelize(key)}Id(s)?`);
@@ -138,16 +203,17 @@ export default class {
 
       return {
         ...parsed,
-        [relKey ?? key]: value,
+        ...(value === undefined ? {} : { [relKey ?? key]: value }),
       };
     }, {});
 
-    const obj = this.filter.find(this.collection, identifier);
+    const obj = this.collection.findBy(identifier);
     const res = obj
-      ? this.collection.update(obj.id, parsedArgs)
-      : this.collection.insert(
-          this.serializer.deserialize(
-            this.server.build(dasherize(this.type), {
+      ? obj.update(deserialize(parsedArgs))
+      : this.collection.create(
+          this.server.build(
+            dasherize(this.type),
+            deserialize({
               ...identifier,
               ...parsedArgs,
             })
@@ -155,10 +221,7 @@ export default class {
         );
 
     return {
-      [camelize(this.type)]: this.serializer.serialize({
-        ...relKeys.reduce((rels, key) => ({ ...rels, [key]: null })),
-        ...res,
-      }),
+      [camelize(this.type)]: serialize(res.toJSON(), this.type),
       clientMutationId,
     };
   }