How to use

status

function

in

Array

it ('should set the status to CRIT when metrics function throws an Error', async () => {
  const err = new Error('crash');
  const { Testee } = makeMocks(err);
  const testeeInstance = new Testee();
  testeeInstance.status = [ constants.OK ];
  expect(testeeInstance.status.status[0]).toEqual(constants.OK);
  await testeeInstance.start();
  return expect(testeeInstance.status.status[0]).toEqual(constants.CRIT);
});

test('should be false when a different milestone is specified', async () => {
 const milestone = new Milestone()
 const settings = {
  do: 'milestone',
  must_include: {
   regex: 'Version 2'
  }
 }
 let validation = await milestone.validate(createMockContext({title: 'Version 1'}), settings)
 expect(validation.status).toBe('fail')
})

test('return correct output if all inputs are valid', async () => {
 let rule = {do: 'label', must_include: {regex: 'A'}}
 let input = ['A', 'C']
 let res = options.process('label', input, rule)
 expect(res.status).toBe('pass')

 rule = [{do: 'label', must_include: {regex: 'A'}}, {do: 'label', must_exclude: {regex: 'B'}}]
 input = ['A', 'C']
 res = options.process('label', input, rule)
 expect(res.status).toBe('pass')
})

test('description is correct', async () => {
 let label = new Label()

 let settings = {
  do: 'label',
  must_exclude: {
   regex: 'Work in Progress'
  }
 }

 let validation = await label.validate(createMockContext('Work in Progress'), settings)

 expect(validation.status).toBe('fail')
 expect(validation.validations[0].description).toBe('label included "Work in Progress"')

 validation = await label.validate(createMockContext('Just Label'), settings)
 expect(validation.validations[0].description).toBe("label must exclude 'Work in Progress'")
})

test('return error if unsupported options are provided', async () => {
 const rule = {do: 'label', must_be_include: {regex: 'A'}}
 const input = ['A']
 const res = options.process('label', input, rule)
 expect(res.status).toBe('error')
 expect(res.validations[0].description).toBe(`Cannot find module './options/must_be_include' from 'options.js'`)
})

test('mergeable is false if regex found or true if not when there are multiple labels', async () => {
 let label = new Label()

 let settings = {
  do: 'label',
  must_include: {
   regex: '456'
  }
 }

 let validation = await label.validate(createMockContext(['abc', 'experimental', 'xyz']), settings)
 expect(validation.status).toBe('fail')

 validation = await label.validate(createMockContext(['Some Label', '123', '456']), settings)
 expect(validation.status).toBe('pass')
})

test('fail gracefully if invalid regex', async () => {
 let title = new Title()

 let settings = {
  do: 'title',
  must_exclude: {
   regex: '@#$@#$@#$'
  }
 }

 let titleValidation = await title.validate(mockContext('WIP Title'), settings)
 expect(titleValidation.status).toBe('pass')
})

test('that mergeable is true when the same as minimum', async () => {
 const assignee = new Assignee()

 const settings = {
  do: 'assignee',
  min: {
   count: 2
  }
 }
 let validation = await assignee.validate(createMockPR(2), settings)
 expect(validation.status).toBe('pass')
})

test('fail gracefully if invalid regex', async () => {
 let label = new Label()

 let settings = {
  do: 'label',
  must_exclude: {
   regex: '@#$@#$@#$'
  }
 }

 let validation = await label.validate(createMockContext('WIP'), settings)
 expect(validation.status).toBe('pass')
})

test('shoud be false when milestone is set in settings but null in PR', async () => {
 const milestone = new Milestone()
 const settings = {
  do: 'milestone',
  must_include: {
   regex: 'Version 1'
  }
 }
 let validation = await milestone.validate(createMockContext(), settings)
 expect(validation.status).toBe('fail')
})

test('that mergeable is false when less than minimum', async () => {
 const assignee = new Assignee()

 const settings = {
  do: 'assignee',
  min: {
   count: 2
  }
 }

 let validation = await assignee.validate(createMockPR(1), settings)
 expect(validation.status).toBe('fail')
})

test('checks that deep validation works if it closes an issue with milestone requirement', async () => {
 const milestone = new Milestone()
 const settings = {
  do: 'milestone',
  must_include: {
   regex: 'Version 1'
  }
 }

 let validation = await milestone.validate(createMockContext(null, 'closes #1', {milestone: {title: 'Version 1'}}), settings)
 expect(validation.status).toBe('pass')
})

test('mergeable is true if must_include is one of the label', async () => {
 let label = new Label()

 let settings = {
  do: 'label',
  must_include: {
   regex: 'abc'
  }
 }

 let validation = await label.validate(createMockContext(['abc', 'experimental', 'xyz']), settings)
 expect(validation.status).toBe('pass')

 validation = await label.validate(createMockContext(['Some Label', '123', '456']), settings)
 expect(validation.status).toBe('fail')
})

test('validate returns correctly', async () => {
 let label = new Label()

 let settings = {
  do: 'label',
  must_exclude: {
   regex: 'wip'
  }
 }

 let results = await label.validate(createMockContext(['wip']), settings)
 expect(results.status).toBe('fail')

 results = await label.validate(createMockContext(['a', 'b']), settings)
 expect(results.status).toBe('pass')
})

test('mergeable is false if regex found or true if not when there is only one label', async () => {
 let label = new Label()

 let settings = {
  do: 'label',
  must_include: {
   regex: 'Some Label'
  }
 }

 let validation = await label.validate(createMockContext('work in progress'), settings)
 expect(validation.status).toBe('fail')

 validation = await label.validate(createMockContext('Some Label'), settings)
 expect(validation.status).toBe('pass')
})