Add support for challenge terms

README.md

@@ -215,4 +215,4 @@ npm run cov-e2e
 - TBD
 
 ## Verification
-Refer to the verification document `Verification.md`
+Refer to the verification document `Verification.md`

src/services/ProcessorService.js

@@ -120,6 +120,13 @@ update.schema = {
         fileName: Joi.string().required(),
         challengeId: Joi.string().uuid().required()
       })).allow(null),
+      terms: Joi.array().items(Joi.object().keys({
+        id: Joi.number().strict(true).integer().positive().required(),
+        agreeabilityType: Joi.string().required(),
+        title: Joi.string(),
+        url: Joi.string().allow(''),
+        templateId: Joi.string()
+      })).allow(null),
       groups: Joi.array().items(Joi.string()).allow(null), // group names
       created: Joi.date(),
       createdBy: Joi.string(), // user handle

test/common/testData.js

@@ -73,7 +73,28 @@ const challengeUpdatedMessage = {
     created: '2019-02-03T00:00:00',
     createdBy: 'admin',
     updated: '2019-02-04T01:01:00',
-    updatedBy: 'user'
+    updatedBy: 'user',
+    terms: [
+      {
+        id: 21343,
+        agreeabilityType: 'DocuSignable',
+        title: 'Competition Non-Disclosure Agreement',
+        url: '',
+        templateId: '0c5b7081-1fff-4484-a20f-824c97a03b9b'
+      },
+      {
+        id: 20723,
+        agreeabilityType: 'Non-electronically-agreeable',
+        title: 'Subcontractor Services Agreement 2009-09-02',
+        url: 'http://www.topcoder.com/i/terms/Subcontractor+Services+Agreement+2009-09-02.pdf'
+      },
+      {
+        id: 20645,
+        agreeabilityType: 'Electronically-agreeable',
+        title: '2008 TCO Marathon Match Competition Official Rules',
+        url: 'http://topcoder.com/mm-terms'
+      }
+    ]
   }
 }
 
@@ -98,7 +119,16 @@ const challengePartiallyUpdatedMessage = {
     }],
     groups: ['group4'],
     updated: '2019-01-02T00:00:00',
-    updatedBy: 'user'
+    updatedBy: 'user',
+    terms: [
+      {
+        id: 21343,
+        agreeabilityType: 'DocuSignable',
+        title: 'Competition Non-Disclosure Agreement',
+        url: '',
+        templateId: '0c5b7081-1fff-4484-a20f-824c97a03b9b'
+      }
+    ]
   }
 }
 

test/common/testHelper.js

@@ -9,6 +9,17 @@ const expect = require('chai').expect
 
 const client = helper.getESClient()
 
