Attempt to make tests more consistent

.meteor/packages

@@ -75,13 +75,14 @@ tmeasday:publish-counts
 vsivsi:job-collection
 react-meteor-data
 percolate:migrations
-johanbrook:[email protected]
+
 
 # Testing packages
 dburles:factory
 dispatch:mocha
 practicalmeteor:chai
 practicalmeteor:sinon
+johanbrook:publication-collector
 
 # Performance & Debugging Tools
 # meteorhacks:fast-render                   # improve initial page loads

imports/plugins/core/discounts/server/methods/methods.app-test.js

@@ -40,6 +40,7 @@ describe("discounts methods", function () {
     // });
 
     it("should delete rate with discounts permission", function (done) {
+      this.timeout(5000);
       sandbox.stub(Roles, "userIsInRole", () => true);
       const discountInsertSpy = sandbox.spy(Discounts, "insert");
       const discountId = Meteor.call("discounts/addRate", rate);

imports/plugins/included/inventory/server/hooks/hooks.js

@@ -88,7 +88,6 @@ Products.after.insert((userId, doc) => {
   if (doc.type !== "variant") {
     return false;
   }
-  // Meteor.call("inventory/register", doc);
   registerInventory(doc);
 });
 

imports/plugins/included/inventory/server/hooks/inventory-hooks.app-test.js

@@ -1,49 +1,43 @@
 /* eslint dot-notation: 0 */
 import { Meteor } from "meteor/meteor";
-import { Inventory, Orders, Cart }  from "/lib/collections";
-import { Reaction, Logger } from "/server/api";
+import { Inventory, Orders, Products }  from "/lib/collections";
+import { Reaction } from "/server/api";
 import { expect } from "meteor/practicalmeteor:chai";
 import { sinon } from "meteor/practicalmeteor:sinon";
 import Fixtures from "/server/imports/fixtures";
-import { getShop } from "/server/imports/fixtures/shops";
+import { createCart } from "/server/imports/fixtures/cart";
+import { addProductSingleVariant } from "/server/imports/fixtures/products";
+import { registerInventory } from "../methods/inventory";
 
 Fixtures();
 
-function reduceCart(cart) {
-  Cart.update(cart._id, {
-    $set: {
-      "items.0.quantity": 1
-    }
-  });
-  Cart.update(cart._id, {
-    $set: {
-      "items.1.quantity": 1
-    }
-  });
-  Cart.update(cart._id, {
-    $pull: {
-      "items.$.quantity": { $gt: 1 }
-    }
-  });
+
+function resetInventory() {
+  Inventory.remove({});
+  const products = Products.find().fetch();
+  for (let product of products) {
+    registerInventory(product);
+  }
 }
 
 describe("Inventory Hooks", function () {
+  this.timeout(50000);
   let originals;
   let sandbox;
+  let cart;
 
   before(function () {
     originals = {
-      mergeCart: Meteor.server.method_handlers["cart/mergeCart"],
-      createCart: Meteor.server.method_handlers["cart/createCart"],
-      copyCartToOrder: Meteor.server.method_handlers["cart/copyCartToOrder"],
-      addToCart: Meteor.server.method_handlers["cart/addToCart"],
-      setShipmentAddress: Meteor.server.method_handlers["cart/setShipmentAddress"],
-      setPaymentAddress: Meteor.server.method_handlers["cart/setPaymentAddress"]
+      copyCartToOrder: Meteor.server.method_handlers["cart/copyCartToOrder"]
     };
   });
 
   beforeEach(function () {
     sandbox = sinon.sandbox.create();
+    Products.direct.remove({});
+    const { product, variant } = addProductSingleVariant();
+    cart = createCart(product._id, variant._id);
+    resetInventory();
   });
 
   afterEach(function () {
@@ -61,27 +55,20 @@ describe("Inventory Hooks", function () {
   it("should move allocated inventory to 'sold' when an order is created", function () {
     sandbox.stub(Meteor.server.method_handlers, "orders/sendNotification", function () {
       check(arguments, [Match.Any]);
-      Logger.warn("running stub notification");
       return true;
     });
-    Inventory.direct.remove({});
-    const cart = Factory.create("cartToOrder");
-    reduceCart(cart);
+    sandbox.stub(Reaction, "hasPermission", () => true);
     sandbox.stub(Reaction, "getShopId", function () {
       return cart.shopId;
     });
-    const shop = getShop();
     const product = cart.items[0];
-    const inventoryItem = Inventory.insert({
+    const inventoryItem = Inventory.findOne({
       productId: product.productId,
       variantId: product.variants._id,
-      shopId: shop._id,
-      workflow: {
-        status: "reserved"
-      },
-      orderItemId: product._id
+      shopId: cart.shopId
     });
     expect(inventoryItem).to.not.be.undefined;
+    // because the cart fixture does not trigger hooks we need to allocate inventory manually
     Inventory.update(inventoryItem._id,
       {
         $set: {
@@ -94,43 +81,34 @@ describe("Inventory Hooks", function () {
     const updatedInventoryItem = Inventory.findOne({
       productId: product.productId,
       variantId: product.variants._id,
-      shopId: shop._id,
+      shopId: cart.shopId,
       orderItemId: product._id
     });
     expect(updatedInventoryItem.workflow.status).to.equal("sold");
   });
 
-  it.skip("should move allocated inventory to 'shipped' when an order is shipped", function (done) {
-    this.timeout(5000);
+  it("should move allocated inventory to 'shipped' when an order is shipped", function (done) {
     sandbox.stub(Meteor.server.method_handlers, "orders/sendNotification", function () {
       check(arguments, [Match.Any]);
-      Logger.warn("running stub notification");
       return true;
     });
     sandbox.stub(Reaction, "hasPermission", () => true);
-    Inventory.direct.remove({});
-    const cart = Factory.create("cartToOrder");
-    reduceCart(cart);
     sandbox.stub(Reaction, "getShopId", function () {
       return cart.shopId;
     });
-    const shop = getShop();
-    const product = cart.items[0];
-    const inventoryItem = Inventory.insert({
-      productId: product.productId,
-      variantId: product.variants._id,
-      shopId: shop._id,
-      workflow: {
-        status: "reserved"
-      },
-      orderItemId: product._id
+    const cartProduct = cart.items[0];
+    const inventoryItem = Inventory.findOne({
+      productId: cartProduct.productId,
+      variantId: cartProduct.variants._id,
+      shopId: cart.shopId
     });
     expect(inventoryItem).to.not.be.undefined;
+    // because the cart fixture does not trigger hooks we need to allocate inventory manuall
     Inventory.update(inventoryItem._id,
       {
         $set: {
           "workflow.status": "reserved",
-          "orderItemId": product._id
+          "orderItemId": cartProduct._id
         }
       });
     spyOnMethod("copyCartToOrder", cart.userId);

imports/plugins/included/inventory/server/methods/inventory.js

@@ -5,7 +5,12 @@ import { Inventory } from "/lib/collections";
 import * as Schemas from "/lib/collections/schemas";
 import { Logger, Reaction } from "/server/api";
 
-
+/**
+ * inventory/register
+ * @summary check a product and update Inventory collection with inventory documents.
+ * @param {Object} product - valid Schemas.Product object
+ * @return {Number} - returns the total amount of new inventory created
+ */
 export function registerInventory(product) {
   check(product, Match.OneOf(Schemas.ProductVariant, Schemas.Product));
   let type;
@@ -77,92 +82,79 @@ export function registerInventory(product) {
   return totalNewInventory;
 }
 
-Meteor.methods({
-  /**
-   * inventory/register
-   * @summary check a product and update Inventory collection with inventory documents.
-   * @param {Object} product - valid Schemas.Product object
-   * @return {Number} - returns the total amount of new inventory created
-   */
-  "inventory/register": function (product) {
-    if (!Reaction.hasPermission("createProduct")) {
-      throw new Meteor.Error(403, "Access Denied");
-    }
-    registerInventory(product);
-  },
-  /**
-   * inventory/adjust
-   * @summary adjust existing inventory when changes are made we get the
-   * inventoryQuantity for each product variant, and compare the qty to the qty
-   * in the inventory records we will add inventoryItems as needed to have the
-   * same amount as the inventoryQuantity but when deleting, we'll refuse to
-   * delete anything not workflow.status = "new"
-   *
-   * @param  {Object} product - Schemas.Product object
-   * @return {[undefined]} returns undefined
-   * @todo  should be variant
-   */
-  "inventory/adjust": function (product) {
-    check(product, Match.OneOf(Schemas.Product, Schemas.ProductVariant));
-    let type;
-    let results;
-    // adds or updates inventory collection with this product
-    switch (product.type) {
-      case "variant":
-        check(product, Schemas.ProductVariant);
-        type = "variant";
-        break;
-      default:
-        check(product, Schemas.Product);
-        type = "simple";
-    }
-    // user needs createProduct permission to adjust inventory
-    if (!Reaction.hasPermission("createProduct")) {
-      throw new Meteor.Error(403, "Access Denied");
-    }
-    // this.unblock();
+function adjustInventory(product) {
+  let type;
+  let results;
+  // adds or updates inventory collection with this product
+  switch (product.type) {
+    case "variant":
+      check(product, Schemas.ProductVariant);
+      type = "variant";
+      break;
+    default:
+      check(product, Schemas.Product);
+      type = "simple";
+  }
+  // user needs createProduct permission to adjust inventory
+  if (!Reaction.hasPermission("createProduct")) {
+    throw new Meteor.Error(403, "Access Denied");
+  }
+  // this.unblock();
 
-    // Quantity and variants of this product's variant inventory
-    if (type === "variant") {
-      const variant = {
-        _id: product._id,
-        qty: product.inventoryQuantity || 0
-      };
+  // Quantity and variants of this product's variant inventory
+  if (type === "variant") {
+    const variant = {
+      _id: product._id,
+      qty: product.inventoryQuantity || 0
+    };
 
-      const inventory = Inventory.find({
-        productId: product.ancestors[0],
-        variantId: product._id
-      });
-      const itemCount = inventory.count();
+    const inventory = Inventory.find({
+      productId: product.ancestors[0],
+      variantId: product._id
+    });
+    const itemCount = inventory.count();
 
-      if (itemCount !== variant.qty) {
-        if (itemCount < variant.qty) {
-          // we need to register some new variants to inventory
-          results = itemCount + Meteor.call("inventory/register", product);
-        } else if (itemCount > variant.qty) {
-          // determine how many records to delete
-          const removeQty = itemCount - variant.qty;
-          // we're only going to delete records that are new
-          const removeInventory = Inventory.find({
-            "variantId": variant._id,
-            "workflow.status": "new"
-          }, {
-            sort: {
-              updatedAt: -1
-            },
-            limit: removeQty
-          }).fetch();
+    if (itemCount !== variant.qty) {
+      if (itemCount < variant.qty) {
+        // we need to register some new variants to inventory
+        results = itemCount + Meteor.call("inventory/register", product);
+      } else if (itemCount > variant.qty) {
+        // determine how many records to delete
+        const removeQty = itemCount - variant.qty;
+        // we're only going to delete records that are new
+        const removeInventory = Inventory.find({
+          "variantId": variant._id,
+          "workflow.status": "new"
+        }, {
+          sort: {
+            updatedAt: -1
+          },
+          limit: removeQty
+        }).fetch();
 
-          results = itemCount;
-          // delete latest inventory "status:new" records
-          for (const inventoryItem of removeInventory) {
-            results -= Meteor.call("inventory/remove", inventoryItem);
-            // we could add handling for the case when aren't enough "new" items
-          }
-          Logger.info(`adjust variant ${variant._id} from ${itemCount} to ${results}`);
+        results = itemCount;
+        // delete latest inventory "status:new" records
+        for (const inventoryItem of removeInventory) {
+          results -= Meteor.call("inventory/remove", inventoryItem);
+          // we could add handling for the case when aren't enough "new" items
         }
       }
+      Logger.info(
+        `adjust variant ${variant._id} from ${itemCount} to ${results}`
+      );
     }
   }
+}
 
+Meteor.methods({
+  "inventory/register": function (product) {
+    if (!Reaction.hasPermission("createProduct")) {
+      throw new Meteor.Error(403, "Access Denied");
+    }
+    registerInventory(product);
+  },
+  "inventory/adjust": function (product) { // TODO: this should be variant
+    check(product, Match.OneOf(Schemas.Product, Schemas.ProductVariant));
+    adjustInventory(product);
+  }
 });

imports/plugins/included/inventory/server/startup/init.js

@@ -9,7 +9,7 @@ Hooks.Events.add("afterCoreInit", () => {
   if (!inventory) {
     const products = Products.find().fetch();
     for (const product of products) {
-      Logger.info(`Registering product ${product.title}`);
+      Logger.debug(`Registering product ${product.title}`);
       registerInventory(product);
     }
   }

imports/plugins/included/payments-example/server/methods/example-payment-methods.app-test.js

@@ -72,7 +72,10 @@ describe("Submit payment", function () {
   });
 
   it("should call Example API with card and payment data", function () {
-    this.timeout(3000);
+    // this is a ridiculous timeout for a test that should run in subseconds
+    // but a bug in the Meteor test runner (or something) seems to make this test stall
+    // it actually stalls after the entire test is completed
+    this.timeout(30000);
     const cardData = {
       name: "Test User",
       number: "4242424242424242",

private/data/Shops.json

@@ -3434,7 +3434,7 @@
     },
     "PHP": {
       "format": "%s %v",
-      "symbol": "PHP"
+      "symbol": "₱"
     },
     "PLN": {
       "format": "%s%v",

server/global.app-test.js

@@ -0,0 +1,4 @@
+before(function () {
+  this.timeout(6000);
+  Meteor._sleepForMs(500);
+});