Added integration and unit tests for the feature flag

Ankita2002-Fr · Ankita2002-Fr · commit 04b8b02ad687 · 2021-06-28T17:49:21.000+05:30
diff --git a/controllers/featureFlags.js b/controllers/featureFlags.js
@@ -10,8 +10,9 @@ const featureFlagQuery = require('../models/featureFlags')
 const getFeatureFlags = async (req, res) => {
   try {
     const allFeatureFlags = await featureFlagQuery.fetchFeatureFlag()
+    // console.log(res.status);
     return res.json({
-      message: 'All feature-flags returned successfully',
+      message: 'FeatureFlags returned successfully!',
       featureflags: allFeatureFlags.length > 0 ? allFeatureFlags : []
     })
   } catch (err) {
@@ -31,8 +32,8 @@ const addFeatureFlag = async (req, res) => {
   try {
     const featureFlag = await featureFlagQuery.addFeatureFlags(req.body, req.userData.username)
     return res.json({
-      message: 'FeatureFlag added successfully',
-      featureFlag
+      message: 'FeatureFlag added successfully!',
+      data: featureFlag
     })
   } catch (err) {
     logger.error(`Error while adding featureFlag info: ${err}`)
@@ -51,7 +52,7 @@ const updateFeatureFlag = async (req, res) => {
   try {
     const result = await featureFlagQuery.updateFeatureFlags(req.body, req.params.id)
     if (result.isUpdated) {
-      return res.json({ message: 'FeatureFlag updated successfully!' })
+      return res.status(204).send()
     }
     return res.boom.notFound('FeatureFlag doesn\'t exist')
   } catch (err) {
diff --git a/middlewares/validators/featureFlags.js b/middlewares/validators/featureFlags.js
@@ -6,7 +6,9 @@ const validateFeatureFlag = async (req, res, next) => {
     title: joi.string().required(),
     created_at: joi.number().optional(),
     updated_at: joi.number().optional(),
-    config: joi.object().required(),
+    config: joi.object({
+      enabled: joi.boolean().required()
+    }).required(),
     launched_at: joi.number().optional()
   })
 
@@ -22,7 +24,9 @@ const validateFeatureFlag = async (req, res, next) => {
 const updateFeatureFlags = async (req, res, next) => {
   const schema = joi.object().keys({
     title: joi.string().optional(),
-    config: joi.object().required()
+    config: joi.object({
+      enabled: joi.boolean().required()
+    }).required()
   })
   try {
     await schema.validateAsync(req.body)
diff --git a/models/featureFlags.js b/models/featureFlags.js
@@ -24,18 +24,14 @@ const fetchFeatureFlag = async () => {
       if (!users.includes(item.owner)) { users.push(item.owner) }
     })
 
-    const getImage = async (usersData) => {
-      return await userModel.fetchUserImage(usersData)
-    }
-
     let start = 0
     let end = 10
 
     for (let i = 0; i < Math.ceil(users.length / 10); i++) {
       const usersData = users.slice(start, end)
+      const image = await userModel.fetchUserImage(usersData)
       start = end
       end += 10
-      const image = await getImage(usersData)
       Object.assign(result, image)
     }
 
@@ -120,6 +116,7 @@ const deleteFeatureFlag = async (featureFlagId) => {
         isDeleted: false
       }
     }
+    await featureFlagModel.doc(featureFlagId).delete()
     return {
       isDeleted: true
     }
diff --git a/models/users.js b/models/users.js
@@ -174,12 +174,11 @@ const updateUserPicture = async (image, userId) => {
  */
 const fetchUserImage = async (users) => {
   const data = await userModel.where('username', 'in', users).get()
-  const hash = {}
+  const images = {}
   data.forEach((item) => {
-    hash[item.data().username] = item.data().img
+    images[item.data().username] = item.data().img
   })
-  // console.log(hash)
-  return hash
+  return images
 }
 
 module.exports = {
diff --git a/test/fixtures/featureFlag/featureFlag.js b/test/fixtures/featureFlag/featureFlag.js
@@ -0,0 +1,11 @@
+module.exports = () => {
+  return [
+    {
+      name: 'Test-feature',
+      title: 'Test',
+      config: {
+        enabled: true
+      }
+    }
+  ]
+}
diff --git a/test/fixtures/user/user.js b/test/fixtures/user/user.js
@@ -92,6 +92,26 @@ module.exports = () => {
       roles: {
         super_user: true
       }
+    },
+    {
+      username: 'ankita',
+      first_name: 'Ankita',
+      last_name: 'Bannore',
+      yoe: 0,
+      img: './img.png',
+      linkedin_id: 'ankitabannore',
+      github_id: 'Ankita2002-Fr',
+      github_display_name: 'Ankita Bannore',
+      isMember: true,
+      phone: '1234567890',
+      email: 'abc@gmail.com',
+      tokens: {
+        githubAccessToken: 'githubAccessToken'
+      },
+      status: 'active',
+      roles: {
+        app_owner: true
+      }
     }
   ]
 }
diff --git a/test/integration/featureFlag.test.js b/test/integration/featureFlag.test.js
@@ -0,0 +1,215 @@
+const chai = require('chai')
+const { expect } = require('chai')
+const chaiHttp = require('chai-http')
+
+const app = require('../../server')
+const authService = require('../../services/authService')
+const addUser = require('../utils/addUser')
+const cleanDb = require('../utils/cleanDb')
+const featureFlagQuery = require('../../models/featureFlags')
+
+// Import fixtures
+const userData = require('../fixtures/user/user')()
+const featureFlagData = require('../fixtures/featureFlag/featureFlag')()
+
+const config = require('config')
+const cookieName = config.get('userToken.cookieName')
+
+const appOwner = userData[5]
+chai.use(chaiHttp)
+
+describe('FeatureFlag', function () {
+  let jwt
+  let featureFlag
+  beforeEach(async function () {
+    const userId = await addUser(appOwner)
+    jwt = authService.generateAuthToken({ userId })
+    featureFlag = await featureFlagQuery.addFeatureFlags(featureFlagData[0], appOwner.username)
+  })
+
+  afterEach(async function () {
+    await cleanDb()
+  })
+
+  describe('GET /featureFlags', function () {
+    it('Should return all feature flags', function (done) {
+      chai
+        .request(app)
+        .get('/featureFlags')
+        .end((res, err) => {
+          if (err) { return done() }
+
+          expect(res).to.have.status(200)
+          expect(res.body).to.be.a('object')
+          expect(res.body.message).to.equal('FeatureFlags returned successfully!')
+          expect(res.body.featureFlags).to.be.a('array')
+
+          return done()
+        })
+    })
+  })
+
+  describe('POST /featureFlags', function () {
+    it('Should add the feature flag in db', function (done) {
+      chai
+        .request(app)
+        .post('/featureFlags')
+        .set('cookie', `${cookieName} = ${jwt}`)
+        .send({
+          name: 'test',
+          title: 'test-feature',
+          config: {
+            enabled: true
+          }
+        }, appOwner.username)
+        .end((err, res) => {
+          if (err) { return done() }
+          expect(res).to.have.status(200)
+          expect(res.body).to.be.a('object')
+          const { data } = res.body
+          expect(data).to.be.a('object')
+          expect(data.name).to.be.a('string')
+          expect(data.title).to.be.a('string')
+          expect(data.created_at).to.be.a('number')
+          expect(data.updated_at).to.be.a('number')
+          expect(data.config).to.be.a('object')
+          expect(data.config.enabled).to.be.a('boolean')
+          expect(data.owner).to.be.a('string')
+          expect(res.body.message).to.equal('FeatureFlag added successfully!')
+
+          return done()
+        })
+    })
+
+    it('Should return 401 if user not logged in', function (done) {
+      chai
+        .request(app)
+        .post('/featureFlags')
+        .end((res, err) => {
+          if (err) { return done() }
+
+          expect(res).to.have.status(401)
+          expect(res.body).to.be.an('object')
+          expect(res.body).to.eql({
+            statusCode: 401,
+            error: 'Unauthorized',
+            message: 'Unauthenticated User'
+          })
+
+          return done()
+        })
+    })
+  })
+
+  describe('PATCH /featureFlags/:id', function () {
+    it('Should update the feature flag', function (done) {
+      chai
+        .request(app)
+        .patch(`/featureFlags/${featureFlag.id}`)
+        .set('cookie', `${cookieName}=${jwt}`)
+        .send({
+          config: {
+            enabled: false
+          }
+        })
+        .end((err, res) => {
+          if (err) { return done() }
+          expect(res).to.have.status(204)
+
+          return done()
+        })
+    })
+
+    it('Should return 401 if user not logged in', function (done) {
+      chai
+        .request(app)
+        .patch(`/featureFlags/${featureFlag.id}`)
+        .end((res, err) => {
+          if (err) { return done() }
+
+          expect(res).to.have.status(401)
+          expect(res.body).to.be.an('object')
+          expect(res.body).to.eql({
+            statusCode: 401,
+            error: 'Unauthorized',
+            message: 'Unauthenticated User'
+          })
+
+          return done()
+        })
+    })
+
+    it('Should return 404 if feature flag does not exist', function (done) {
+      chai
+        .request(app)
+        .patch('/featureFlags/featureFlagId')
+        .end((res, err) => {
+          if (err) { return done() }
+
+          expect(res).to.have.status(404)
+          expect(res.body).to.be.an('object')
+          expect(res.body).to.eql({
+            statusCode: 404,
+            error: 'Not Found',
+            message: 'No featureFlag found'
+          })
+
+          return done()
+        })
+    })
+  })
+
+  describe('DELETE /featureFlags/:id', function () {
+    it('Should delete the feature flag', function (done) {
+      chai
+        .request(app)
+        .delete(`/featureFlags/${featureFlag.id}`)
+        .set('cookie', `${cookieName}=${jwt}`)
+        .end((err, res) => {
+          if (err) { return done() }
+
+          expect(res).to.have.status(200)
+
+          return done()
+        })
+    })
+
+    it('Should return 401 if user not logged in', function (done) {
+      chai
+        .request(app)
+        .delete(`/featureFlags/${featureFlag.id}`)
+        .end((res, err) => {
+          if (err) { return done() }
+
+          expect(res).to.have.status(401)
+          expect(res.body).to.be.an('object')
+          expect(res.body).to.eql({
+            statusCode: 401,
+            error: 'Unauthorized',
+            message: 'Unauthenticated User'
+          })
+
+          return done()
+        })
+    })
+
+    it('Should return 404 if feature flag does not exist', function (done) {
+      chai
+        .request(app)
+        .delete('/featureFlags/featureFlagId')
+        .end((res, err) => {
+          if (err) { return done() }
+
+          expect(res).to.have.status(404)
+          expect(res.body).to.be.an('object')
+          expect(res.body).to.eql({
+            statusCode: 404,
+            error: 'Not Found',
+            message: 'No feature flag found'
+          })
+
+          return done()
+        })
+    })
+  })
+})
diff --git a/test/unit/models/featureFlag.test.js b/test/unit/models/featureFlag.test.js

Original file line number	Diff line number	Diff line change
`@@ -24,18 +24,14 @@ const fetchFeatureFlag = async () => {`
`24`	`24`	`if (!users.includes(item.owner)) { users.push(item.owner) }`
`25`	`25`	`})`
`26`	`26`
`27`		`- const getImage = async (usersData) => {`
`28`		`- return await userModel.fetchUserImage(usersData)`
`29`		`- }`
`30`		`-`
`31`	`27`	`let start = 0`
`32`	`28`	`let end = 10`
`33`	`29`
`34`	`30`	`for (let i = 0; i < Math.ceil(users.length / 10); i++) {`
`35`	`31`	`const usersData = users.slice(start, end)`
	`32`	`+ const image = await userModel.fetchUserImage(usersData)`
`36`	`33`	`start = end`
`37`	`34`	`end += 10`
`38`		`- const image = await getImage(usersData)`
`39`	`35`	`Object.assign(result, image)`
`40`	`36`	`}`
`41`	`37`
`@@ -120,6 +116,7 @@ const deleteFeatureFlag = async (featureFlagId) => {`
`120`	`116`	`isDeleted: false`
`121`	`117`	`}`
`122`	`118`	`}`
	`119`	`+ await featureFlagModel.doc(featureFlagId).delete()`
`123`	`120`	`return {`
`124`	`121`	`isDeleted: true`
`125`	`122`	`}`