@24i/smartapps-bigscreen-rnv-build-engine 0.17.10-alpha.2 → 0.17.10-alpha.4

package/dist/src/__tests__/sdks/sdk-utils/sdk-installer/services/download.spec.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = __importDefault(require("stream"));
+const nock_1 = __importDefault(require("nock"));
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const fs_1 = __importDefault(require("fs"));
+const services_1 = require("../../../../../sdks/sdk-utils/sdk-installer/services");
+jest.mock('fs');
+fs_1.default.createWriteStream.mockImplementation(() => new stream_1.default.PassThrough());
+describe('SDK Installer - Downloader', () => {
+    const HTTP_RESPONSE_STATUS_CODE_OK = 200;
+    const HTTP_RESPONSE_STATUS_CODE_NOT_FOUND = 404;
+    const httpBasePath = 'http://s3.amazonaws.com';
+    const zipRelativeFilePath = '/file.zip';
+    const zipFileHttpUrl = `${httpBasePath}${zipRelativeFilePath}`;
+    const headersWithZipContentType = { 'Content-Type': 'application/zip' };
+    const saveFilePath = `${process.cwd()}/test.zip`;
+    const makeValidHttpNock = () => (0, nock_1.default)(httpBasePath)
+        .get(zipRelativeFilePath)
+        .reply(HTTP_RESPONSE_STATUS_CODE_OK, '', headersWithZipContentType);
+    nock_1.default.disableNetConnect();
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    afterAll(() => {
+        nock_1.default.enableNetConnect();
+        nock_1.default.cleanAll();
+        nock_1.default.restore();
+    });
+    describe('Supported protocols', () => {
+        it('calls http.get for URL with HTTP protocol', async () => {
+            makeValidHttpNock();
+            const getSpy = jest.spyOn(http_1.default, 'get');
+            await (0, services_1.download)(zipFileHttpUrl, saveFilePath);
+            expect(getSpy).toBeCalledTimes(1);
+        });
+        it('calls https.get for URL with HTTPS protocol', async () => {
+            (0, nock_1.default)(httpBasePath.replace('http:', 'https:'))
+                .get(zipRelativeFilePath)
+                .reply(HTTP_RESPONSE_STATUS_CODE_OK, '', headersWithZipContentType);
+            const getSpy = jest.spyOn(https_1.default, 'get');
+            await (0, services_1.download)(zipFileHttpUrl.replace('http:', 'https:'), saveFilePath);
+            expect(getSpy).toBeCalledTimes(1);
+        });
+        it('throws an error when URL has unsupported protocol', async () => {
+            await expect(async () => {
+                await (0, services_1.download)('ftp://file.zip', saveFilePath);
+            }).rejects.toThrow(new Error('ftp protocol is not supported'));
+        });
+    });
+    describe('Handling response errors', () => {
+        it('throws an error when returned content type is not application/zip', async () => {
+            (0, nock_1.default)(httpBasePath)
+                .get('/file.json')
+                .reply(HTTP_RESPONSE_STATUS_CODE_OK, '', { 'Content-Type': 'application/json' });
+            await expect(async () => {
+                await (0, services_1.download)(`${httpBasePath}/file.json`, saveFilePath);
+            }).rejects.toThrow(new Error('Wrong Content-Type: expected application/zip, received application/json'));
+            (0, nock_1.default)(httpBasePath)
+                .get(zipRelativeFilePath)
+                .reply(HTTP_RESPONSE_STATUS_CODE_OK, '');
+            await expect(async () => {
+                await (0, services_1.download)(zipFileHttpUrl, saveFilePath);
+            }).rejects.toThrow(new Error('Missing Content-Type: expected application/zip'));
+        });
+        it('throws an error when request status is not 200', async () => {
+            (0, nock_1.default)(httpBasePath)
+                .get(zipRelativeFilePath)
+                .reply(HTTP_RESPONSE_STATUS_CODE_NOT_FOUND, '', headersWithZipContentType);
+            await expect(async () => {
+                await (0, services_1.download)(zipFileHttpUrl, saveFilePath);
+            }).rejects.toThrow(new Error('Request Failed. Status Code: 404'));
+        });
+    });
+    describe('Writing received data into a file', () => {
+        beforeEach(() => {
+            makeValidHttpNock();
+        });
+        it('Creates dest path if does not exist', async () => {
+            const mkDirSync = jest.spyOn(fs_1.default, 'mkdirSync');
+            fs_1.default.existsSync.mockImplementationOnce(() => false);
+            await (0, services_1.download)(zipFileHttpUrl, saveFilePath);
+            expect(mkDirSync).toBeCalledTimes(1);
+            expect(mkDirSync).toHaveBeenCalledWith(process.cwd(), { recursive: true });
+        });
+        it('Does not create dest path if path exists', async () => {
+            const mkDirSync = jest.spyOn(fs_1.default, 'mkdirSync');
+            fs_1.default.existsSync.mockImplementationOnce(() => true);
+            await (0, services_1.download)(zipFileHttpUrl, saveFilePath);
+            expect(mkDirSync).toBeCalledTimes(0);
+        });
+        it('Calls write fn with dest param', async () => {
+            const createWriteStream = jest.spyOn(fs_1.default, 'createWriteStream');
+            await (0, services_1.download)(zipFileHttpUrl, saveFilePath);
+            expect(createWriteStream).toBeCalledTimes(1);
+            expect(createWriteStream).toHaveBeenCalledWith(saveFilePath);
+        });
+    });
+});

