@genesislcap/build-kit 14.162.4-alpha-ea9526e.0 → 14.162.4

package/test/utils/build-context.test.ts

@@ -0,0 +1,68 @@
+import { basename, resolve } from 'node:path';
+import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+import { COMMAND } from '../../src/types';
+import { loadBuildContext } from '../../src/utils';
+
+const suite = createLogicSuite('Build context utils');
+
+suite('returns populated build context', async () => {
+  const actual = await loadBuildContext(process.cwd(), COMMAND.DEV, { foo: 'bar' });
+
+  assert.equal(actual.cli, {
+    command: 'dev',
+    isDev: true,
+    isAnalyze: false,
+    isBuild: false,
+    isTest: false,
+    isRun: false,
+    isLint: false,
+    options: {
+      foo: 'bar',
+    },
+  });
+
+  assert.equal(actual.env, {
+    isCI: !!process.env.CI,
+  });
+
+  assert.equal(actual.enable, {
+    apiExtractor: null,
+    cemAnalyzer: null,
+    mft: null,
+  });
+
+  assert.equal(actual.config, {
+    app: {},
+    builder: {
+      default: 'webpack',
+      dev: 'vite',
+      lint: 'eslint-stylelint',
+      test: 'uvu-playwright',
+    },
+    clean: true,
+    copyAssets: ['**/*.{css,jpg,png,svg,mp4,ogg,webm}'],
+    env: [
+      'API_HOST',
+      'DEFAULT_ORGANISATION',
+      'DEFAULT_USER',
+      'DEFAULT_PASSWORD',
+      'ENABLE_SSO',
+      'GENX.*',
+      'GENX_*',
+      'FORCE_HTTP',
+      'SOCKET_EXT',
+    ],
+    federation: {
+      name: 'buildKit',
+      remotes: {},
+      shared: {},
+    },
+  });
+
+  assert.equal(actual.pkg.name, '@genesislcap/build-kit');
+
+  assert.equal(basename(actual.dirs.cwd), 'build-kit');
+  assert.equal(basename(actual.dirs.workspace || ''), basename(resolve('../../../..')));
+});
+
+suite.run();

package/test/utils/env.test.ts

