ultimate-jekyll-manager 1.1.9 → 1.2.0

package/dist/test/suites/build/expect.test.js

@@ -0,0 +1,59 @@
+// Smoke-test the expect() implementation itself. Mirrors EM/BXM's expect.test.js.
+// If this breaks, every other test reports nonsense — verify the matchers
+// directly so the framework's own foundation can't silently rot.
+
+module.exports = {
+  layer: 'build',
+  description: 'expect() matcher set',
+  type: 'group',
+  tests: [
+    {
+      name: 'toBe + toEqual basics',
+      run: async (ctx) => {
+        ctx.expect(1).toBe(1);
+        ctx.expect({ a: 1 }).toEqual({ a: 1 });
+        ctx.expect([1, 2]).toEqual([1, 2]);
+      },
+    },
+    {
+      name: '.not negates',
+      run: async (ctx) => {
+        ctx.expect(1).not.toBe(2);
+        ctx.expect({ a: 1 }).not.toEqual({ a: 2 });
+      },
+    },
+    {
+      name: 'toContain works on arrays and strings',
+      run: async (ctx) => {
+        ctx.expect([1, 2, 3]).toContain(2);
+        ctx.expect('hello world').toContain('world');
+      },
+    },
+    {
+      name: 'toThrow catches sync + async throws',
+      run: async (ctx) => {
+        await ctx.expect(() => { throw new Error('boom'); }).toThrow('boom');
+        await ctx.expect(async () => { throw new Error('async boom'); }).toThrow(/async/);
+      },
+    },
+    {
+      name: 'toBeGreaterThan / toBeLessThan',
+      run: async (ctx) => {
+        ctx.expect(5).toBeGreaterThan(3);
+        ctx.expect(3).toBeLessThan(5);
+      },
+    },
+    {
+      name: 'failing assertions throw AssertionError',
+      run: async (ctx) => {
+        try {
+          ctx.expect(1).toBe(2);
+        } catch (e) {
+          ctx.expect(e.name).toBe('AssertionError');
+          return;
+        }
+        throw new Error('expected assertion to throw');
+      },
+    },
+  ],
+};

package/dist/test/suites/build/exports.test.js

@@ -0,0 +1,32 @@
+// Verify every entry in package.json#exports is require()-able from the built
+// dist/. Catches packaging mistakes where dist/ is missing a file referenced
+// from exports (which would explode at consumer install-time).
+//
+// We resolve relative to dist/test/runner.js — same context the framework
+// runs in.
+
+module.exports = {
+  layer: 'build',
+  description: 'package.json exports resolve to real files in dist/',
+  run: async (ctx) => {
+    const path = require('path');
+    const fs   = require('fs');
+    // distRoot is the directory containing this very test file's grandparent
+    // → dist/test/suites/build/exports.test.js → ../../../ = dist/.
+    const distRoot = path.resolve(__dirname, '..', '..', '..');
+    const pkgPath  = path.resolve(distRoot, '..', 'package.json');
+    const pkg      = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+
+    ctx.expect(typeof pkg.exports).toBe('object');
+
+    for (const [subpath, target] of Object.entries(pkg.exports)) {
+      // target is './dist/<...>.js' — verify the file exists.
+      const targetPath = path.resolve(path.dirname(pkgPath), target);
+      ctx.expect(fs.existsSync(targetPath)).toBe(true);
+    }
+
+    // Spot-check the canonical entry — require() it and verify shape.
+    const Manager = require('../../../build.js');
+    ctx.expect(typeof Manager).toBe('function');
+  },
+};

package/dist/test/suites/build/logger.test.js

