import formRulesGenerator from '@shell/utils/validators/formRules';

const mockT = (key: string, args: any) => {
  return JSON.stringify({
    message: key,
    ...args
  });
};

describe('formRules', () => {
  const formRules = formRulesGenerator(mockT, { key: 'testDisplayKey' });

  it('"required" : returns undefined when value supplied', () => {
    const testValue = 'foo';
    const formRuleResult = formRules.required(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"required" : returns the correct message when value undefined', () => {
    const formRuleResult = formRules.required(undefined);
    const expectedResult = JSON.stringify({
      message: 'validation.required',
      key:     'testDisplayKey'
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"https" : returns undefined when valid https url value is supplied', () => {
    const testValue = 'https://url.com';
    const formRuleResult = formRules.https(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"https" : returns correct message when http url value is supplied', () => {
    const testValue = 'http://url.com';
    const formRuleResult = formRules.https(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.setting.serverUrl.https' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  describe('localhost', () => {
    const message = JSON.stringify({ message: 'validation.setting.serverUrl.localhost' });
    const testCases = [
      ['http://LOCALhosT:8005', message],
      ['http://localhost:8005', message],
      ['https://localhost:8005', message],
      ['localhost', message],
      ['http://127.0.0.1', message],
      ['https://127.0.0.1', message],
      ['127.0.0.1', message],
      ['https://test.com', undefined],
      ['https://test.com/localhost', undefined],
      [undefined, undefined]
    ];

    it.each(testCases)(
      'should return undefined or correct message based on the provided url',
      (url, expected) => {
        const formRuleResult = formRules.localhost(url);

        expect(formRuleResult).toStrictEqual(expected);
      }
    );
  });

  describe('trailingForwardSlash', () => {
    const message = JSON.stringify({ message: 'validation.setting.serverUrl.trailingForwardSlash' });
    const testCases = [
      ['https://test.com', undefined],
      ['https://test.com/', message],
      ['https://', undefined],
      ['/', undefined],
      [undefined, undefined]
    ];

    it.each(testCases)(
      'should return undefined or correct message based on the provided url',
      (url, expected) => {
        const formRuleResult = formRules.trailingForwardSlash(url);

        expect(formRuleResult).toStrictEqual(expected);
      }
    );
  });

  describe('gitRepository', () => {
    const message = JSON.stringify({ message: 'validation.git.repository' });
    const testCases = [
      // Valid HTTP(s)
      ['https://github.com/rancher/dashboard.git', undefined],
      ['http://github.com/rancher/dashboard.git', undefined],
      ['https://github.com/rancher/dashboard', undefined],
      ['https://github.com/rancher/dashboard/', undefined],

      // Valid SSH
      ['git@github.com:rancher/dashboard.git', undefined],
      ['git@github.com:rancher/dashboard', undefined],
      ['git@github.com:rancher/dashboard/', undefined],

      // Not valid HTTP(s)
      ['https://github.com/rancher/  dashboard.git', message],
      ['http://github.com/rancher/  dashboard.git', message],
      ['https://github.com/rancher/dashboard ', message],
      ['foo://github.com/rancher/dashboard/', message],
      ['github.com/rancher/dashboard/', message],

      // Not valid SSH
      ['git@github.com:rancher/  dashboard.git', message],
      ['git@github.com:rancher/dashboard  ', message],
      ['git@github.comrancher/dashboard', message],

      [undefined, undefined]
    ];

    it.each(testCases)(
      'should return undefined or correct message based on the provided Git url: %p',
      (url, expected) => {
        const formRuleResult = formRules.gitRepository(url);

        expect(formRuleResult).toStrictEqual(expected);
      }
    );
  });

  describe('alphanumeric', () => {
    const message = JSON.stringify({ message: 'validation.alphanumeric', key: 'testDisplayKey' });
    const testCases = [
      ['', undefined],
      ['aaaAAAA111', undefined],
      ['aaaAAAA111//', message],
      ['/', message],
      ['+1', message],
      [undefined, undefined]
    ];

    it.each(testCases)(
      'should return undefined or correct message based on the provided url',
      (val, expected) => {
        const formRuleResult = formRules.alphanumeric(val);

        expect(formRuleResult).toStrictEqual(expected);
      }
    );
  });

  it('"interval" : returns undefined when valid hour interval value is supplied', () => {
    const testValue = '5h';
    const formRuleResult = formRules.interval(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"interval" : returns undefined when valid minute interval value is supplied', () => {
    const testValue = '5m';
    const formRuleResult = formRules.interval(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"interval" : returns undefined when valid second interval value is supplied', () => {
    const testValue = '5s';
    const formRuleResult = formRules.interval(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"interval" : returns correct message when interval unit is supplied but not integer', () => {
    const testValue = 's';
    const formRuleResult = formRules.interval(testValue);
    const expectedResult = JSON.stringify({
      message: 'validation.monitoring.route.interval',
      key:     'testDisplayKey'
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"interval" : returns correct message when interval integer is supplied but not unit', () => {
    const testValue = '5';
    const formRuleResult = formRules.interval(testValue);
    const expectedResult = JSON.stringify({
      message: 'validation.monitoring.route.interval',
      key:     'testDisplayKey'
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"containerImage" : returns undefined when valid container with image is supplied', () => {
    const testValue = { image: 'imageName' };
    const formRuleResult = formRules.containerImage(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"containerImage" : returns correct message when container without image is supplied', () => {
    const testValue = { name: 'testName' };
    const formRuleResult = formRules.containerImage(testValue);
    const expectedResult = JSON.stringify({
      message: 'workload.validation.containerImage',
      name:    testValue.name
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"containerImages" : returns undefined when valid jobTemplate value is supplied', () => {
    const testValue = { jobTemplate: { spec: { template: { spec: { containers: [{ image: 'imageName', name: 'name' }] } } } } };
    const formRuleResult = formRules.containerImages(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"containerImages" : returns undefined when valid non-jobTemplate value is supplied', () => {
    const testValue = { template: { spec: { containers: [{ image: 'imageName', name: 'name' }] } } };
    const formRuleResult = formRules.containerImages(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"containerImages" : returns correct message when supplied value contains no containers', () => {
    const testValue = { template: { spec: { containers: [] } } };
    const formRuleResult = formRules.containerImages(testValue);
    const expectedResult = JSON.stringify({
      message: 'validation.required',
      key:     JSON.stringify({ message: 'workload.container.titles.containers' })
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"containerImages" : returns correct message when supplied value has containers but one has no image', () => {
    const testValue = { template: { spec: { containers: [{ name: 'testName' }] } } };
    const formRuleResult = formRules.containerImages(testValue);
    const expectedResult = JSON.stringify({
      message: 'workload.validation.containerImage',
      name:    'testName'
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  describe('"registryUrl": has the expected output for each input', () => {
    const expectedTranslation = JSON.stringify({ message: 'cluster.privateRegistry.privateRegistryUrlError' });
    const testCases = [
      // Empty
      [undefined, undefined],

      // Word
      ['registry', expectedTranslation],

      // Without schema
      ['registry.io', undefined],

      // With schemas
      ['http://registry.io', undefined],
      ['https://registry.io', undefined],
    ];

    it.each(testCases)(
      'should return undefined or correct message based on the provided url',
      (url, expected) => {
        const formRuleResult = formRules.registryUrl(url);

        expect(formRuleResult).toStrictEqual(expected);
      }
    );
  });

  it('"ruleGroups" : returns undefined when rulegroups are supplied', () => {
    const testValue = { groups: ['group1'] };
    const formRuleResult = formRules.ruleGroups(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"groupsAreValid" : returns undefined when valid rulegroups are supplied', () => {
    const testValue = [
      {
        name:  'group',
        rules: [
          {
            alert:  { name: 'alertname' },
            record: { name: 'recordname' },
            expr:   { name: 'exprname' },
            labels: ['label1']
          }
        ]
      }
    ];
    const formRuleResult = formRules.groupsAreValid(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"groupsAreValid" : returns correct message when rules are empty', () => {
    const testValue = [
      {
        name:  'group',
        rules: []
      }
    ];
    const formRuleResult = formRules.groupsAreValid(testValue);
    const expectedResult = JSON.stringify({
      message: 'validation.prometheusRule.groups.valid.singleEntry',
      index:   1
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"groupsAreValid" : returns correct message when rule alert is empty', () => {
    const testValue = [
      {
        name:  'group',
        rules: [
          {
            alert:  '',
            record: '',
            expr:   '',
            labels: { severity: 'none' }
          }
        ]
      }
    ];
    const formRuleResult = formRules.groupsAreValid(testValue);
    const expectedResult = JSON.stringify({
      message:    'validation.prometheusRule.groups.valid.rule.alertName',
      groupIndex: 1,
      ruleIndex:  1
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"groupsAreValid" : returns correct message when rule record is empty', () => {
    const testValue = [
      {
        name:  'group',
        rules: [
          {
            alert:  'name',
            record: '',
            expr:   '',
            labels: { severity: 'none' }
          }
        ]
      }
    ];
    const formRuleResult = formRules.groupsAreValid(testValue);
    const expectedResult = JSON.stringify({
      message:    'validation.prometheusRule.groups.valid.rule.recordName',
      groupIndex: 1,
      ruleIndex:  1
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"groupsAreValid" : returns correct message when rule expr is empty', () => {
    const testValue = [
      {
        name:  'group',
        rules: [
          {
            alert:  'name',
            record: 'record',
            expr:   '',
            labels: { severity: 'none' }
          }
        ]
      }
    ];
    const formRuleResult = formRules.groupsAreValid(testValue);
    const expectedResult = JSON.stringify({
      message:    'validation.prometheusRule.groups.valid.rule.expr',
      groupIndex: 1,
      ruleIndex:  1
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"groupsAreValid" : returns correct message when rule labels is empty', () => {
    const testValue = [
      {
        name:  'group',
        rules: [
          {
            alert:  'name',
            record: 'record',
            expr:   'expr',
            labels: {}
          }
        ]
      }
    ];
    const formRuleResult = formRules.groupsAreValid(testValue);
    const expectedResult = JSON.stringify({
      message:    'validation.prometheusRule.groups.valid.rule.labels',
      groupIndex: 1,
      ruleIndex:  1
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"matching" : returns undefined when is not empty and match_re is not empty', () => {
    const testValue = { match: 'matchValue', match_re: 'match_reValue' };
    const formRuleResult = formRules.matching(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"matching" : returns undefined when match is empty and match_re is not empty', () => {
    const testValue = { match: '', match_re: 'match_reValue' };
    const formRuleResult = formRules.matching(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"matching" : returns undefined when match is not empty and match_re is empty', () => {
    const testValue = { match: 'matchValue', match_re: '' };
    const formRuleResult = formRules.matching(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"matching" : returns correct message when match is empty and match_re is empty', () => {
    const testValue = { match: '', match_re: '' };
    const formRuleResult = formRules.matching(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.monitoring.route.match' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"clusterName" : returns undefined when "isRke2" is false', () => {
    const testValue = 'clusterName';
    const formRuleResult = formRules.clusterName(false)(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"clusterName" : returns undefined when "isRke2" is true and clusterName is valid', () => {
    const testValue = 'clustername';
    const formRuleResult = formRules.clusterName(true)(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"clusterName" : returns correct message when "isRke2" is true and clusterName is 5 characters long with "c-" as a prefix', () => {
    const testValue = 'c-12345';
    const formRuleResult = formRules.clusterName(true)(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.cluster.name' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"clusterName" : returns undefined when "isRke2" is true and clusterName is less than 5 characters long with "c-" as a prefix', () => {
    const testValue = 'c-1234';
    const formRuleResult = formRules.clusterName(true)(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"clusterName" : returns undefined when "isRke2" is true and clusterName is more than 5 characters long with "c-" as a prefix', () => {
    const testValue = 'c-123456';
    const formRuleResult = formRules.clusterName(true)(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"roleTemplateRules" : returns undefined when type is RBAC role and value contains valid rules', () => {
    const testValue: [{}] = [
      {
        verbs: ['verb1'], resources: ['resource1'], apiGroups: ['apiGroup1']
      }
    ];
    const formRuleResult = formRules.roleTemplateRules('rbac.authorization.k8s.io.role')(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"roleTemplateRules" : returns correct message when type is RBAC role and value is missing verbs', () => {
    const testValue: [{}] = [
      {
        verbs: [], resources: ['resource1'], apiGroups: ['apiGroup1']
      }
    ];
    const formRuleResult = formRules.roleTemplateRules('rbac.authorization.k8s.io.role')(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.roleTemplate.roleTemplateRules.missingVerb' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"roleTemplateRules" : returns correct message when type is RBAC role and value is missing resources', () => {
    const testValue: [{}] = [
      {
        verbs: ['verb1'], resources: [], apiGroups: ['apiGroup1']
      }
    ];
    const formRuleResult = formRules.roleTemplateRules('rbac.authorization.k8s.io.role')(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.roleTemplate.roleTemplateRules.missingResource' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"roleTemplateRules" : returns correct message when type is RBAC role rule defines both resources and nonResourceURLs', () => {
    const testValue: [{}] = [
      {
        verbs: ['verb1'], resources: ['resource1'], apiGroups: ['apiGroup1'], nonResourceURLs: ['nonResourceUrl1']
      }
    ];
    const formRuleResult = formRules.roleTemplateRules('rbac.authorization.k8s.io.role')(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.roleTemplate.roleTemplateRules.noResourceAndNonResource' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"roleTemplateRules" : returns correct message when type is RBAC role and value is missing apiGroups', () => {
    const testValue: [{}] = [
      {
        verbs: ['verb1'], resources: ['resource1'], apiGroups: []
      }
    ];
    const formRuleResult = formRules.roleTemplateRules('rbac.authorization.k8s.io.role')(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.roleTemplate.roleTemplateRules.missingApiGroup' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"roleTemplateRules" : returns undefined when type is not RBAC role and value contains valid rules', () => {
    const testValue: [{}] = [
      {
        verbs: ['verb1'], resources: ['resource1'], apiGroups: ['apiGroup1']
      }
    ];
    const formRuleResult = formRules.roleTemplateRules('nonrbactype')(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"roleTemplateRules" : returns undefined when type is not RBAC role and value is missing resources and nonResourceURLs and apiGroups', () => {
    const testValue: [{}] = [
      {
        verbs: ['verb1'], nonResourceURLs: [], resources: [], apiGroups: []
      }
    ];
    const formRuleResult = formRules.roleTemplateRules('nonrbactype')(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.roleTemplate.roleTemplateRules.missingOneResource' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"servicePort" : returns undefined when servicePort is valid', () => {
    const testValue = {
      name:       'portName',
      nodePort:   '8081',
      port:       '8082',
      targetPort: '8083',
      idx:        0
    };
    const formRuleResult = formRules.servicePort(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"servicePort" : returns correct message when servicePort name is empty', () => {
    const testValue = {
      name:       '',
      nodePort:   '8081',
      port:       '8082',
      targetPort: '8083',
      idx:        0
    };
    const formRuleResult = formRules.servicePort(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.service.ports.name.required', position: 1 });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"servicePort" : returns correct message when servicePort nodePort is not an integer', () => {
    const testValue = {
      name:       'portName',
      nodePort:   'test',
      port:       '8082',
      targetPort: '8083',
      idx:        0
    };
    const formRuleResult = formRules.servicePort(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.service.ports.nodePort.requiredInt', position: 1 });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"servicePort" : returns correct message when servicePort port is not an integer', () => {
    const testValue = {
      name:       'portName',
      nodePort:   '8081',
      port:       'test',
      targetPort: '8083',
      idx:        0
    };
    const formRuleResult = formRules.servicePort(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.service.ports.port.requiredInt', position: 1 });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"servicePort" : returns correct message when port is not provided', () => {
    const testValue = {
      name:       'portName',
      nodePort:   '8081',
      targetPort: '8083',
      idx:        0
    };
    const formRuleResult = formRules.servicePort(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.service.ports.port.required', position: 1 });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"servicePort" : returns correct message when targetPort port is not an integer but is a valid dnsLabelIanaServiceName', () => {
    const testValue = {
      name:       'portName',
      nodePort:   '8081',
      port:       '8082',
      targetPort: 'test',
      idx:        0
    };
    const formRuleResult = formRules.servicePort(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"servicePort" : returns correct message when targetPort port is not an integer but is not a valid dnsLabelIanaServiceName', () => {
    const testValue = {
      name:       'portName',
      nodePort:   '8081',
      port:       '8082',
      targetPort: 'te st',
      idx:        0
    };
    const formRuleResult = formRules.servicePort(testValue);
    const expectedResult = JSON.stringify({
      message: 'validation.chars', key: 'testDisplayKey', count: 1, chars: 'Space'
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"servicePort" : returns correct message when targetPort port is below the valid range', () => {
    const testValue = {
      name:       'portName',
      nodePort:   '8081',
      port:       '8082',
      targetPort: '0',
      idx:        0
    };
    const formRuleResult = formRules.servicePort(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.service.ports.targetPort.between', position: 1 });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"servicePort" : returns correct message when targetPort port is above the valid range', () => {
    const testValue = {
      name:       'portName',
      nodePort:   '8081',
      port:       '8082',
      targetPort: '65536',
      idx:        0
    };
    const formRuleResult = formRules.servicePort(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.service.ports.targetPort.between', position: 1 });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"clusterIp" : always returns undefined', () => {
    const formRuleResult = formRules.clusterIp('');

    expect(formRuleResult).toBeUndefined();
  });

  it('"externalName" : returns undefined when value is a valid externalName', () => {
    const testValue = 'test';
    const formRuleResult = formRules.externalName(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"externalName" : returns expected message when value empty', () => {
    const testValue = '';
    const formRuleResult = formRules.externalName(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.service.externalName.none' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"externalName" : returns expected message when value starts with a dot', () => {
    const testValue = '.hostname';
    const formRuleResult = formRules.externalName(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.dns.hostname.startDot', key: 'testDisplayKey' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"externalName" : returns expected message when value starts is too long for a hostname', () => {
    const testValue = 'There.are.many.variations.of.passages.of.Lorem.Ipsum.available.but.the.majority.have.suffered.alteration.in.some.form.by.injected.humour.or.randomised.words.which.dont.look.even.slightly.believable.If.you.are.going.to.use.a.passage.of.Lorem.Ipsum.you.need';
    const formRuleResult = formRules.externalName(testValue);
    const expectedResult = JSON.stringify({
      message: 'validation.dns.hostname.tooLong', key: 'testDisplayKey', max: 253
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"externalName" : returns expected message when value contains invalid characters', () => {
    const testValue = 'www.host*name.com';
    const formRuleResult = formRules.externalName(testValue);
    const expectedResult = JSON.stringify({
      message: 'validation.chars', key: 'testDisplayKey', count: 1, chars: '"*"'
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"externalName" : returns expected message when hostname label starts with a dash', () => {
    const testValue = 'www.-hostname.com';
    const formRuleResult = formRules.externalName(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.dns.hostname.startHyphen', key: 'testDisplayKey' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"externalName" : returns expected message when hostname label ends with a dash', () => {
    const testValue = 'www.hostname-.com';
    const formRuleResult = formRules.externalName(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.dns.hostname.endHyphen', key: 'testDisplayKey' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"externalName" : returns expected message when hostname label contains a double-dash at the third character position', () => {
    const testValue = 'www.ho--stname.com';
    const formRuleResult = formRules.externalName(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.dns.doubleHyphen', key: 'testDisplayKey' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"externalName" : returns expected message when hostname label is empty', () => {
    const testValue = 'www..com';
    const formRuleResult = formRules.externalName(testValue);
    const expectedResult = JSON.stringify({
      message: 'validation.dns.hostname.emptyLabel', key: 'testDisplayKey', min: 1
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"externalName" : returns expected message when hostname label is too long', () => {
    const testValue = 'www.0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef.com';
    const formRuleResult = formRules.externalName(testValue);
    const expectedResult = JSON.stringify({
      message: 'validation.dns.hostname.tooLongLabel', key: 'testDisplayKey', max: 63
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"backupTarget" : returns undefined when value is valid backupTarget', () => {
    const testValue = JSON.stringify({ type: 'type' });
    const formRuleResult = formRules.backupTarget(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"backupTarget" : returns expected message when value is backupTarget without a type', () => {
    const testValue = JSON.stringify({});
    const formRuleResult = formRules.backupTarget(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.required', key: 'Type' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"backupTarget" : returns expected message when value is backupTarget with a type of s3 but no accessKeyId', () => {
    const testValue = JSON.stringify({ type: 's3' });
    const formRuleResult = formRules.backupTarget(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.required', key: 'accessKeyId' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"backupTarget" : returns expected message when value is backupTarget with a type of s3 but no secretAccessKey', () => {
    const testValue = JSON.stringify({ type: 's3', accessKeyId: 'id' });
    const formRuleResult = formRules.backupTarget(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.required', key: 'secretAccessKey' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"backupTarget" : returns expected message when value is backupTarget with a type of s3 but no bucketRegion', () => {
    const testValue = JSON.stringify({
      type: 's3', accessKeyId: 'id', secretAccessKey: 'key'
    });
    const formRuleResult = formRules.backupTarget(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.required', key: 'bucketRegion' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"backupTarget" : returns expected message when value is backupTarget with a type of s3 but no bucketName', () => {
    const testValue = JSON.stringify({
      type: 's3', accessKeyId: 'id', secretAccessKey: 'key', bucketRegion: 'region'
    });
    const formRuleResult = formRules.backupTarget(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.required', key: 'bucketName' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"backupTarget" : returns undefined when value is backupTarget with a type of s3 and all other values', () => {
    const testValue = JSON.stringify({
      type: 's3', accessKeyId: 'id', secretAccessKey: 'key', bucketRegion: 'region', bucketName: 'name'
    });
    const formRuleResult = formRules.backupTarget(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"imageUrl" : returns undefined when value is a valid imageUrl', () => {
    const testValue = 'https://url/image.iso';
    const formRuleResult = formRules.imageUrl(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"imageUrl" : returns expected message when value has an invalid file extension', () => {
    const testValue = 'https://url/image.isi';
    const formRuleResult = formRules.imageUrl(testValue);
    const expectedResult = JSON.stringify({ message: 'harvester.validation.image.ruleTip' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"fileRequired" : returns undefined when value has an image name key', () => {
    const testValue = { 'harvesterhci.io/image-name': 'test' };
    const formRuleResult = formRules.fileRequired(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"fileRequired" : returns expected message when value is invalid', () => {
    const testValue = {};
    const formRuleResult = formRules.fileRequired(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.required', key: JSON.stringify({ message: 'harvester.image.fileName' }) });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"dnsLabel" : returns undefined when valid dnsLabel value is supplied', () => {
    const testValue = 'bob';
    const formRuleResult = formRules.dnsLabel(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"dnsLabel" : returns correct message when dnsLabel value with invalid characters is supplied', () => {
    const testValue = 'bob*bob';
    const formRuleResult = formRules.dnsLabel(testValue);
    const expectedResult = JSON.stringify({
      message: 'validation.chars',
      key:     'testDisplayKey',
      count:   1,
      chars:   '"*"'
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"dnsLabel" : returns correct message when  dnsLabel value that starts with a dash is supplied', () => {
    const testValue = '-bob';
    const formRuleResult = formRules.dnsLabel(testValue);
    const expectedResult = JSON.stringify({
      message: 'validation.dns.label.startHyphen',
      key:     'testDisplayKey'
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"dnsLabel" : returns correct message when  dnsLabel value that ends with a dash is supplied', () => {
    const testValue = 'bob-';
    const formRuleResult = formRules.dnsLabel(testValue);
    const expectedResult = JSON.stringify({
      message: 'validation.dns.label.endHyphen',
      key:     'testDisplayKey'
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"dnsLabel" : returns correct message when dnsLabel value with double-dash after first two characters is supplied', () => {
    const testValue = 'jo--jane';
    const formRuleResult = formRules.dnsLabel(testValue);
    const expectedResult = JSON.stringify({
      message: 'validation.dns.doubleHyphen',
      key:     'testDisplayKey'
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"dnsLabel" : returns correct message when dnsLabel value is too long', () => {
    const testValue = 'abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz';
    const formRuleResult = formRules.dnsLabel(testValue);
    const expectedResult = JSON.stringify({
      message: 'validation.dns.label.tooLongLabel',
      key:     'testDisplayKey',
      max:     63
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  // this rule is pretty much identical to the standard dnsLabel other than the dnsLabel length
  it('"dnsLabelIanaServiceName" : returns correct message when dnsLabel value is too long', () => {
    const testValue = '0123456789abcdef';
    const formRuleResult = formRules.dnsLabelIanaServiceName(testValue);
    const expectedResult = JSON.stringify({
      message: 'validation.dns.label.tooLongLabel',
      key:     'testDisplayKey',
      max:     15
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  // this rule is pretty much identical to the standard dnsLabel other than the startNumber test
  it('"dnsLabelRestricted" : returns correct message when dnsLabel starts with a number', () => {
    const testValue = '1testUrl';
    const formRuleResult = formRules.dnsLabelRestricted(testValue);
    const expectedResult = JSON.stringify({
      message: 'validation.dns.label.startNumber',
      key:     'testDisplayKey'
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  // this rule is pretty much identical to the standard dnsLabel other than the startNumber test
  it('"hostName" : returns undefined when value is valid hostname', () => {
    const testValue = 'www.url.com';
    const formRuleResult = formRules.hostname(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"hostName" : returns expected message when value starts with a dot', () => {
    const testValue = '.hostname';
    const formRuleResult = formRules.hostname(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.dns.hostname.startDot', key: 'testDisplayKey' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"hostName" : returns expected message when value starts is too long for a hostname', () => {
    const testValue = 'There.are.many.variations.of.passages.of.Lorem.Ipsum.available.but.the.majority.have.suffered.alteration.in.some.form.by.injected.humour.or.randomised.words.which.dont.look.even.slightly.believable.If.you.are.going.to.use.a.passage.of.Lorem.Ipsum.you.need';
    const formRuleResult = formRules.hostname(testValue);
    const expectedResult = JSON.stringify({
      message: 'validation.dns.hostname.tooLong', key: 'testDisplayKey', max: 253
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"hostName" : returns expected message when value contains invalid characters', () => {
    const testValue = 'www.host*name.com';
    const formRuleResult = formRules.hostname(testValue);
    const expectedResult = JSON.stringify({
      message: 'validation.chars', key: 'testDisplayKey', count: 1, chars: '"*"'
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"hostName" : returns expected message when value contains a space character', () => {
    const testValue = 'www.host name.com';
    const formRuleResult = formRules.hostname(testValue);
    const expectedResult = JSON.stringify({
      message: 'validation.chars', key: 'testDisplayKey', count: 1, chars: 'Space'
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"hostName" : returns expected message when hostname label starts with a dash', () => {
    const testValue = 'www.-hostname.com';
    const formRuleResult = formRules.hostname(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.dns.hostname.startHyphen', key: 'testDisplayKey' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"hostName" : returns expected message when hostname label ends with a dash', () => {
    const testValue = 'www.hostname-.com';
    const formRuleResult = formRules.hostname(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.dns.hostname.endHyphen', key: 'testDisplayKey' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"hostName" : returns expected message when hostname label contains a double-dash at the third character position', () => {
    const testValue = 'www.ho--stname.com';
    const formRuleResult = formRules.hostname(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.dns.doubleHyphen', key: 'testDisplayKey' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"hostName" : returns expected message when hostname label is too long', () => {
    const testValue = 'www.0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef.com';
    const formRuleResult = formRules.hostname(testValue);
    const expectedResult = JSON.stringify({
      message: 'validation.dns.hostname.tooLongLabel', key: 'testDisplayKey', max: 63
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  // this rule is pretty much identical to the standard hostname, but also allows for wildcards
  it('"wildcardHostname" : returns undefined when value is valid hostname', () => {
    const testValue = 'www.url.com';
    const formRuleResult = formRules.wildcardHostname(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"wildcardHostname" : returns expected message when value starts with a dot', () => {
    const testValue = '.hostname';
    const formRuleResult = formRules.wildcardHostname(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.dns.hostname.startDot', key: 'testDisplayKey' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"wildcardHostname" : returns expected message when value starts is too long for a hostname', () => {
    const testValue = 'There.are.many.variations.of.passages.of.Lorem.Ipsum.available.but.the.majority.have.suffered.alteration.in.some.form.by.injected.humour.or.randomised.words.which.dont.look.even.slightly.believable.If.you.are.going.to.use.a.passage.of.Lorem.Ipsum.you.need';
    const formRuleResult = formRules.wildcardHostname(testValue);
    const expectedResult = JSON.stringify({
      message: 'validation.dns.hostname.tooLong', key: 'testDisplayKey', max: 253
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"wildcardHostname" : returns expected message when value contains invalid characters', () => {
    const testValue = 'www.host*name.com';
    const formRuleResult = formRules.wildcardHostname(testValue);
    const expectedResult = JSON.stringify({
      message: 'validation.chars', key: 'testDisplayKey', count: 1, chars: '"*"'
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"wildcardHostname" : returns expected message when value contains a space character', () => {
    const testValue = 'www.host name.com';
    const formRuleResult = formRules.wildcardHostname(testValue);
    const expectedResult = JSON.stringify({
      message: 'validation.chars', key: 'testDisplayKey', count: 1, chars: 'Space'
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"wildcardHostname" : returns expected message when hostname label starts with a dash', () => {
    const testValue = 'www.-hostname.com';
    const formRuleResult = formRules.wildcardHostname(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.dns.hostname.startHyphen', key: 'testDisplayKey' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"wildcardHostname" : returns expected message when hostname label ends with a dash', () => {
    const testValue = 'www.hostname-.com';
    const formRuleResult = formRules.wildcardHostname(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.dns.hostname.endHyphen', key: 'testDisplayKey' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"wildcardHostname" : returns expected message when hostname label contains a double-dash at the third character position', () => {
    const testValue = 'www.ho--stname.com';
    const formRuleResult = formRules.wildcardHostname(testValue);
    const expectedResult = JSON.stringify({ message: 'validation.dns.doubleHyphen', key: 'testDisplayKey' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"wildcardHostname" : returns expected message when hostname label is too long', () => {
    const testValue = 'www.0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef.com';
    const formRuleResult = formRules.wildcardHostname(testValue);
    const expectedResult = JSON.stringify({
      message: 'validation.dns.hostname.tooLongLabel', key: 'testDisplayKey', max: 63
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"wildcardHostname" : returns expected message when wildcard character is not the first part', () => {
    const testValue = 'www.*.hostname.com';
    const formRuleResult = formRules.wildcardHostname(testValue);
    const expectedResult = JSON.stringify({
      message: 'validation.chars', key: 'testDisplayKey', count: 1, chars: '"*"'
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"wildcardHostname" : returns expected message when wildcard character is at the beginning but not its own part', () => {
    const testValue = '*hostname.com';
    const formRuleResult = formRules.wildcardHostname(testValue);

    const expectedResult = JSON.stringify({
      message: 'validation.chars', key: 'testDisplayKey', count: 1, chars: '"*"'
    });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"wildcardHostname" : returns valid when wildcard character is the first part', () => {
    const testValue = '*.hostname.com';
    const formRuleResult = formRules.wildcardHostname(testValue);

    expect(formRuleResult).toBeUndefined();
  });

  it('"absolutePath" : return expected message when path doesn\'t begin with a "/"', () => {
    const formRuleResult = formRules.absolutePath('absolute_path');
    const expectedResult = JSON.stringify({ message: 'validation.path', key: 'testDisplayKey' });

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  it('"absolutePath" : returns undefined when path begins with a "/"', () => {
    const formRuleResult = formRules.absolutePath('/absolute_path');

    expect(formRuleResult).toBeUndefined();
  });

  it('"testRule" : always returns the expected string', () => {
    const formRuleResult = formRules.testRule('');
    const expectedResult = 'This is an error returned by the testRule validator';

    expect(formRuleResult).toStrictEqual(expectedResult);
  });

  /**
   * Test all factory validators
   * @param rule - the name of the factory validator
   * @param argument - the value to validate
   * @param correctValues - an array of values that should pass the validation
   * @param wrongValues - an array of values that should fail the validation
   */
  describe.each([
    ['minValue', 2, [3], [1]],
    ['maxValue', 256, [1], [300]],
    ['betweenValues', [2, 256], [3], [1, 300]],
    ['minLength', 2, ['test'], ['x']],
    ['maxLength', 10, ['x'], ['wrong value']],
    ['betweenLengths', [2, 10], ['test'], ['x', 'wrong value']],
  ])('given factory validator %p with parameter %p', (rule, argument, correctValues, wrongValues) => {
    it.each(wrongValues as [])('should return error for value %p', (wrong) => {
      const formRuleResult = (formRules as any)[rule](argument)(wrong);

      expect(formRuleResult).not.toBeUndefined();
    });

    it.each(correctValues as [])('should return valid for value %p', (correct) => {
      const formRuleResult = (formRules as any)[rule](argument)(correct);

      expect(formRuleResult).toBeUndefined();
    });
  });

  /**
   * Test all standard validators
   * @param rule - the name of the standard validator
   * @param correctValues - an array of values that should pass the validation
   * @param wrongValues - an array of values that should fail the validation
   */
  describe.each([
    ['requiredInt', [2, 2.2], ['e']],
    ['isInteger', ['2', 2, 0], [2.2, 'e', '1.0']],
    ['isPositive', ['0', 1], [-1]],
    ['isOctal', ['0', 0, 10], ['01']],
    ['cronSchedule', ['0 * * * *', '@daily'], ['0 * * **']],
  ])('given validator %p', (rule, correctValues, wrongValues) => {
    it.each(wrongValues as [])('should return error for value %p', (wrong) => {
      const formRuleResult = (formRules as any)[rule](wrong);

      expect(formRuleResult).not.toBeUndefined();
    });

    it.each(correctValues as [])('should return valid for value %p', (correct) => {
      const formRuleResult = (formRules as any)[rule](correct);

      expect(formRuleResult).toBeUndefined();
    });
  });
});