@projectcaluma/ember-testing 10.1.0 → 11.0.0-beta.2

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

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

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

@@ -1,25 +1,25 @@
 import { camelize } from "@ember/string";
 
 export default class {
-  constructor(type, collection, db) {
+  constructor(type) {
     this.type = type;
-    this.collection = collection;
-    this.db = db;
   }
 
   _getFilterFns(rawFilters) {
     const filters = Array.isArray(rawFilters)
       ? // new format
-        rawFilters.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 }), {});
+        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 };
-        })
+            return { key, value, options };
+          })
       : // old format
         Object.entries(rawFilters).map(([key, value]) => ({
           key,

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,25 +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));
   }
 
-  task(records, value) {
-    const task = this.db.tasks.findBy({ slug: value });
+  tasks(records, value, { invert = false }) {
+    return records.filter((record) => invert !== value.includes(record.taskId));
+  }
 
-    return records.filter((record) => record.taskId === task?.id);
+  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))
+      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))
+      value.every((g) => invert !== record.addressedGroups?.includes(g))
     );
   }
 }

package/addon/mirage-graphql/handler.js

@@ -14,7 +14,7 @@ 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() };
     }, {});

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

@@ -1,48 +1,24 @@
-import moment from "moment";
+import { DateTime } from "luxon";
 
-import {
-  register,
-  deserialize,
-} from "@projectcaluma/ember-testing/mirage-graphql";
+import { register } from "@projectcaluma/ember-testing/mirage-graphql";
 import BaseMock from "@projectcaluma/ember-testing/mirage-graphql/mocks/base";
 
 export default class extends BaseMock {
   _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 });
-
-      const { id } = deserialize(res.answer);
-      this.db.documents.update(doc.id, {
-        answerIds: [...new Set([...(doc.answerIds || []), id])],
-      });
-    }
-
-    return res;
   }
 
   @register("SaveDocumentStringAnswerPayload")
