@atlassian/webresource-webpack-plugin 4.10.2-64a2ef2

package/test/use-cases/specify-explicit-context/specify-explicit-context.test.js

@@ -0,0 +1,89 @@
+const assert = require('chai').assert;
+const parse = require('xml-parser');
+const webpack = require('webpack');
+const fs = require('fs');
+const path = require('path');
+
+const targetDir = path.join(__dirname, 'target');
+const webresourceOutput = path.join(targetDir, 'META-INF', 'plugin-descriptor', 'wr-webpack-bundles.xml');
+
+describe('specify-explicit-context', function() {
+    const config = require('./webpack.config.js');
+
+    let stats;
+    let error;
+    let wrNodes;
+
+    function getWebresourceLike(needle) {
+        return wrNodes.find(n => n.attributes.key.indexOf(needle) > -1);
+    }
+
+    function getContexts(node) {
+        return node.children.filter(n => n.name === 'context');
+    }
+
+    function getContent(nodes) {
+        return nodes.map(n => n.content);
+    }
+
+    beforeEach(done => {
+        webpack(config, (err, st) => {
+            error = err;
+            stats = st;
+
+            const xmlFile = fs.readFileSync(webresourceOutput, 'utf-8');
+            const results = parse(xmlFile);
+            wrNodes = results.root.children.filter(n => n.attributes.key.startsWith('entry'));
+            done();
+        });
+    });
+
+    it('should run without error', () => {
+        assert.ok(wrNodes);
+        assert.equal(stats.hasErrors(), false);
+        assert.equal(stats.hasWarnings(), false);
+    });
+
+    it('should add additional contexts as specified in the contextMap', () => {
+        const wrWithGoodConfig = getWebresourceLike('good-newcontexts');
+        const contexts = getContent(getContexts(wrWithGoodConfig));
+        assert.ok(contexts);
+        assert.equal(contexts.length, 3);
+        assert.include(contexts, 'some:weird:context');
+        assert.include(contexts, 'foo.bar');
+        assert.include(contexts, 'app-good-newcontexts');
+    });
+
+    it('should add the entrypoint name as a context when there is no contextMap config for it', () => {
+        const wrWithImplicitConfig = getWebresourceLike('good-implicit');
+        const contexts = getContent(getContexts(wrWithImplicitConfig));
+        assert.ok(contexts);
+        assert.equal(contexts.length, 1);
+        assert.include(contexts, 'app-good-implicit');
+    });
+
+    it('should ignore non-array configuration values gracefully', () => {
+        const wrWithBadConfig = getWebresourceLike('bad-objectlike');
+        const contexts = getContent(getContexts(wrWithBadConfig));
+        assert.ok(contexts);
+        assert.equal(contexts.length, 1);
+        assert.include(contexts, 'app-bad-objectlike');
+    });
+
+    it('should ignore falsy configuration values gracefully', () => {
+        const wrWithBadConfig = getWebresourceLike('bad-falsy');
+        const contexts = getContent(getContexts(wrWithBadConfig));
+        assert.ok(contexts);
+        assert.equal(contexts.length, 1);
+        assert.include(contexts, 'app-bad-falsy');
+    });
+
+    it('should ignore non-string context names gracefully', () => {
+        const wrWithBadValues = getWebresourceLike('bad-emptyvalues');
+        const contexts = getContent(getContexts(wrWithBadValues));
+        assert.ok(contexts);
+        assert.equal(contexts.length, 2);
+        assert.include(contexts, 'app-bad-emptyvalues');
+        assert.include(contexts, 'foo.bar');
+    });
+});

package/test/use-cases/specify-explicit-context/src/app.js

@@ -0,0 +1,5 @@
+import $ from 'jquery';
+
+$(() => {
+    $('body').html('hello world');
+});

package/test/use-cases/specify-explicit-context/webpack.config.js

