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

package/addon/scenarios/distribution.js

@@ -0,0 +1,287 @@
+import faker from "faker";
+import moment from "moment";
+
+export function createBlueprint(server) {
+  const inquiryForm = server.create("form", { slug: "inquiry" });
+  const inquiryAnswerForm = server.create("form", { slug: "inquiry-answer" });
+
+  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",
+  });
+
+  server.create("question", {
+    slug: "inquiry-answer-status",
+    type: "CHOICE",
+    formIds: [inquiryAnswerForm.id],
+    isRequired: "true",
+    label: "Status",
+    options: [
+      server.create("option", {
+        slug: "inquiry-answer-status-positive",
+        label: "Positive",
+      }),
+      server.create("option", {
+        slug: "inquiry-answer-status-negative",
+        label: "Negative",
+      }),
+      server.create("option", {
+        slug: "inquiry-answer-status-needs-interaction",
+        label: "Needs interaction",
+      }),
+    ],
+  });
+  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(
+  server,
+  distributionCase,
+  { from, to, remark, deadline },
+  workItemAttrs = {}
+) {
+  const document = server.create("document", { formId: "inquiry" });
+
+  server.create("answer", {
+    document,
+    questionId: "inquiry-remark",
+    value: remark ?? faker.lorem.paragraph(),
+  });
+
+  server.create("answer", {
+    document,
+    questionId: "inquiry-deadline",
+    value: deadline ?? faker.date.future(),
+  });
+
+  return server.create("work-item", {
+    taskId: "inquiry",
+    document,
+    status: "SUSPENDED",
+    case: distributionCase,
+    addressedGroups: [to.id],
+    controllingGroups: [from.id],
+    ...workItemAttrs,
+  });
+}
+
+export function sendInquiry(server, { inquiry }) {
+  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",
+    case: childCase,
+    addressedGroups: inquiry.addressedGroups,
+  });
+
+  inquiry.update({ status: "READY", childCase });
+
+  return inquiry;
+}
+
+export function answerInquiry(server, { inquiry, status, reason }) {
+  if (inquiry.status !== "READY") {
+    inquiry = sendInquiry(server, { inquiry });
+  }
+
+  server.create("answer", {
+    document: inquiry.childCase.document,
+    questionId: "inquiry-answer-status",
+    value: status,
+  });
+
+  server.create("answer", {
+    document: inquiry.childCase.document,
+    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", {
+    status: "RUNNING",
+    workflowId: "distribution",
+  });
+
+  const g = groups[0];
+  const g1 = groups[1];
+  const g2 = groups[2];
+  const g3 = groups[3];
+  const g4 = groups[4];
+
+  const create = (...args) => createInquiry(server, distributionCase, ...args);
+  const send = (...args) => sendInquiry(server, ...args);
+  const answer = (...args) => answerInquiry(server, ...args);
+  const confirm = (...args) => confirmInquiry(...args);
+  const revise = (...args) => reviseInquiry(server, ...args);
+
+  // controlling
+  create({ from: g, to: g1 });
+  send({
+    inquiry: create({
+      from: g,
+      to: g2,
+      deadline: faker.date.past(),
+    }),
+  });
+  confirm({
+    inquiry: answer({
+      inquiry: create({
+        from: g,
+        to: g3,
+        deadline: faker.date.past(),
+      }),
+      status: "inquiry-answer-status-needs-interaction",
+    }),
+  });
+
+  // "override" third controlling inquiry
+  confirm({
+    inquiry: answer({
+      inquiry: create({ from: g, to: g3 }, { createdAt: faker.date.recent() }),
+      status: "inquiry-answer-status-positive",
+    }),
+  });
+
+  // addressed
+  confirm({
+    inquiry: answer({
+      inquiry: create({ from: g2, to: g }),
+      status: "inquiry-answer-status-needs-interaction",
+    }),
+  });
+  // "override" first addressed inquiry
+  send({
+    inquiry: create(
+      {
+        from: g2,
+        to: g,
+        deadline: moment.utc().add(2, "days").toDate(),
+      },
+      { createdAt: faker.date.recent() }
+    ),
+  });
+  confirm({
+    inquiry: answer({
+      inquiry: create({ from: g4, to: g }),
+      status: "inquiry-answer-status-negative",
+    }),
+  });
+  answer({
+    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
+  confirm({
+    inquiry: answer({
+      inquiry: create({ from: g2, to: g3 }),
+      status: "inquiry-answer-status-needs-interaction",
+    }),
+  });
+  confirm({
+    inquiry: answer({
+      inquiry: create({ from: g3, to: g4 }),
+      status: "inquiry-answer-status-positive",
+    }),
+  });
+}

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

@@ -3,6 +3,8 @@ import faker from "faker";
 import moment from "moment";
 
 export default Factory.extend({
+  id: () => faker.datatype.uuid(),
+
   afterCreate(answer, server) {
     if (!answer.question) {
       return;

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

@@ -1,11 +1,12 @@
 import { Factory } from "ember-cli-mirage";
 import faker from "faker";
 
-const STATUS = ["RUNNING", "COMPLETED", "CANCELED"];
+const STATUS = ["RUNNING", "COMPLETED", "CANCELED", "SUSPENDED"];
 
 export default Factory.extend({
-  createdByUser: faker.datatype.uuid(),
-  createdAt: faker.date.past(),
-  modifiedAt: faker.date.past(),
-  status: faker.random.arrayElement(STATUS),
+  id: () => faker.datatype.uuid(),
+  createdByUser: () => faker.datatype.uuid(),
+  createdAt: () => faker.date.past(),
+  modifiedAt: () => faker.date.past(),
+  status: () => faker.random.arrayElement(STATUS),
 });

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

@@ -1,3 +1,6 @@
 import { Factory } from "ember-cli-mirage";
+import faker from "faker";
 
-export default Factory.extend({});
+export default Factory.extend({
+  id: () => faker.datatype.uuid(),
+});

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

@@ -2,11 +2,12 @@ import { Factory } from "ember-cli-mirage";
 import faker from "faker";
 
 export default Factory.extend({
-  createdAt: faker.date.past(),
-  modifiedAt: faker.date.past(),
-  createdByUser: faker.datatype.uuid(),
-  uploadUrl: faker.internet.url(),
-  downloadUrl: faker.internet.url(),
+  id: () => faker.datatype.uuid(),
+  createdAt: () => faker.date.past(),
+  modifiedAt: () => faker.date.past(),
+  createdByUser: () => faker.datatype.uuid(),
+  uploadUrl: () => faker.internet.url(),
+  downloadUrl: () => faker.internet.url(),
 
   afterCreate(file) {
     /*

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

@@ -2,6 +2,9 @@ import { Factory } from "ember-cli-mirage";
 import faker from "faker";
 
 export default Factory.extend({
+  id() {
+    return this.slug;
+  },
   name: (i) => `Form #${i + 1}`,
   slug: (i) => `form-${i + 1}`,
   description: () => faker.lorem.paragraph(),

package/addon-mirage-support/factories/format-validator.js

@@ -2,6 +2,9 @@ import { Factory } from "ember-cli-mirage";
 import faker from "faker";
 
 export default Factory.extend({
+  id() {
+    return this.slug;
+  },
   name: (i) => `Validator #${i + 1}`,
   slug: (i) => `validator-${i + 1}`,
   errorMsg: () => faker.lorem.paragraph(),

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

@@ -1,6 +1,9 @@
 import { Factory } from "ember-cli-mirage";
 
 export default Factory.extend({
+  id() {
+    return this.slug;
+  },
   slug: (i) => `option-${i + 1}`,
   label: (i) => `Option ${i + 1}`,
   meta: () => ({}),

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

@@ -2,6 +2,10 @@ import { Factory } from "ember-cli-mirage";
 import faker from "faker";
 
 export default Factory.extend({
+  id() {
+    return this.slug;
+  },
+
   type: "TEXT",
 
   slug: (i) => `question-${i + 1}`,
@@ -18,6 +22,11 @@ export default Factory.extend({
           maxLength: faker.datatype.number({ min: 1, max: 255 }),
         });
       }
+      if (question.minLength === undefined) {
+        question.update({
+          minLength: faker.datatype.number({ min: 1, max: 10 }),
+        });
+      }
     } else if (["INTEGER", "FLOAT"].includes(question.type)) {
       if (question.minValue === undefined) {
         question.update({
@@ -69,6 +78,16 @@ export default Factory.extend({
           staticContent: (i) => `static-${i + 1}`,
         });
       }
+    } else if (question.type === "ACTION_BUTTON") {
+      if (question.action === undefined) {
+        question.update({ action: "COMPLETE" });
+      }
+      if (question.color === undefined) {
+        question.update({ color: "PRIMARY" });
+      }
+      if (question.validateOnEnter === undefined) {
+        question.update({ validateOnEnter: false });
+      }
     }
   },
 });

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

@@ -1,12 +1,13 @@
 import { Factory } from "ember-cli-mirage";
 import faker from "faker";
 
-const TYPES = ["SIMPLE", "COMPLETE_WORKFLOW_FORM", "COMPLETE_TASK_FORM"];
-
 export default Factory.extend({
+  id() {
+    return this.slug;
+  },
   name: (i) => `Task #${i + 1}`,
   slug: (i) => `task-${i + 1}`,
-  type: faker.random.arrayElement(TYPES),
-  createdByUser: faker.datatype.uuid(),
-  createdAt: faker.date.past(),
+  type: "SIMPLE",
+  createdByUser: () => faker.datatype.uuid(),
+  createdAt: () => faker.date.past(),
 });

package/addon-mirage-support/factories/work-item.js

@@ -1,13 +1,15 @@
 import { Factory } from "ember-cli-mirage";
 import faker from "faker";
 
-const STATUS = ["READY", "CANCELED", "COMPLETED", "SKIPPED"];
+const STATUS = ["READY", "CANCELED", "COMPLETED", "SKIPPED", "SUSPENDED"];
 
 export default Factory.extend({
-  createdByUser: faker.datatype.uuid(),
-  createdAt: faker.date.past(),
-  deadline: faker.date.future(),
-  status: faker.random.arrayElement(STATUS),
+  id: () => faker.datatype.uuid(),
+  name: () => faker.lorem.words(5),
+  createdByUser: () => faker.datatype.uuid(),
+  createdAt: () => faker.date.past(),
+  deadline: () => faker.date.future(),
+  status: () => faker.random.arrayElement(STATUS),
   addressedGroups: () => ["group1", "group2"],
   closedAt() {
     return STATUS.filter((s) => s !== "READY").includes(this.status)

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/document.js

@@ -4,4 +4,5 @@ export default Model.extend({
   form: belongsTo(),
   answers: hasMany(),
   case: belongsTo(),
+  workItem: belongsTo(),
 });

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(),
-  defaultAnswer: belongsTo("answer"),
+  subForm: belongsTo("form", { inverse: null }),
+  rowForm: belongsTo("form", { inverse: null }),
+  defaultAnswer: belongsTo("answer", { inverse: null }),
 });

package/addon-mirage-support/models/work-item.js

@@ -2,5 +2,7 @@ import { Model, belongsTo } from "ember-cli-mirage";
 
 export default Model.extend({
   case: belongsTo(),
+  childCase: belongsTo("case", { inverse: "parentWorkItem" }),
   task: belongsTo(),
+  document: belongsTo(),
 });

package/index.js

@@ -15,6 +15,6 @@ module.exports = {
       destDir: "mirage",
     });
 
-    return mergeTrees([appTree, mirageTree]);
+    return mergeTrees([appTree, mirageTree].filter(Boolean));
   },
 };

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@projectcaluma/ember-testing",
-  "version": "9.0.0",
+  "version": "10.2.0-beta.1",
   "description": "Ember addon for testing with Caluma addons.",
   "keywords": [
     "ember-addon"
   ],
   "license": "LGPL-3.0-or-later",
+  "homepage": "https://docs.caluma.io/ember-caluma",
+  "repository": "github:projectcaluma/ember-caluma",
   "scripts": {
     "test": "npm-run-all test:*",
     "test:ember": "ember test",
@@ -15,23 +17,25 @@
     "broccoli-funnel": "^3.0.8",
     "broccoli-merge-trees": "^4.2.0",
     "ember-apollo-client": "^3.2.0",
-    "ember-auto-import": "^2.2.0",
-    "ember-cli-babel": "^7.26.6",
-    "ember-cli-htmlbars": "^5.7.1",
+    "ember-auto-import": "^2.2.3",
+    "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.5.3",
+    "graphql": "^15.8.0",
     "graphql-iso-date": "^3.6.1",
     "graphql-tools": "^4.0.8",
     "moment": "^2.29.1"
   },
   "devDependencies": {
     "@ember/optional-features": "2.0.0",
-    "@ember/test-helpers": "2.4.2",
-    "@embroider/test-setup": "0.44.1",
+    "@ember/test-helpers": "2.6.0",
+    "@embroider/test-setup": "0.49.0",
     "broccoli-asset-rev": "3.0.0",
-    "ember-cli": "3.28.0",
+    "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",
     "ember-cli-sri": "2.1.1",
@@ -40,20 +44,20 @@
     "ember-export-application-global": "2.0.1",
     "ember-load-initializers": "2.1.2",
     "ember-maybe-import-regenerator": "1.0.0",
-    "ember-qunit": "5.1.4",
+    "ember-qunit": "5.1.5",
     "ember-resolver": "8.0.3",
-    "ember-source": "3.28.1",
+    "ember-source": "3.28.8",
     "ember-source-channel-url": "3.0.0",
-    "ember-try": "1.4.0",
+    "ember-try": "2.0.0",
     "get-graphql-schema": "2.1.2",
-    "graphql-tag": "2.12.5",
+    "graphql-tag": "2.12.6",
     "loader.js": "4.7.0",
-    "qunit": "2.17.1",
+    "qunit": "2.17.2",
     "qunit-dom": "2.0.0",
-    "webpack": "5.52.1"
+    "webpack": "5.65.0"
   },
   "engines": {
-    "node": "10.* || >= 12"
+    "node": "12.* || 14.* || >= 16"
   },
   "ember": {
     "edition": "octane"

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

@@ -1,9 +0,0 @@
-import { register } from "@projectcaluma/ember-testing/mirage-graphql";
-import BaseMock from "@projectcaluma/ember-testing/mirage-graphql/mocks/base";
-
-export default class extends BaseMock {
-  @register("Case")
-  handleCase({ __typename }) {
-    return { __typename };
-  }
-}

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

@@ -1,55 +0,0 @@
-import { classify } from "@ember/string";
-
-import { register } from "@projectcaluma/ember-testing/mirage-graphql";
-import BaseMock from "@projectcaluma/ember-testing/mirage-graphql/mocks/base";
-
-export default class extends BaseMock {
-  @register("Task")
-  handleTask(root, vars, ...args) {
-    const serialized = this.handle.fn.call(this, root, vars);
-
-    let taskId =
-      root.taskId || (root.node && root.node(root, vars, ...args).id);
-
-    try {
-      taskId = atob(taskId).split(":")[1];
-    } catch (e) {
-      // pass
-    }
-
-    let __typename = root.__typename;
-
-    if (taskId) {
-      __typename = `${classify(
-        this.collection.findBy({ id: taskId }).type.toLowerCase()
-      )}Task`;
-    }
-
-    return { ...serialized, __typename };
-  }
-
-  handleInterfaceType(root, vars, _, meta) {
-    return this.handle.fn.call(
-      this,
-      root,
-      { ...vars, id: root.taskId },
-      _,
-      meta
-    );
-  }
-
-  @register("SimpleTask")
-  handleSimpleTask(...args) {
-    return this.handleInterfaceType(...args);
-  }
-
-  @register("CompleteWorkflowFormTask")
-  handleCompleteWorkflowForm(...args) {
-    return this.handleInterfaceType(...args);
-  }
-
-  @register("CompleteTaskFormTask")
-  handleCompleteTaskForm(...args) {
-    return this.handleInterfaceType(...args);
-  }
-}