[Test Improver] Add unit tests for role-template and cron-schedule validators (#17681)

* test: add unit tests for role-template and cron-schedule validators

Add 19 unit tests covering:
- roleTemplateRules: all branching logic including RBAC.ROLE-specific
  checks, noResourceAndNonResource, missingVerb, missingOneResource,
  and default parameter handling
- cronSchedule / cronScheduleRule: valid/invalid cron expressions,
  cronstrue mock, default parameter, error accumulation

Coverage: 0% → 100% stmts/branches/fns/lines for both files

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* ci: trigger checks

---------

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

Author: github-actions[bot]

shell/utils/validators/__tests__/cron-schedule.test.ts

@@ -0,0 +1,79 @@
+import cronstrue from 'cronstrue';
+import { cronSchedule, cronScheduleRule } from '@shell/utils/validators/cron-schedule';
+
+jest.mock('cronstrue', () => ({ toString: jest.fn() }));
+
+const mockCronstrue = cronstrue as jest.Mocked<typeof cronstrue>;
+const mockGetters = { 'i18n/t': (key: string) => key };
+
+describe('cronScheduleRule', () => {
+  it('calls cronstrue.toString with verbose:true', () => {
+    mockCronstrue.toString.mockReturnValue('every minute');
+    cronScheduleRule.validation('* * * * *');
+
+    expect(mockCronstrue.toString).toHaveBeenCalledWith('* * * * *', { verbose: true });
+  });
+
+  it('has the correct message key', () => {
+    expect(cronScheduleRule.message).toStrictEqual('validation.invalidCron');
+  });
+});
+
+describe('cronSchedule', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('does not add an error for a valid cron expression', () => {
+    mockCronstrue.toString.mockReturnValue('every minute');
+    const errors: string[] = [];
+
+    cronSchedule('* * * * *', mockGetters, errors);
+
+    expect(errors).toStrictEqual([]);
+  });
+
+  it('adds an error for an invalid cron expression', () => {
+    mockCronstrue.toString.mockImplementation(() => {
+      throw new Error('Invalid cron expression');
+    });
+    const errors: string[] = [];
+
+    cronSchedule('not-a-cron', mockGetters, errors);
+
+    expect(errors).toStrictEqual(['validation.invalidCron']);
+  });
+
+  it('uses default empty string for schedule when not provided', () => {
+    mockCronstrue.toString.mockImplementation(() => {
+      throw new Error('Invalid cron expression');
+    });
+    const errors: string[] = [];
+
+    cronSchedule(undefined as any, mockGetters, errors);
+
+    expect(errors).toStrictEqual(['validation.invalidCron']);
+  });
+
+  it('does not push multiple errors for a single invalid schedule', () => {
+    mockCronstrue.toString.mockImplementation(() => {
+      throw new Error('Invalid');
+    });
+    const errors: string[] = [];
+
+    cronSchedule('bad', mockGetters, errors);
+
+    expect(errors).toHaveLength(1);
+  });
+
+  it('preserves existing errors when adding a new one', () => {
+    mockCronstrue.toString.mockImplementation(() => {
+      throw new Error('Invalid');
+    });
+    const errors = ['existing error'];
+
+    cronSchedule('bad', mockGetters, errors);
+
+    expect(errors).toStrictEqual(['existing error', 'validation.invalidCron']);
+  });
+});

shell/utils/validators/__tests__/role-template.test.ts

