apostrophe 3.5.0 → 3.8.1

package/test/extra_node_modules/improve-global/index.js

@@ -0,0 +1,7 @@
+module.exports = {
+  improve: '@apostrophecms/global',
+  options: {
+    testGlobalLevelLoaded: true,
+    testGlobalLevel: true
+  }
+};

package/test/extra_node_modules/improve-piece-type/index.js

@@ -0,0 +1,7 @@
+module.exports = {
+  improve: '@apostrophecms/piece-type',
+  options: {
+    testPieceTypeLevelLoaded: true,
+    testPieceTypeLevel: true
+  }
+};

package/test/improve-overrides.js

@@ -0,0 +1,30 @@
+const t = require('../test-lib/test.js');
+const assert = require('assert');
+
+describe('Improve Overrides', function() {
+
+  this.timeout(t.timeout);
+
+  it('"improve" should work, but project level should override it', async function() {
+    let apos;
+    try {
+      apos = await t.create({
+        root: module,
+        modules: {
+          'improve-piece-type': {},
+          'improve-global': {}
+        }
+      });
+      assert(apos.global.options.verifyProjectLevelLoaded);
+      assert.strictEqual(apos.user.options.testPieceTypeLevelLoaded, true);
+      assert.strictEqual(apos.user.options.testPieceTypeLevel, true);
+      assert.strictEqual(apos.global.options.testPieceTypeLevelLoaded, true);
+      assert.strictEqual(apos.global.options.testPieceTypeLevel, false);
+      assert.strictEqual(apos.global.options.testGlobalLevelLoaded, true);
+      assert.strictEqual(apos.global.options.testGlobalLevel, false);
+    } finally {
+      t.destroy(apos);
+    }
+  });
+
+});

package/test/job.js

@@ -0,0 +1,224 @@
+const t = require('../test-lib/test.js');
+const assert = require('assert');
+const Promise = require('bluebird');
+let apos;
+
+describe('Job module', function() {
+
+  this.timeout(t.timeout);
+
+  after(async function() {
+    return t.destroy(apos);
+  });
+
+  let jobModule;
+
+  it('should be a property of the apos object', async function() {
+    this.timeout(t.timeout);
+    this.slow(2000);
+
+    apos = await t.create({
+      root: module,
+      modules: {
+        article: {
+          extend: '@apostrophecms/piece-type'
+        }
+      }
+    });
+    jobModule = apos.modules['@apostrophecms/job'];
+    assert(apos.modules['@apostrophecms/job']);
+  });
+
+  it('has a related database collection', async function () {
+    assert(jobModule.db);
+  });
+
+  let jobOne;
+
+  it('should create a new job', async function () {
+    jobOne = await jobModule.start({});
+
+    assert(jobOne._id);
+
+    const found = await jobModule.db.findOne({ _id: jobOne._id });
+
+    assert(found);
+    assert(found.status === 'running');
+    assert(found.ended === false);
+  });
+
+  it('should end a job and mark it as successful', async function () {
+    const result = await jobModule.end(jobOne, 'success', { testing: 'testing' });
+
+    assert(result.result.nModified === 1);
+
+    const found = await jobModule.db.findOne({ _id: jobOne._id });
+
+    assert(found);
+    assert(found.status === 'completed');
+    assert(found.ended === true);
+  });
+  let jar;
+  it('should get admin jar', async () => {
+    await t.createAdmin(apos);
+
+    jar = await t.getUserJar(apos);
+
+    assert(jar);
+  });
+
+  it('should access a job via REST API GET request', async function () {
+    const job = await apos.http.get(`/api/v1/@apostrophecms/job/${jobOne._id}`, {
+      jar
+    });
+
+    assert(job._id === jobOne._id);
+  });
+
+  let articleIds;
+
+  it('can insert many test articles', async function () {
+    const req = apos.task.getReq();
+
+    const promises = [];
+
+    for (let i = 1; i <= 500; i++) {
+      promises.push(insert(req, apos.modules.article, 'article', {}, i));
+    }
+
+    const inserted = await Promise.all(promises);
+    articleIds = inserted.map(doc => doc._id);
+
+    assert(inserted.length === 500);
+    assert(!!inserted[0]._id);
+  });
+
+  let jobTwo;
+  it('can run a batch job', async function () {
+    const req = apos.task.getReq();
+
+    jobTwo = await jobModule.runBatch(
+      req,
+      articleIds,
+      async function(req, id) {
+        await apos.doc.db.updateOne({
+          _id: id
+        }, {
+          $set: {
+            checked: true
+          }
+        });
+      }
+    );
+
+    assert(!!jobTwo.jobId);
+  });
+
+  it('can follow the second job as it works', async function () {
+    const { completed } = await pollJob({
+      route: `${jobModule.action}/${jobTwo.jobId}`
+    }, {
+      jar
+    });
+
+    assert(completed === articleIds.length);
+    const index = Math.floor(Math.random() * (articleIds.length - 1));
+
+    const article = await apos.http.get(`/api/v1/article/${articleIds[index]}`, {
+      jar
+    });
+
+    assert(article.checked === true);
+  });
+
+  const logged = [];
+
+  let jobThree;
+
+  it('can run a generic job', async function () {
+    const req = apos.task.getReq();
+
+    jobThree = await jobModule.run(
+      req,
+      async function(req, reporters) {
+        let count = 1;
+        reporters.setTotal(articleIds.length);
+
+        for (const id of articleIds) {
+          await Promise.delay(3);
+          logged.push(id);
+          if (count % 2) {
+            reporters.success();
+          } else {
+            reporters.failure();
+          }
+          count++;
+        }
+      }
+    );
+
+    assert(!!jobThree.jobId);
+  });
+
+  it('can follow the third job as it works', async function () {
+    const route = `${jobModule.action}/${jobThree.jobId}`;
+    const { total } = await apos.http.get(route, { jar });
+    // Tests setTotal()
+    assert(total === articleIds.length);
+
+    const {
+      completed,
+      good,
+      bad
+    } = await pollJob({
+      route
+    }, {
+      jar
+    });
+
+    assert(completed === articleIds.length);
+    // Tests success()
+    assert(good === (articleIds.length / 2));
+    // Tests failure()
+    assert(bad === (articleIds.length / 2));
+  });
+});
+
+function padInteger (i, places) {
+  let s = i + '';
+  while (s.length < places) {
+    s = '0' + s;
+  }
+  return s;
+}
+
+async function insert (req, pieceModule, title, data, i) {
+  const docData = Object.assign(pieceModule.newInstance(), {
+    title: `${title} #${padInteger(i, 5)}`,
+    slug: `${title}-${padInteger(i, 5)}`,
+    ...data
+  });
+
+  return pieceModule.insert(req, docData);
+};
+
+async function pollJob(job, { jar }) {
+  const {
+    processed,
+    total,
+    good,
+    bad
+  } = await apos.http.get(job.route, { jar });
+
+  if (processed < total) {
+    Promise.delay(100);
+
+    return await pollJob(job, { jar });
+  } else {
+    return {
+      completed: processed,
+      good,
+      bad
+    };
+  }
+}