package/dist/src/__tests__/sdks/sdk-utils/sdk-installer/services/install.spec.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const childProcess = __importStar(require("child_process"));
+const services_1 = require("../../../../../sdks/sdk-utils/sdk-installer/services");
+jest.mock('child_process');
+describe('SDK Installer - Installer', () => {
+    childProcess.execSync.mockImplementation(() => '');
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('Calling external install.js script', () => {
+        it('Calls with install.js path only when install path is not provided', () => {
+            const execSyncSpy = jest.spyOn(childProcess, 'execSync');
+            (0, services_1.install)('/install/from');
+            expect(execSyncSpy).toHaveBeenCalledTimes(1);
+            const params = execSyncSpy.mock.calls[0];
+            const command = params[0];
+            expect(command).toBe('node /install/from/install.js');
+        });
+        it('Calls with install path when it is provided', () => {
+            const execSyncSpy = jest.spyOn(childProcess, 'execSync');
+            (0, services_1.install)('/install/from', '/install/to');
+            expect(execSyncSpy).toHaveBeenCalledTimes(1);
+            const params = execSyncSpy.mock.calls[0];
+            const command = params[0];
+            expect(command).toBe('node /install/from/install.js /install/to');
+        });
+    });
+    it('returns installed path', () => {
+        childProcess.execSync.mockImplementationOnce(() => 'INSTALL_PATH=/sdk');
+        const pathInstalledTo = (0, services_1.install)('/install/from');
+        expect(pathInstalledTo).toBe('/sdk');
+    });
+});

package/dist/src/__tests__/sdks/sdk-utils/sdk-installer/services/unzip.spec.js

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const childProcess = __importStar(require("child_process"));
+const services_1 = require("../../../../../sdks/sdk-utils/sdk-installer/services");
+jest.mock('child_process');
+describe('SDK Installer - Unzipper', () => {
+    childProcess.spawnSync.mockImplementation(() => ({ stderr: '' }));
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it('calls spawnSync with needed params', () => {
+        const spawnSyncSpy = jest.spyOn(childProcess, 'spawnSync');
+        (0, services_1.unzip)('/path/file.zip');
+        expect(spawnSyncSpy).toHaveBeenCalledTimes(1);
+        const params = spawnSyncSpy.mock.calls[0];
+        const command = params[0];
+        expect(command).toBe('unzip');
+        const args = params[1] || [];
+        expect(args).not.toBeUndefined();
+        expect(args.includes('/path/file.zip')).toBe(true);
+    });
+    it('throws an error when error occurs during unzipping', async () => {
+        childProcess.spawnSync.mockImplementationOnce(() => ({ stderr: 'error' }));
+        expect(() => {
+            (0, services_1.unzip)('');
+        }).toThrow(new Error('error'));
+    });
+});