@@ -0,0 +1,212 @@
+import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+import type { BuildContext } from '../../src/types';
+import { ENV } from '../../src/types';
+import { setEnvVars, setNodeEnv } from '../../src/utils';
+
+const suite1 = createLogicSuite('setNodeEnv');
+
+suite1('updates NODE_ENV', () => {
+  setNodeEnv(ENV.TEST);
+  assert.is(process.env.NODE_ENV, ENV.TEST);
+});
+
+suite1('can handle repeated calls', () => {
+  setNodeEnv(ENV.DEV);
+  setNodeEnv(ENV.DEV);
+  assert.is(process.env.NODE_ENV, ENV.DEV);
+});
+
+suite1.run();
+
+const suite2 = createLogicSuite('setEnvVars');
+
+suite2('should handle multiple -e arguments', () => {
+  const mockContext = {
+    pkg: {},
+    cli: {
+      options: {
+        env: ['KEY1=VAL1', 'KEY2=VAL2'],
+      },
+    },
+  };
+  setEnvVars(mockContext as unknown as BuildContext);
+  assert.is(process.env.KEY1, 'VAL1');
+  assert.is(process.env.KEY2, 'VAL2');
+});
+
+suite2('should handle multiple -e arguments with the same key', () => {
+  const mockContext = {
+    pkg: {},
+    cli: {
+      options: {
+        env: ['KEY1=VAL1', 'KEY1=VAL2'],
+      },
+    },
+  };
+  setEnvVars(mockContext as unknown as BuildContext);
+  assert.is(process.env.KEY1, 'VAL2');
+});
+
+suite2('should handle -e KEY (config[KEY] exists in package.json - string)', () => {
+  const mockContext = {
+    pkg: {
+      config: {
+        KEY: 'ABC',
+      },
+    },
+    cli: {
+      options: {
+        env: 'KEY',
+      },
+    },
+  };
+  setEnvVars(mockContext as unknown as BuildContext);
+  assert.is(process.env.KEY, mockContext.pkg.config.KEY);
+});
+
+suite2('should handle -e KEY (config[KEY] exists in package.json - number)', () => {
+  const mockContext = {
+    pkg: {
+      config: {
+        KEY: 5,
+      },
+    },
+    cli: {
+      options: {
+        env: 'KEY',
+      },
+    },
+  };
+  setEnvVars(mockContext as unknown as BuildContext);
+  assert.is(process.env.KEY, `${mockContext.pkg.config.KEY}`);
+});
+
+suite2('should handle -e KEY (config[KEY] exists in package.json - boolean false)', () => {
+  const mockContext = {
+    pkg: {
+      config: {
+        KEY: false,
+      },
+    },
+    cli: {
+      options: {
+        env: 'KEY',
+      },
+    },
+  };
+  setEnvVars(mockContext as unknown as BuildContext);
+  assert.is(process.env.KEY, `${mockContext.pkg.config.KEY}`);
+});
+
+suite2('should handle -e KEY (config[KEY] exists in package.json - boolean true)', () => {
+  const mockContext = {
+    pkg: {
+      config: {
+        KEY: true,
+      },
+    },
+    cli: {
+      options: {
+        env: 'KEY',
+      },
+    },
+  };
+  setEnvVars(mockContext as unknown as BuildContext);
+  assert.is(process.env.KEY, `${mockContext.pkg.config.KEY}`);
+});
+
+// -e CI
+suite2("should handle -e KEY (config[KEY] doesn't exist in package.json)", () => {
+  const mockContext = {
+    pkg: {
+      config: {},
+    },
+    cli: {
+      options: {
+        env: 'KEY',
+      },
+    },
+  };
+  setEnvVars(mockContext as unknown as BuildContext);
+  assert.is(process.env.KEY, '1');
+});
+
+// -e API_HOST=API_HOST_DEV1 (where API_HOST_DEV1 exists in config)
+suite2('should handle -e KEY=VAL (config[VAL] exists in package.json - string)', () => {
+  const mockContext = {
+    pkg: {
+      config: {
+        KEY: 'ABC',
+        VAL: 'XYZ',
+      },
+    },
+    cli: {
+      options: {
+        env: 'KEY=VAL',
+      },
+    },
+  };
+  setEnvVars(mockContext as unknown as BuildContext);
+  assert.is(process.env.KEY, mockContext.pkg.config.VAL);
+});
+
+suite2('should handle -e KEY=VAL (config[VAL] exists in package.json - boolean false)', () => {
+  const mockContext = {
+    pkg: {
+      config: {
+        KEY: 'ABC',
+        VAL: false,
+      },
+    },
+    cli: {
+      options: {
+        env: 'KEY=VAL',
+      },
+    },
+  };
+  setEnvVars(mockContext as unknown as BuildContext);
+  assert.is(process.env.KEY, `${mockContext.pkg.config.VAL}`);
+});
+
+// referencing enother env var
+suite2(
+  "should handle -e KEY=VAL (config[VAL] doesn't exist in package.json, process.env[VAL] exists)",
+  () => {
+    const mockContext = {
+      pkg: {
+        config: {},
+      },
+      cli: {
+        options: {
+          env: 'KEY=VAL',
+        },
+      },
+    };
+    const VAL = 'ABC';
+    process.env.VAL = VAL;
+    setEnvVars(mockContext as unknown as BuildContext);
+    assert.is(process.env.KEY, VAL);
+    delete process.env.VAL;
+  },
+);
+
+// -e KEY=literal e.g. -e API_HOST=ws://host/
+suite2(
+  "should handle -e KEY=VAL (config[VAL] doesn't exist in package.json, process.env[VAL] doesn't exist)",
+  () => {
+    const mockContext = {
+      pkg: {
+        config: {},
+      },
+      cli: {
+        options: {
+          env: 'KEY=VAL',
+        },
+      },
+    };
+    setEnvVars(mockContext as unknown as BuildContext);
+    assert.is(process.env.KEY, 'VAL');
+  },
+);
+
+suite2.run();

package/test/utils/handlebars.test.ts