package/test/modules/@apostrophecms/global/index.js

@@ -0,0 +1,8 @@
+module.exports = {
+  options: {
+    verifyProjectLevelLoaded: true,
+    // Verify we can override these
+    testPieceTypeLevel: false,
+    testGlobalLevel: false
+  }
+};

package/test/modules/fragment-all/views/aux-test.html

@@ -0,0 +1,7 @@
+{% extends data.outerLayout %}
+
+{% import "fragment.html" as fragment %}
+
+{% block main %}
+{% render fragment.auxTest('Gee Whiz') %}
+{% endblock %}

package/test/modules/fragment-all/views/fragment.html

@@ -28,3 +28,8 @@
 {% fragment _print(text) %}
   {{ text }}
 {% endfragment %}
+
+{% fragment auxTest(s) %}
+  {{ apos.util.slugify(s) }}
+  {{ __t('apostrophe:modifyOrDelete') }}
+{% endfragment %}

package/test/package.json

@@ -1,10 +1,11 @@
-
 {
   "name": "test",
   "dependencies": {
-    "apostrophe": "^3.0.0"
+    "apostrophe": "^3.0.0",
+    "improve-global": "1.0.0",
+    "improve-piece-type": "1.0.0"
   },
   "devDependencies": {
-    "test-bundle": {}
-    }
+    "test-bundle": "1.0.0"
+  }
 }

package/test/pieces.js

@@ -768,6 +768,23 @@ describe('Pieces', function() {
     relatedArticleId = response._articles[0]._id;
   });
 
+  it('can GET a single product using projections', async () => {
+    const response = await apos.http.get(`/api/v1/product/${relatedProductId}`, {
+      qs: {
+        project: {
+          _id: 1,
+          title: 1
+        }
+      }
+    });
+
+    const keys = Object.keys(response);
+
+    assert(response);
+    assert(keys.length === 2);
+    assert(keys.every((key) => [ '_id', 'title' ].includes(key)));
+  });
+
   it('can GET a single article with reverse relationships', async () => {
     const response = await apos.http.get(`/api/v1/article/${relatedArticleId}`);
     assert(response);
@@ -1246,4 +1263,21 @@ describe('Pieces', function() {
     assert(fs.readFileSync(path.join(__dirname, 'public', resume.attachment._url), 'utf8') === fs.readFileSync(path.join(__dirname, '/public/static-test.txt'), 'utf8'));
   });
 
+  it('should convert a piece keeping only the present fields', async () => {
+    const req = apos.task.getReq();
+
+    const inputPiece = {
+      title: 'new product name'
+    };
+
+    const existingPiece = {
+      color: 'red'
+    };
+
+    await apos.modules.product.convert(req, inputPiece, existingPiece, { presentFieldsOnly: true });
+
+    assert(Object.keys(existingPiece).length === 2);
+    assert(existingPiece.title === 'new product name');
+    assert(existingPiece.color === 'red');
+  });
 });