@@ -0,0 +1,34 @@
+const path = require('path');
+const WrmPlugin = require('../../../src/WrmPlugin');
+const FRONTEND_SRC_DIR = path.join(__dirname, 'src');
+const OUTPUT_DIR = path.join(__dirname, 'target');
+
+module.exports = {
+    mode: 'development',
+    entry: {
+        'app-good-newcontexts': path.join(FRONTEND_SRC_DIR, 'app.js'),
+        'app-good-implicit': path.join(FRONTEND_SRC_DIR, 'app.js'),
+        'app-bad-emptyarray': path.join(FRONTEND_SRC_DIR, 'app.js'),
+        'app-bad-emptyvalues': path.join(FRONTEND_SRC_DIR, 'app.js'),
+        'app-bad-objectlike': path.join(FRONTEND_SRC_DIR, 'app.js'),
+        'app-bad-falsy': path.join(FRONTEND_SRC_DIR, 'app.js'),
+    },
+    plugins: [
+        new WrmPlugin({
+            pluginKey: 'com.atlassian.plugin.test',
+            xmlDescriptors: path.join(OUTPUT_DIR, 'META-INF', 'plugin-descriptor', 'wr-webpack-bundles.xml'),
+            contextMap: {
+                'app-good-newcontexts': ['some:weird:context', 'foo.bar'],
+                'app-bad-emptyarray': [],
+                'app-bad-emptyvalues': [false, '', undefined, 'foo.bar'],
+                'app-bad-objectlike': {},
+                'app-bad-falsy': '',
+            },
+            verbose: false,
+        }),
+    ],
+    output: {
+        filename: '[name].js',
+        path: OUTPUT_DIR,
+    },
+};

package/test/use-cases/specify-explicit-context-no-autogenerated/specify-explicit-context-no-autogenerated.test.js

@@ -0,0 +1,84 @@
+const assert = require('chai').assert;
+const parse = require('xml-parser');
+const webpack = require('webpack');
+const fs = require('fs');
+const path = require('path');
+
+const targetDir = path.join(__dirname, 'target');
+const webresourceOutput = path.join(targetDir, 'META-INF', 'plugin-descriptor', 'wr-webpack-bundles.xml');
+
+describe('specify-explicit-context (with no auto-generated values)', function() {
+    const config = require('./webpack.config.js');
+
+    let stats;
+    let error;
+    let wrNodes;
+
+    function getWebresourceLike(needle) {
+        return wrNodes.find(n => n.attributes.key.indexOf(needle) > -1);
+    }
+
+    function getContexts(node) {
+        return node.children.filter(n => n.name === 'context');
+    }
+
+    function getContent(nodes) {
+        return nodes.map(n => n.content);
+    }
+
+    beforeEach(done => {
+        webpack(config, (err, st) => {
+            error = err;
+            stats = st;
+
+            const xmlFile = fs.readFileSync(webresourceOutput, 'utf-8');
+            const results = parse(xmlFile);
+            wrNodes = results.root.children.filter(n => n.attributes.key.startsWith('entry'));
+            done();
+        });
+    });
+
+    it('should run without error', () => {
+        assert.ok(wrNodes);
+        assert.equal(stats.hasErrors(), false);
+        assert.equal(stats.hasWarnings(), false);
+    });
+
+    it('should add additional contexts as specified in the contextMap', () => {
+        const wrWithGoodConfig = getWebresourceLike('good-newcontexts');
+        const contexts = getContent(getContexts(wrWithGoodConfig));
+        assert.ok(contexts);
+        assert.include(contexts, 'some:weird:context');
+        assert.include(contexts, 'foo.bar');
+        assert.notInclude(contexts, 'app-good-newcontexts');
+    });
+
+    it('should add the entrypoint name as a context when there is no contextMap config for it', () => {
+        const wrWithImplicitConfig = getWebresourceLike('good-implicit');
+        const contexts = getContent(getContexts(wrWithImplicitConfig));
+        assert.ok(contexts);
+        assert.equal(contexts.length, 0);
+    });
+
+    it('should ignore non-array configuration values gracefully', () => {
+        const wrWithBadConfig = getWebresourceLike('bad-objectlike');
+        const contexts = getContent(getContexts(wrWithBadConfig));
+        assert.ok(contexts);
+        assert.equal(contexts.length, 0);
+    });
+
+    it('should ignore falsy configuration values gracefully', () => {
+        const wrWithBadConfig = getWebresourceLike('bad-falsy');
+        const contexts = getContent(getContexts(wrWithBadConfig));
+        assert.ok(contexts);
+        assert.equal(contexts.length, 0);
+    });
+
+    it('should ignore non-string context names gracefully', () => {
+        const wrWithBadValues = getWebresourceLike('bad-emptyvalues');
+        const contexts = getContent(getContexts(wrWithBadValues));
+        assert.ok(contexts);
+        assert.include(contexts, 'foo.bar');
+        assert.notInclude(contexts, 'app-bad-emptyvalues');
+    });
+});