@@ -0,0 +1,149 @@
+import { roleTemplateRules } from '@shell/utils/validators/role-template';
+import { RBAC } from '@shell/config/types';
+
+const mockGetters = { 'i18n/t': (key: string) => key };
+
+describe('roleTemplateRules', () => {
+  it('adds no errors for valid rules with no type', () => {
+    const rules = [{
+      verbs: ['get'], resources: ['pods'], apiGroups: ['']
+    }];
+    const errors: string[] = [];
+
+    roleTemplateRules(rules, mockGetters, errors);
+
+    expect(errors).toStrictEqual([]);
+  });
+
+  it('adds missingVerb error when a rule has empty verbs', () => {
+    const rules = [{
+      verbs: [], resources: ['pods'], apiGroups: ['']
+    }];
+    const errors: string[] = [];
+
+    roleTemplateRules(rules, mockGetters, errors);
+
+    expect(errors).toStrictEqual(['validation.roleTemplate.roleTemplateRules.missingVerb']);
+  });
+
+  it('adds noResourceAndNonResource error when a rule has both resources and nonResourceURLs', () => {
+    const rules = [{
+      verbs:           ['get'],
+      resources:       ['pods'],
+      nonResourceURLs: ['/healthz'],
+      apiGroups:       [''],
+    }];
+    const errors: string[] = [];
+
+    roleTemplateRules(rules, mockGetters, errors);
+
+    expect(errors).toStrictEqual(['validation.roleTemplate.roleTemplateRules.noResourceAndNonResource']);
+  });
+
+  it('adds missingResource error for RBAC.ROLE type when resources are empty', () => {
+    const rules = [{
+      verbs: ['get'], resources: [], nonResourceURLs: ['/healthz'], apiGroups: ['']
+    }];
+    const errors: string[] = [];
+
+    roleTemplateRules(rules, mockGetters, errors, [RBAC.ROLE]);
+
+    expect(errors).toStrictEqual(['validation.roleTemplate.roleTemplateRules.missingResource']);
+  });
+
+  it('adds missingApiGroup error for RBAC.ROLE type when apiGroups are empty', () => {
+    const rules = [{
+      verbs: ['get'], resources: ['pods'], apiGroups: []
+    }];
+    const errors: string[] = [];
+
+    roleTemplateRules(rules, mockGetters, errors, [RBAC.ROLE]);
+
+    expect(errors).toStrictEqual(['validation.roleTemplate.roleTemplateRules.missingApiGroup']);
+  });
+
+  it('adds noResourceAndNonResource error for non-RBAC.ROLE when rule has resources and nonResourceUrls', () => {
+    const rules = [{
+      verbs:           ['get'],
+      resources:       ['pods'],
+      nonResourceUrls: ['/healthz'],
+      apiGroups:       [''],
+    }];
+    const errors: string[] = [];
+
+    roleTemplateRules(rules, mockGetters, errors, [RBAC.CLUSTER_ROLE]);
+
+    expect(errors).toStrictEqual(['validation.roleTemplate.roleTemplateRules.noResourceAndNonResource']);
+  });
+
+  it('adds missingOneResource error when rule has neither resources nor nonResourceURLs', () => {
+    const rules = [{
+      verbs: ['get'], resources: [], nonResourceURLs: [], apiGroups: []
+    }];
+    const errors: string[] = [];
+
+    roleTemplateRules(rules, mockGetters, errors, [RBAC.CLUSTER_ROLE]);
+
+    expect(errors).toStrictEqual(['validation.roleTemplate.roleTemplateRules.missingOneResource']);
+  });
+
+  it('adds multiple errors when multiple rules are invalid', () => {
+    const rules = [
+      {
+        verbs: [], resources: ['pods'], apiGroups: ['']
+      },
+      {
+        verbs: ['get'], resources: [], nonResourceURLs: [], apiGroups: []
+      },
+    ];
+    const errors: string[] = [];
+
+    roleTemplateRules(rules, mockGetters, errors, [RBAC.CLUSTER_ROLE]);
+
+    expect(errors).toStrictEqual([
+      'validation.roleTemplate.roleTemplateRules.missingVerb',
+      'validation.roleTemplate.roleTemplateRules.missingOneResource',
+    ]);
+  });
+
+  it('handles empty rules array with no errors', () => {
+    const errors: string[] = [];
+
+    roleTemplateRules([], mockGetters, errors);
+
+    expect(errors).toStrictEqual([]);
+  });
+
+  it('uses default empty array for rules when not provided', () => {
+    const errors: string[] = [];
+
+    roleTemplateRules(undefined as any, mockGetters, errors);
+
+    expect(errors).toStrictEqual([]);
+  });
+
+  it('adds both missingResource and missingApiGroup errors for RBAC.ROLE with empty resources and apiGroups', () => {
+    const rules = [{
+      verbs: ['get'], resources: [], nonResourceURLs: ['/healthz'], apiGroups: []
+    }];
+    const errors: string[] = [];
+
+    roleTemplateRules(rules, mockGetters, errors, [RBAC.ROLE]);
+
+    expect(errors).toStrictEqual([
+      'validation.roleTemplate.roleTemplateRules.missingResource',
+      'validation.roleTemplate.roleTemplateRules.missingApiGroup',
+    ]);
+  });
+
+  it('does not add RBAC.ROLE-specific errors when type is not RBAC.ROLE', () => {
+    const rules = [{
+      verbs: ['get'], resources: ['pods'], apiGroups: ['']
+    }];
+    const errors: string[] = [];
+
+    roleTemplateRules(rules, mockGetters, errors, [RBAC.CLUSTER_ROLE]);
+
+    expect(errors).toStrictEqual([]);
+  });
+});