@@ -0,0 +1,62 @@
+// src/lib/logger.js — the only file under src/lib/ currently. Used everywhere
+// in UJM's gulp pipeline as `Manager.logger('task-name')`. Output shape matters
+// because dev.log parsers (and humans grepping logs) depend on the `[time]
+// name: message` prefix.
+
+module.exports = {
+  layer: 'build',
+  description: 'Logger (src/lib/logger.js)',
+  type: 'group',
+  tests: [
+    {
+      name: 'Logger constructor stores name',
+      run: async (ctx) => {
+        const Logger = require('../../../lib/logger.js');
+        const log = new Logger('my-task');
+        ctx.expect(log.name).toBe('my-task');
+      },
+    },
+    {
+      name: 'Logger exposes log/error/warn/info methods',
+      run: async (ctx) => {
+        const Logger = require('../../../lib/logger.js');
+        const log = new Logger('x');
+        for (const m of ['log', 'error', 'warn', 'info']) {
+          ctx.expect(typeof log[m]).toBe('function');
+        }
+      },
+    },
+    {
+      name: 'Logger.format is chalk',
+      run: async (ctx) => {
+        const Logger = require('../../../lib/logger.js');
+        const log = new Logger('x');
+        // chalk-with-default-export exposes `red`, `green`, `cyan` etc. as functions.
+        ctx.expect(typeof log.format.red).toBe('function');
+        ctx.expect(typeof log.format.green).toBe('function');
+      },
+    },
+    {
+      name: 'Logger output goes through console with prefix',
+      run: async (ctx) => {
+        const Logger = require('../../../lib/logger.js');
+        const log = new Logger('prefix-test');
+
+        const captured = [];
+        const orig = console.log;
+        console.log = (...args) => captured.push(args);
+        try {
+          log.log('hello world');
+        } finally {
+          console.log = orig;
+        }
+
+        ctx.expect(captured.length).toBe(1);
+        const first = captured[0][0];
+        // Strip ANSI for stable assertion.
+        const plain = first.replace(/\[[0-9;]*m/g, '');
+        ctx.expect(plain).toMatch(/\[\d\d:\d\d:\d\d\] 'prefix-test':/);
+      },
+    },
+  ],
+};

package/dist/test/suites/build/manager.test.js

@@ -0,0 +1,186 @@
+// Manager static/prototype methods exposed by src/build.js.
+//
+// These are the public surface consumer projects consume through
+// `require('ultimate-jekyll-manager/build')`. Tests assert that:
+//   - Static + instance forms match (Manager.foo === Manager.prototype.foo)
+//   - Env-gated boolean checks reflect process.env correctly
+//   - getArguments + getMemoryUsage return well-shaped objects
+//   - getRootPath/getEnvironment short-circuit checks don't throw
+//
+// We DO NOT assert getConfig/getPackage/getUJMConfig here because those
+// require a Jekyll project on disk; consumer tests verify those against
+// their own project.
+
+module.exports = {
+  layer: 'build',
+  description: 'Manager (build.js) public surface',
+  type: 'group',
+  tests: [
+    {
+      name: 'Manager constructor is a function',
+      run: async (ctx) => {
+        const Manager = require('../../../build.js');
+        ctx.expect(typeof Manager).toBe('function');
+      },
+    },
+    {
+      name: 'static methods match prototype methods',
+      run: async (ctx) => {
+        const Manager = require('../../../build.js');
+        const names = ['getArguments', 'isServer', 'isBuildMode', 'isQuickMode', 'actLikeProduction', 'getEnvironment', 'getRootPath', 'getMemoryUsage', 'logger'];
+        for (const name of names) {
+          ctx.expect(typeof Manager[name]).toBe('function');
+          ctx.expect(typeof Manager.prototype[name]).toBe('function');
+          ctx.expect(Manager[name]).toBe(Manager.prototype[name]);
+        }
+      },
+    },
+    {
+      name: 'isBuildMode reflects UJ_BUILD_MODE env',
+      run: async (ctx) => {
+        const Manager = require('../../../build.js');
+        const original = process.env.UJ_BUILD_MODE;
+        try {
+          process.env.UJ_BUILD_MODE = 'true';
+          ctx.expect(Manager.isBuildMode()).toBe(true);
+          process.env.UJ_BUILD_MODE = 'false';
+          ctx.expect(Manager.isBuildMode()).toBe(false);
+          delete process.env.UJ_BUILD_MODE;
+          ctx.expect(Manager.isBuildMode()).toBe(false);
+        } finally {
+          if (original === undefined) delete process.env.UJ_BUILD_MODE;
+          else process.env.UJ_BUILD_MODE = original;
+        }
+      },
+    },
+    {
+      name: 'isQuickMode reflects UJ_QUICK env',
+      run: async (ctx) => {
+        const Manager = require('../../../build.js');
+        const original = process.env.UJ_QUICK;
+        try {
+          process.env.UJ_QUICK = 'true';
+          ctx.expect(Manager.isQuickMode()).toBe(true);
+          delete process.env.UJ_QUICK;
+          ctx.expect(Manager.isQuickMode()).toBe(false);
+        } finally {
+          if (original === undefined) delete process.env.UJ_QUICK;
+          else process.env.UJ_QUICK = original;
+        }
+      },
+    },
+    {
+      name: 'isServer reflects UJ_IS_SERVER env',
+      run: async (ctx) => {
+        const Manager = require('../../../build.js');
+        const original = process.env.UJ_IS_SERVER;
+        try {
+          process.env.UJ_IS_SERVER = 'true';
+          ctx.expect(Manager.isServer()).toBe(true);
+          delete process.env.UJ_IS_SERVER;
+          ctx.expect(Manager.isServer()).toBe(false);
+        } finally {
+          if (original === undefined) delete process.env.UJ_IS_SERVER;
+          else process.env.UJ_IS_SERVER = original;
+        }
+      },
+    },
+    {
+      name: 'getEnvironment maps server flag to environment string',
+      run: async (ctx) => {
+        const Manager = require('../../../build.js');
+        const original = process.env.UJ_IS_SERVER;
+        try {
+          process.env.UJ_IS_SERVER = 'true';
+          ctx.expect(Manager.getEnvironment()).toBe('production');
+          delete process.env.UJ_IS_SERVER;
+          ctx.expect(Manager.getEnvironment()).toBe('development');
+        } finally {
+          if (original === undefined) delete process.env.UJ_IS_SERVER;
+          else process.env.UJ_IS_SERVER = original;
+        }
+      },
+    },
+    {
+      name: 'actLikeProduction is true when isBuildMode OR UJ_AUDIT_FORCE',
+      run: async (ctx) => {
+        const Manager = require('../../../build.js');
+        const origBuild = process.env.UJ_BUILD_MODE;
+        const origAudit = process.env.UJ_AUDIT_FORCE;
+        try {
+          delete process.env.UJ_BUILD_MODE;
+          delete process.env.UJ_AUDIT_FORCE;
+          ctx.expect(Manager.actLikeProduction()).toBe(false);
+
+          process.env.UJ_BUILD_MODE = 'true';
+          ctx.expect(Manager.actLikeProduction()).toBe(true);
+          delete process.env.UJ_BUILD_MODE;
+
+          process.env.UJ_AUDIT_FORCE = 'true';
+          ctx.expect(Manager.actLikeProduction()).toBe(true);
+        } finally {
+          if (origBuild === undefined) delete process.env.UJ_BUILD_MODE; else process.env.UJ_BUILD_MODE = origBuild;
+          if (origAudit === undefined) delete process.env.UJ_AUDIT_FORCE; else process.env.UJ_AUDIT_FORCE = origAudit;
+        }
+      },
+    },
+    {
+      name: 'getRootPath("package") points at UJM root',
+      run: async (ctx) => {
+        const Manager = require('../../../build.js');
+        const path = require('path');
+        const root = Manager.getRootPath('package');
+        ctx.expect(typeof root).toBe('string');
+        // Should resolve to the directory containing src/build.js's parent.
+        // dist/build.js → dist/ ; package root = parent.
+        const fs = require('fs');
+        ctx.expect(fs.existsSync(path.join(root, 'package.json'))).toBe(true);
+      },
+    },
+    {
+      name: 'getMemoryUsage returns shape with MB-sized numbers',
+      run: async (ctx) => {
+        const Manager = require('../../../build.js');
+        const mem = Manager.getMemoryUsage();
+        ctx.expect(typeof mem).toBe('object');
+        for (const key of ['rss', 'heapTotal', 'heapUsed', 'external']) {
+          ctx.expect(typeof mem[key]).toBe('number');
+          ctx.expect(mem[key]).toBeGreaterThan(0);
+        }
+      },
+    },
+    {
+      name: 'getArguments returns object with _ array + boolean defaults',
+      run: async (ctx) => {
+        const Manager = require('../../../build.js');
+        const args = Manager.getArguments();
+        ctx.expect(typeof args).toBe('object');
+        ctx.expect(Array.isArray(args._)).toBe(true);
+        ctx.expect(typeof args.browser).toBe('boolean');
+        ctx.expect(typeof args.debug).toBe('boolean');
+      },
+    },
+    {
+      name: 'logger returns object with log/error/warn/info methods',
+      run: async (ctx) => {
+        const Manager = require('../../../build.js');
+        const log = Manager.logger('test-logger');
+        ctx.expect(typeof log.log).toBe('function');
+        ctx.expect(typeof log.error).toBe('function');
+        ctx.expect(typeof log.warn).toBe('function');
+        ctx.expect(typeof log.info).toBe('function');
+        ctx.expect(log.name).toBe('test-logger');
+      },
+    },
+    {
+      name: 'processBatches processes items in chunks and returns flat results',
+      run: async (ctx) => {
+        const Manager = require('../../../build.js');
+        const log = { log: () => {} };
+        const items = [1, 2, 3, 4, 5, 6, 7];
+        const results = await Manager.processBatches(items, 3, async (n) => n * 2, log);
+        ctx.expect(results).toEqual([2, 4, 6, 8, 10, 12, 14]);
+      },
+    },
+  ],
+};

package/dist/test/suites/build/merge-jekyll-configs.test.js

@@ -0,0 +1,95 @@
+// mergeJekyllConfigs from src/gulp/tasks/utils/merge-jekyll-configs.js.
+// Critical for Jekyll's --config chain: project's `collections` + `defaults`
+// must coexist with UJM's, not silently override. Regression here means
+// custom collections vanish at build time.
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+module.exports = {
+  layer: 'build',
+  description: 'mergeJekyllConfigs (utils/merge-jekyll-configs.js)',
+  type: 'group',
+  tests: [
+    {
+      name: 'merges collections from both configs (project additions win)',
+      run: async (ctx) => {
+        const mergeJekyllConfigs = require('../../../gulp/tasks/utils/merge-jekyll-configs.js');
+        const yaml = require('js-yaml');
+
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ujm-merge-'));
+        const ujmPath = path.join(dir, 'ujm.yml');
+        const projPath = path.join(dir, 'proj.yml');
+        const outPath = path.join(dir, 'merged.yml');
+
+        fs.writeFileSync(ujmPath, 'collections:\n  posts:\n    output: true\n  team:\n    output: true\n', 'utf8');
+        fs.writeFileSync(projPath, 'collections:\n  posts:\n    output: false\n  blog:\n    output: true\n', 'utf8');
+
+        try {
+          const result = mergeJekyllConfigs(ujmPath, projPath, outPath, { log: () => {} });
+          ctx.expect(result).toBe(outPath);
+          const merged = yaml.load(fs.readFileSync(outPath, 'utf8'));
+          ctx.expect(merged.collections.team.output).toBe(true);   // UJM-only retained
+          ctx.expect(merged.collections.blog.output).toBe(true);   // project addition
+          ctx.expect(merged.collections.posts.output).toBe(false); // project wins on conflict
+        } finally {
+          fs.rmSync(dir, { recursive: true, force: true });
+        }
+      },
+    },
+    {
+      name: 'dedups defaults by scope key (project wins)',
+      run: async (ctx) => {
+        const mergeJekyllConfigs = require('../../../gulp/tasks/utils/merge-jekyll-configs.js');
+        const yaml = require('js-yaml');
+
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ujm-merge-'));
+        const ujmPath = path.join(dir, 'ujm.yml');
+        const projPath = path.join(dir, 'proj.yml');
+        const outPath = path.join(dir, 'merged.yml');
+
+        fs.writeFileSync(ujmPath, `defaults:
+  - scope: { path: "dist/pages", type: "draft" }
+    values: { layout: "ujm-layout" }
+  - scope: { path: "dist/blog", type: "posts" }
+    values: { layout: "blog" }
+`, 'utf8');
+        fs.writeFileSync(projPath, `defaults:
+  - scope: { path: "dist/pages", type: "draft" }
+    values: { layout: "project-layout" }
+`, 'utf8');
+
+        try {
+          mergeJekyllConfigs(ujmPath, projPath, outPath, { log: () => {} });
+          const merged = yaml.load(fs.readFileSync(outPath, 'utf8'));
+          const draft = merged.defaults.find((d) => d.scope.path === 'dist/pages' && d.scope.type === 'draft');
+          const blog  = merged.defaults.find((d) => d.scope.path === 'dist/blog');
+          ctx.expect(draft.values.layout).toBe('project-layout');  // project wins
+          ctx.expect(blog.values.layout).toBe('blog');             // UJM-only retained
+        } finally {
+          fs.rmSync(dir, { recursive: true, force: true });
+        }
+      },
+    },
+    {
+      name: 'returns null when there is nothing to merge',
+      run: async (ctx) => {
+        const mergeJekyllConfigs = require('../../../gulp/tasks/utils/merge-jekyll-configs.js');
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ujm-merge-'));
+        const ujmPath = path.join(dir, 'ujm.yml');
+        const projPath = path.join(dir, 'proj.yml');
+        const outPath = path.join(dir, 'merged.yml');
+        fs.writeFileSync(ujmPath, '# no collections or defaults\n', 'utf8');
+        fs.writeFileSync(projPath, '# also empty\n', 'utf8');
+        try {
+          const result = mergeJekyllConfigs(ujmPath, projPath, outPath, { log: () => {} });
+          ctx.expect(result).toBeNull();
+          ctx.expect(fs.existsSync(outPath)).toBe(false);
+        } finally {
+          fs.rmSync(dir, { recursive: true, force: true });
+        }
+      },
+    },
+  ],
+};

package/dist/test/suites/build/mode-helpers.test.js

@@ -0,0 +1,65 @@
+// Cross-context mode helpers (src/utils/mode-helpers.js) attached to the
+// build.js Manager via attachTo(). These mirror EM/BXM's mode-helpers and
+// are the canonical signal for "what kind of process am I in?".
+
+module.exports = {
+  layer: 'build',
+  description: 'mode-helpers (isTesting / isDevelopment / isProduction / getVersion)',
+  type: 'group',
+  tests: [
+    {
+      name: 'helpers attach to Manager statically AND on prototype',
+      run: async (ctx) => {
+        const Manager = require('../../../build.js');
+        for (const name of ['isTesting', 'isDevelopment', 'isProduction', 'getVersion']) {
+          ctx.expect(typeof Manager[name]).toBe('function');
+          ctx.expect(typeof Manager.prototype[name]).toBe('function');
+        }
+      },
+    },
+    {
+      name: 'isTesting reflects UJ_TEST_MODE env',
+      run: async (ctx) => {
+        const Manager = require('../../../build.js');
+        // UJ_TEST_MODE=true is set by `npx mgr test` — these tests run under it.
+        ctx.expect(Manager.isTesting()).toBe(true);
+
+        const original = process.env.UJ_TEST_MODE;
+        try {
+          delete process.env.UJ_TEST_MODE;
+          ctx.expect(Manager.isTesting()).toBe(false);
+        } finally {
+          if (original === undefined) delete process.env.UJ_TEST_MODE;
+          else process.env.UJ_TEST_MODE = original;
+        }
+      },
+    },
+    {
+      name: 'isDevelopment false when UJ_BUILD_MODE=true',
+      run: async (ctx) => {
+        const Manager = require('../../../build.js');
+        const original = process.env.UJ_BUILD_MODE;
+        try {
+          process.env.UJ_BUILD_MODE = 'true';
+          ctx.expect(Manager.isDevelopment()).toBe(false);
+          ctx.expect(Manager.isProduction()).toBe(true);
+        } finally {
+          if (original === undefined) delete process.env.UJ_BUILD_MODE;
+          else process.env.UJ_BUILD_MODE = original;
+        }
+      },
+    },
+    {
+      name: 'getVersion returns a non-empty string when run from a package',
+      run: async (ctx) => {
+        const Manager = require('../../../build.js');
+        const v = Manager.getVersion();
+        // May be null if cwd has no package.json; but in our test runs cwd is UJM root, so set.
+        if (v !== null) {
+          ctx.expect(typeof v).toBe('string');
+          ctx.expect(v.length).toBeGreaterThan(0);
+        }
+      },
+    },
+  ],
+};

package/dist/test/suites/build/template-transform.test.js

@@ -0,0 +1,94 @@
+// createTemplateTransform from src/gulp/tasks/utils/template-transform.js.
+// A gulp Transform stream that templatizes file contents using node-powertools'
+// `[ ]` bracket syntax. Used by defaults.js and distribute.js theme fallback.
+//
+// We don't run it through gulp — we synthesize a fake vinyl-like file object
+// (with .isDirectory(), .path, .contents, .relative) and push it through the
+// stream directly.
+
+module.exports = {
+  layer: 'build',
+  description: 'createTemplateTransform (utils/template-transform.js)',
+  type: 'group',
+  tests: [
+    {
+      name: 'replaces [site.theme.id] with config value in .html files',
+      run: async (ctx) => {
+        const createTemplateTransform = require('../../../gulp/tasks/utils/template-transform.js');
+        const tx = createTemplateTransform({ site: { theme: { id: 'classy' } } });
+
+        const file = {
+          path:        '/tmp/test.html',
+          relative:    'test.html',
+          contents:    Buffer.from('themes/[site.theme.id]/file.html'),
+          isDirectory: () => false,
+        };
+
+        await new Promise((resolve, reject) => {
+          tx.write(file);
+          tx.end();
+          tx.on('data', (f) => {
+            try {
+              ctx.expect(f.contents.toString()).toBe('themes/classy/file.html');
+              resolve();
+            } catch (e) { reject(e); }
+          });
+          tx.on('error', reject);
+        });
+      },
+    },
+    {
+      name: 'leaves non-matching extensions untouched (e.g. .css)',
+      run: async (ctx) => {
+        const createTemplateTransform = require('../../../gulp/tasks/utils/template-transform.js');
+        const tx = createTemplateTransform({ site: { theme: { id: 'classy' } } });
+
+        const original = 'a { content: "[site.theme.id]"; }';
+        const file = {
+          path:        '/tmp/test.css',
+          relative:    'test.css',
+          contents:    Buffer.from(original),
+          isDirectory: () => false,
+        };
+
+        await new Promise((resolve, reject) => {
+          tx.write(file);
+          tx.end();
+          tx.on('data', (f) => {
+            try {
+              ctx.expect(f.contents.toString()).toBe(original);
+              resolve();
+            } catch (e) { reject(e); }
+          });
+          tx.on('error', reject);
+        });
+      },
+    },
+    {
+      name: 'passes directories through untouched',
+      run: async (ctx) => {
+        const createTemplateTransform = require('../../../gulp/tasks/utils/template-transform.js');
+        const tx = createTemplateTransform({ site: {} });
+
+        const file = {
+          path:        '/tmp/dir',
+          relative:    'dir',
+          contents:    null,
+          isDirectory: () => true,
+        };
+
+        await new Promise((resolve, reject) => {
+          tx.write(file);
+          tx.end();
+          tx.on('data', (f) => {
+            try {
+              ctx.expect(f.contents).toBeNull();
+              resolve();
+            } catch (e) { reject(e); }
+          });
+          tx.on('error', reject);
+        });
+      },
+    },
+  ],
+};

package/dist/test/suites/build/templating-brackets.test.js

@@ -0,0 +1,46 @@
+// UJM templating uses node-powertools' `template()`. Two bracket configs are
+// in active use:
+//   `{ x }`    — default (used wherever defaults.js / others omit `brackets`)
+//   `[ x ]`    — distribute.js theme fallback + template-transform.js
+//
+// This suite locks in those conventions so a node-powertools upgrade or an
+// accidental reconfiguration would fail loudly here rather than silently
+// breaking Jekyll output. (Liquid syntax `{{ }}` is handled by Jekyll itself,
+// NOT node-powertools — those placeholders pass through node-powertools
+// untouched.)
+
+module.exports = {
+  layer: 'build',
+  description: 'node-powertools templating brackets ({} and [])',
+  type: 'group',
+  tests: [
+    {
+      name: 'default { } brackets resolve nested keys',
+      run: async (ctx) => {
+        const { template } = require('node-powertools');
+        const out = template('hello {name.first} {name.last}', {
+          name: { first: 'Ian', last: 'Wiedenman' },
+        });
+        ctx.expect(out).toBe('hello Ian Wiedenman');
+      },
+    },
+    {
+      name: '[ ] brackets resolve nested keys when explicitly configured',
+      run: async (ctx) => {
+        const { template } = require('node-powertools');
+        const out = template('themes/[site.theme.id]/file', {
+          site: { theme: { id: 'classy' } },
+        }, { brackets: ['[', ']'] });
+        ctx.expect(out).toBe('themes/classy/file');
+      },
+    },
+    {
+      name: '[ ] brackets leave Jekyll {{ }} placeholders alone',
+      run: async (ctx) => {
+        const { template } = require('node-powertools');
+        const out = template('a [x] b {{ x }} c', { x: 'X' }, { brackets: ['[', ']'] });
+        ctx.expect(out).toBe('a X b {{ x }} c');
+      },
+    },
+  ],
+};