package/test/reverse-relationship.js

@@ -0,0 +1,170 @@
+// Bug report that motivated these tests:
+//
+// If products are related to salespeople, and salespeople have a reverse relationship
+// back to products allowing that relationship to be viewed from the other end, everything
+// works.
+//
+// But if products are also related to locations, the reverse relationship back from
+// salespeople stops working.
+
+const t = require('../test-lib/test.js');
+const assert = require('assert');
+
+describe('Basic reverse relationships', function() {
+
+  this.timeout(t.timeout);
+
+  it('basic reverse relationship query works', async function () {
+    let apos;
+    try {
+      apos = await t.create({
+        root: module,
+        modules: {
+          product: {
+            options: {
+              alias: 'product'
+            },
+            extend: '@apostrophecms/piece-type',
+            fields: {
+              add: {
+                _salespeople: {
+                  type: 'relationship',
+                  withType: 'salesperson'
+                }
+              }
+            }
+          },
+          salesperson: {
+            options: {
+              alias: 'salesperson'
+            },
+            extend: '@apostrophecms/piece-type',
+            fields: {
+              add: {
+                _products: {
+                  type: 'relationshipReverse',
+                  withType: 'product',
+                  reverseOf: '_salespeople'
+                }
+              }
+            }
+          }
+        }
+      });
+
+      const req = apos.task.getReq();
+      const salesperson = await apos.salesperson.insert(req, {
+        title: 'Willie Loman'
+      });
+      await apos.salesperson.insert(req, {
+        title: 'Bernie Sanders'
+      });
+      await apos.product.insert(req, {
+        title: 'Soap',
+        _salespeople: [ salesperson ]
+      });
+      await apos.product.insert(req, {
+        title: 'Rope'
+      });
+      const fetched = await apos.salesperson.find(req, {
+        title: 'Willie Loman'
+      }).toObject();
+      assert(fetched);
+      assert.strictEqual(fetched.title, 'Willie Loman');
+      assert(fetched._products);
+      assert.strictEqual(fetched._products.length, 1);
+      assert.strictEqual(fetched._products[0].title, 'Soap');
+    } finally {
+      if (apos) {
+        await t.destroy(apos);
+      }
+    }
+  });
+});
+
+describe('Reverse relationships plus an extra relationship', function() {
+
+  this.timeout(t.timeout);
+
+  it('basic reverse relationship query works in the presence of an extra relationship with the types configured in an unexpected order', async function () {
+    let apos;
+    try {
+      apos = await t.create({
+        root: module,
+        modules: {
+          salesperson: {
+            options: {
+              alias: 'salesperson'
+            },
+            extend: '@apostrophecms/piece-type',
+            fields: {
+              add: {
+                _products: {
+                  type: 'relationshipReverse',
+                  withType: 'product',
+                  reverseOf: '_salespeople'
+                }
+              }
+            }
+          },
+          location: {
+            options: {
+              alias: 'location'
+            },
+            extend: '@apostrophecms/piece-type'
+          },
+          product: {
+            options: {
+              alias: 'product'
+            },
+            extend: '@apostrophecms/piece-type',
+            fields: {
+              add: {
+                _salespeople: {
+                  type: 'relationship',
+                  withType: 'salesperson'
+                },
+                _location: {
+                  type: 'relationship',
+                  withType: 'location'
+                }
+              }
+            }
+          }
+        }
+      });
+
+      const req = apos.task.getReq();
+      const salesperson = await apos.salesperson.insert(req, {
+        title: 'Willie Loman'
+      });
+      await apos.salesperson.insert(req, {
+        title: 'Bernie Sanders'
+      });
+      await apos.product.insert(req, {
+        title: 'Soap',
+        _salespeople: [ salesperson ]
+      });
+      await apos.product.insert(req, {
+        title: 'Rope'
+      });
+      const fetched = await apos.salesperson.find(req, {
+        title: 'Willie Loman'
+      }).toObject();
+      const soap = await apos.product.find(req, {
+        title: 'Soap'
+      }).toObject();
+      assert(fetched);
+      assert.strictEqual(fetched.title, 'Willie Loman');
+      assert(fetched._products);
+      assert.strictEqual(fetched._products.length, 1);
+      assert.strictEqual(fetched._products[0].title, 'Soap');
+      assert.strictEqual(soap.title, 'Soap');
+      assert.strictEqual(soap._salespeople[0].title, 'Willie Loman');
+    } finally {
+      if (apos) {
+        await t.destroy(apos);
+      }
+    }
+  });
+});

