Merge pull request #12 from Meteor-Community-Packages/fix/dev-tools

fix(deps/tests): upgrade tests to support Meteor 2 + 3

Author: jankapunkt

.eslintignore

@@ -1,3 +1,7 @@
 node_modules
 .meteor
 package.js
+.meteor
+.npm
+packages/
+tests/

package-lock.json

@@ -5,15 +5,16 @@
     "lint": "eslint ."
   },
   "devDependencies": {
-    "babel-cli": "^6.26.0",
-    "babel-eslint": "^8.2.1",
+    "@babel/core": "^7.26.0",
+    "@babel/eslint-parser": "^7.25.9",
     "eslint": "^8.56.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-plugin-import": "^2.29.1"
   },
+  "babel": {},
   "eslintConfig": {
     "extends": "airbnb-base",
-    "parser": "babel-eslint",
+    "parser": "@babel/eslint-parser",
     "env": {
       "browser": true,
       "jest": true

package.json

@@ -1,9 +1,8 @@
+/* global Collection2 */
 // collection2 checks to make sure that simpl-schema package is added
-import 'meteor/aldeed:collection2/dynamic';
+import 'meteor/aldeed:collection2/static';
 import SimpleSchema from 'meteor/aldeed:simple-schema';
 
-Collection2.load();
-
 // Extend the schema options allowed by SimpleSchema
 SimpleSchema.extendOptions(['denyInsert', 'denyUpdate']);
 
@@ -21,7 +20,6 @@ Collection2.on('schema.attached', (collection, ss) => {
     if (!this.isSet) return;
 
     const def = this.definition;
-
     if (def.denyInsert && this.isInsert) return 'insertNotAllowed';
     if (def.denyUpdate && (this.isUpdate || this.isUpsert)) return 'updateNotAllowed';
   });

package/deny/deny.js

@@ -1,5 +1,5 @@
-aldeed:collection2@4.0.0
-aldeed:schema-deny@4.0.0
+aldeed:collection2@4.0.4
+aldeed:schema-deny@4.0.2
 aldeed:simple-schema@1.13.1
 allow-deny@1.1.1
 autopublish@1.0.7

tests/.meteor/versions

@@ -1,4 +1,4 @@
-import expect from 'expect';
+import { expect } from 'chai';
 import { Mongo } from 'meteor/mongo';
 import SimpleSchema from 'meteor/aldeed:simple-schema';
 
@@ -17,52 +17,109 @@ test.attachSchema(new SimpleSchema({
 }));
 
 describe('deny', () => {
-  it('denyInsert', (done) => {
-    test.insert({
-      denyInsert: 'foo',
-    }, (error) => {
-      expect(error && error.message).toBe('Deny insert cannot be set during an insert in test insert');
-
+  describe('denyInsert', () => {
+    const evaluateInsert = ({ error, message }) => {
+      expect(error && error.message).to.equal(message);
       const validationErrors = test.simpleSchema().namedContext().validationErrors();
-      expect(validationErrors.length).toBe(1);
-
+      expect(validationErrors.length).to.equal(1);
       const key = validationErrors[0] || {};
-      expect(key.name).toBe('denyInsert');
-      expect(key.type).toBe('insertNotAllowed');
+      expect(key.name).to.equal('denyInsert');
+      expect(key.type).to.equal('insertNotAllowed');
+    };
 
-      done();
+    it('denies insert (async)', async () => {
+      try {
+        await test.insertAsync({ denyInsert: 'foo', })
+      } catch (error) {
+        evaluateInsert({ error, message: 'Deny insert cannot be set during an insert in test insertAsync' })
+      }
     });
+
+    if (Meteor.isServer) {
+      it('denies insert (sync)', () => {
+        try {
+          test.insert({ denyInsert: 'foo', });
+        } catch (error) {
+          evaluateInsert({ error, message: 'Deny insert cannot be set during an insert in test insert' })
+        }
+      });
+    }
+    if (Meteor.isClient) {
+      it('denies insert (sync)', (done) => {
+        test.insert({ denyInsert: 'foo', }, error => {
+          evaluateInsert({ error, message: 'Deny insert cannot be set during an insert in test insert' })
+          done()
+        });
+      });
+    }
   });
 
-  it('denyUpdate', (done) => {
-    test.insert({
-      denyUpdate: 'foo',
-    }, (err, newId) => {
-      expect(typeof newId).toBe('string');
+  describe('denyUpdate', () => {
+    const evaluateUpdate = ({ error, message }) => {
+      expect(error && error.message).to.equal(message);
+
+      const validationErrors = test.simpleSchema().namedContext().validationErrors();
+      expect(validationErrors.length).to.equal(1);
+
+      const key = validationErrors[0] || {};
+      expect(key.name).to.equal('denyUpdate');
+      expect(key.type).to.equal('updateNotAllowed');
+    }
+
+    it('denies update (async)', async () => {
+      const newId = await test.insertAsync({ denyUpdate: 'foo' });
+      try {
+        await test.updateAsync(newId, { $set: {
+            denyUpdate: 'foo',
+          },
+        })
+      } catch (error) {
+        evaluateUpdate({ error, message: 'Deny update cannot be set during an update in test updateAsync' })
+      }
 
-      test.update(newId, {
+      // valid use case
+      // Now test valid case
+      await test.updateAsync(newId, {
         $set: {
-          denyUpdate: 'foo',
+          denyInsert: 'foo',
         },
-      }, (error) => {
-        expect(error && error.message).toBe('Deny update cannot be set during an update in test update');
+      })
+    });
 
-        const validationErrors = test.simpleSchema().namedContext().validationErrors();
-        expect(validationErrors.length).toBe(1);
+    it('denyUpdate', (done) => {
+      test.insert({
+        denyUpdate: 'foo',
+      }, (err, newId) => {
+        expect(typeof newId).to.equal('string');
 
-        const key = validationErrors[0] || {};
-        expect(key.name).toBe('denyUpdate');
-        expect(key.type).toBe('updateNotAllowed');
+        try {
+          test.update(newId, {
+            $set: {
+              denyUpdate: 'foo',
+            },
+          }, (error) => {
+            expect(error && error.message).to.equal('Deny update cannot be set during an update in test update');
 
-        // Now test valid case
-        test.update(newId, {
-          $set: {
-            denyInsert: 'foo',
-          },
-        }, (e) => {
-          expect(!!e).toBe(false);
-          done();
-        });
+            const validationErrors = test.simpleSchema().namedContext().validationErrors();
+            expect(validationErrors.length).to.equal(1);
+
+            const key = validationErrors[0] || {};
+            expect(key.name).to.equal('denyUpdate');
+            expect(key.type).to.equal('updateNotAllowed');
+
+            // Now test valid case
+            test.update(newId, {
+              $set: {
+                denyInsert: 'foo',
+              },
+            }, (e) => {
+              expect(!!e).to.equal(false);
+              done();
+            });
+          });
+        } catch (error) {
+
+        }
       });
     });
   });