+/**
+ * function to deeply compare arrays  regardeless of the order
+ *
+ * @param {Array} arr1 The first array to compare
+ * @param {Array} arr2 The second array to compare
+ * @returns {Boolean} The flag indicating whether the arrays have the same content regardless of the order
+ */
+const deepCompareArrays = (arr1, arr2) => {
+  return _(arr1).xorWith(arr2, _.isEqual).isEmpty()
+}
+
 /**
  * Get elastic search data.
  * @param {String} id the Elastic search data id
@@ -54,5 +65,6 @@ function expectSamePhase (phase1, phase2) {
 module.exports = {
   getESData,
   expectObj,
-  expectSamePhase
+  expectSamePhase,
+  deepCompareArrays
 }

test/e2e/processor.test.js

@@ -81,6 +81,7 @@ describe('TC Challenge Processor E2E Tests', () => {
     }
     expect(data.endDate).to.exist // eslint-disable-line
     expect(new Date(data.endDate).getTime() - new Date(challengeUpdatedMessage.payload.startDate).getTime()).to.equal(300000)
+    expect(testHelper.deepCompareArrays(challengeUpdatedMessage.payload.terms, data.terms), true)
   })
 
   it('partially update challenge message', async () => {
@@ -100,6 +101,97 @@ describe('TC Challenge Processor E2E Tests', () => {
     }
     expect(data.endDate).to.exist // eslint-disable-line
     expect(new Date(data.endDate).getTime() - new Date(expectedData.startDate).getTime()).to.equal(300000)
+    expect(testHelper.deepCompareArrays(challengePartiallyUpdatedMessage.payload.terms, data.terms), true)
+  })
+
+  it('update challenge message - invalid parameters, terms with negative id message', async () => {
+    const message = _.cloneDeep(challengeUpdatedMessage)
+    message.payload.terms[0].id = -20
+    try {
+      await ProcessorService.update(message)
+    } catch (err) {
+      expect(err).to.exist // eslint-disable-line
+      expect(err.name).to.equal('ValidationError')
+      const msg = '"id" must be a positive number'
+      expect(err.message.indexOf(msg) >= 0).to.equal(true)
+      return
+    }
+    throw new Error('There should be validation error.')
+  })
+
+  it('update challenge message - invalid parameters, terms with invalid aggreeability type message', async () => {
+    const message = _.cloneDeep(challengeUpdatedMessage)
+    message.payload.terms[0].agreeabilityType = 800
+    try {
+      await ProcessorService.update(message)
+    } catch (err) {
+      expect(err).to.exist // eslint-disable-line
+      expect(err.name).to.equal('ValidationError')
+      const msg = '"agreeabilityType" must be a string'
+      expect(err.message.indexOf(msg) >= 0).to.equal(true)
+      return
+    }
+    throw new Error('There should be validation error.')
+  })
+
+  it('update challenge message - invalid parameters, terms with missing aggreeability type message', async () => {
+    const message = _.cloneDeep(challengeUpdatedMessage)
+    delete message.payload.terms[0].agreeabilityType
+    try {
+      await ProcessorService.update(message)
+    } catch (err) {
+      expect(err).to.exist // eslint-disable-line
+      expect(err.name).to.equal('ValidationError')
+      const msg = '"agreeabilityType" is required'
+      expect(err.message.indexOf(msg) >= 0).to.equal(true)
+      return
+    }
+    throw new Error('There should be validation error.')
+  })
+
+  it('update challenge message - invalid parameters, terms with invalid title message', async () => {
+    const message = _.cloneDeep(challengeUpdatedMessage)
+    message.payload.terms[0].title = 800
+    try {
+      await ProcessorService.update(message)
+    } catch (err) {
+      expect(err).to.exist // eslint-disable-line
+      expect(err.name).to.equal('ValidationError')
+      const msg = '"title" must be a string'
+      expect(err.message.indexOf(msg) >= 0).to.equal(true)
+      return
+    }
+    throw new Error('There should be validation error.')
+  })
+
+  it('update challenge message - invalid parameters, terms with invalid url message', async () => {
+    const message = _.cloneDeep(challengeUpdatedMessage)
+    message.payload.terms[0].url = 800
+    try {
+      await ProcessorService.update(message)
+    } catch (err) {
+      expect(err).to.exist // eslint-disable-line
+      expect(err.name).to.equal('ValidationError')
+      const msg = '"url" must be a string'
+      expect(err.message.indexOf(msg) >= 0).to.equal(true)
+      return
+    }
+    throw new Error('There should be validation error.')
+  })
+
+  it('update challenge message - invalid parameters, terms with invalid templateId message', async () => {
+    const message = _.cloneDeep(challengeUpdatedMessage)
+    message.payload.terms[0].templateId = 800
+    try {
+      await ProcessorService.update(message)
+    } catch (err) {
+      expect(err).to.exist // eslint-disable-line
+      expect(err.name).to.equal('ValidationError')
+      const msg = '"templateId" must be a string'
+      expect(err.message.indexOf(msg) >= 0).to.equal(true)
+      return
+    }
+    throw new Error('There should be validation error.')
   })
 
   it('update challenge message - not found', async () => {

test/unit/processor.test.js

@@ -81,6 +81,7 @@ describe('TC Challenge Processor Unit Tests', () => {
     }
     expect(data.endDate).to.exist // eslint-disable-line
     expect(new Date(data.endDate).getTime() - new Date(challengeUpdatedMessage.payload.startDate).getTime()).to.equal(300000)
+    expect(testHelper.deepCompareArrays(challengeUpdatedMessage.payload.terms, data.terms), true)
   })
 
   it('partially update challenge message', async () => {
@@ -100,6 +101,97 @@ describe('TC Challenge Processor Unit Tests', () => {
     }
     expect(data.endDate).to.exist // eslint-disable-line
     expect(new Date(data.endDate).getTime() - new Date(expectedData.startDate).getTime()).to.equal(300000)
+    expect(testHelper.deepCompareArrays(challengePartiallyUpdatedMessage.payload.terms, data.terms), true)
+  })
+
+  it('update challenge message - invalid parameters, terms with negative id message', async () => {
+    const message = _.cloneDeep(challengeUpdatedMessage)
+    message.payload.terms[0].id = -20
+    try {
+      await ProcessorService.update(message)
+    } catch (err) {
+      expect(err).to.exist // eslint-disable-line
+      expect(err.name).to.equal('ValidationError')
+      const msg = '"id" must be a positive number'
+      expect(err.message.indexOf(msg) >= 0).to.equal(true)
+      return
+    }
+    throw new Error('There should be validation error.')
+  })
+
+  it('update challenge message - invalid parameters, terms with invalid aggreeability type message', async () => {
+    const message = _.cloneDeep(challengeUpdatedMessage)
+    message.payload.terms[0].agreeabilityType = 800
+    try {
+      await ProcessorService.update(message)
+    } catch (err) {
+      expect(err).to.exist // eslint-disable-line
+      expect(err.name).to.equal('ValidationError')
+      const msg = '"agreeabilityType" must be a string'
+      expect(err.message.indexOf(msg) >= 0).to.equal(true)
+      return
+    }
+    throw new Error('There should be validation error.')
+  })
+
+  it('update challenge message - invalid parameters, terms with missing aggreeability type message', async () => {
+    const message = _.cloneDeep(challengeUpdatedMessage)
+    delete message.payload.terms[0].agreeabilityType
+    try {
+      await ProcessorService.update(message)
+    } catch (err) {
+      expect(err).to.exist // eslint-disable-line
+      expect(err.name).to.equal('ValidationError')
+      const msg = '"agreeabilityType" is required'
+      expect(err.message.indexOf(msg) >= 0).to.equal(true)
+      return
+    }
+    throw new Error('There should be validation error.')
+  })
+
+  it('update challenge message - invalid parameters, terms with invalid title message', async () => {
+    const message = _.cloneDeep(challengeUpdatedMessage)
+    message.payload.terms[0].title = 800
+    try {
+      await ProcessorService.update(message)
+    } catch (err) {
+      expect(err).to.exist // eslint-disable-line
+      expect(err.name).to.equal('ValidationError')
+      const msg = '"title" must be a string'
+      expect(err.message.indexOf(msg) >= 0).to.equal(true)
+      return
+    }
+    throw new Error('There should be validation error.')
+  })
+
+  it('update challenge message - invalid parameters, terms with invalid url message', async () => {
+    const message = _.cloneDeep(challengeUpdatedMessage)
+    message.payload.terms[0].url = 800
+    try {
+      await ProcessorService.update(message)
+    } catch (err) {
+      expect(err).to.exist // eslint-disable-line
+      expect(err.name).to.equal('ValidationError')
+      const msg = '"url" must be a string'
+      expect(err.message.indexOf(msg) >= 0).to.equal(true)
+      return
+    }
+    throw new Error('There should be validation error.')
+  })
+
+  it('update challenge message - invalid parameters, terms with invalid templateId message', async () => {
+    const message = _.cloneDeep(challengeUpdatedMessage)
+    message.payload.terms[0].templateId = 800
+    try {
+      await ProcessorService.update(message)
+    } catch (err) {
+      expect(err).to.exist // eslint-disable-line
+      expect(err.name).to.equal('ValidationError')
+      const msg = '"templateId" must be a string'
+      expect(err.message.indexOf(msg) >= 0).to.equal(true)
+      return
+    }
+    throw new Error('There should be validation error.')
   })
 
   it('update challenge message - not found', async () => {