feat: (strf-8740) cover StencilStart.assembleTemplates() with tests

lib/stencil-start.js

@@ -1,7 +1,6 @@
 require('colors');
 const browserSyncInstance = require('browser-sync').create();
-const recursiveRead = require('recursive-readdir');
-const async = require('async');
+const { promisify } = require('util');
 const fetchModule = require('node-fetch');
 const fsModule = require('fs');
 const path = require('path');
@@ -29,6 +28,7 @@ class StencilStart {
         buildConfigManger = buildConfigManagerInstance,
         templateAssembler = templateAssemblerModule,
         CyclesDetector = Cycles,
+        logger = console,
     } = {}) {
         this.browserSync = browserSync;
         this.fetch = fetch;
@@ -39,6 +39,7 @@ class StencilStart {
         this.buildConfigManger = buildConfigManger;
         this.templateAssembler = templateAssembler;
         this.CyclesDetector = CyclesDetector;
+        this.logger = logger;
     }
 
     async run(cliOptions, dotStencilFilePath, stencilCliVersion) {
@@ -70,7 +71,7 @@ class StencilStart {
 
         await this.startLocalServer(cliOptions, updatedStencilConfig);
 
-        console.log(this.getStartUpInfo(updatedStencilConfig, dotStencilFilePath));
+        this.logger.log(this.getStartUpInfo(updatedStencilConfig, dotStencilFilePath));
 
         await this.startBrowserSync(cliOptions, updatedStencilConfig, browserSyncPort);
     }
@@ -186,7 +187,7 @@ class StencilStart {
         const storefrontConfigPath = path.join(themePath, '.config/storefront.json');
         this.browserSync.watch(storefrontConfigPath, (event, file) => {
             if (event === 'change') {
-                console.log('storefront.json changed');
+                this.logger.log('storefront.json changed');
                 this.browserSync.emitter.emit('storefront_config_file:changed', {
                     event,
                     path: file,
@@ -197,19 +198,13 @@ class StencilStart {
         });
 
         const templatesPath = path.join(themePath, 'templates');
-        this.browserSync.watch(templatesPath, { ignoreInitial: true }, () => {
-            this.assembleTemplates(templatesPath, (err, results) => {
-                if (err) {
-                    console.error(err);
-                    return;
-                }
-
-                try {
-                    new this.CyclesDetector(results).detect();
-                } catch (e) {
-                    console.error(e);
-                }
-            });
+        this.browserSync.watch(templatesPath, { ignoreInitial: true }, async () => {
+            try {
+                const results = await this.assembleTemplates(templatesPath);
+                new this.CyclesDetector(results).detect();
+            } catch (e) {
+                this.logger.error(e);
+            }
         });
 
         // tunnel value should be true/false or a string with name
@@ -256,26 +251,21 @@ class StencilStart {
 
     /**
      * Assembles all the needed templates and resolves their partials.
+     *
      * @param {string} templatesPath
-     * @param {function} callback
+     * @returns {object[]}
      */
-    assembleTemplates(templatesPath, callback) {
-        recursiveRead(templatesPath, ['!*.html'], (err, files) => {
-            const templateNames = files.map((file) =>
-                file.replace(templatesPath + path.sep, '').replace('.html', ''),
-            );
-
-            async.map(
-                templateNames,
-                this.templateAssembler.assemble.bind(null, templatesPath),
-                (err2, results) => {
-                    if (err2) {
-                        callback(err2);
-                    }
-                    callback(null, results);
-                },
-            );
-        });
+    async assembleTemplates(templatesPath) {
+        const filesPaths = await this.fsUtils.recursiveReadDir(templatesPath, ['!*.html']);
+        const templateNames = filesPaths.map((file) =>
+            file.replace(templatesPath + path.sep, '').replace('.html', ''),
+        );
+
+        return Promise.all(
+            templateNames.map(async (templateName) =>
+                promisify(this.templateAssembler.assemble)(templatesPath, templateName),
+            ),
+        );
     }
 
     /**

lib/stencil-start.spec.js

@@ -0,0 +1,123 @@
+const fetchMockModule = require('fetch-mock-jest');
+const path = require('path');
+
+const StencilStart = require('./stencil-start');
+
+afterAll(() => jest.restoreAllMocks());
+
+describe('StencilStart unit tests', () => {
+    const getBrowserSyncStub = () => ({
+        watch: jest.fn(),
+        init: jest.fn(),
+    });
+    const getFetchStub = () => fetchMockModule.sandbox();
+    const getFsStub = () => ({
+        existsSync: jest.fn(),
+    });
+    const getFsUtilsStub = () => ({
+        parseJsonFile: jest.fn(),
+        recursiveReadDir: jest.fn(),
+    });
+    const getCliCommonStub = () => ({
+        checkNodeVersion: jest.fn(),
+    });
+    const getThemeConfigManagerStub = () => ({});
+    const getBuildConfigMangerStub = () => ({});
+    const getTemplateAssemblerStub = () => ({});
+    const getCyclesDetectorConstructorStub = () => jest.fn();
+    const getLoggerStub = () => ({
+        log: jest.fn(),
+        error: jest.fn(),
+    });
+
+    const createStencilStartInstance = ({
+        browserSync,
+        fetch,
+        fs,
+        fsUtils,
+        cliCommon,
+        themeConfigManager,
+        buildConfigManger,
+        templateAssembler,
+        CyclesDetector,
+        logger,
+    } = {}) => {
+        const passedArgs = {
+            browserSync: browserSync || getBrowserSyncStub(),
+            fetch: fetch || getFetchStub(),
+            fs: fs || getFsStub(),
+            fsUtils: fsUtils || getFsUtilsStub(),
+            cliCommon: cliCommon || getCliCommonStub(),
+            themeConfigManager: themeConfigManager || getThemeConfigManagerStub(),
+            buildConfigManger: buildConfigManger || getBuildConfigMangerStub(),
+            templateAssembler: templateAssembler || getTemplateAssemblerStub(),
+            CyclesDetector: CyclesDetector || getCyclesDetectorConstructorStub(),
+            logger: logger || getLoggerStub(),
+        };
+        const instance = new StencilStart(passedArgs);
+
+        return {
+            passedArgs,
+            instance,
+        };
+    };
+
+    describe('constructor', () => {
+        it('should create an instance of StencilStart without options parameters passed', async () => {
+            const instance = new StencilStart();
+
+            expect(instance).toBeInstanceOf(StencilStart);
+        });
+
+        it('should create an instance of StencilStart with all options parameters passed', async () => {
+            const { instance } = createStencilStartInstance();
+
+            expect(instance).toBeInstanceOf(StencilStart);
+        });
+    });
+
+    describe('assembleTemplates method', () => {
+        it('should obtain names of all templates in the passed templatesPath and return results of call templateAssembler.assemble for each template name', async () => {
+            const templatesPath = '/some/absolute/templates/path';
+            const templateNamesMock = ['layout/base', 'pages/page1'];
+            const filesPathsMock = [
+                templatesPath + path.sep + templateNamesMock[0] + '.html',
+                templatesPath + path.sep + templateNamesMock[1] + '.html',
+            ];
+            const templateAssemblerResults = [
+                {
+                    [templateNamesMock[0]]: 'html file content 1',
+                },
+                {
+                    [templateNamesMock[0]]: 'html file content 1',
+                    [templateNamesMock[1]]: 'html file content 2',
+                },
+            ];
+            const fsUtilsStub = {
+                recursiveReadDir: jest.fn().mockResolvedValue(filesPathsMock),
+            };
+            const templateAssemblerStub = {
+                assemble: jest
+                    .fn()
+                    .mockImplementationOnce((p, n, cb) => cb(null, templateAssemblerResults[0]))
+                    .mockImplementationOnce((p, n, cb) => cb(null, templateAssemblerResults[1])),
+            };
+
+            const { instance } = createStencilStartInstance({
+                fsUtils: fsUtilsStub,
+                templateAssembler: templateAssemblerStub,
+            });
+            const result = await instance.assembleTemplates(templatesPath);
+
+            expect(fsUtilsStub.recursiveReadDir).toHaveBeenCalledTimes(1);
+            expect(fsUtilsStub.recursiveReadDir).toHaveBeenCalledWith(templatesPath, ['!*.html']);
+
+            expect(templateAssemblerStub.assemble.mock.calls).toEqual([
+                [templatesPath, templateNamesMock[0], expect.any(Function)],
+                [templatesPath, templateNamesMock[1], expect.any(Function)],
+            ]);
+
+            expect(result).toStrictEqual(templateAssemblerResults);
+        });
+    });
+});