package/dist/src/__tests__/utils/forEachSupportedPlatformFlavour.spec.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const forEachSupportedPlatformFlavour_1 = require("../../utils/forEachSupportedPlatformFlavour");
+describe('forEachSupportedPlatformFlavour', () => {
+    const originalConsoleLog = console.log;
+    beforeEach(() => {
+        console.log = jest.fn();
+    });
+    afterEach(() => {
+        console.log = originalConsoleLog;
+        jest.resetAllMocks();
+        jest.clearAllMocks();
+        jest.resetModules();
+    });
+    it('calls provided callback for each supported flavour', () => {
+        const rnvC = {
+            runtime: {
+                scheme: 'scheme1',
+            },
+            buildConfig: {
+                defaults: {
+                    supportedPlatforms: [
+                        'webtv',
+                        'tizen',
+                        'webos',
+                    ],
+                },
+                platforms: {
+                    webtv: { deploy: { supportedFlavours: ['flavour1', 'flavour2'] } },
+                    tizen: { deploy: { supportedFlavours: ['flavour2', 'flavour3'] } },
+                    webos: { deploy: { supportedFlavours: ['flavour4'] } },
+                    hbbtv: { deploy: { supportedFlavours: ['flavour1', 'flavour2'] } },
+                },
+            },
+        };
+        const spyCb = jest.fn();
+        (0, forEachSupportedPlatformFlavour_1.forEachSupportedPlatformFlavour)(rnvC, spyCb);
+        expect(spyCb).toBeCalledTimes(5);
+        expect(spyCb.mock.calls[0][0]).toStrictEqual({
+            platform: 'webtv', flavour: 'flavour1', scheme: 'scheme1',
+        });
+        expect(spyCb.mock.calls[1][0]).toStrictEqual({
+            platform: 'webtv', flavour: 'flavour2', scheme: 'scheme1',
+        });
+        expect(spyCb.mock.calls[2][0]).toStrictEqual({
+            platform: 'tizen', flavour: 'flavour2', scheme: 'scheme1',
+        });
+        expect(spyCb.mock.calls[3][0]).toStrictEqual({
+            platform: 'tizen', flavour: 'flavour3', scheme: 'scheme1',
+        });
+        expect(spyCb.mock.calls[4][0]).toStrictEqual({
+            platform: 'webos', flavour: 'flavour4', scheme: 'scheme1',
+        });
+    });
+    it('logs progress message', () => {
+        const rnvC = {
+            runtime: {
+                scheme: 'scheme1',
+            },
+            buildConfig: {
+                defaults: {
+                    supportedPlatforms: [
+                        'tizen',
+                        'webos',
+                    ],
+                },
+                platforms: {
+                    tizen: { deploy: { supportedFlavours: ['flavour1', 'flavour2'] } },
+                    webos: { deploy: { supportedFlavours: ['flavour1'] } },
+                },
+            },
+        };
+        const spyCb = jest.fn();
+        const mockedLog = console.log;
+        (0, forEachSupportedPlatformFlavour_1.forEachSupportedPlatformFlavour)(rnvC, spyCb);
+        expect(mockedLog).toBeCalledTimes(3);
+        expect(mockedLog.mock.calls[0][0]).toBe('\nProcessing "tizen" platform (1/2) and its "flavour1" flavour (1/2)...');
+        expect(mockedLog.mock.calls[1][0]).toBe('\nProcessing "tizen" platform (1/2) and its "flavour2" flavour (2/2)...');
+        expect(mockedLog.mock.calls[2][0]).toBe('\nProcessing "webos" platform (2/2) and its "flavour1" flavour (1/1)...');
+    });
+    it('not throws when supported flavour for platform are not defined', () => {
+        const rnvC = {
+            runtime: {
+                scheme: 'scheme1',
+            },
+            buildConfig: {
+                defaults: {
+                    supportedPlatforms: [
+                        'tizen',
+                        'webos',
+                        'webtv',
+                    ],
+                },
+                platforms: {
+                    tizen: { deploy: {} },
+                    webos: {},
+                },
+            },
+        };
+        const spyCb = jest.fn();
+        expect(() => (0, forEachSupportedPlatformFlavour_1.forEachSupportedPlatformFlavour)(rnvC, spyCb)).not.toThrow();
+        expect(spyCb).toBeCalledTimes(0);
+    });
+});