package/test/use-cases/specify-explicit-context-no-autogenerated/src/app.js

@@ -0,0 +1,5 @@
+import $ from 'jquery';
+
+$(() => {
+    $('body').html('hello world');
+});

package/test/use-cases/specify-explicit-context-no-autogenerated/webpack.config.js

@@ -0,0 +1,35 @@
+const path = require('path');
+const WrmPlugin = require('../../../src/WrmPlugin');
+const FRONTEND_SRC_DIR = path.join(__dirname, 'src');
+const OUTPUT_DIR = path.join(__dirname, 'target');
+
+module.exports = {
+    mode: 'development',
+    entry: {
+        'app-good-newcontexts': path.join(FRONTEND_SRC_DIR, 'app.js'),
+        'app-good-implicit': path.join(FRONTEND_SRC_DIR, 'app.js'),
+        'app-bad-emptyarray': path.join(FRONTEND_SRC_DIR, 'app.js'),
+        'app-bad-emptyvalues': path.join(FRONTEND_SRC_DIR, 'app.js'),
+        'app-bad-objectlike': path.join(FRONTEND_SRC_DIR, 'app.js'),
+        'app-bad-falsy': path.join(FRONTEND_SRC_DIR, 'app.js'),
+    },
+    plugins: [
+        new WrmPlugin({
+            pluginKey: 'com.atlassian.plugin.test',
+            xmlDescriptors: path.join(OUTPUT_DIR, 'META-INF', 'plugin-descriptor', 'wr-webpack-bundles.xml'),
+            addEntrypointNameAsContext: false,
+            contextMap: {
+                'app-good-newcontexts': ['some:weird:context', 'foo.bar'],
+                'app-bad-emptyarray': [],
+                'app-bad-emptyvalues': [false, '', undefined, 'foo.bar'],
+                'app-bad-objectlike': {},
+                'app-bad-falsy': '',
+            },
+            verbose: false,
+        }),
+    ],
+    output: {
+        filename: '[name].js',
+        path: OUTPUT_DIR,
+    },
+};

package/test/use-cases/specify-explicit-name/specify-explicit-name.test.js

@@ -0,0 +1,110 @@
+const assert = require('chai').assert;
+const parse = require('xml-parser');
+const webpack = require('webpack');
+const fs = require('fs');
+const path = require('path');
+
+const targetDir = path.join(__dirname, 'target');
+const webresourceOutput = path.join(targetDir, 'META-INF', 'plugin-descriptor', 'wr-webpack-bundles.xml');
+
+describe('specify-explicit-webresource-name', function() {
+    const config = require('./webpack.config.js');
+
+    let stats;
+    let wrNodes;
+
+    function findWrEndingWith(key) {
+        return wrNodes.find(n => n.attributes.key.endsWith(key));
+    }
+
+    beforeEach(done => {
+        webpack(config, (err, st) => {
+            stats = st;
+
+            const xmlFile = fs.readFileSync(webresourceOutput, 'utf-8');
+            const results = parse(xmlFile);
+            wrNodes = results.root.children.filter(n => n.name === 'web-resource');
+            done();
+        });
+    });
+
+    it('should work without error', () => {
+        assert.notEqual(wrNodes.length, 0);
+        assert.equal(stats.hasErrors(), false);
+        assert.equal(stats.hasWarnings(), false);
+    });
+
+    it('should create a webresource with an explicit name when it is mapped in config', () => {
+        let node = findWrEndingWith('mapped-with-string');
+        assert.exists(node);
+        assert.propertyVal(node.attributes, 'key', 'customkey-mapped-with-string');
+    });
+
+    it('should create a webresource with an explicit key when it is mapped in config', () => {
+        let node = findWrEndingWith('mapped-with-object');
+        assert.exists(node);
+        assert.propertyVal(node.attributes, 'key', 'customkey-mapped-with-object');
+    });
+
+    it('should create a webresource with an explicit name when it is mapped in config', () => {
+        let node = findWrEndingWith('mapped-with-object-with-only-name');
+        assert.exists(node);
+        assert.property(
+            node.attributes,
+            'key',
+            'entrypoint-app-good-mapped-with-object-with-only-name',
+            'no "key" was provided so should be auto-generated'
+        );
+        assert.propertyVal(
+            node.attributes,
+            'name',
+            'Legacy Name for App 2',
+            'should use the configured value for "name"'
+        );
+    });
+
+    it('should create a webresource with an explicit key and name when it is mapped in config', () => {
+        let node = findWrEndingWith('mapped-with-object-with-name');
+        assert.exists(node);
+        assert.propertyVal(
+            node.attributes,
+            'key',
+            'customkey-mapped-with-object-with-name',
+            'should use the configured value for "key"'
+        );
+        assert.propertyVal(
+            node.attributes,
+            'name',
+            'Legacy Name for App 1',
+            'should use the configured value for "name"'
+        );
+    });
+
+    it('should auto-generate the name if there is no config provided', () => {
+        let node = findWrEndingWith('app-good-autonamed');
+        assert.exists(node);
+        assert.propertyVal(
+            node.attributes,
+            'key',
+            'entrypoint-app-good-autonamed',
+            'there was no mapping for this web-resource, so the key is auto-generated'
+        );
+    });
+
+    it('should auto-generate the name when the supplied value is not a string', () => {
+        let badNodes = wrNodes.filter(n => n.attributes.key.startsWith('entrypoint-app-bad'));
+        assert.equal(badNodes.length, 2);
+        assert.propertyVal(
+            badNodes[0].attributes,
+            'key',
+            'entrypoint-app-bad-objectlike',
+            'an object is not a string, so the key is auto-generated'
+        );
+        assert.propertyVal(
+            badNodes[1].attributes,
+            'key',
+            'entrypoint-app-bad-falsy',
+            'falsy values are not strings, so the key is auto-generated'
+        );
+    });
+});

