refactor(runner-providers): resolve provider types strictly

Author: edersonbrilhante

lambdas/libs/runner-providers/provider-types.test.ts

@@ -1,43 +1,28 @@
 import { describe, expect, it } from 'vitest';
 
-import {
-  defaultRunnerProvider,
-  normalizeRunnerProviderType,
-  resolveRunnerProviderType,
-  runnerProviderTypes,
-} from './provider-types';
+import { defaultRunnerProvider, resolveRunnerProviderType, runnerProviderTypes } from './provider-types';
+
+const defaultProviderInputs = [undefined, '', '   '] as const;
+const supportedProviderCases = runnerProviderTypes.flatMap(
+  (provider) =>
+    [
+      [provider, provider],
+      [` ${provider.toUpperCase()} `, provider],
+    ] as const,
+);
 
 describe('runner provider configuration', () => {
   it('defines an explicit default provider', () => {
     expect(runnerProviderTypes).toContain(defaultRunnerProvider);
   });
 });
 
-describe('runner provider normalization', () => {
-  it.each([
-    [undefined, 'ec2'],
-    ['', 'ec2'],
-    ['   ', 'ec2'],
-    [' EC2 ', 'ec2'],
-  ])('normalizes provider type %j to %j', (type, expected) => {
-    expect(normalizeRunnerProviderType(type)).toBe(expected);
+describe('runner provider resolution', () => {
+  it.each(defaultProviderInputs)('resolves default provider input %j', (type) => {
+    expect(resolveRunnerProviderType(type)).toBe(defaultRunnerProvider);
   });
 
-  it.each([[' Unknown '], ['unsupported-provider'], [null], [1]])(
-    'returns undefined for unsupported provider type %j',
-    (type) => {
-      expect(normalizeRunnerProviderType(type)).toBeUndefined();
-    },
-  );
-});
-
-describe('runner provider resolution', () => {
-  it.each([
-    [undefined, 'ec2'],
-    ['', 'ec2'],
-    ['   ', 'ec2'],
-    [' EC2 ', 'ec2'],
-  ])('resolves provider type %j to %j', (type, expected) => {
+  it.each(supportedProviderCases)('resolves provider type %j to %j', (type, expected) => {
     expect(resolveRunnerProviderType(type)).toBe(expected);
   });
 

lambdas/libs/runner-providers/provider-types.ts

@@ -4,21 +4,19 @@ export type RunnerProviderType = (typeof runnerProviderTypes)[number];
 
 export const defaultRunnerProvider = 'ec2' satisfies RunnerProviderType;
 
-export function normalizeRunnerProviderType(type: unknown): RunnerProviderType | undefined {
+export function resolveRunnerProviderType(type: unknown): RunnerProviderType {
   if (type === undefined) return defaultRunnerProvider;
-  if (typeof type !== 'string') return undefined;
+  if (typeof type !== 'string') {
+    throw new Error(`Unsupported runner provider type '${String(type)}'`);
+  }
 
   const normalizedType = type.trim().toLowerCase();
   if (!normalizedType) return defaultRunnerProvider;
 
-  return runnerProviderTypes.find((runnerProviderType) => runnerProviderType === normalizedType);
-}
-
-export function resolveRunnerProviderType(type: unknown): RunnerProviderType {
-  const normalizedType = normalizeRunnerProviderType(type);
-  if (!normalizedType) {
+  const runnerProviderType = runnerProviderTypes.find((provider) => provider === normalizedType);
+  if (!runnerProviderType) {
     throw new Error(`Unsupported runner provider type '${String(type)}'`);
   }
 
-  return normalizedType;
+  return runnerProviderType;
 }

lambdas/libs/runner-providers/webhook.test.ts

@@ -24,30 +24,13 @@ describe('selectDynamicLabelQueue', () => {
     });
   });
 
-  it('skips an unsupported provider strategy and selects the next supported queue', () => {
-    const unsupportedQueue = runnerQueue('unsupported-provider');
-    (unsupportedQueue as unknown as { runnerProvider: string }).runnerProvider = 'unsupported';
-    const ec2Queue = runnerQueue('ec2');
+  it.each([['unsupported'], [42]])('throws for unsupported runner provider %j', (runnerProvider) => {
+    const queue = runnerQueue('unsupported-provider');
+    (queue as unknown as { runnerProvider: unknown }).runnerProvider = runnerProvider;
 
-    expect(
-      selectDynamicLabelQueue(
-        [unsupportedQueue, ec2Queue],
-        ['self-hosted', 'linux'],
-        ['ghr-ec2-instance-type:t3.large'],
-      ),
-    ).toEqual({
-      queue: ec2Queue,
-      labels: ['self-hosted', 'linux', 'ghr-ec2-instance-type:t3.large'],
-    });
-  });
-
-  it('rejects a malformed non-string runner provider without throwing', () => {
-    const queue = runnerQueue('malformed-provider');
-    (queue as unknown as { runnerProvider: number }).runnerProvider = 42;
-
-    expect(
+    expect(() =>
       selectDynamicLabelQueue([queue], ['self-hosted', 'linux'], ['ghr-ec2-instance-type:t3.large']),
-    ).toBeUndefined();
+    ).toThrow(`Unsupported runner provider type '${String(runnerProvider)}'`);
   });
 });
 

lambdas/libs/runner-providers/webhook.ts

@@ -1,13 +1,9 @@
-import { createChildLogger } from '@aws-github-runner/aws-powertools-util';
-
 import { createRunnerProviderRegistry } from './core';
 
 import type { DynamicLabelDispatchTarget, RunnerMatcherConfig, WebhookProviderCapabilities } from './contracts';
-import { normalizeRunnerProviderType } from './provider-types';
+import { resolveRunnerProviderType } from './provider-types';
 import { enabledWebhookProviders } from './providers.config.webhook';
 
-const logger = createChildLogger('runner-provider-webhook');
-
 export const webhookProviderRegistry = createRunnerProviderRegistry<WebhookProviderCapabilities>(
   enabledWebhookProviders.map((provider) => provider.createPlugin()),
 );
@@ -18,13 +14,8 @@ export function selectDynamicLabelQueue(
   sanitizedGhrLabels: string[],
 ): DynamicLabelDispatchTarget | undefined {
   for (const queue of matches) {
-    const provider = normalizeRunnerProviderType(queue.runnerProvider);
-    const dynamicLabels = provider ? webhookProviderRegistry.capability(provider, 'dynamicLabels') : undefined;
-
-    if (!dynamicLabels) {
-      logger.warn(`Queue ${queue.id} has unsupported runner provider '${provider ?? String(queue.runnerProvider)}'`);
-      continue;
-    }
+    const provider = resolveRunnerProviderType(queue.runnerProvider);
+    const dynamicLabels = webhookProviderRegistry.capability(provider, 'dynamicLabels');
 
     const target = dynamicLabels.selectQueue({ queue, nonGhrLabels, sanitizedGhrLabels });
     if (target) return target;