actions/k8s-set-context
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Vidya reddy pretty code (#53)

Browse Source 
* updated action file with node16

* Code consistency using prettier and its workflow

* Enforce Prettier

* code fix

* code fix

* code fix

Co-authored-by: Vidya Reddy <vidyareddy@microsoft.com>
This commit is contained in:
Vidya Reddy 2022-06-24 16:08:48 -07:00 committed by GitHub
parent e972a5b196
commit b6c5bf067a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
37 changed files with 9089 additions and 9033 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
.github/ISSUE_TEMPLATE/issue--bug-report---feature-request.md vendored
View File

@ -1,7 +1,7 @@
---
name: "Issue: Bug Report / Feature Request"
name: 'Issue: Bug Report / Feature Request'
about: Create a report to help us improve
title: ""
title: ''
labels: need-to-triage
assignees: "@Azure/aks-atlanta"
assignees: '@Azure/aks-atlanta'
---

12
.github/workflows/default-labels.yml vendored
View File

@ -3,7 +3,7 @@ name: Setting Default Labels
# Controls when the action will run.
on:
schedule:
- cron: "0 0/3 * * *"
- cron: '0 0/3 * * *'
# A workflow run is made up of one or more jobs that can run sequentially or in parallel
jobs:
@ -17,19 +17,19 @@ jobs:
name: Setting Issue as Idle
with:
repo-token: ${{ secrets.GITHUB_TOKEN }}
stale-issue-message: "This issue is idle because it has been open for 14 days with no activity."
stale-issue-label: "idle"
stale-issue-message: 'This issue is idle because it has been open for 14 days with no activity.'
stale-issue-label: 'idle'
days-before-stale: 14
days-before-close: -1
operations-per-run: 100
exempt-issue-labels: "backlog"
exempt-issue-labels: 'backlog'
- uses: actions/stale@v3
name: Setting PR as Idle
with:
repo-token: ${{ secrets.GITHUB_TOKEN }}
stale-pr-message: "This PR is idle because it has been open for 14 days with no activity."
stale-pr-label: "idle"
stale-pr-message: 'This PR is idle because it has been open for 14 days with no activity.'
stale-pr-label: 'idle'
days-before-stale: 14
days-before-close: -1
operations-per-run: 100

4
.github/workflows/integration-tests.yml vendored
View File

@ -3,11 +3,11 @@ on:
pull_request:
branches:
- main
- "releases/*"
- 'releases/*'
push:
branches:
- main
- "releases/*"
- 'releases/*'
jobs:
kubeconfig-method-integration-test:

18
.github/workflows/prettify-code.yml vendored Normal file
View File

@ -0,0 +1,18 @@
name: 'Run prettify'
on:
pull_request:
push:
branches: [main]
jobs:
prettier:
name: Prettier Check
runs-on: ubuntu-latest
steps:
- name: Checkout Repository
uses: actions/checkout@v2
- name: Enforce Prettier
uses: actionsx/prettier@v2
with:
args: --check .

2
.github/workflows/release-pr.yml vendored
View File

@ -4,7 +4,7 @@ on:
workflow_dispatch:
inputs:
release:
description: "Define release version (ex: v1, v2, v3)"
description: 'Define release version (ex: v1, v2, v3)'
required: true
jobs:

4
.github/workflows/unit-tests.yml vendored
View File

@ -3,11 +3,11 @@ on:
pull_request:
branches:
- main
- "releases/*"
- 'releases/*'
push:
branches:
- main
- "releases/*"
- 'releases/*'
jobs:
unit-test:

4
.prettierignore Normal file
View File

@ -0,0 +1,4 @@
# dependencies
/node_modules
coverage
/lib

8
.prettierrc.json Normal file
View File

@ -0,0 +1,8 @@
{
"trailingComma": "none",
"bracketSpacing": false,
"semi": false,
"tabWidth": 3,
"singleQuote": true,
"printWidth": 80
}

2
README.md
View File

@ -80,7 +80,7 @@ kubectl get secret <service-account-secret-name> -n <namespace> -o yaml
cluster-type: arc
cluster-name: <cluster-name>
resource-group: <resource-group>
token: "${{ secrets.SA_TOKEN }}"
token: '${{ secrets.SA_TOKEN }}'
```
### Service principal approach for arc cluster

16
SECURITY.md
View File

@ -4,7 +4,7 @@
Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), and [many more](https://opensource.microsoft.com/).
If you believe you have found a security vulnerability in any Microsoft-owned repository that meets Microsoft's [definition](https://docs.microsoft.com/en-us/previous-versions/tn-archive/cc751383(v=technet.10)) of a security vulnerability, please report it to us as described below.
If you believe you have found a security vulnerability in any Microsoft-owned repository that meets Microsoft's [definition](<https://docs.microsoft.com/en-us/previous-versions/tn-archive/cc751383(v=technet.10)>) of a security vulnerability, please report it to us as described below.
## Reporting Security Issues
@ -14,13 +14,13 @@ You should receive a response within 24 hours. If for some reason you do not, pl
Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue:
* Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.)
* Full paths of source file(s) related to the manifestation of the issue
* The location of the affected source code (tag/branch/commit or direct URL)
* Any special configuration required to reproduce the issue
* Step-by-step instructions to reproduce the issue
* Proof-of-concept or exploit code (if possible)
* Impact of the issue, including how an attacker might exploit the issue
- Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.)
- Full paths of source file(s) related to the manifestation of the issue
- The location of the affected source code (tag/branch/commit or direct URL)
- Any special configuration required to reproduce the issue
- Step-by-step instructions to reproduce the issue
- Proof-of-concept or exploit code (if possible)
- Impact of the issue, including how an attacker might exploit the issue
This information will help us triage your report more quickly.

32
action.yml
View File

@ -1,39 +1,39 @@
name: "Kubernetes Set Context"
description: "Set the context of a target Kubernetes cluster and export the kubeconfig which is used by subsequent actions"
name: 'Kubernetes Set Context'
description: 'Set the context of a target Kubernetes cluster and export the kubeconfig which is used by subsequent actions'
inputs:
# Please ensure you have used azure/login in the workflow before this action
cluster-type:
description: "Acceptable values: generic or arc"
description: 'Acceptable values: generic or arc'
required: true
default: "generic"
default: 'generic'
method:
description: "Acceptable values: kubeconfig or service-account or service-principal"
description: 'Acceptable values: kubeconfig or service-account or service-principal'
required: true
default: "kubeconfig"
default: 'kubeconfig'
kubeconfig:
description: "Contents of kubeconfig file"
description: 'Contents of kubeconfig file'
required: false
context:
description: "If your kubeconfig has multiple contexts, use this field to use a specific context, otherwise the default one would be chosen"
description: 'If your kubeconfig has multiple contexts, use this field to use a specific context, otherwise the default one would be chosen'
required: false
k8s-url:
description: "Cluster Url"
description: 'Cluster Url'
required: false
k8s-secret:
description: "Service account secret (run kubectl get serviceaccounts <service-account-name> -o yaml and copy the service-account-secret-name)"
description: 'Service account secret (run kubectl get serviceaccounts <service-account-name> -o yaml and copy the service-account-secret-name)'
required: false
token:
description: "Token extracted from the secret of service account (should be base 64 decoded)"
description: 'Token extracted from the secret of service account (should be base 64 decoded)'
required: false
resource-group:
description: "Azure resource group name"
description: 'Azure resource group name'
required: false
cluster-name:
description: "Azure connected cluster name"
description: 'Azure connected cluster name'
required: false
branding:
color: "blue"
color: 'blue'
runs:
using: "node16"
main: "lib/run.js"
using: 'node16'
main: 'lib/run.js'

16
jest.config.js
View File

@ -2,11 +2,11 @@ module.exports = {
restoreMocks: true,
clearMocks: true,
resetMocks: true,
moduleFileExtensions: ["js", "ts"],
testEnvironment: "node",
testMatch: ["**/*.test.ts"],
moduleFileExtensions: ['js', 'ts'],
testEnvironment: 'node',
testMatch: ['**/*.test.ts'],
transform: {
"^.+\\.ts$": "ts-jest",
'^.+\\.ts$': 'ts-jest'
},
verbose: true,
coverageThreshold: {
@ -14,7 +14,7 @@ module.exports = {
branches: 0,
functions: 40,
lines: 22,
statements: 22,
},
},
};
statements: 22
}
}
}

22
package-lock.json generated
View File

@ -20,6 +20,7 @@
"@types/js-yaml": "^4.0.4",
"@types/node": "^16.0.0",
"jest": "^28.1.1",
"prettier": "2.7.1",
"ts-jest": "^28.0.5",
"typescript": "4.7.4"
}
@ -4390,6 +4391,21 @@
"uuid": "bin/uuid"
}
},
"node_modules/prettier": {
"version": "2.7.1",
"resolved": "https://registry.npmjs.org/prettier/-/prettier-2.7.1.tgz",
"integrity": "sha512-ujppO+MkdPqoVINuDFDRLClm7D78qbDt0/NR+wp5FqEZOoTNAjPHWj17QRhu7geIHJfcNhRk1XVQmF8Bp3ye+g==",
"dev": true,
"bin": {
"prettier": "bin-prettier.js"
},
"engines": {
"node": ">=10.13.0"
},
"funding": {
"url": "https://github.com/prettier/prettier?sponsor=1"
}
},
"node_modules/v8-to-istanbul": {
"version": "9.0.0",
"resolved": "https://registry.npmjs.org/v8-to-istanbul/-/v8-to-istanbul-9.0.0.tgz",
@ -7359,6 +7375,12 @@
"find-up": "^4.0.0"
}
},
"prettier": {
"version": "2.7.1",
"resolved": "https://registry.npmjs.org/prettier/-/prettier-2.7.1.tgz",
"integrity": "sha512-ujppO+MkdPqoVINuDFDRLClm7D78qbDt0/NR+wp5FqEZOoTNAjPHWj17QRhu7geIHJfcNhRk1XVQmF8Bp3ye+g==",
"dev": true
},
"pretty-format": {
"version": "28.1.1",
"resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-28.1.1.tgz",

5
package.json
View File

@ -6,7 +6,9 @@
"scripts": {
"build": "tsc --outDir ./lib --rootDir ./src",
"test": "jest",
"test-coverage": "jest --coverage"
"test-coverage": "jest --coverage",
"format": "prettier --write .",
"format-check": "prettier --check ."
},
"keywords": [
"actions",
@ -27,6 +29,7 @@
"@types/js-yaml": "^4.0.4",
"@types/node": "^16.0.0",
"jest": "^28.1.1",
"prettier": "2.7.1",
"ts-jest": "^28.0.5",
"typescript": "4.7.4"
}

136
src/kubeconfigs/arc.test.ts
View File

@ -1,103 +1,103 @@
import * as actions from "@actions/exec";
import * as io from "@actions/io";
import { getRequiredInputError } from "../../tests/util";
import { getArcKubeconfig, KUBECONFIG_LOCATION } from "./arc";
import * as az from "./azCommands";
import * as actions from '@actions/exec'
import * as io from '@actions/io'
import {getRequiredInputError} from '../../tests/util'
import {getArcKubeconfig, KUBECONFIG_LOCATION} from './arc'
import * as az from './azCommands'
describe("Arc kubeconfig", () => {
test("it throws error without resource group", async () => {
describe('Arc kubeconfig', () => {
test('it throws error without resource group', async () => {
await expect(getArcKubeconfig()).rejects.toThrow(
getRequiredInputError("resource-group")
);
});
getRequiredInputError('resource-group')
)
})
test("it throws error without cluster name", async () => {
process.env["INPUT_RESOURCE-GROUP"] = "group";
test('it throws error without cluster name', async () => {
process.env['INPUT_RESOURCE-GROUP'] = 'group'
await expect(getArcKubeconfig()).rejects.toThrow(
getRequiredInputError("cluster-name")
);
});
getRequiredInputError('cluster-name')
)
})
describe("runs az cli commands", () => {
const group = "group";
const name = "name";
const path = "path";
const kubeconfig = "kubeconfig";
describe('runs az cli commands', () => {
const group = 'group'
const name = 'name'
const path = 'path'
const kubeconfig = 'kubeconfig'
beforeEach(() => {
process.env["INPUT_RESOURCE-GROUP"] = group;
process.env["INPUT_CLUSTER-NAME"] = name;
process.env['INPUT_RESOURCE-GROUP'] = group
process.env['INPUT_CLUSTER-NAME'] = name
jest.spyOn(io, "which").mockImplementation(async () => path);
jest.spyOn(az, "runAzCliCommand").mockImplementation(async () => {});
jest.spyOn(io, 'which').mockImplementation(async () => path)
jest.spyOn(az, 'runAzCliCommand').mockImplementation(async () => {})
jest
.spyOn(az, "runAzKubeconfigCommandBlocking")
.mockImplementation(async () => kubeconfig);
});
.spyOn(az, 'runAzKubeconfigCommandBlocking')
.mockImplementation(async () => kubeconfig)
})
it("throws an error without method", async () => {
it('throws an error without method', async () => {
await expect(getArcKubeconfig()).rejects.toThrow(
getRequiredInputError("method")
);
});
getRequiredInputError('method')
)
})
describe("service account method", () => {
describe('service account method', () => {
beforeEach(() => {
process.env["INPUT_METHOD"] = "service-account";
});
process.env['INPUT_METHOD'] = 'service-account'
})
it("throws an error without token", async () => {
it('throws an error without token', async () => {
await expect(getArcKubeconfig()).rejects.toThrow(
getRequiredInputError("token")
);
});
getRequiredInputError('token')
)
})
it("gets the kubeconfig", async () => {
const token = "token";
process.env["INPUT_TOKEN"] = token;
it('gets the kubeconfig', async () => {
const token = 'token'
process.env['INPUT_TOKEN'] = token
expect(await getArcKubeconfig()).toBe(kubeconfig);
expect(await getArcKubeconfig()).toBe(kubeconfig)
expect(az.runAzKubeconfigCommandBlocking).toHaveBeenCalledWith(
path,
[
"connectedk8s",
"proxy",
"-n",
'connectedk8s',
'proxy',
'-n',
name,
"-g",
'-g',
group,
"--token",
'--token',
token,
"-f",
KUBECONFIG_LOCATION,
'-f',
KUBECONFIG_LOCATION
],
KUBECONFIG_LOCATION
);
});
});
)
})
})
describe("service principal method", () => {
describe('service principal method', () => {
beforeEach(() => {
process.env["INPUT_METHOD"] = "service-principal";
});
process.env['INPUT_METHOD'] = 'service-principal'
})
it("gets the kubeconfig", async () => {
expect(await getArcKubeconfig()).toBe(kubeconfig);
it('gets the kubeconfig', async () => {
expect(await getArcKubeconfig()).toBe(kubeconfig)
expect(az.runAzKubeconfigCommandBlocking).toHaveBeenCalledWith(
path,
[
"connectedk8s",
"proxy",
"-n",
'connectedk8s',
'proxy',
'-n',
name,
"-g",
'-g',
group,
"-f",
KUBECONFIG_LOCATION,
'-f',
KUBECONFIG_LOCATION
],
KUBECONFIG_LOCATION
);
});
});
});
});
)
})
})
})
})

62
src/kubeconfigs/arc.ts
View File

@ -1,68 +1,68 @@
import * as core from "@actions/core";
import * as io from "@actions/io";
import { Method, parseMethod } from "../types/method";
import * as path from "path";
import { runAzCliCommand, runAzKubeconfigCommandBlocking } from "./azCommands";
import * as core from '@actions/core'
import * as io from '@actions/io'
import {Method, parseMethod} from '../types/method'
import * as path from 'path'
import {runAzCliCommand, runAzKubeconfigCommandBlocking} from './azCommands'
const RUNNER_TEMP: string = process.env["RUNNER_TEMP"] || "";
const RUNNER_TEMP: string = process.env['RUNNER_TEMP'] || ''
export const KUBECONFIG_LOCATION: string = path.join(
RUNNER_TEMP,
`arc_kubeconfig_${Date.now()}`
);
)
/**
* Gets the kubeconfig based on provided method for an Arc Kubernetes cluster
* @returns The kubeconfig wrapped in a Promise
*/
export async function getArcKubeconfig(): Promise<string> {
const resourceGroupName = core.getInput("resource-group", { required: true });
const clusterName = core.getInput("cluster-name", { required: true });
const azPath = await io.which("az", true);
const resourceGroupName = core.getInput('resource-group', {required: true})
const clusterName = core.getInput('cluster-name', {required: true})
const azPath = await io.which('az', true)
const method: Method | undefined = parseMethod(
core.getInput("method", { required: true })
);
core.getInput('method', {required: true})
)
await runAzCliCommand(azPath, ["extension", "add", "-n", "connectedk8s"]);
await runAzCliCommand(azPath, ['extension', 'add', '-n', 'connectedk8s'])
switch (method) {
case Method.SERVICE_ACCOUNT:
const saToken = core.getInput("token", { required: true });
const saToken = core.getInput('token', {required: true})
return await runAzKubeconfigCommandBlocking(
azPath,
[
"connectedk8s",
"proxy",
"-n",
'connectedk8s',
'proxy',
'-n',
clusterName,
"-g",
'-g',
resourceGroupName,
"--token",
'--token',
saToken,
"-f",
KUBECONFIG_LOCATION,
'-f',
KUBECONFIG_LOCATION
],
KUBECONFIG_LOCATION
);
)
case Method.SERVICE_PRINCIPAL:
return await runAzKubeconfigCommandBlocking(
azPath,
[
"connectedk8s",
"proxy",
"-n",
'connectedk8s',
'proxy',
'-n',
clusterName,
"-g",
'-g',
resourceGroupName,
"-f",
KUBECONFIG_LOCATION,
'-f',
KUBECONFIG_LOCATION
],
KUBECONFIG_LOCATION
);
)
case undefined:
core.warning("Defaulting to kubeconfig method");
core.warning('Defaulting to kubeconfig method')
case Method.KUBECONFIG:
default:
throw Error("Kubeconfig method not supported for Arc cluster");
throw Error('Kubeconfig method not supported for Arc cluster')
}
}

22
src/kubeconfigs/azCommands.test.ts
View File

@ -1,14 +1,14 @@
import * as actions from "@actions/exec";
import { runAzCliCommand } from "./azCommands";
import * as actions from '@actions/exec'
import {runAzCliCommand} from './azCommands'
describe("Az commands", () => {
test("it runs an az cli command", async () => {
const path = "path";
const args = ["args"];
describe('Az commands', () => {
test('it runs an az cli command', async () => {
const path = 'path'
const args = ['args']
jest.spyOn(actions, "exec").mockImplementation(async () => 0);
jest.spyOn(actions, 'exec').mockImplementation(async () => 0)
expect(await runAzCliCommand(path, args));
expect(actions.exec).toBeCalledWith(path, args, {});
});
});
expect(await runAzCliCommand(path, args))
expect(actions.exec).toBeCalledWith(path, args, {})
})
})

24
src/kubeconfigs/azCommands.ts
View File

@ -1,9 +1,9 @@
import * as fs from "fs";
import { ExecOptions } from "@actions/exec/lib/interfaces";
import { exec } from "@actions/exec";
import { spawn } from "child_process";
import * as fs from 'fs'
import {ExecOptions} from '@actions/exec/lib/interfaces'
import {exec} from '@actions/exec'
import {spawn} from 'child_process'
const AZ_TIMEOUT_SECONDS: number = 120;
const AZ_TIMEOUT_SECONDS: number = 120
/**
* Executes an az cli command
@ -16,7 +16,7 @@ export async function runAzCliCommand(
args: string[],
options: ExecOptions = {}
) {
await exec(azPath, args, options);
await exec(azPath, args, options)
}
/**
* Executes an az cli command that will set the kubeconfig
@ -32,13 +32,13 @@ export async function runAzKubeconfigCommandBlocking(
): Promise<string> {
const proc = spawn(azPath, args, {
detached: true,
stdio: "ignore",
});
proc.unref();
stdio: 'ignore'
})
proc.unref()
await sleep(AZ_TIMEOUT_SECONDS);
return fs.readFileSync(kubeconfigPath).toString();
await sleep(AZ_TIMEOUT_SECONDS)
return fs.readFileSync(kubeconfigPath).toString()
}
const sleep = (seconds: number) =>
new Promise((resolve) => setTimeout(resolve, seconds * 1000));
new Promise((resolve) => setTimeout(resolve, seconds * 1000))

195
src/kubeconfigs/default.test.ts
View File

@ -1,150 +1,149 @@
import * as fs from "fs";
import { getRequiredInputError } from "../../tests/util";
import { createKubeconfig, getDefaultKubeconfig } from "./default";
import * as fs from 'fs'
import {getRequiredInputError} from '../../tests/util'
import {createKubeconfig, getDefaultKubeconfig} from './default'
describe("Default kubeconfig", () => {
test("it creates a kubeconfig with proper format", () => {
const certAuth = "certAuth";
const token = "token";
const clusterUrl = "clusterUrl";
describe('Default kubeconfig', () => {
test('it creates a kubeconfig with proper format', () => {
const certAuth = 'certAuth'
const token = 'token'
const clusterUrl = 'clusterUrl'
const kc = createKubeconfig(certAuth, token, clusterUrl);
const kc = createKubeconfig(certAuth, token, clusterUrl)
const expected = JSON.stringify({
apiVersion: "v1",
kind: "Config",
apiVersion: 'v1',
kind: 'Config',
clusters: [
{
name: "default",
name: 'default',
cluster: {
server: clusterUrl,
"certificate-authority-data": certAuth,
"insecure-skip-tls-verify": false,
},
},
'certificate-authority-data': certAuth,
'insecure-skip-tls-verify': false
}
}
],
users: [{ name: "default-user", user: { token } }],
users: [{name: 'default-user', user: {token}}],
contexts: [
{
name: "loaded-context",
name: 'loaded-context',
context: {
cluster: "default",
user: "default-user",
name: "loaded-context",
},
},
cluster: 'default',
user: 'default-user',
name: 'loaded-context'
}
}
],
preferences: {},
"current-context": "loaded-context",
});
'current-context': 'loaded-context'
})
expect(kc).toBe(expected)
})
expect(kc).toBe(expected);
});
test("it throws error without method", () => {
test('it throws error without method', () => {
expect(() => getDefaultKubeconfig()).toThrow(
getRequiredInputError("method")
);
});
getRequiredInputError('method')
)
})
describe("default method", () => {
describe('default method', () => {
beforeEach(() => {
process.env["INPUT_METHOD"] = "default";
});
process.env['INPUT_METHOD'] = 'default'
})
test("it throws error without kubeconfig", () => {
test('it throws error without kubeconfig', () => {
expect(() => getDefaultKubeconfig()).toThrow(
getRequiredInputError("kubeconfig")
);
});
getRequiredInputError('kubeconfig')
)
})
test("it gets default config through kubeconfig input", () => {
const kc = "example kc";
process.env["INPUT_KUBECONFIG"] = kc;
test('it gets default config through kubeconfig input', () => {
const kc = 'example kc'
process.env['INPUT_KUBECONFIG'] = kc
expect(getDefaultKubeconfig()).toBe(kc);
});
});
expect(getDefaultKubeconfig()).toBe(kc)
})
})
test("it defaults to default method", () => {
process.env["INPUT_METHOD"] = "unknown";
test('it defaults to default method', () => {
process.env['INPUT_METHOD'] = 'unknown'
const kc = "example kc";
process.env["INPUT_KUBECONFIG"] = kc;
const kc = 'example kc'
process.env['INPUT_KUBECONFIG'] = kc
expect(getDefaultKubeconfig()).toBe(kc);
});
expect(getDefaultKubeconfig()).toBe(kc)
})
test("it defaults to default method from service-principal", () => {
process.env["INPUT_METHOD"] = "service-principal";
test('it defaults to default method from service-principal', () => {
process.env['INPUT_METHOD'] = 'service-principal'
const kc = "example kc";
process.env["INPUT_KUBECONFIG"] = kc;
const kc = 'example kc'
process.env['INPUT_KUBECONFIG'] = kc
expect(getDefaultKubeconfig()).toBe(kc);
});
expect(getDefaultKubeconfig()).toBe(kc)
})
describe("service-account method", () => {
describe('service-account method', () => {
beforeEach(() => {
process.env["INPUT_METHOD"] = "service-account";
});
process.env['INPUT_METHOD'] = 'service-account'
})
test("it throws error without cluster url", () => {
test('it throws error without cluster url', () => {
expect(() => getDefaultKubeconfig()).toThrow(
getRequiredInputError("k8s-url")
);
});
getRequiredInputError('k8s-url')
)
})
test("it throws error without k8s secret", () => {
process.env["INPUT_K8S-URL"] = "url";
test('it throws error without k8s secret', () => {
process.env['INPUT_K8S-URL'] = 'url'
expect(() => getDefaultKubeconfig()).toThrow(
getRequiredInputError("k8s-secret")
);
});
getRequiredInputError('k8s-secret')
)
})
test("it gets kubeconfig through service-account", () => {
const k8sUrl = "https://testing-dns-4za.hfp.earth.azmk8s.io:443";
const token = "ZXlKaGJHY2lPcUpTVXpJMU5pSX=";
const cert = "LS0tLS1CRUdJTiBDRWyUSUZJQ";
const k8sSecret = fs.readFileSync("tests/sample-secret.yml").toString();
test('it gets kubeconfig through service-account', () => {
const k8sUrl = 'https://testing-dns-4za.hfp.earth.azmk8s.io:443'
const token = 'ZXlKaGJHY2lPcUpTVXpJMU5pSX='
const cert = 'LS0tLS1CRUdJTiBDRWyUSUZJQ'
const k8sSecret = fs.readFileSync('tests/sample-secret.yml').toString()
process.env["INPUT_K8S-URL"] = k8sUrl;
process.env["INPUT_K8S-SECRET"] = k8sSecret;
process.env['INPUT_K8S-URL'] = k8sUrl
process.env['INPUT_K8S-SECRET'] = k8sSecret
const expectedConfig = JSON.stringify({
apiVersion: "v1",
kind: "Config",
apiVersion: 'v1',
kind: 'Config',
clusters: [
{
name: "default",
name: 'default',
cluster: {
server: k8sUrl,
"certificate-authority-data": cert,
"insecure-skip-tls-verify": false,
},
},
'certificate-authority-data': cert,
'insecure-skip-tls-verify': false
}
}
],
users: [
{
name: "default-user",
user: { token: Buffer.from(token, "base64").toString() },
},
name: 'default-user',
user: {token: Buffer.from(token, 'base64').toString()}
}
],
contexts: [
{
name: "loaded-context",
name: 'loaded-context',
context: {
cluster: "default",
user: "default-user",
name: "loaded-context",
},
},
cluster: 'default',
user: 'default-user',
name: 'loaded-context'
}
}
],
preferences: {},
"current-context": "loaded-context",
});
'current-context': 'loaded-context'
})
expect(getDefaultKubeconfig()).toBe(expectedConfig);
});
});
});
expect(getDefaultKubeconfig()).toBe(expectedConfig)
})
})
})

62
src/kubeconfigs/default.ts
View File

@ -1,8 +1,8 @@
import * as core from "@actions/core";
import * as jsyaml from "js-yaml";
import { KubeConfig } from "@kubernetes/client-node";
import { K8sSecret, parseK8sSecret } from "../types/k8sSecret";
import { Method, parseMethod } from "../types/method";
import * as core from '@actions/core'
import * as jsyaml from 'js-yaml'
import {KubeConfig} from '@kubernetes/client-node'
import {K8sSecret, parseK8sSecret} from '../types/k8sSecret'
import {Method, parseMethod} from '../types/method'
/**
* Gets the kubeconfig based on provided method for a default Kubernetes cluster
@ -10,39 +10,41 @@ import { Method, parseMethod } from "../types/method";
*/
export function getDefaultKubeconfig(): string {
const method: Method | undefined = parseMethod(
core.getInput("method", { required: true })
);
core.getInput('method', {required: true})
)
switch (method) {
case Method.SERVICE_ACCOUNT: {
const clusterUrl = core.getInput("k8s-url", { required: true });
const clusterUrl = core.getInput('k8s-url', {required: true})
core.debug(
"Found clusterUrl. Creating kubeconfig using certificate and token"
);
'Found clusterUrl. Creating kubeconfig using certificate and token'
)
const k8sSecret: string = core.getInput("k8s-secret", {
required: true,
});
const parsedK8sSecret: K8sSecret = parseK8sSecret(jsyaml.load(k8sSecret));
const certAuth: string = parsedK8sSecret.data["ca.crt"];
const k8sSecret: string = core.getInput('k8s-secret', {
required: true
})
const parsedK8sSecret: K8sSecret = parseK8sSecret(
jsyaml.load(k8sSecret)
)
const certAuth: string = parsedK8sSecret.data['ca.crt']
const token: string = Buffer.from(
parsedK8sSecret.data.token,
"base64"
).toString();
'base64'
).toString()
return createKubeconfig(certAuth, token, clusterUrl);
return createKubeconfig(certAuth, token, clusterUrl)
}
case Method.SERVICE_PRINCIPAL: {
core.warning(
"Service Principal method not supported for default cluster type"
);
'Service Principal method not supported for default cluster type'
)
}
case undefined: {
core.warning("Defaulting to kubeconfig method");
core.warning('Defaulting to kubeconfig method')
}
default: {
core.debug("Setting context using kubeconfig");
return core.getInput("kubeconfig", { required: true });
core.debug('Setting context using kubeconfig')
return core.getInput('kubeconfig', {required: true})
}
}
}
@ -59,18 +61,18 @@ export function createKubeconfig(
token: string,
clusterUrl: string
): string {
const kc = new KubeConfig();
const kc = new KubeConfig()
kc.loadFromClusterAndUser(
{
name: "default",
name: 'default',
server: clusterUrl,
caData: certAuth,
skipTLSVerify: false,
skipTLSVerify: false
},
{
name: "default-user",
token,
name: 'default-user',
token
}
);
return kc.exportConfig();
)
return kc.exportConfig()
}

48
src/run.test.ts
View File

@ -1,30 +1,30 @@
import { getRequiredInputError } from "../tests/util";
import { run } from "./run";
import fs from "fs";
import * as utils from "./utils";
import {getRequiredInputError} from '../tests/util'
import {run} from './run'
import fs from 'fs'
import * as utils from './utils'
describe("Run", () => {
it("throws error without cluster type", async () => {
await expect(run()).rejects.toThrow(getRequiredInputError("cluster-type"));
});
describe('Run', () => {
it('throws error without cluster type', async () => {
await expect(run()).rejects.toThrow(getRequiredInputError('cluster-type'))
})
it("writes kubeconfig and sets context", async () => {
const kubeconfig = "kubeconfig";
it('writes kubeconfig and sets context', async () => {
const kubeconfig = 'kubeconfig'
process.env["INPUT_CLUSTER-TYPE"] = "default";
process.env["RUNNER_TEMP"] = "/sample/path";
process.env['INPUT_CLUSTER-TYPE'] = 'default'
process.env['RUNNER_TEMP'] = '/sample/path'
jest
.spyOn(utils, "getKubeconfig")
.mockImplementation(async () => kubeconfig);
jest.spyOn(fs, "writeFileSync").mockImplementation(() => {});
jest.spyOn(fs, "chmodSync").mockImplementation(() => {});
jest.spyOn(utils, "setContext").mockImplementation(() => kubeconfig);
.spyOn(utils, 'getKubeconfig')
.mockImplementation(async () => kubeconfig)
jest.spyOn(fs, 'writeFileSync').mockImplementation(() => {})
jest.spyOn(fs, 'chmodSync').mockImplementation(() => {})
jest.spyOn(utils, 'setContext').mockImplementation(() => kubeconfig)
expect(await run());
expect(utils.getKubeconfig).toHaveBeenCalled();
expect(fs.writeFileSync).toHaveBeenCalled();
expect(fs.chmodSync).toHaveBeenCalled();
expect(utils.setContext).toHaveBeenCalled();
});
});
expect(await run())
expect(utils.getKubeconfig).toHaveBeenCalled()
expect(fs.writeFileSync).toHaveBeenCalled()
expect(fs.chmodSync).toHaveBeenCalled()
expect(utils.setContext).toHaveBeenCalled()
})
})

36
src/run.ts
View File

@ -1,8 +1,8 @@
import * as core from "@actions/core";
import * as path from "path";
import * as fs from "fs";
import { Cluster, parseCluster } from "./types/cluster";
import { setContext, getKubeconfig } from "./utils";
import * as core from '@actions/core'
import * as path from 'path'
import * as fs from 'fs'
import {Cluster, parseCluster} from './types/cluster'
import {setContext, getKubeconfig} from './utils'
/**
* Sets the Kubernetes context based on supplied action inputs
@ -10,27 +10,27 @@ import { setContext, getKubeconfig } from "./utils";
export async function run() {
// get inputs
const clusterType: Cluster | undefined = parseCluster(
core.getInput("cluster-type", {
required: true,
core.getInput('cluster-type', {
required: true
})
);
const runnerTempDirectory: string = process.env["RUNNER_TEMP"];
)
const runnerTempDirectory: string = process.env['RUNNER_TEMP']
const kubeconfigPath: string = path.join(
runnerTempDirectory,
`kubeconfig_${Date.now()}`
);
)
// get kubeconfig and update context
const kubeconfig: string = await getKubeconfig(clusterType);
const kubeconfigWithContext: string = setContext(kubeconfig);
const kubeconfig: string = await getKubeconfig(clusterType)
const kubeconfigWithContext: string = setContext(kubeconfig)
// output kubeconfig
core.debug(`Writing kubeconfig contents to ${kubeconfigPath}`);
fs.writeFileSync(kubeconfigPath, kubeconfigWithContext);
fs.chmodSync(kubeconfigPath, "600");
core.debug("Setting KUBECONFIG environment variable");
core.exportVariable("KUBECONFIG", kubeconfigPath);
core.debug(`Writing kubeconfig contents to ${kubeconfigPath}`)
fs.writeFileSync(kubeconfigPath, kubeconfigWithContext)
fs.chmodSync(kubeconfigPath, '600')
core.debug('Setting KUBECONFIG environment variable')
core.exportVariable('KUBECONFIG', kubeconfigPath)
}
// Run the application
run().catch(core.setFailed);
run().catch(core.setFailed)

38
src/types/cluster.test.ts
View File

@ -1,24 +1,24 @@
import { Cluster, parseCluster } from "./cluster";
import {Cluster, parseCluster} from './cluster'
describe("Cluster type", () => {
test("it has required values", () => {
const vals = <any>Object.values(Cluster);
expect(vals.includes("arc")).toBe(true);
expect(vals.includes("generic")).toBe(true);
});
describe('Cluster type', () => {
test('it has required values', () => {
const vals = <any>Object.values(Cluster)
expect(vals.includes('arc')).toBe(true)
expect(vals.includes('generic')).toBe(true)
})
test("it can parse valid values from a string", () => {
expect(parseCluster("arc")).toBe(Cluster.ARC);
expect(parseCluster("Arc")).toBe(Cluster.ARC);
expect(parseCluster("ARC")).toBe(Cluster.ARC);
test('it can parse valid values from a string', () => {
expect(parseCluster('arc')).toBe(Cluster.ARC)
expect(parseCluster('Arc')).toBe(Cluster.ARC)
expect(parseCluster('ARC')).toBe(Cluster.ARC)
expect(parseCluster("generic")).toBe(Cluster.GENERIC);
expect(parseCluster("Generic")).toBe(Cluster.GENERIC);
expect(parseCluster("GENERIC")).toBe(Cluster.GENERIC);
});
expect(parseCluster('generic')).toBe(Cluster.GENERIC)
expect(parseCluster('Generic')).toBe(Cluster.GENERIC)
expect(parseCluster('GENERIC')).toBe(Cluster.GENERIC)
})
test("it will return undefined if it can't parse values from a string", () => {
expect(parseCluster("invalid")).toBe(undefined);
expect(parseCluster("unsupportedType")).toBe(undefined);
});
});
expect(parseCluster('invalid')).toBe(undefined)
expect(parseCluster('unsupportedType')).toBe(undefined)
})
})

6
src/types/cluster.ts
View File

@ -1,6 +1,6 @@
export enum Cluster {
ARC = "arc",
GENERIC = "generic",
ARC = 'arc',
GENERIC = 'generic'
}
/**
@ -13,4 +13,4 @@ export const parseCluster = (str: string): Cluster | undefined =>
Object.keys(Cluster).filter(
(k) => Cluster[k].toString().toLowerCase() === str.toLowerCase()
)[0] as keyof typeof Cluster
];
]

52
src/types/k8sSecret.test.ts
View File

@ -1,33 +1,33 @@
import { parseK8sSecret, K8sSecret } from "./k8sSecret";
import {parseK8sSecret, K8sSecret} from './k8sSecret'
describe("K8sSecret type", () => {
describe("Parsing from any", () => {
test("it returns a type guarded secret", () => {
const secret = { data: { token: "token", "ca.crt": "cert" } };
expect(() => parseK8sSecret(secret)).not.toThrow();
});
describe('K8sSecret type', () => {
describe('Parsing from any', () => {
test('it returns a type guarded secret', () => {
const secret = {data: {token: 'token', 'ca.crt': 'cert'}}
expect(() => parseK8sSecret(secret)).not.toThrow()
})
test("it throws an error when secret not provided", () => {
expect(() => parseK8sSecret(undefined)).toThrow();
});
test('it throws an error when secret not provided', () => {
expect(() => parseK8sSecret(undefined)).toThrow()
})
test("it throws an error when there is no data field", () => {
const secret = {};
expect(() => parseK8sSecret(secret)).toThrow();
});
test('it throws an error when there is no data field', () => {
const secret = {}
expect(() => parseK8sSecret(secret)).toThrow()
})
test("it throws an error when there is no token", () => {
test('it throws an error when there is no token', () => {
const secret = {
data: {
"ca.crt": "cert",
},
};
expect(() => parseK8sSecret(secret)).toThrow();
});
'ca.crt': 'cert'
}
}
expect(() => parseK8sSecret(secret)).toThrow()
})
test("it throws an error when there is no ca.crt field", () => {
const secret = { data: { token: "token" } };
expect(() => parseK8sSecret(secret)).toThrow();
});
});
});
test('it throws an error when there is no ca.crt field', () => {
const secret = {data: {token: 'token'}}
expect(() => parseK8sSecret(secret)).toThrow()
})
})
})

20
src/types/k8sSecret.ts
View File

@ -1,10 +1,10 @@
import * as util from "util";
import * as util from 'util'
export interface K8sSecret {
data: {
token: string;
"ca.crt": string;
};
token: string
'ca.crt': string
}
}
/**
@ -13,13 +13,13 @@ export interface K8sSecret {
* @returns A type guarded K8sSecret
*/
export function parseK8sSecret(secret: any): K8sSecret {
if (!secret) throw Error("K8s secret yaml is invalid");
if (!secret.data) throw k8sSecretMissingFieldError("data");
if (!secret.data.token) throw k8sSecretMissingFieldError("token");
if (!secret.data["ca.crt"]) throw k8sSecretMissingFieldError("ca.crt");
if (!secret) throw Error('K8s secret yaml is invalid')
if (!secret.data) throw k8sSecretMissingFieldError('data')
if (!secret.data.token) throw k8sSecretMissingFieldError('token')
if (!secret.data['ca.crt']) throw k8sSecretMissingFieldError('ca.crt')
return secret as K8sSecret;
return secret as K8sSecret
}
const k8sSecretMissingFieldError = (field: string): Error =>
Error(util.format("K8s secret yaml does not contain %s field", field));
Error(util.format('K8s secret yaml does not contain %s field', field))

46
src/types/method.test.ts
View File

@ -1,29 +1,29 @@
import { Method, parseMethod } from "./method";
import {Method, parseMethod} from './method'
describe("Method type", () => {
test("it has required values", () => {
const vals = <any>Object.values(Method);
expect(vals.includes("kubeconfig")).toBe(true);
expect(vals.includes("service-account")).toBe(true);
expect(vals.includes("service-principal")).toBe(true);
});
describe('Method type', () => {
test('it has required values', () => {
const vals = <any>Object.values(Method)
expect(vals.includes('kubeconfig')).toBe(true)
expect(vals.includes('service-account')).toBe(true)
expect(vals.includes('service-principal')).toBe(true)
})
test("it can parse valid values from a string", () => {
expect(parseMethod("kubeconfig")).toBe(Method.KUBECONFIG);
expect(parseMethod("Kubeconfig")).toBe(Method.KUBECONFIG);
expect(parseMethod("KUBECONFIG")).toBe(Method.KUBECONFIG);
test('it can parse valid values from a string', () => {
expect(parseMethod('kubeconfig')).toBe(Method.KUBECONFIG)
expect(parseMethod('Kubeconfig')).toBe(Method.KUBECONFIG)
expect(parseMethod('KUBECONFIG')).toBe(Method.KUBECONFIG)
expect(parseMethod("service-account")).toBe(Method.SERVICE_ACCOUNT);
expect(parseMethod("Service-Account")).toBe(Method.SERVICE_ACCOUNT);
expect(parseMethod("SERVICE-ACCOUNT")).toBe(Method.SERVICE_ACCOUNT);
expect(parseMethod('service-account')).toBe(Method.SERVICE_ACCOUNT)
expect(parseMethod('Service-Account')).toBe(Method.SERVICE_ACCOUNT)
expect(parseMethod('SERVICE-ACCOUNT')).toBe(Method.SERVICE_ACCOUNT)
expect(parseMethod("service-principal")).toBe(Method.SERVICE_PRINCIPAL);
expect(parseMethod("Service-Principal")).toBe(Method.SERVICE_PRINCIPAL);
expect(parseMethod("SERVICE-PRINCIPAL")).toBe(Method.SERVICE_PRINCIPAL);
});
expect(parseMethod('service-principal')).toBe(Method.SERVICE_PRINCIPAL)
expect(parseMethod('Service-Principal')).toBe(Method.SERVICE_PRINCIPAL)
expect(parseMethod('SERVICE-PRINCIPAL')).toBe(Method.SERVICE_PRINCIPAL)
})
test("it will return undefined if it can't parse values from a string", () => {
expect(parseMethod("invalid")).toBe(undefined);
expect(parseMethod("unsupportedType")).toBe(undefined);
});
});
expect(parseMethod('invalid')).toBe(undefined)
expect(parseMethod('unsupportedType')).toBe(undefined)
})
})

8
src/types/method.ts
View File

@ -1,7 +1,7 @@
export enum Method {
KUBECONFIG = "kubeconfig",
SERVICE_ACCOUNT = "service-account",
SERVICE_PRINCIPAL = "service-principal",
KUBECONFIG = 'kubeconfig',
SERVICE_ACCOUNT = 'service-account',
SERVICE_PRINCIPAL = 'service-principal'
}
/**
@ -14,4 +14,4 @@ export const parseMethod = (str: string): Method | undefined =>
Object.keys(Method).filter(
(k) => Method[k].toString().toLowerCase() === str.toLowerCase()
)[0] as keyof typeof Method
];
]

68
src/utils.test.ts
View File

@ -1,47 +1,47 @@
import fs from "fs";
import * as arc from "./kubeconfigs/arc";
import * as def from "./kubeconfigs/default";
import { Cluster } from "./types/cluster";
import { getKubeconfig, setContext } from "./utils";
import fs from 'fs'
import * as arc from './kubeconfigs/arc'
import * as def from './kubeconfigs/default'
import {Cluster} from './types/cluster'
import {getKubeconfig, setContext} from './utils'
describe("Utils", () => {
describe("get kubeconfig", () => {
test("it gets arc kubeconfig when type is arc", async () => {
const arcKubeconfig = "arckubeconfig";
describe('Utils', () => {
describe('get kubeconfig', () => {
test('it gets arc kubeconfig when type is arc', async () => {
const arcKubeconfig = 'arckubeconfig'
jest
.spyOn(arc, "getArcKubeconfig")
.mockImplementation(async () => arcKubeconfig);
.spyOn(arc, 'getArcKubeconfig')
.mockImplementation(async () => arcKubeconfig)
expect(await getKubeconfig(Cluster.ARC)).toBe(arcKubeconfig);
});
expect(await getKubeconfig(Cluster.ARC)).toBe(arcKubeconfig)
})
test("it defaults to default kubeconfig", async () => {
const defaultKubeconfig = "arckubeconfig";
test('it defaults to default kubeconfig', async () => {
const defaultKubeconfig = 'arckubeconfig'
jest
.spyOn(def, "getDefaultKubeconfig")
.mockImplementation(() => defaultKubeconfig);
.spyOn(def, 'getDefaultKubeconfig')
.mockImplementation(() => defaultKubeconfig)
expect(await getKubeconfig(undefined)).toBe(defaultKubeconfig);
expect(await getKubeconfig(Cluster.GENERIC)).toBe(defaultKubeconfig);
});
});
expect(await getKubeconfig(undefined)).toBe(defaultKubeconfig)
expect(await getKubeconfig(Cluster.GENERIC)).toBe(defaultKubeconfig)
})
})
describe("set context", () => {
const kc = fs.readFileSync("tests/sample-kubeconfig.yml").toString();
describe('set context', () => {
const kc = fs.readFileSync('tests/sample-kubeconfig.yml').toString()
test("it doesn't change kubeconfig without context", () => {
expect(setContext(kc)).toBe(kc);
});
expect(setContext(kc)).toBe(kc)
})
test("it writes the context to the kubeconfig", () => {
process.env["INPUT_CONTEXT"] = "example";
test('it writes the context to the kubeconfig', () => {
process.env['INPUT_CONTEXT'] = 'example'
const received = JSON.parse(setContext(kc));
const received = JSON.parse(setContext(kc))
const expectedKc = JSON.parse(
fs.readFileSync("tests/expected-kubeconfig.json").toString()
);
fs.readFileSync('tests/expected-kubeconfig.json').toString()
)
expect(received).toMatchObject(expectedKc);
});
});
});
expect(received).toMatchObject(expectedKc)
})
})
})

32
src/utils.ts
View File

@ -1,9 +1,9 @@
import * as core from "@actions/core";
import * as fs from "fs";
import { KubeConfig } from "@kubernetes/client-node";
import { getDefaultKubeconfig } from "./kubeconfigs/default";
import { getArcKubeconfig } from "./kubeconfigs/arc";
import { Cluster } from "./types/cluster";
import * as core from '@actions/core'
import * as fs from 'fs'
import {KubeConfig} from '@kubernetes/client-node'
import {getDefaultKubeconfig} from './kubeconfigs/default'
import {getArcKubeconfig} from './kubeconfigs/arc'
import {Cluster} from './types/cluster'
/**
* Gets the kubeconfig based on Kubernetes cluster type
@ -15,13 +15,13 @@ export async function getKubeconfig(
): Promise<string> {
switch (type) {
case Cluster.ARC: {
return await getArcKubeconfig();
return await getArcKubeconfig()
}
case undefined: {
core.warning("Cluster type not recognized. Defaulting to generic.");
core.warning('Cluster type not recognized. Defaulting to generic.')
}
default: {
return getDefaultKubeconfig();
return getDefaultKubeconfig()
}
}
}
@ -32,17 +32,17 @@ export async function getKubeconfig(
* @returns Updated kubeconfig with the context
*/
export function setContext(kubeconfig: string): string {
const context: string = core.getInput("context");
const context: string = core.getInput('context')
if (!context) {
core.debug("Can't set context because context is unspecified.");
return kubeconfig;
core.debug("Can't set context because context is unspecified.")
return kubeconfig
}
// load current kubeconfig
const kc = new KubeConfig();
kc.loadFromString(kubeconfig);
const kc = new KubeConfig()
kc.loadFromString(kubeconfig)
// update kubeconfig
kc.setCurrentContext(context);
return kc.exportConfig();
kc.setCurrentContext(context)
return kc.exportConfig()
}

6
tests/sample-secret.yml
View File

@ -8,7 +8,7 @@ metadata:
annotations:
kubernetes.io/service-account.name: default
kubernetes.io/service-account.uid: e1414a3z-22fe-48d1-ab9e-18e4a5b91c
creationTimestamp: "2020-03-02T06:40:31Z"
creationTimestamp: '2020-03-02T06:40:31Z'
managedFields:
- apiVersion: v1
fieldsType: FieldsV1
@ -26,10 +26,10 @@ metadata:
f:type: {}
manager: kube-controller-manager
operation: Update
time: "2020-03-02T06:40:31Z"
time: '2020-03-02T06:40:31Z'
name: default-token-bl8ra
namespace: default
resourceVersion: "278"
resourceVersion: '278'
selfLink: /api/v1/namespaces/default/secrets/default-token-bl8ra
uid: e6d8b21b-2e3a-4606-98za-54fb44fdc
type: kubernetes.io/service-account-token

2
tests/util.ts
View File

@ -4,4 +4,4 @@
* @returns Error with explanation message
*/
export const getRequiredInputError = (inputName) =>
Error(`Input required and not supplied: ${inputName}`);
Error(`Input required and not supplied: ${inputName}`)