package/test/use-cases/specify-explicit-name/src/app.js

@@ -0,0 +1,5 @@
+import $ from 'jquery';
+
+$(() => {
+    $('body').html('hello world');
+});

package/test/use-cases/specify-explicit-name/webpack.config.js

@@ -0,0 +1,43 @@
+const path = require('path');
+const WrmPlugin = require('../../../src/WrmPlugin');
+const FRONTEND_SRC_DIR = path.join(__dirname, 'src');
+const OUTPUT_DIR = path.join(__dirname, 'target');
+
+module.exports = {
+    mode: 'development',
+    entry: {
+        'app-good-mapped-with-string': path.join(FRONTEND_SRC_DIR, 'app.js'),
+        'app-good-mapped-with-object': path.join(FRONTEND_SRC_DIR, 'app.js'),
+        'app-good-mapped-with-object-with-name': path.join(FRONTEND_SRC_DIR, 'app.js'),
+        'app-good-mapped-with-object-with-only-name': path.join(FRONTEND_SRC_DIR, 'app.js'),
+        'app-good-autonamed': path.join(FRONTEND_SRC_DIR, 'app.js'),
+        'app-bad-objectlike': path.join(FRONTEND_SRC_DIR, 'app.js'),
+        'app-bad-falsy': path.join(FRONTEND_SRC_DIR, 'app.js'),
+    },
+    plugins: [
+        new WrmPlugin({
+            pluginKey: 'com.atlassian.plugin.test',
+            xmlDescriptors: path.join(OUTPUT_DIR, 'META-INF', 'plugin-descriptor', 'wr-webpack-bundles.xml'),
+            webresourceKeyMap: {
+                'app-good-mapped-with-string': 'customkey-mapped-with-string',
+                'app-good-mapped-with-object': {
+                    key: 'customkey-mapped-with-object',
+                },
+                'app-good-mapped-with-object-with-name': {
+                    key: 'customkey-mapped-with-object-with-name',
+                    name: 'Legacy Name for App 1',
+                },
+                'app-good-mapped-with-object-with-only-name': {
+                    name: 'Legacy Name for App 2',
+                },
+                'app-bad-objectlike': {},
+                'app-bad-falsy': '',
+            },
+            verbose: false,
+        }),
+    ],
+    output: {
+        filename: '[name].js',
+        path: OUTPUT_DIR,
+    },
+};

package/test/use-cases/specify-explicit-state/specify-explicit-state.test.js