package/dist/src/__tests__/utils/generatePngSpriteMap.spec.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const generatePngSpriteMap_1 = require("../../utils/generatePngSpriteMap");
+const mockIconBase64 = 'iVBORw0KGgoAAAANSUhEUgAAABAAAAAQBAMAAADt3eJSAAAAMFBMVEU0OkArMjhobHEoPUPFEBIuO0L+AAC2FBZ2JyuNICOfGx7xAwTjCAlCNTvVDA1aLzQ3COjMAAAAVUlEQVQI12NgwAaCDSA0888GCItjn0szWGBJTVoGSCjWs8TleQCQYV95evdxkFT8Kpe0PLDi5WfKd4LUsN5zS1sKFolt8bwAZrCaGqNYJAgFDEpQAAAzmxafI4vZWwAAAABJRU5ErkJggg==`';
+describe.skip('generatePngSpriteMap', () => {
+    jest.setTimeout(60000);
+    const originalConsoleLogFn = console.log;
+    const projectDir = path_1.default.resolve(process.cwd(), 'temp_generatePngSpriteMap');
+    const platformAssetsDir = path_1.default.resolve(projectDir, 'platformAssets');
+    const runtimeDir = path_1.default.resolve(platformAssetsDir, 'runtime');
+    const iconsDir = path_1.default.resolve(projectDir, 'icons');
+    const rnvC = {
+        runtime: {
+            appId: 'appId',
+        },
+        platform: 'platform1',
+        paths: {
+            project: {
+                dir: projectDir,
+                builds: {
+                    dir: path_1.default.resolve(projectDir, 'platformBuilds'),
+                },
+                assets: {
+                    dir: platformAssetsDir,
+                },
+            },
+        },
+        buildConfig: {
+            common: {
+                pngIconPrefix: 'png-',
+            },
+        },
+    };
+    beforeEach(() => {
+        fs_1.default.mkdirSync(iconsDir, { recursive: true });
+        fs_1.default.mkdirSync(rnvC.paths.project.builds.dir, { recursive: true });
+        fs_1.default.mkdirSync(runtimeDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.resolve(iconsDir, 'icon1.png'), mockIconBase64, 'base64');
+        fs_1.default.writeFileSync(path_1.default.resolve(iconsDir, 'icon2.png'), mockIconBase64, 'base64');
+        fs_1.default.mkdirSync(path_1.default.resolve(iconsDir, 'inner'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.resolve(iconsDir, 'inner/icon3.png'), mockIconBase64, 'base64');
+        console.log = () => { };
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(projectDir, { recursive: true });
+        console.log = originalConsoleLogFn;
+    });
+    it('generates png_icons.css and png_icons.json files', async () => {
+        await (0, generatePngSpriteMap_1.generatePngSpriteMap)(rnvC);
+        expect(fs_1.default.existsSync(path_1.default.resolve(runtimeDir, 'png_icons.css'))).toBeTruthy();
+        expect(fs_1.default.existsSync(path_1.default.resolve(platformAssetsDir, 'png_icons.json'))).toBeTruthy();
+        const outputJsonPath = path_1.default.resolve(platformAssetsDir, 'png_icons.json');
+        expect(fs_1.default.existsSync(outputJsonPath)).toBe(true);
+        const outputJsonContent = JSON.parse(fs_1.default.readFileSync(outputJsonPath).toString());
+        expect(Object.keys(outputJsonContent)).toStrictEqual([
+            'png-icon1',
+            'png-icon2',
+            'png-icon3',
+        ]);
+    });
+    it('remove empty files when nothing is generated', async () => {
+        fs_1.default.rmSync(iconsDir, { recursive: true });
+        fs_1.default.mkdirSync(iconsDir, { recursive: true });
+        await (0, generatePngSpriteMap_1.generatePngSpriteMap)(rnvC);
+        expect(fs_1.default.existsSync(path_1.default.resolve(runtimeDir, 'sprite.png'))).toBeFalsy();
+        expect(fs_1.default.existsSync(path_1.default.resolve(runtimeDir, 'png_icons.css'))).toBeFalsy();
+        expect(fs_1.default.existsSync(path_1.default.resolve(platformAssetsDir, 'png_icons.json'))).toBeFalsy();
+    });
+    it('no empty files when icons folder is not present', async () => {
+        fs_1.default.rmSync(iconsDir, { recursive: true });
+        await (0, generatePngSpriteMap_1.generatePngSpriteMap)(rnvC);
+        expect(fs_1.default.existsSync(path_1.default.resolve(runtimeDir, 'sprite.png'))).toBeFalsy();
+        expect(fs_1.default.existsSync(path_1.default.resolve(runtimeDir, 'png_icons.css'))).toBeFalsy();
+        expect(fs_1.default.existsSync(path_1.default.resolve(platformAssetsDir, 'png_icons.json'))).toBeFalsy();
+    });
+});

package/dist/src/__tests__/utils/generateSvgSpriteMap.spec.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const generateSvgSpriteMap_1 = require("../../utils/generateSvgSpriteMap");
+describe('generateSvgSpriteMap', () => {
+    const originalConsoleLogFn = console.log;
+    const projectDir = path_1.default.resolve(process.cwd(), 'temp_generateSvgSpriteMap');
+    const platformAssetsDir = path_1.default.resolve(projectDir, 'platformAssets');
+    const runtimeDir = path_1.default.resolve(platformAssetsDir, 'runtime');
+    const iconsDir = path_1.default.resolve(projectDir, 'icons');
+    const svgoConfigPath = path_1.default.resolve(iconsDir, '.svgo.yml');
+    const outputCssFilePath = path_1.default.resolve(runtimeDir, 'svg_icons.css');
+    const outputJsonFilePath = path_1.default.resolve(platformAssetsDir, 'svg_icons.json');
+    const rnvC = {
+        runtime: {
+            appId: 'appId',
+        },
+        platform: 'platform1',
+        paths: {
+            project: {
+                dir: projectDir,
+                builds: {
+                    dir: path_1.default.resolve(projectDir, 'platformBuilds'),
+                },
+                assets: {
+                    dir: platformAssetsDir,
+                },
+            },
+        },
+        buildConfig: {
+            common: {
+                svgIconsMaskList: [],
+                svgIconPrefix: 'svg-',
+            },
+        },
+    };
+    beforeEach(() => {
+        fs_1.default.mkdirSync(iconsDir, { recursive: true });
+        fs_1.default.mkdirSync(rnvC.paths.project.builds.dir, { recursive: true });
+        fs_1.default.mkdirSync(runtimeDir, { recursive: true });
+        console.log = () => { };
+    });
+    afterEach(() => {
+        fs_1.default.rmdirSync(projectDir, { recursive: true });
+        console.log = originalConsoleLogFn;
+    });
+    it('should not generate any output when no icons are found', () => {
+        (0, generateSvgSpriteMap_1.generateSvgSpriteMap)(rnvC);
+        expect(fs_1.default.existsSync(outputCssFilePath)).toBeFalsy();
+        expect(fs_1.default.existsSync(outputJsonFilePath)).toBeFalsy();
+    });
+    it('should not generate any output when no .svgo.yml is not found', () => {
+        const svgData = '<svg viewBox="0 0 10 10"><circle cx="0" cy="0" r="10" fill="red" /></svg>';
+        fs_1.default.writeFileSync(path_1.default.resolve(iconsDir, 'icon1.svg'), svgData);
+        (0, generateSvgSpriteMap_1.generateSvgSpriteMap)(rnvC);
+        expect(fs_1.default.existsSync(outputCssFilePath)).toBeFalsy();
+        expect(fs_1.default.existsSync(outputJsonFilePath)).toBeFalsy();
+    });
+    it('should not generate any output when no icons folder is not found', () => {
+        (0, child_process_1.execSync)(`rm -rf ${iconsDir}`);
+        (0, generateSvgSpriteMap_1.generateSvgSpriteMap)(rnvC);
+        expect(fs_1.default.existsSync(outputCssFilePath)).toBeFalsy();
+        expect(fs_1.default.existsSync(outputJsonFilePath)).toBeFalsy();
+    });
+    it('generates svg_icons.css and svg_icons.json when input icons are found', () => {
+        fs_1.default.writeFileSync(svgoConfigPath, 'multipass: true');
+        const svgData = '<svg viewBox="0 0 10 10"><circle cx="0" cy="0" r="10" fill="red" /></svg>';
+        fs_1.default.writeFileSync(path_1.default.resolve(iconsDir, 'icon1.svg'), svgData);
+        fs_1.default.writeFileSync(path_1.default.resolve(iconsDir, 'icon2.svg'), svgData);
+        fs_1.default.mkdirSync(path_1.default.resolve(iconsDir, 'inner'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.resolve(iconsDir, 'inner/icon3.svg'), svgData);
+        rnvC.buildConfig.common.svgIconsMaskList.push('icon1.svg');
+        (0, generateSvgSpriteMap_1.generateSvgSpriteMap)(rnvC);
+        rnvC.buildConfig.common.svgIconsMaskList.length = 0;
+        expect(fs_1.default.existsSync(outputCssFilePath)).toBe(true);
+        const outputCssContentRows = fs_1.default.readFileSync(outputCssFilePath).toString().split('\n');
+        expect(outputCssContentRows).toHaveLength(15);
+        expect(outputCssContentRows[0]).toBe('.icon-svg-icon1 {');
+        expect(outputCssContentRows[1].startsWith('    background-image: url(')).toBe(true);
+        expect(outputCssContentRows[2]).toBe('}');
+        expect(outputCssContentRows[3]).toBe('');
+        expect(outputCssContentRows[4]).toBe('.icon-mask-svg-icon1 {');
+        expect(outputCssContentRows[5].startsWith('    -webkit-mask-image: url(')).toBe(true);
+        expect(outputCssContentRows[6]).toBe('}');
+        expect(outputCssContentRows[7]).toBe('');
+        expect(outputCssContentRows[8]).toBe('.icon-svg-icon2 {');
+        expect(outputCssContentRows[9].startsWith('    background-image: url(')).toBe(true);
+        expect(outputCssContentRows[10]).toBe('}');
+        expect(outputCssContentRows[11]).toBe('');
+        expect(outputCssContentRows[12]).toBe('.icon-svg-icon3 {');
+        expect(outputCssContentRows[13].startsWith('    background-image: url(')).toBe(true);
+        expect(outputCssContentRows[14]).toBe('}');
+        const outputJsonPath = path_1.default.resolve(platformAssetsDir, 'svg_icons.json');
+        expect(fs_1.default.existsSync(outputJsonPath)).toBe(true);
+        const outputJsonContent = JSON.parse(fs_1.default.readFileSync(outputJsonPath).toString());
+        expect(outputJsonContent).toStrictEqual({
+            'svg-icon1': '',
+            'svg-icon2': '',
+            'svg-icon3': '',
+            'mask-svg-icon1': '',
+        });
+    });
+});

package/dist/src/__tests__/utils/mergeSvgAndPngIcons.spec.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const mergeSvgAndPngIcons_1 = require("../../utils/mergeSvgAndPngIcons");
+describe('mergeSvgAndPngIcons', () => {
+    const originalConsoleLogFn = console.log;
+    const projectDir = path_1.default.resolve(process.cwd(), 'temp_mergeSvgAndPngIcons');
+    const platformAssetsDir = path_1.default.resolve(projectDir, 'platformAssets');
+    const runtimeDir = path_1.default.resolve(platformAssetsDir, 'runtime');
+    const iconsDir = path_1.default.resolve(projectDir, 'icons');
+    const svgCssFilePath = path_1.default.resolve(runtimeDir, 'svg_icons.css');
+    const pngCssFilePath = path_1.default.resolve(runtimeDir, 'png_icons.css');
+    const svgJsonFilePath = path_1.default.resolve(platformAssetsDir, 'svg_icons.json');
+    const pngJsonFilePath = path_1.default.resolve(platformAssetsDir, 'png_icons.json');
+    const mergedCssFilePath = path_1.default.resolve(runtimeDir, 'icons.css');
+    const mergedJsonFilePath = path_1.default.resolve(platformAssetsDir, 'icons.json');
+    const rnvC = {
+        runtime: {
+            appId: 'appId',
+        },
+        platform: 'platform1',
+        paths: {
+            project: {
+                dir: projectDir,
+                builds: {
+                    dir: path_1.default.resolve(projectDir, 'platformBuilds'),
+                },
+                assets: {
+                    dir: platformAssetsDir,
+                },
+            },
+        },
+        buildConfig: {
+            common: {
+                svgIconsMaskList: [],
+            },
+        },
+    };
+    beforeEach(() => {
+        fs_1.default.mkdirSync(iconsDir, { recursive: true });
+        fs_1.default.mkdirSync(rnvC.paths.project.builds.dir, { recursive: true });
+        fs_1.default.mkdirSync(runtimeDir, { recursive: true });
+        fs_1.default.writeFileSync(svgCssFilePath, 'svg_icons_css_content');
+        fs_1.default.writeFileSync(pngCssFilePath, 'png_icons_css_content');
+        fs_1.default.writeFileSync(svgJsonFilePath, JSON.stringify({ svg_icon_json_entry: '' }));
+        fs_1.default.writeFileSync(pngJsonFilePath, JSON.stringify({ png_icon_json_entry: '' }));
+        console.log = () => { };
+    });
+    afterEach(() => {
+        fs_1.default.rmdirSync(projectDir, { recursive: true });
+        console.log = originalConsoleLogFn;
+    });
+    it('should create icons files from svg_icons and png_icons', () => {
+        (0, mergeSvgAndPngIcons_1.mergeSvgAndPngIcons)(rnvC);
+        const mergedCssContentRows = fs_1.default.readFileSync(mergedCssFilePath).toString().split('\n');
+        expect(mergedCssContentRows).toHaveLength(2);
+        expect(mergedCssContentRows[0]).toBe('svg_icons_css_content');
+        expect(mergedCssContentRows[1]).toBe('png_icons_css_content');
+        const mergedJsonContent = JSON.parse(fs_1.default.readFileSync(mergedJsonFilePath).toString());
+        expect(mergedJsonContent).toMatchObject({
+            svg_icon_json_entry: '',
+            png_icon_json_entry: '',
+        });
+    });
+    it('should create icons files from svg_icons when png_icons does not exist', () => {
+        (0, child_process_1.execSync)(`rm -rf ${pngCssFilePath}`);
+        (0, child_process_1.execSync)(`rm -rf ${pngJsonFilePath}`);
+        (0, mergeSvgAndPngIcons_1.mergeSvgAndPngIcons)(rnvC);
+        const mergedCssContentRows = fs_1.default.readFileSync(mergedCssFilePath).toString().split('\n');
+        expect(mergedCssContentRows).toHaveLength(1);
+        expect(mergedCssContentRows[0]).toBe('svg_icons_css_content');
+        const mergedJsonContent = JSON.parse(fs_1.default.readFileSync(mergedJsonFilePath).toString());
+        expect(mergedJsonContent).toMatchObject({
+            svg_icon_json_entry: '',
+        });
+    });
+    it('should create icons files from png_icons when svg_icons does not exist', () => {
+        (0, child_process_1.execSync)(`rm -rf ${svgCssFilePath}`);
+        (0, child_process_1.execSync)(`rm -rf ${svgJsonFilePath}`);
+        (0, mergeSvgAndPngIcons_1.mergeSvgAndPngIcons)(rnvC);
+        const mergedCssContentRows = fs_1.default.readFileSync(mergedCssFilePath).toString().split('\n');
+        expect(mergedCssContentRows).toHaveLength(1);
+        expect(mergedCssContentRows[0]).toBe('png_icons_css_content');
+        const mergedJsonContent = JSON.parse(fs_1.default.readFileSync(mergedJsonFilePath).toString());
+        expect(mergedJsonContent).toMatchObject({
+            png_icon_json_entry: '',
+        });
+    });
+    it('should create blank icons files from when nothing exists', () => {
+        (0, child_process_1.execSync)(`rm -rf ${svgCssFilePath}`);
+        (0, child_process_1.execSync)(`rm -rf ${svgJsonFilePath}`);
+        (0, child_process_1.execSync)(`rm -rf ${pngCssFilePath}`);
+        (0, child_process_1.execSync)(`rm -rf ${pngJsonFilePath}`);
+        (0, mergeSvgAndPngIcons_1.mergeSvgAndPngIcons)(rnvC);
+        const mergedCssContentRows = fs_1.default.readFileSync(mergedCssFilePath).toString();
+        expect(mergedCssContentRows).toHaveLength(0);
+        const mergedJsonContent = JSON.parse(fs_1.default.readFileSync(mergedJsonFilePath).toString());
+        expect(mergedJsonContent).toMatchObject({});
+    });
+    it('should remove svg_icons.css and png_icons.css after merge', () => {
+        (0, mergeSvgAndPngIcons_1.mergeSvgAndPngIcons)(rnvC);
+        expect(fs_1.default.existsSync(mergedCssFilePath)).toBeTruthy();
+        expect(fs_1.default.existsSync(mergedJsonFilePath)).toBeTruthy();
+        expect(fs_1.default.existsSync(svgCssFilePath)).toBeFalsy();
+        expect(fs_1.default.existsSync(pngCssFilePath)).toBeFalsy();
+    });
+});