@@ -0,0 +1,277 @@
+import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+import { render } from '../../src/utils';
+
+const suite = createLogicSuite('Handlebars templating utils');
+
+const scenarios = [
+  {
+    description: 'upperCase',
+    template: '{ "name": "{{upperCase name}}" }',
+    data: { name: 'Abc' },
+    expected: '{ "name": "ABC" }',
+  },
+  {
+    description: 'upperCase (non-existing variable)',
+    template: '{ "name": "{{upperCase doesnotexist}}" }',
+    data: {},
+    expected: '{ "name": "" }',
+  },
+
+  {
+    description: 'lowerCase',
+    template: '{ "name": "{{lowerCase name}}" }',
+    data: { name: 'AbC' },
+    expected: '{ "name": "abc" }',
+  },
+  {
+    description: 'lowerCase (non-existing variable)',
+    template: '{ "name": "{{lowerCase doesnotexist}}" }',
+    data: {},
+    expected: '{ "name": "" }',
+  },
+
+  {
+    description: 'kebabCase',
+    template: '{ "name": "{{kebabCase name}}" }',
+    data: { name: 'AbCd' },
+    expected: '{ "name": "ab-cd" }',
+  },
+  {
+    description: 'kebabCase',
+    template: '{ "name": "{{kebabCase name}}" }',
+    data: { name: 'ab.cd' },
+    expected: '{ "name": "ab-cd" }',
+  },
+  {
+    description: 'kebabCase',
+    template: '{ "name": "{{kebabCase name}}" }',
+    data: { name: 'ab cd' },
+    expected: '{ "name": "ab-cd" }',
+  },
+  {
+    description: 'kebabCase',
+    template: '{ "name": "{{kebabCase doesnotexist}}" }',
+    data: { name: 'ab cd' },
+    expected: '{ "name": "" }',
+  },
+
+  {
+    description: 'camelCase',
+    template: '{ "name": "{{camelCase name}}" }',
+    data: { name: 'AbCd' },
+    expected: '{ "name": "abCd" }',
+  },
+  {
+    description: 'camelCase',
+    template: '{ "name": "{{camelCase name}}" }',
+    data: { name: 'ab.cd' },
+    expected: '{ "name": "abCd" }',
+  },
+  {
+    description: 'camelCase',
+    template: '{ "name": "{{camelCase name}}" }',
+    data: { name: 'ab cd' },
+    expected: '{ "name": "abCd" }',
+  },
+  {
+    description: 'camelCase',
+    template: '{ "name": "{{camelCase doesnotexist}}" }',
+    data: { name: 'ab cd' },
+    expected: '{ "name": "" }',
+  },
+
+  {
+    description: 'capitalCase',
+    template: '{ "name": "{{capitalCase name}}" }',
+    data: { name: 'AbCd' },
+    expected: '{ "name": "Ab Cd" }',
+  },
+  {
+    description: 'capitalCase',
+    template: '{ "name": "{{capitalCase name}}" }',
+    data: { name: 'ab.cd' },
+    expected: '{ "name": "Ab Cd" }',
+  },
+  {
+    description: 'capitalCase',
+    template: '{ "name": "{{capitalCase name}}" }',
+    data: { name: 'ab cd' },
+    expected: '{ "name": "Ab Cd" }',
+  },
+  {
+    description: 'capitalCase',
+    template: '{ "name": "{{capitalCase doesnotexist}}" }',
+    data: { name: 'ab cd' },
+    expected: '{ "name": "" }',
+  },
+
+  {
+    description: 'snakeCase',
+    template: '{ "name": "{{snakeCase name}}" }',
+    data: { name: 'AbCd' },
+    expected: '{ "name": "ab_cd" }',
+  },
+  {
+    description: 'snakeCase',
+    template: '{ "name": "{{snakeCase name}}" }',
+    data: { name: 'ab.cd' },
+    expected: '{ "name": "ab_cd" }',
+  },
+  {
+    description: 'snakeCase',
+    template: '{ "name": "{{snakeCase name}}" }',
+    data: { name: 'ab cd' },
+    expected: '{ "name": "ab_cd" }',
+  },
+  {
+    description: 'snakeCase',
+    template: '{ "name": "{{snakeCase doesnotexist}}" }',
+    data: { name: 'ab cd' },
+    expected: '{ "name": "" }',
+  },
+
+  {
+    description: 'dotCase',
+    template: '{ "name": "{{dotCase name}}" }',
+    data: { name: 'AbCd' },
+    expected: '{ "name": "ab.cd" }',
+  },
+  {
+    description: 'dotCase',
+    template: '{ "name": "{{dotCase name}}" }',
+    data: { name: 'ab.cd' },
+    expected: '{ "name": "ab.cd" }',
+  },
+  {
+    description: 'dotCase',
+    template: '{ "name": "{{dotCase name}}" }',
+    data: { name: 'ab cd' },
+    expected: '{ "name": "ab.cd" }',
+  },
+  {
+    description: 'dotCase',
+    template: '{ "name": "{{dotCase doesnotexist}}" }',
+    data: { name: 'ab cd' },
+    expected: '{ "name": "" }',
+  },
+
+  {
+    description: 'pascalCase',
+    template: '{ "name": "{{pascalCase name}}" }',
+    data: { name: 'AbCd' },
+    expected: '{ "name": "AbCd" }',
+  },
+  {
+    description: 'pascalCase',
+    template: '{ "name": "{{pascalCase name}}" }',
+    data: { name: 'ab.cd' },
+    expected: '{ "name": "AbCd" }',
+  },
+  {
+    description: 'pascalCase',
+    template: '{ "name": "{{pascalCase name}}" }',
+    data: { name: 'ab cd' },
+    expected: '{ "name": "AbCd" }',
+  },
+  {
+    description: 'pascalCase',
+    template: '{ "name": "{{pascalCase doesnotexist}}" }',
+    data: { name: 'ab cd' },
+    expected: '{ "name": "" }',
+  },
+
+  {
+    description: 'sentenceCase',
+    template: '{ "name": "{{sentenceCase name}}" }',
+    data: { name: 'AbCd' },
+    expected: '{ "name": "Ab cd" }',
+  },
+  {
+    description: 'sentenceCase',
+    template: '{ "name": "{{sentenceCase name}}" }',
+    data: { name: 'ab.cd' },
+    expected: '{ "name": "Ab cd" }',
+  },
+  {
+    description: 'sentenceCase',
+    template: '{ "name": "{{sentenceCase name}}" }',
+    data: { name: 'ab cd' },
+    expected: '{ "name": "Ab cd" }',
+  },
+  {
+    description: 'sentenceCase',
+    template: '{ "name": "{{sentenceCase doesnotexist}}" }',
+    data: { name: 'ab cd' },
+    expected: '{ "name": "" }',
+  },
+
+  {
+    description: 'pathCase',
+    template: '{ "name": "{{pathCase name}}" }',
+    data: { name: 'AbCd' },
+    expected: '{ "name": "ab/cd" }',
+  },
+  {
+    description: 'pathCase',
+    template: '{ "name": "{{pathCase name}}" }',
+    data: { name: 'ab.cd' },
+    expected: '{ "name": "ab/cd" }',
+  },
+  {
+    description: 'pathCase',
+    template: '{ "name": "{{pathCase name}}" }',
+    data: { name: 'ab cd' },
+    expected: '{ "name": "ab/cd" }',
+  },
+  {
+    description: 'pathCase',
+    template: '{ "name": "{{pathCase doesnotexist}}" }',
+    data: { name: 'ab cd' },
+    expected: '{ "name": "" }',
+  },
+
+  {
+    description: 'constantCase',
+    template: '{ "name": "{{constantCase name}}" }',
+    data: { name: 'AbCd' },
+    expected: '{ "name": "AB_CD" }',
+  },
+  {
+    description: 'constantCase',
+    template: '{ "name": "{{constantCase name}}" }',
+    data: { name: 'ab.cd' },
+    expected: '{ "name": "AB_CD" }',
+  },
+  {
+    description: 'constantCase',
+    template: '{ "name": "{{constantCase name}}" }',
+    data: { name: 'ab cd' },
+    expected: '{ "name": "AB_CD" }',
+  },
+  {
+    description: 'constantCase',
+    template: '{ "name": "{{constantCase doesnotexist}}" }',
+    data: { name: 'ab cd' },
+    expected: '{ "name": "" }',
+  },
+  {
+    description: 'ifEquals',
+    template: '{{#ifEquals type "pie"}}true{{/ifEquals}}',
+    data: { type: 'pie' },
+    expected: 'true',
+  },
+  {
+    description: 'ifEquals',
+    template: '{{#ifEquals type "pie"}}true{{else}}false{{/ifEquals}}',
+    data: { type: 'line' },
+    expected: 'false',
+  },
+];
+
+scenarios.forEach((scenario) => {
+  suite(scenario.description, () => {
+    assert.is(render(scenario.template, scenario.data), scenario.expected);
+  });
+});
+
+suite.run();