@@ -0,0 +1,96 @@
+const assert = require('chai').assert;
+const parse = require('xml-parser');
+const webpack = require('webpack');
+const fs = require('fs');
+const path = require('path');
+
+const targetDir = path.join(__dirname, 'target');
+const webresourceOutput = path.join(targetDir, 'META-INF', 'plugin-descriptor', 'wr-webpack-bundles.xml');
+
+describe('specify-explicit-webresource-state', function() {
+    const config = require('./webpack.config.js');
+
+    let stats;
+    let wrNodes;
+
+    function findWrEndingWith(key) {
+        return wrNodes.find(n => n.attributes.key.endsWith(key));
+    }
+
+    beforeEach(done => {
+        webpack(config, (err, st) => {
+            stats = st;
+
+            const xmlFile = fs.readFileSync(webresourceOutput, 'utf-8');
+            const results = parse(xmlFile);
+            wrNodes = results.root.children.filter(node => node.name === 'web-resource');
+            done();
+        });
+    });
+
+    it('should work without error', () => {
+        assert.notEqual(wrNodes.length, 0);
+        assert.equal(stats.hasErrors(), false);
+        assert.equal(stats.hasWarnings(), false);
+    });
+
+    describe('providing a plain string', () => {
+        it('should create a webresource with an implicit state', () => {
+            const node = findWrEndingWith('plain-string');
+            assert.exists(node);
+            assert.notProperty(
+                node.attributes,
+                'state',
+                'WRM assumes missing state means enabled, so attribute is unneeded'
+            );
+        });
+    });
+
+    describe('providing only a key', () => {
+        it('should create a webresource with an implicit state', () => {
+            const node = findWrEndingWith('only-key');
+            assert.exists(node);
+            assert.notProperty(
+                node.attributes,
+                'state',
+                'WRM assumes missing state means enabled, so attribute is unneeded'
+            );
+        });
+    });
+
+    describe('providing only a state', () => {
+        it('should create a webresource with an explicit state', () => {
+            const node = findWrEndingWith('only-state');
+            assert.exists(node);
+            assert.propertyVal(node.attributes, 'state', 'disabled');
+        });
+
+        it('should interpret a boolean of "true" as enabled', () => {
+            const node = findWrEndingWith('only-state-boolean-enabled');
+            assert.exists(node);
+            assert.propertyVal(node.attributes, 'state', 'enabled');
+        });
+
+        it('should interpret a boolean of "false" as disabled', () => {
+            const node = findWrEndingWith('only-state-boolean-disabled');
+            assert.exists(node);
+            assert.propertyVal(node.attributes, 'state', 'disabled');
+        });
+    });
+
+    describe('providing an explicit key and state', () => {
+        it('should create a webresource with explicit values when the state is "enabled"', () => {
+            const node = findWrEndingWith('key-state-enabled');
+            assert.exists(node);
+            assert.propertyVal(node.attributes, 'key', 'customkey-key-state-enabled');
+            assert.propertyVal(node.attributes, 'state', 'enabled');
+        });
+
+        it('should create a webresource with explicit values when the state is "disabled"', () => {
+            const node = findWrEndingWith('key-state-disabled');
+            assert.exists(node);
+            assert.propertyVal(node.attributes, 'key', 'customkey-key-state-disabled');
+            assert.propertyVal(node.attributes, 'state', 'disabled');
+        });
+    });
+});

package/test/use-cases/specify-explicit-state/src/app.js

@@ -0,0 +1,5 @@
+import $ from 'jquery';
+
+$(() => {
+    $('body').html('hello world');
+});

package/test/use-cases/specify-explicit-state/webpack.config.js

