refactor: convert schema utils functions to yargs

Author: rossiam

packages/cli/src/__tests__/lib/commands/schema-util.test.ts

@@ -54,7 +54,7 @@ export default class InvitesSchemaCreateCommand extends APICommand<typeof Invite
 		const schemaAppsById = new Map<string, SchemaApp>()
 
 		const updateFromUserInput = async (): Promise<string | CancelAction> => {
-			const schemaAppId = await chooseSchemaApp(this, this.flags['schema-app'])
+			const schemaAppId = await chooseSchemaApp(this, this.flags['schema-app'], { autoChoose: true })
 			if (!schemaAppsById.has(schemaAppId)) {
 				const schemaApp = await this.client.schema.get(schemaAppId)
 				schemaAppsById.set(schemaAppId, schemaApp)

packages/cli/src/commands/invites/schema/create.ts

@@ -20,7 +20,7 @@ export const chooseSchemaInvitation = async (command: APICommand<typeof APIComma
 		sortKeyName: 'description',
 	}
 	const listItems = async (): Promise<SchemaAppInvitation[]> => {
-		const schemaAppId = await chooseSchemaApp(command, schemaAppFromArgs)
+		const schemaAppId = await chooseSchemaApp(command, schemaAppFromArgs, { autoChoose: true })
 		return command.client.invitesSchema.list(schemaAppId)
 	}
 	const preselectedId = opts.allowIndex

packages/cli/src/lib/commands/invites-utils.ts

@@ -0,0 +1,63 @@
+import { jest } from '@jest/globals'
+
+import type {
+	OrganizationResponse,
+} from '@smartthings/core-sdk'
+
+import {
+	InputDefinition,
+	selectDef,
+	staticDef,
+	undefinedDef,
+} from '../../../../lib/item-input/index.js'
+
+
+const selectDefMock = jest.fn<typeof selectDef>()
+const staticDefMock = jest.fn<typeof staticDef>()
+const undefinedDefMock = {} as typeof undefinedDef
+jest.unstable_mockModule('../../../../lib/item-input/index.js', () => ({
+	selectDef: selectDefMock,
+	staticDef: staticDefMock,
+	undefinedDef: undefinedDefMock,
+}))
+
+
+const { organizationDef } = await import('../../../../lib/command/util/organizations-util.js')
+
+
+describe('organizationDef', () => {
+	const organization1 = { name: 'Organization 1', organizationId: 'organization-id-1' }
+
+	it('returns undefinedDef when given no organizations', () => {
+		expect(organizationDef('organization-needing thing', [])).toBe(undefinedDefMock)
+	})
+
+	it('returns staticDef for a single organization', () => {
+		const mockDef = {} as InputDefinition<string | undefined>
+		staticDefMock.mockReturnValueOnce(mockDef)
+
+		expect(organizationDef('organization-needing thing', [organization1])).toBe(mockDef)
+
+		expect(staticDefMock).toHaveBeenCalledExactlyOnceWith('organization-id-1')
+	})
+
+	it('returns selectDef for multiple organizations', () => {
+		const organization2 = { name: 'Organization 2', organizationId: 'organization-id-2' }
+		const organizations = [organization1, organization2] as OrganizationResponse[]
+		const mockDef = {} as InputDefinition<string | undefined>
+		selectDefMock.mockReturnValueOnce(mockDef)
+
+		expect(organizationDef('organization-needing thing', organizations)).toBe(mockDef)
+
+		const helpText =
+			'The organization with which the organization-needing thing should be associated.'
+		expect(selectDefMock).toHaveBeenCalledExactlyOnceWith(
+			'Organization',
+			[
+				{ name: 'Organization 1', value: 'organization-id-1' },
+				{ name: 'Organization 2', value: 'organization-id-2' },
+			],
+			{ helpText },
+		)
+	})
+})

src/__tests__/lib/command/util/organizations-util.test.ts

@@ -0,0 +1,178 @@
+import { jest } from '@jest/globals'
+
+import type { SchemaAppRequest } from '@smartthings/core-sdk'
+
+import { awsHelpText } from '../../../../lib/aws-util.js'
+import type {
+	booleanDef,
+	createFromUserInput,
+	InputDefinition,
+	listSelectionDef,
+	objectDef,
+	optionalDef,
+	optionalStringDef,
+	selectDef,
+	staticDef,
+	stringDef,
+	undefinedDef,
+	updateFromUserInput,
+} from '../../../../lib/item-input/index.js'
+
+
+const booleanDefMock = jest.fn<typeof booleanDef>()
+const createFromUserInputMock = jest.fn<typeof createFromUserInput>()
+const listSelectionDefMock = jest.fn<typeof listSelectionDef>()
+const objectDefMock = jest.fn<typeof objectDef>()
+const optionalDefMock = jest.fn<typeof optionalDef>()
+const optionalStringDefMock = jest.fn<typeof optionalStringDef>()
+const selectDefMock = jest.fn<typeof selectDef>()
+const staticDefMock = jest.fn<typeof staticDef>()
+const stringDefMock = jest.fn<typeof stringDef>()
+const undefinedDefMock = {} as typeof undefinedDef
+const updateFromUserInputMock = jest.fn<typeof updateFromUserInput>()
+jest.unstable_mockModule('../../../../lib/item-input/index.js', () => ({
+	booleanDef: booleanDefMock,
+	createFromUserInput: createFromUserInputMock,
+	listSelectionDef: listSelectionDefMock,
+	maxItemValueLength: 16,
+	objectDef: objectDefMock,
+	optionalDef: optionalDefMock,
+	optionalStringDef: optionalStringDefMock,
+	selectDef: selectDefMock,
+	staticDef: staticDefMock,
+	stringDef: stringDefMock,
+	undefinedDef: undefinedDefMock,
+	updateFromUserInput: updateFromUserInputMock,
+}))
+
+
+const {
+	arnDef,
+	webHookUrlDef,
+} = await import('../../../../lib/command/util/schema-util-input-primitives.js')
+
+
+const generatedStringDef = { name: 'Generated String Def' } as InputDefinition<string>
+const generatedARNDef = { name: 'Generated ARN Def' } as InputDefinition<string | undefined>
+const lambdaInitialValue = { appName: 'Schema App', hostingType: 'lambda' } as SchemaAppRequest
+const webhookInitialValue = { appName: 'Schema App', hostingType: 'webhook' } as SchemaAppRequest
+
+describe('arnDef', () => {
+	it('uses undefinedDef when in China but ARN is not for China', () => {
+		expect(arnDef('ARN', true, undefined)).toBe(undefinedDefMock)
+		expect(arnDef('ARN', true, undefined, { forChina: false })).toBe(undefinedDefMock)
+	})
+
+	it('uses undefinedDef when not in China but for China', () => {
+		expect(arnDef('ARN', false, undefined, { forChina: true })).toBe(undefinedDefMock)
+	})
+
+	it('uses required stringDef in China', () => {
+		stringDefMock.mockReturnValueOnce(generatedStringDef)
+		optionalDefMock.mockReturnValueOnce(generatedARNDef)
+
+		expect(arnDef('ARN', true, lambdaInitialValue, { forChina: true })).toBe(generatedARNDef)
+
+		expect(stringDefMock).toHaveBeenCalledExactlyOnceWith('ARN', { helpText: awsHelpText })
+		expect(optionalDefMock).toHaveBeenCalledExactlyOnceWith(
+			generatedStringDef,
+			expect.any(Function),
+			{ initiallyActive: true },
+		)
+
+		expect(optionalStringDefMock).not.toHaveBeenCalled()
+	})
+
+	it('uses optional string def for global', () => {
+		optionalStringDefMock.mockReturnValueOnce(generatedStringDef)
+		optionalDefMock.mockReturnValueOnce(generatedARNDef)
+
+		expect(arnDef('ARN', false)).toBe(generatedARNDef)
+
+		expect(optionalStringDefMock)
+			.toHaveBeenCalledExactlyOnceWith('ARN', { helpText: awsHelpText })
+		expect(optionalDefMock).toHaveBeenCalledExactlyOnceWith(
+			generatedStringDef,
+			expect.any(Function),
+			{ initiallyActive: false },
+		)
+
+		expect(stringDefMock).not.toHaveBeenCalled()
+	})
+
+	it.each`
+		initialValue                  | initiallyActive
+		${{ hostingType: 'lambda' }}  | ${true}
+		${{ hostingType: 'webhook' }} | ${false}
+		${undefined}                  | ${false}
+	`('uses initiallyActive $initiallyActive for initialValue $initialValue', ({ initialValue, initiallyActive }) => {
+		optionalStringDefMock.mockReturnValueOnce(generatedStringDef)
+		optionalDefMock.mockReturnValueOnce(generatedARNDef)
+
+		expect(arnDef('ARN', false, initialValue)).toBe(generatedARNDef)
+
+		expect(optionalDefMock).toHaveBeenCalledExactlyOnceWith(generatedStringDef, expect.any(Function), { initiallyActive })
+	})
+
+	it('predicate function tests for hostingType of "lambda"', async () => {
+		optionalStringDefMock.mockReturnValueOnce(generatedStringDef)
+		optionalDefMock.mockReturnValueOnce(generatedARNDef)
+
+		expect(arnDef('ARN', false, lambdaInitialValue)).toBe(generatedARNDef)
+
+		const checkIfActiveFunction = optionalDefMock.mock.calls[0][1]
+
+		expect(checkIfActiveFunction([{ hostingType: 'lambda' }])).toBe(true)
+		expect(checkIfActiveFunction([{ hostingType: 'webhook' }])).toBe(false)
+		expect(checkIfActiveFunction()).toBe(false)
+	})
+})
+
+describe('webHookUrlDef', () => {
+	it('uses undefinedDef when in China', () => {
+		expect(webHookUrlDef(true, undefined)).toBe(undefinedDefMock)
+	})
+
+	it('uses stringDef when not in China', () => {
+		stringDefMock.mockReturnValueOnce(generatedStringDef)
+		optionalDefMock.mockReturnValueOnce(generatedARNDef)
+
+		expect(webHookUrlDef(false, webhookInitialValue)).toBe(generatedARNDef)
+
+		expect(stringDefMock).toHaveBeenCalledExactlyOnceWith('Webhook URL')
+		expect(optionalDefMock).toHaveBeenCalledExactlyOnceWith(
+			generatedStringDef,
+			expect.any(Function),
+			{ initiallyActive: true },
+		)
+
+		expect(optionalStringDefMock).not.toHaveBeenCalled()
+	})
+
+	it.each`
+		initialValue                  | initiallyActive
+		${{ hostingType: 'webhook' }} | ${true}
+		${{ hostingType: 'lambda' }}  | ${false}
+		${undefined}                  | ${false}
+	`('uses initiallyActive $initiallyActive for initialValue $initialValue', ({ initialValue, initiallyActive }) => {
+		stringDefMock.mockReturnValueOnce(generatedStringDef)
+		optionalDefMock.mockReturnValueOnce(generatedARNDef)
+
+		expect(webHookUrlDef(false, initialValue)).toBe(generatedARNDef)
+
+		expect(optionalDefMock).toHaveBeenCalledExactlyOnceWith(generatedStringDef, expect.any(Function), { initiallyActive })
+	})
+
+	it('predicate function tests for hostingType of "webhook"', async () => {
+		optionalStringDefMock.mockReturnValueOnce(generatedStringDef)
+		optionalDefMock.mockReturnValueOnce(generatedARNDef)
+
+		expect(webHookUrlDef(false, webhookInitialValue)).toBe(generatedARNDef)
+
+		const checkIfActiveFunction = optionalDefMock.mock.calls[0][1]
+
+		expect(checkIfActiveFunction([{ hostingType: 'lambda' }])).toBe(false)
+		expect(checkIfActiveFunction([{ hostingType: 'webhook' }])).toBe(true)
+		expect(checkIfActiveFunction()).toBe(false)
+	})
+})