@projectcaluma/ember-testing 10.1.0 → 10.2.0-beta.1

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 {
-  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")

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

@@ -1,5 +1,6 @@
 import { camelize, dasherize, classify } from "@ember/string";
-import { singularize } from "ember-inflector";
+import { singularize, pluralize } from "ember-inflector";
+import faker from "faker";
 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,72 @@
+import {
+  register,
+  deserialize,
+} from "@projectcaluma/ember-testing/mirage-graphql";
+import BaseMock from "@projectcaluma/ember-testing/mirage-graphql/mocks/base";
+
+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",
+      });
+    }
+
+    return this.handleSavePayload.fn.call(this, _, {
+      input: { id: input.id, status: "COMPLETED" },
+    });
+  }
+}

package/addon/mirage-graphql/schema.graphql

@@ -361,11 +361,6 @@ type Case implements Node {
   """
   id: ID!
 
-  """
-  Stores a path to the given object
-  """
-  path: [String]!
-
   """
   Time when case has either been canceled or completed
   """
@@ -1163,11 +1158,6 @@ type Document implements Node {
   The ID of the object.
   """
   id: ID!
-
-  """
-  Stores a path to the given object
-  """
-  path: [String]!
   form: Form!
 
   """
@@ -4078,7 +4068,6 @@ enum SortableDocumentAttributes {
   CREATED_BY_GROUP
   MODIFIED_BY_USER
   MODIFIED_BY_GROUP
-  PATH
   FORM
   SOURCE
 }
@@ -4991,11 +4980,6 @@ type WorkItem implements Node {
   """
   id: ID!
 
-  """
-  Stores a path to the given object
-  """
-  path: [String]!
-
   """
   Will be set from Task, if not provided.
   """

package/addon/scenarios/distribution.js

@@ -8,12 +8,16 @@ export function createBlueprint(server) {
   server.create("question", {
     slug: "inquiry-remark",
     label: "Remark",
+    isRequired: "true",
+    maxLength: 9999,
+    minLength: 0,
     formIds: [inquiryForm.id],
     type: "TEXTAREA",
   });
   server.create("question", {
     slug: "inquiry-deadline",
     label: "Deadline",
+    isRequired: "true",
     formIds: [inquiryForm.id],
     type: "DATE",
   });
@@ -22,6 +26,8 @@ export function createBlueprint(server) {
     slug: "inquiry-answer-status",
     type: "CHOICE",
     formIds: [inquiryAnswerForm.id],
+    isRequired: "true",
+    label: "Status",
     options: [
       server.create("option", {
         slug: "inquiry-answer-status-positive",
@@ -39,12 +45,28 @@ export function createBlueprint(server) {
   });
   server.create("question", {
     slug: "inquiry-answer-reason",
+    isRequired: "true",
+    maxLength: 9999,
+    minLength: 0,
     label: "Reason",
     type: "TEXTAREA",
     formIds: [inquiryAnswerForm.id],
   });
 
+  server.create("workflow", { slug: "distribution" });
+  server.create("workflow", { slug: "inquiry" });
+
   server.create("task", { slug: "inquiry" });
+  server.create("task", {
+    slug: "compose-inquiry-answer",
+    type: "COMPLETE_WORKFLOW_FORM",
+  });
+  server.create("task", { slug: "confirm-inquiry-answer" });
+  server.create("task", { slug: "revise-inquiry-answer" });
+  server.create("task", {
+    slug: "adjust-inquiry-answer",
+    type: "COMPLETE_WORKFLOW_FORM",
+  });
 }
 
 export function createInquiry(
@@ -53,27 +75,22 @@ export function createInquiry(
   { from, to, remark, deadline },
   workItemAttrs = {}
 ) {
-  const form = server.schema.forms.findBy({ slug: "inquiry" });
-  const document = server.create("document", { form });
+  const document = server.create("document", { formId: "inquiry" });
 
   server.create("answer", {
     document,
-    question: server.schema.questions.findBy({
-      slug: "inquiry-remark",
-    }),
+    questionId: "inquiry-remark",
     value: remark ?? faker.lorem.paragraph(),
   });
 
   server.create("answer", {
     document,
-    question: server.schema.questions.findBy({
-      slug: "inquiry-deadline",
-    }),
+    questionId: "inquiry-deadline",
     value: deadline ?? faker.date.future(),
   });
 
   return server.create("work-item", {
-    task: server.schema.tasks.findBy({ slug: "inquiry" }),
+    taskId: "inquiry",
     document,
     status: "SUSPENDED",
     case: distributionCase,
@@ -84,16 +101,21 @@ export function createInquiry(
 }
 
 export function sendInquiry(server, { inquiry }) {
-  inquiry.update({
+  const childCase = server.create("case", {
+    status: "RUNNING",
+    workflowId: "inquiry",
+    document: server.create("document", { formId: "inquiry-answer" }),
+  });
+
+  server.create("work-item", {
+    taskId: "compose-inquiry-answer",
     status: "READY",
-    childCase: server.create("case", {
-      status: "RUNNING",
-      document: server.create("document", {
-        form: server.schema.forms.findBy({ slug: "inquiry-answer" }),
-      }),
-    }),
+    case: childCase,
+    addressedGroups: inquiry.addressedGroups,
   });
 
+  inquiry.update({ status: "READY", childCase });
+
   return inquiry;
 }
 
@@ -104,32 +126,74 @@ export function answerInquiry(server, { inquiry, status, reason }) {
 
   server.create("answer", {
     document: inquiry.childCase.document,
-    question: server.schema.questions.findBy({
-      slug: "inquiry-answer-status",
-    }),
+    questionId: "inquiry-answer-status",
     value: status,
   });
 
   server.create("answer", {
     document: inquiry.childCase.document,
-    question: server.schema.questions.findBy({
-      slug: "inquiry-answer-reason",
-    }),
+    questionId: "inquiry-answer-reason",
     value: reason ?? faker.lorem.paragraph(),
   });
 
+  inquiry.childCase.workItems
+    .filter((workItem) => workItem.taskId === "compose-inquiry-answer")
+    .update({ status: "COMPLETED" });
+  server.create("work-item", {
+    taskId: "confirm-inquiry-answer",
+    status: "READY",
+    case: inquiry.childCase,
+    addressedGroups: inquiry.addressedGroups,
+  });
+  server.create("work-item", {
+    taskId: "revise-inquiry-answer",
+    status: "READY",
+    case: inquiry.childCase,
+    addressedGroups: inquiry.addressedGroups,
+  });
+
+  return inquiry;
+}
+
+export function confirmInquiry({ inquiry }) {
   inquiry.update({ status: "COMPLETED" });
   inquiry.childCase.update({
     status: "COMPLETED",
     closedAt: faker.date.recent(),
   });
+  inquiry.childCase.workItems
+    .filter((workItem) => workItem.taskId === "confirm-inquiry-answer")
+    .update({ status: "COMPLETED" });
+  inquiry.childCase.workItems
+    .filter((workItem) => workItem.taskId === "revise-inquiry-answer")
+    .update({ status: "CANCELED" });
+
+  return inquiry;
+}
+
+export function reviseInquiry(server, { inquiry }) {
+  server.create("work-item", {
+    taskId: "adjust-inquiry-answer",
+    status: "READY",
+    case: inquiry.childCase,
+    addressedGroups: inquiry.addressedGroups,
+  });
+  inquiry.childCase.workItems
+    .filter((workItem) => workItem.taskId === "confirm-inquiry-answer")
+    .update({ status: "CANCELED" });
+  inquiry.childCase.workItems
+    .filter((workItem) => workItem.taskId === "revise-inquiry-answer")
+    .update({ status: "COMPLETED" });
 
   return inquiry;
 }
 
 export default function (server, groups) {
+  createBlueprint(server);
+
   const distributionCase = server.create("case", {
-    workflow: server.create("workflow", { slug: "distribution" }),
+    status: "RUNNING",
+    workflowId: "distribution",
   });
 
   const g = groups[0];
@@ -141,8 +205,8 @@ export default function (server, groups) {
   const create = (...args) => createInquiry(server, distributionCase, ...args);
   const send = (...args) => sendInquiry(server, ...args);
   const answer = (...args) => answerInquiry(server, ...args);
-
-  createBlueprint(server);
+  const confirm = (...args) => confirmInquiry(...args);
+  const revise = (...args) => reviseInquiry(server, ...args);
 
   // controlling
   create({ from: g, to: g1 });
@@ -153,24 +217,31 @@ export default function (server, groups) {
       deadline: faker.date.past(),
     }),
   });
-  answer({
-    inquiry: create({
-      from: g,
-      to: g3,
-      deadline: faker.date.past(),
+  confirm({
+    inquiry: answer({
+      inquiry: create({
+        from: g,
+        to: g3,
+        deadline: faker.date.past(),
+      }),
+      status: "inquiry-answer-status-needs-interaction",
     }),
-    status: "inquiry-answer-status-needs-interaction",
   });
+
   // "override" third controlling inquiry
-  answer({
-    inquiry: create({ from: g, to: g3 }, { createdAt: faker.date.recent() }),
-    status: "inquiry-answer-status-positive",
+  confirm({
+    inquiry: answer({
+      inquiry: create({ from: g, to: g3 }, { createdAt: faker.date.recent() }),
+      status: "inquiry-answer-status-positive",
+    }),
   });
 
   // addressed
-  answer({
-    inquiry: create({ from: g2, to: g }),
-    status: "inquiry-answer-status-needs-interaction",
+  confirm({
+    inquiry: answer({
+      inquiry: create({ from: g2, to: g }),
+      status: "inquiry-answer-status-needs-interaction",
+    }),
   });
   // "override" first addressed inquiry
   send({
@@ -183,18 +254,34 @@ export default function (server, groups) {
       { createdAt: faker.date.recent() }
     ),
   });
+  confirm({
+    inquiry: answer({
+      inquiry: create({ from: g4, to: g }),
+      status: "inquiry-answer-status-negative",
+    }),
+  });
   answer({
-    inquiry: create({ from: g4, to: g }),
-    status: "inquiry-answer-status-negative",
+    inquiry: create({ from: g3, to: g }),
+    status: "inquiry-answer-status-positive",
+  });
+  revise({
+    inquiry: answer({
+      inquiry: create({ from: g1, to: g }),
+      status: "inquiry-answer-status-needs-interaction",
+    }),
   });
 
   // more
-  answer({
-    inquiry: create({ from: g2, to: g3 }),
-    status: "inquiry-answer-status-needs-interaction",
+  confirm({
+    inquiry: answer({
+      inquiry: create({ from: g2, to: g3 }),
+      status: "inquiry-answer-status-needs-interaction",
+    }),
   });
-  answer({
-    inquiry: create({ from: g3, to: g4 }),
-    status: "inquiry-answer-status-positive",
+  confirm({
+    inquiry: answer({
+      inquiry: create({ from: g3, to: g4 }),
+      status: "inquiry-answer-status-positive",
+    }),
   });
 }

package/addon-mirage-support/factories/workflow.js

@@ -0,0 +1,9 @@
+import { Factory } from "ember-cli-mirage";
+
+export default Factory.extend({
+  id() {
+    return this.slug;
+  },
+  name: (i) => `Workflow #${i + 1}`,
+  slug: (i) => `workflow-${i + 1}`,
+});

package/addon-mirage-support/models/answer.js

@@ -1,6 +1,7 @@
-import { Model, belongsTo } from "ember-cli-mirage";
+import { Model, belongsTo, hasMany } from "ember-cli-mirage";
 
 export default Model.extend({
-  document: belongsTo(),
+  document: belongsTo("document"),
   question: belongsTo(),
+  documents: hasMany("document", { inverse: null }),
 });

package/addon-mirage-support/models/case.js

@@ -3,5 +3,6 @@ import { Model, belongsTo, hasMany } from "ember-cli-mirage";
 export default Model.extend({
   document: belongsTo(),
   workflow: belongsTo(),
+  parentWorkItem: belongsTo("workItem", { inverse: "childCase" }),
   workItems: hasMany(),
 });

package/addon-mirage-support/models/form.js

@@ -1,5 +1,5 @@
 import { Model, hasMany } from "ember-cli-mirage";
 
 export default Model.extend({
-  questions: hasMany(),
+  questions: hasMany({ inverse: "forms" }),
 });

package/addon-mirage-support/models/question.js

@@ -1,7 +1,9 @@
 import { Model, hasMany, belongsTo } from "ember-cli-mirage";
 
 export default Model.extend({
-  forms: hasMany(),
+  forms: hasMany({ inverse: "questions" }),
   options: hasMany(),
+  subForm: belongsTo("form", { inverse: null }),
+  rowForm: belongsTo("form", { inverse: null }),
   defaultAnswer: belongsTo("answer", { inverse: null }),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projectcaluma/ember-testing",
-  "version": "10.1.0",
+  "version": "10.2.0-beta.1",
   "description": "Ember addon for testing with Caluma addons.",
   "keywords": [
     "ember-addon"
@@ -18,13 +18,13 @@
     "broccoli-merge-trees": "^4.2.0",
     "ember-apollo-client": "^3.2.0",
     "ember-auto-import": "^2.2.3",
-    "ember-cli-babel": "^7.26.6",
+    "ember-cli-babel": "^7.26.11",
     "ember-cli-htmlbars": "^6.0.1",
     "ember-cli-mirage": "^2.2.0",
     "ember-fetch": "^8.0.4",
     "ember-inflector": "^4.0.2",
     "faker": "^5.5.3",
-    "graphql": "^15.6.1",
+    "graphql": "^15.8.0",
     "graphql-iso-date": "^3.6.1",
     "graphql-tools": "^4.0.8",
     "moment": "^2.29.1"
@@ -32,9 +32,9 @@
   "devDependencies": {
     "@ember/optional-features": "2.0.0",
     "@ember/test-helpers": "2.6.0",
-    "@embroider/test-setup": "0.48.1",
+    "@embroider/test-setup": "0.49.0",
     "broccoli-asset-rev": "3.0.0",
-    "ember-cli": "3.28.4",
+    "ember-cli": "3.28.5",
     "ember-cli-code-coverage": "1.0.3",
     "ember-cli-dependency-checker": "3.2.0",
     "ember-cli-inject-live-reload": "2.1.0",