@@ -0,0 +1,51 @@
+const path = require('path');
+const WrmPlugin = require('../../../src/WrmPlugin');
+const FRONTEND_SRC_DIR = path.join(__dirname, 'src');
+const OUTPUT_DIR = path.join(__dirname, 'target');
+
+module.exports = {
+    mode: 'development',
+    entry: {
+        'plain-string': path.join(FRONTEND_SRC_DIR, 'app.js'),
+        'only-key': path.join(FRONTEND_SRC_DIR, 'app.js'),
+        'only-state': path.join(FRONTEND_SRC_DIR, 'app.js'),
+        'only-state-boolean-enabled': path.join(FRONTEND_SRC_DIR, 'app.js'),
+        'only-state-boolean-disabled': path.join(FRONTEND_SRC_DIR, 'app.js'),
+        'key-state-enabled': path.join(FRONTEND_SRC_DIR, 'app.js'),
+        'key-state-disabled': path.join(FRONTEND_SRC_DIR, 'app.js'),
+    },
+    plugins: [
+        new WrmPlugin({
+            pluginKey: 'com.atlassian.plugin.test',
+            xmlDescriptors: path.join(OUTPUT_DIR, 'META-INF', 'plugin-descriptor', 'wr-webpack-bundles.xml'),
+            webresourceKeyMap: {
+                'plain-string': 'customkey-plain-string',
+                'only-key': {
+                    key: 'customkey-only-key',
+                },
+                'only-state': {
+                    state: 'disabled',
+                },
+                'only-state-boolean-enabled': {
+                    state: true,
+                },
+                'only-state-boolean-disabled': {
+                    state: false,
+                },
+                'key-state-enabled': {
+                    key: 'customkey-key-state-enabled',
+                    state: 'enabled',
+                },
+                'key-state-disabled': {
+                    key: 'customkey-key-state-disabled',
+                    state: 'disabled',
+                },
+            },
+            verbose: false,
+        }),
+    ],
+    output: {
+        filename: '[name].js',
+        path: OUTPUT_DIR,
+    },
+};

package/test/use-cases/specify-transformation/disable-transformations.test.js

@@ -0,0 +1,77 @@
+const assert = require('chai').assert;
+const parse = require('xml-parser');
+const webpack = require('webpack');
+const fs = require('fs');
+const path = require('path');
+
+const targetDir = path.join(__dirname, 'target');
+const webresourceOutput = path.join(targetDir, 'META-INF', 'plugin-descriptor', 'wr-webpack-bundles.xml');
+
+describe('specify-transformation', function() {
+    const config = require('./webpack.disable-tranformations.config');
+
+    let stats;
+    let error;
+    let wrNodes;
+
+    function getWebresourceLike(needle) {
+        return wrNodes.find(n => n.attributes.key.indexOf(needle) > -1);
+    }
+
+    function getTransformation(node) {
+        return node.children.filter(childNode => childNode.name === 'transformation');
+    }
+
+    function getTransformationByExtension(transformations, extname) {
+        return transformations.filter(transformation => transformation.attributes.extension === extname)[0];
+    }
+
+    beforeEach(done => {
+        webpack(config, (err, st) => {
+            error = err;
+            stats = st;
+
+            const xmlFile = fs.readFileSync(webresourceOutput, 'utf-8');
+            const results = parse(xmlFile);
+            wrNodes = results.root.children;
+            done();
+        });
+    });
+
+    describe('disabling transformations', () => {
+        let entryJsTrans, entrySoyTrans, entryLessTrans;
+        let jsTrans, htmlTrans, lessTrans, soyTrans, svgTrans, txtTrans;
+
+        beforeEach(function() {
+            const entrypointTransformations = getTransformation(getWebresourceLike('app-one'));
+            const assetTransformations = getTransformation(getWebresourceLike('assets'));
+
+            assert.ok(entrypointTransformations);
+            assert.ok(assetTransformations);
+
+            entryJsTrans = getTransformationByExtension(entrypointTransformations, 'js');
+            entrySoyTrans = getTransformationByExtension(entrypointTransformations, 'soy');
+            entryLessTrans = getTransformationByExtension(entrypointTransformations, 'less');
+
+            jsTrans = getTransformationByExtension(assetTransformations, 'js');
+            htmlTrans = getTransformationByExtension(assetTransformations, 'html');
+            lessTrans = getTransformationByExtension(assetTransformations, 'less');
+            soyTrans = getTransformationByExtension(assetTransformations, 'soy');
+            svgTrans = getTransformationByExtension(assetTransformations, 'svg');
+            txtTrans = getTransformationByExtension(assetTransformations, 'txt');
+        });
+
+        it('should disable all transformations', () => {
+            assert.equal(entryJsTrans, null);
+            assert.equal(entryLessTrans, null);
+            assert.equal(entrySoyTrans, null);
+
+            assert.equal(jsTrans, null);
+            assert.equal(lessTrans, null);
+            assert.equal(htmlTrans, null);
+            assert.equal(soyTrans, null);
+            assert.equal(svgTrans, null);
+            assert.equal(txtTrans, null);
+        });
+    });
+});