@@ -98,13 +74,7 @@ export default class extends BaseMock {
   @register("SaveDefaultDateAnswerPayload")
   handleSaveDateAnswer(_, { input }) {
     const date = input.value;
-    const value = date
-      ? moment({
-          day: date.getUTCDate(),
-          month: date.getUTCMonth(),
-          year: date.getUTCFullYear(),
-        }).format(moment.HTML5_FMT.DATE)
-      : null;
+    const value = date ? DateTime.fromJSDate(date).toISODate() : null;
 
     return this._handleSaveDocumentAnswer(_, {
       ...input,

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

@@ -1,5 +1,6 @@
 import { camelize, dasherize, classify } from "@ember/string";
-import { singularize } from "ember-inflector";
+import { faker } from "@faker-js/faker";
+import { singularize, pluralize } from "ember-inflector";
 import { MockList } from "graphql-tools";
 
 import {
@@ -50,13 +51,16 @@ export const TYPE_MAPPING = {
 };
 
 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, collection, db, server, ...args);
+    this.filter = new Filter(type);
+  }
+
+  get collection() {
+    return this.schema[pluralize(camelize(this.type))];
   }
 
   getHandlers() {
@@ -110,17 +114,22 @@ export default class {
 
   @register("{type}Connection")
   handleConnection(root, vars, _, { fieldName }) {
-    let records = this.filter.filter(this.collection, deserialize(vars));
+    let records = this.filter.filter(
+      this.collection.all().models,
+      deserialize(vars)
+    );
 
     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),
     }));
 
@@ -174,18 +183,19 @@ export default class {
       vars = { id: root[relKey] };
     }
 
-    const record = this.filter.find(this.collection, deserialize(vars));
+    const record = this.collection.findBy(deserialize(vars));
 
-    return record && serialize(record, this.type);
+    return record && serialize(record.toJSON(), this.type);
   }
 
   @register("Save{subtype}{type}Payload")
-  handleSavePayload(_, { input: { clientMutationId, slug, id, ...args } }) {
+  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)?`);
@@ -193,14 +203,14 @@ 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(
+      ? obj.update(deserialize(parsedArgs))
+      : this.collection.create(
           this.server.build(
             dasherize(this.type),
             deserialize({
@@ -211,13 +221,7 @@ export default class {
         );
 
     return {
-      [camelize(this.type)]: serialize(
-        {
-          ...relKeys.reduce((rels, key) => ({ ...rels, [key]: null }), {}),
-          ...res,
-        },
-        this.type
-      ),
+      [camelize(this.type)]: serialize(res.toJSON(), this.type),
       clientMutationId,
     };
   }

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

@@ -1,114 +1,40 @@
-import { MockList } from "graphql-tools";
-
-import {
-  Filter,
-  register,
-  serialize,
-} from "@projectcaluma/ember-testing/mirage-graphql";
+import { register } from "@projectcaluma/ember-testing/mirage-graphql";
 import BaseMock from "@projectcaluma/ember-testing/mirage-graphql/mocks/base";
 
-const questionFilter = new Filter("Question");
-
 export default class extends BaseMock {
   @register("ReorderFormQuestionsPayload")
-  handleReorderFormQuestions(
-    root,
-    { input: { form: slug, questions: questionSlugs, clientMutationId } }
-  ) {
-    const form = this.filter.find(this.collection, { slug });
-
-    const questions = questionSlugs.map((slug) => {
-      return questionFilter.find(this.db.questions, { slug });
-    });
-
-    const res = this.collection.update(form.id, {
-      questionIds: questions.map(({ id }) => id),
-    });
-
-    return {
-      form: {
-        ...serialize(res, this.type),
-        questions: {
-          edges: () =>
-            new MockList(questions.length, () => ({
-              node: (r, v, _, meta) =>
-                serialize(questions[meta.path.prev.key], "Question"),
-            })),
-        },
+  handleReorderFormQuestions(_, { input }) {
+    return this.handleSavePayload.fn.call(this, _, {
+      input: {
+        id: input.form,
+        questionIds: input.questions,
       },
-      clientMutationId,
-    };
+    });
   }
 
   @register("AddFormQuestionPayload")
-  handleAddFormQuestion(
-    root,
-    { input: { form: slug, question: questionSlug, clientMutationId } }
-  ) {
-    const form = this.filter.find(this.collection, { slug });
-
-    const question = questionFilter.find(this.db.questions, {
-      slug: questionSlug,
-    });
-
-    this.db.questions.update(question.id, {
-      formIds: [...(question.formIds || []), form.id],
-    });
-
-    const res = this.collection.update(form.id, {
-      questionIds: [...(form.questionIds || []), question.id],
-    });
-
-    const questions = res.questionIds.map((id) => this.db.questions.find(id));
-
-    return {
-      form: {
-        ...serialize(res, this.type),
-        questions: {
-          edges: () =>
-            new MockList(questions.length, () => ({
-              node: (r, v, _, meta) =>
-                serialize(questions[meta.path.prev.key], "Question"),
-            })),
-        },
+  handleAddFormQuestion(_, { input }) {
+    const form = this.schema.forms.find(input.form);
+
+    return this.handleSavePayload.fn.call(this, _, {
+      input: {
+        id: form.id,
+        questionIds: [...(form.questionIds || []), input.question],
+        questions: undefined,
       },
-      clientMutationId,
-    };
+    });
   }
 
   @register("RemoveFormQuestionPayload")
-  handleRemoveFormQuestion(
-    root,
-    { input: { form: slug, question: questionSlug, clientMutationId } }
-  ) {
-    const form = this.filter.find(this.collection, { slug });
-
-    const question = questionFilter.find(this.db.questions, {
-      slug: questionSlug,
-    });
-
-    this.db.questions.update(question.id, {
-      formIds: question.formIds.filter((id) => id !== form.id),
-    });
-
-    const res = this.collection.update(form.id, {
-      questionIds: form.questionIds.filter((id) => id !== question.id),
-    });
-
-    const questions = res.questionIds.map((id) => this.db.questions.find(id));
-
-    return {
-      form: {
-        ...serialize(res, this.type),
-        questions: {
-          edges: () =>
-            new MockList(questions.length, () => ({
-              node: (r, v, _, meta) =>
-                serialize(questions[meta.path.prev.key], "Question"),
-            })),
-        },
+  handleRemoveFormQuestion(_, { input }) {
+    const form = this.schema.forms.find(input.form);
+
+    return this.handleSavePayload.fn.call(this, _, {
+      input: {
+        id: form.id,
+        questionIds: form.questionIds.filter((id) => id !== input.question),
+        questions: undefined,
       },
-      clientMutationId,
-    };
+    });
   }
 }

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

@@ -1,14 +1,6 @@
-import { MockList } from "graphql-tools";
-
-import {
-  Filter,
-  register,
-  serialize,
-} from "@projectcaluma/ember-testing/mirage-graphql";
+import { register } from "@projectcaluma/ember-testing/mirage-graphql";
 import BaseMock from "@projectcaluma/ember-testing/mirage-graphql/mocks/base";
 
-const optionFilter = new Filter("Option");
-
 export default class extends BaseMock {
   @register("SaveTextQuestionPayload")
   handleSaveTextQuestion(_, { input }) {
@@ -47,50 +39,26 @@ export default class extends BaseMock {
 
   @register("SaveChoiceQuestionPayload")
   handleSaveChoiceQuestion(_, { input }) {
-    const options = input.options.map((slug) =>
-      optionFilter.find(this.db.options, { slug })
-    );
-    const optionIds = options.map(({ id }) => String(id));
-
-    const res = this.handleSavePayload.fn.call(this, _, {
-      input: { ...input, options, optionIds, type: "CHOICE" },
-    });
-
-    Object.assign(res.question, {
-      options: {
-        edges: () =>
-          new MockList(options.length, () => ({
-            node: (r, v, _, meta) =>
-              serialize(options[meta.path.prev.key], "Option"),
-          })),
+    return this.handleSavePayload.fn.call(this, _, {
+      input: {
+        ...input,
+        optionIds: input.options,
+        options: undefined,
+        type: "CHOICE",
       },
     });
-
-    return res;
   }
 
   @register("SaveMultipleChoiceQuestionPayload")
   handleSaveMultipleChoiceQuestion(_, { input }) {
-    const options = input.options.map((slug) =>
-      optionFilter.find(this.db.options, { slug })
-    );
-    const optionIds = options.map(({ id }) => String(id));
-
-    const res = this.handleSavePayload.fn.call(this, _, {
-      input: { ...input, options, optionIds, type: "MULTIPLE_CHOICE" },
-    });
-
-    Object.assign(res.question, {
-      options: {
-        edges: () =>
-          new MockList(options.length, () => ({
-            node: (r, v, _, meta) =>
-              serialize(options[meta.path.prev.key], "Option"),
-          })),
+    return this.handleSavePayload.fn.call(this, _, {
+      input: {
+        ...input,
+        optionIds: input.options,
+        options: undefined,
+        type: "MULTIPLE_CHOICE",
       },
     });
-
-    return res;
   }
 
   @register("SaveTableQuestionPayload")
@@ -98,7 +66,8 @@ export default class extends BaseMock {
     return this.handleSavePayload.fn.call(this, _, {
       input: {
         ...input,
-        ...(input.rowForm ? { rowForm: { slug: input.rowForm } } : {}),
+        rowFormId: input.rowForm,
+        rowForm: undefined,
         type: "TABLE",
       },
     });
@@ -109,7 +78,8 @@ export default class extends BaseMock {
     return this.handleSavePayload.fn.call(this, _, {
       input: {
         ...input,
-        ...(input.subForm ? { subForm: { slug: input.subForm } } : {}),
+        subFormId: input.subForm,
+        subForm: undefined,
         type: "FORM",
       },
     });

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

@@ -0,0 +1,105 @@
+import { DateTime } from "luxon";
+
+import {
+  register,
+  deserialize,
+} from "@projectcaluma/ember-testing/mirage-graphql";
+import BaseMock from "@projectcaluma/ember-testing/mirage-graphql/mocks/base";
+import { createInquiry } from "@projectcaluma/ember-testing/scenarios/distribution";
+
+export default class extends BaseMock {
+  @register("ResumeWorkItemPayload")
+  handleResumeWorkItem(_, { input }) {
+    return this.handleSavePayload.fn.call(this, _, {
+      input: { id: input.id, status: "READY" },
+    });
+  }
+
+  @register("SuspendWorkItemPayload")
+  handleSuspendWorkItem(_, { input }) {
+    return this.handleSavePayload.fn.call(this, _, {
+      input: { id: input.id, status: "SUSPENDED" },
+    });
+  }
+
+  @register("CompleteWorkItemPayload")
+  handleCompleteWorkItem(_, { input }) {
+    const { id } = deserialize(input);
+
+    const workItem = this.collection.find(id);
+
+    const taskId = workItem.taskId;
+    const caseId = workItem.caseId;
+
+    /**
+     * Disclaimer: this is a static configuration of a pre-configured workflow
+     * in the distribution scenario and should most likely be handled properly
+     * like the backend does. However, this small requirement does not justify a
+     * complex implementation of backend logic which is why we keep this static
+     * for now.
+     */
+    if (["adjust-inquiry-answer", "compose-inquiry-answer"].includes(taskId)) {
+      this.server.create("work-item", {
+        caseId,
+        status: "READY",
+        taskId: "confirm-inquiry-answer",
+      });
+      this.server.create("work-item", {
+        caseId,
+        status: "READY",
+        taskId: "revise-inquiry-answer",
+      });
+    } else if (taskId === "confirm-inquiry-answer") {
+      this.collection
+        .findBy({ caseId, taskId: "revise-inquiry-answer" })
+        .update({ status: "CANCELED" });
+      this.collection
+        .findBy({ childCaseId: caseId })
+        .update({ status: "COMPLETED" });
+      this.schema.cases.find(caseId).update({ status: "COMPLETED" });
+    } else if (taskId === "revise-inquiry-answer") {
+      this.collection
+        .findBy({ caseId, taskId: "confirm-inquiry-answer" })
+        .update({ status: "CANCELED" });
+      this.server.create("work-item", {
+        caseId,
+        status: "READY",
+        taskId: "adjust-inquiry-answer",
+      });
+    } else if (taskId === "create-inquiry") {
+      const { addressed_groups: groups } = JSON.parse(input.context);
+
+      groups.forEach((group) => {
+        createInquiry(
+          this.server,
+          workItem.case,
+          {
+            to: { id: group },
+            from: { id: workItem.addressedGroups[0] },
+            remark: "",
+            deadline: DateTime.now().plus({ days: 30 }).toJSDate(),
+          },
+          {
+            createdAt: new Date(),
+          }
+        );
+
+        this.server.create("work-item", {
+          taskId: "create-inquiry",
+          status: "READY",
+          addressedGroups: [group],
+        });
+      });
+
+      this.server.create("work-item", {
+        taskId: "create-inquiry",
+        status: "READY",
+        addressedGroups: workItem.addressedGroups,
+      });
+    }
+
+    return this.handleSavePayload.fn.call(this, _, {
+      input: { id: input.id, status: "COMPLETED" },
+    });
+  }
+}