package/test/utils/https.test.ts

@@ -0,0 +1,14 @@
+import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+import { getDevCertOptions } from '../../src/utils/https';
+
+const suite = createLogicSuite('https dev server');
+
+suite('should have default cert options', () => {
+  const options = getDevCertOptions();
+  assert.ok(
+    options,
+    'Dev server cert options could not be created. Please ensure the local cert and key is available in build-kit/cert and is being published.',
+  );
+});
+
+suite.run();

package/test/utils/proxy.test.ts

@@ -0,0 +1,96 @@
+import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+import type { ServerOptions } from 'http-proxy';
+import type { DevProxies } from '../../src/utils/proxy';
+import { convertWsEndpointToHTTP, createDevProxies, createDevProxy } from '../../src/utils/proxy';
+
+const suite = createLogicSuite('dev server proxies');
+
+suite('should convert websocket to http endpoints as expected', ({ runCases }) => {
+  runCases(convertWsEndpointToHTTP, [
+    [
+      ['wss://public-foundation.genesislab.global/gwf/', 'gwf'],
+      'https://public-foundation.genesislab.global/',
+    ],
+    [
+      ['wss://public-foundation.genesislab.global/gwf/'],
+      'https://public-foundation.genesislab.global/gwf/',
+    ],
+    [['wss://public-foundation.genesislab.global'], 'https://public-foundation.genesislab.global'],
+    [
+      ['ws://public-foundation.genesislab.global/gwf/', 'gwf'],
+      'http://public-foundation.genesislab.global/',
+    ],
+    [
+      ['ws://public-foundation.genesislab.global/gwf/'],
+      'http://public-foundation.genesislab.global/gwf/',
+    ],
+    [['ws://public-foundation.genesislab.global'], 'http://public-foundation.genesislab.global'],
+    [['wss://localhost:6060/gwf/', 'gwf'], 'https://localhost:6060/'],
+    [['ws://localhost:6060/gwf/', 'gwf'], 'http://localhost:6060/'],
+    [['ws://localhost:6060/gwf/'], 'http://localhost:6060/gwf/'],
+    [['ws://localhost:6060'], 'http://localhost:6060'],
+  ]);
+});
+
+suite('createDevProxy should return the expected proxy for given target', () => {
+  const proxy = createDevProxy({
+    target: 'https://rte.ie',
+    path: '/api',
+    options: {
+      ws: false,
+      cookieDomainRewrite: {
+        'old.domain': 'new.domain',
+        '*': '',
+      },
+    },
+  });
+  const expectedProxy: DevProxies = {
+    ['/api']: {
+      target: 'https://rte.ie',
+      secure: false,
+      changeOrigin: true,
+      cookieDomainRewrite: {
+        'old.domain': 'new.domain',
+        '*': '',
+      },
+      ws: false,
+      headers: {
+        origin: 'https://rte.ie',
+      },
+    },
+  };
+  assert.equal(proxy, expectedProxy);
+});
+
+suite('createDevProxy should return undefined when no target or API_HOST is set', () => {
+  assert.not.ok(createDevProxy({ path: '/api' }));
+  assert.not.ok(createDevProxy({}));
+});
+
+suite('createDevProxies should return default proxies for given target', () => {
+  const proxies = createDevProxies({ target: 'https://rte.ie' });
+  const expectedServerOptions: ServerOptions = {
+    target: 'https://rte.ie',
+    secure: false,
+    changeOrigin: true,
+    cookieDomainRewrite: 'localhost',
+    ws: true,
+    headers: {
+      origin: 'https://rte.ie',
+    },
+  };
+  const expectedProxies: DevProxies = {
+    ['/sm']: expectedServerOptions,
+    ['/sso']: expectedServerOptions,
+    ['/gwf']: expectedServerOptions,
+  };
+  assert.equal(proxies, expectedProxies);
+});
+
+// TODO: Double-check this one vs API_HOST requirement to not be set (fails on dev machines vs works on CI)
+// suite('createDevProxies should return undefined when no target or API_HOST is set', () => {
+//   assert.not.ok(createDevProxies({ paths: ['/sm', '/gwf'] }));
+//   assert.not.ok(createDevProxies());
+// });
+
+suite.run();