package/test/templates.js

@@ -182,7 +182,6 @@ describe('Templates', function() {
   it('should render fragments containing async components correctly', async () => {
     const req = apos.task.getReq();
     const result = await apos.modules['fragment-page'].renderPage(req, 'page');
-
     const aboveFragment = result.indexOf('Above Fragment');
     const beforeComponent = result.indexOf('Before Component');
     const componentText = result.indexOf('Component Text');
@@ -295,4 +294,11 @@ describe('Templates', function() {
     ]);
   });
 
+  it('should support apos helpers and localization in fragments', async () => {
+    const req = apos.task.getReq();
+    const result = await apos.modules['fragment-all'].renderPage(req, 'aux-test');
+    assert(result.includes('gee-whiz'));
+    assert(result.includes('Modify / Delete'));
+  });
+
 });

package/test-lib/test.js

@@ -1,9 +1,16 @@
 const fs = require('fs-extra');
 const path = require('path');
 
-fs.removeSync(path.join(__dirname, '/../test/node_modules'));
-fs.mkdirSync(path.join(__dirname, '/../test/node_modules'));
-fs.symlinkSync(path.join(__dirname, '/..'), path.join(__dirname, '/../test/node_modules/apostrophe'), 'dir');
+const testNodeModules = path.join(__dirname, '/../test/node_modules');
+fs.removeSync(testNodeModules);
+fs.mkdirSync(testNodeModules);
+fs.symlinkSync(path.join(__dirname, '/..'), path.join(testNodeModules, 'apostrophe'), 'dir');
+
+const extras = path.join(__dirname, '../test/extra_node_modules');
+const dirs = fs.existsSync(extras) ? fs.readdirSync(extras) : [];
+for (const dir of dirs) {
+  fs.symlinkSync(path.join(extras, dir), path.join(testNodeModules, dir), 'dir');
+}
 
 // Need a "project level" package.json for functionality that checks
 // whether packages in node_modules are project level or not
@@ -12,15 +19,19 @@ const packageJson = path.join(__dirname, '/../test/package.json');
 // Remove it first, in case it's the old-style symlink to the main package.json,
 // which would break
 fs.removeSync(packageJson);
-fs.writeFileSync(packageJson, `
-{
-  "name": "test",
-  "dependencies": {
-    "apostrophe": "^3.0.0"
+const packageJsonInfo = {
+  name: 'test',
+  dependencies: {
+    apostrophe: '^3.0.0'
   },
-  "devDependencies": {
-    "test-bundle": {}
-    }
-}`);
+  devDependencies: {
+    'test-bundle': '1.0.0'
+  }
+};
+for (const dir of dirs) {
+  packageJsonInfo.dependencies[dir] = '1.0.0';
+}
+
+fs.writeFileSync(packageJson, JSON.stringify(packageJsonInfo, null, '  '));
 
 module.exports = require('./util.js');

package/test-lib/util.js

@@ -37,6 +37,7 @@ async function create(options) {
       _: [],
       'ignore-orphan-modules': true
     },
+    test: true,
     autoBuild: false,
     ...options
   };
@@ -56,8 +57,40 @@ async function create(options) {
   return require('../index.js')(config);
 }
 
+// Create an admin user. By default the username and password are both 'admin'
+async function createAdmin(apos, { username, password } = {}) {
+  const user = apos.user.newInstance();
+  const name = username || 'admin';
+
+  user.title = name;
+  user.username = name;
+  user.password = password || 'admin';
+  user.email = `${name}@admin.io`;
+  user.role = 'admin';
+
+  return await apos.user.insert(apos.task.getReq(), user);
+}
+
+async function getUserJar(apos, { username, password } = {}) {
+  const jar = apos.http.jar();
+
+  // Log in
+  await apos.http.post('/api/v1/@apostrophecms/login/login', {
+    body: {
+      username: username || 'admin',
+      password: password || 'admin',
+      session: true
+    },
+    jar
+  });
+
+  return jar;
+}
+
 module.exports = {
   destroy,
   create,
+  createAdmin,
+  getUserJar,
   timeout: (process.env.TEST_TIMEOUT && parseInt(process.env.TEST_TIMEOUT)) || 20000
 };