add test env

packages/component-invite/config/test.js

+module.exports = {
+  mailer: {
+    from: 'test@example.com',
+  },
+  'invite-reset-password': {
+    url:
+      process.env.PUBSWEET_INVITE_PASSWORD_RESET_URL ||
+      'http://localhost:3000/invite',
+  },
+  roles: {
+    global: ['admin', 'editorInChief', 'author'],
+    collection: ['handlingEditor', 'reviewer'],
+    inviteRights: {
+      admin: ['admin', 'editorInChief', 'author'],
+      editorInChief: ['handlingEditor'],
+      handlingEditor: ['reviewer'],
+    },
+  },
+}

packages/component-invite/package.json

@@ -6,6 +6,9 @@
   "files": [
     "src"
   ],
+  "scripts": {
+    "test": "jest"
+  },
   "repository": {
     "type": "git",
     "url": "https://gitlab.coko.foundation/xpub/xpub"
@@ -22,5 +25,12 @@
   "devDependencies": {
     "jest": "^22.1.1",
     "supertest": "^3.0.0"
+  },
+  "jest": {
+    "moduleNameMapper": {
+      "\\.s?css$": "identity-obj-proxy"
+    },
+    "transformIgnorePatterns": ["/node_modules/(?!@?pubsweet)"],
+    "testPathIgnorePatterns": ["/node_modules", "config/"]
   }
 }

packages/component-invite/src/helpers/helpers.js

 const logger = require('@pubsweet/logger')
+const uuid = require('uuid')
+const crypto = require('crypto')
 
 const checkForUndefinedParams = (...params) => {
   if (params.includes(undefined)) {
@@ -86,9 +88,75 @@ const handleNotFoundError = async (error, item) => {
   return response
 }
 
+const createNewTeam = async (collectionId, emailType, user, TeamModel) => {
+  let permissions, group, name
+  switch (user.roles[0]) {
+    case 'handlingEditor':
+      emailType = 'invite-handling-editor'
+      permissions = 'editor'
+      group = 'editor'
+      name = 'Handling Editor'
+      break
+    case 'reviewer':
+      emailType = 'invite-reviewer'
+      permissions = 'reviewer'
+      group = 'reviewer'
+      name = 'Reviewer'
+      break
+    default:
+      break
+  }
+
+  const teamBody = {
+    teamType: {
+      name: user.roles[0],
+      permissions,
+    },
+    group,
+    name,
+    object: {
+      type: 'collection',
+      id: collectionId,
+    },
+    members: [user.id],
+  }
+  const team = new TeamModel(teamBody)
+  await team.save()
+  return emailType
+}
+
+const createNewUser = async (
+  email,
+  role,
+  firstName,
+  lastName,
+  affiliation,
+  title,
+  UserModel,
+) => {
+  const userBody = {
+    username: uuid.v4().slice(0, 8),
+    email,
+    password: uuid.v4(),
+    roles: [role],
+    passwordResetToken: crypto.randomBytes(32).toString('hex'),
+    isConfirmed: false,
+    firstName,
+    lastName,
+    affiliation,
+    title,
+    admin: role === 'admin',
+  }
+  let newUser = new UserModel(userBody)
+  newUser = await newUser.save()
+  return newUser
+}
+
 module.exports = {
   checkForUndefinedParams,
   validateEmailAndToken,
   hasInviteRight,
   handleNotFoundError,
+  createNewTeam,
+  createNewUser,
 }

packages/component-invite/src/routes/post.js

@@ -2,20 +2,19 @@ const logger = require('@pubsweet/logger')
 const mailService = require('pubsweet-component-mail-service')
 const get = require('lodash/get')
 const config = require('config')
-const uuid = require('uuid')
-const crypto = require('crypto')
 const helpers = require('../helpers/helpers')
 
 const configRoles = config.get('roles')
 
 module.exports = models => async (req, res) => {
   const { email, role, firstName, lastName, affiliation, title } = req.body
+
   if (!helpers.checkForUndefinedParams(email, role)) {
     res.status(400).json({ error: 'Email and role are required' })
     logger.error('some parameters are missing')
     return
   }
-
+  // console.log(req.body)
   const collectionId = get(req, 'params.collectionId')
   const reqUser = await models.User.find(req.user)
   let collection
@@ -85,58 +84,25 @@ module.exports = models => async (req, res) => {
       return
     }
 
-    const userBody = {
-      username: uuid.v4().slice(0, 8),
+    const newUser = await helpers.createNewUser(
       email,
-      password: uuid.v4(),
-      roles: [role],
-      passwordResetToken: crypto.randomBytes(32).toString('hex'),
-      isConfirmed: false,
+      role,
       firstName,
       lastName,
       affiliation,
       title,
-      admin: role === 'admin',
-    }
-    let newUser = new models.User(userBody)
-    newUser = await newUser.save()
+      models.User,
+    )
 
     let emailType = 'invite-editor-in-chief'
-    if (collection) {
-      let permissions, group, name
-      switch (newUser.roles[0]) {
-        case 'handlingEditor':
-          emailType = 'invite-handling-editor'
-          permissions = 'editor'
-          group = 'editor'
-          name = 'Handling Editor'
-          break
-        case 'reviewer':
-          emailType = 'invite-reviewer'
-          permissions = 'reviewer'
-          group = 'reviewer'
-          name = 'Reviewer'
-          break
-        default:
-          break
-      }
-
-      const teamBody = {
-        teamType: {
-          name: newUser.roles[0],
-          permissions,
-        },
-        group,
-        name,
-        object: {
-          type: 'collection',
-          id: collection.id,
-        },
-        members: [newUser.id],
-      }
-      const team = new models.Team(teamBody)
-      await team.save()
-    }
+    emailType = !collection
+      ? emailType
+      : await helpers.createNewTeam(
+          collection.id,
+          emailType,
+          newUser,
+          models.Team,
+        )
 
     await mailService.setupEmail(
       newUser.email,

packages/component-invite/src/tests/fixtures/collections.js

+const users = require('./users')
+
+module.exports = {
+  standardCollection: {
+    id: '2c4fb766-a798-4c32-b857-c5d21a2ab331',
+    title: 'Standard Collection',
+    type: 'collection',
+    fragments: [],
+    owners: [users.admin.id],
+    save: jest.fn(),
+  },
+}

packages/component-invite/src/tests/fixtures/fixtures.js

+const users = require('./users')
+const collections = require('./collections')
+
+module.exports = {
+  users,
+  collections,
+}

packages/component-invite/src/tests/fixtures/users.js

+module.exports = {
+  admin: {
+    type: 'user',
+    username: 'admin',
+    email: 'admin@example.com',
+    password: 'test',
+    admin: true,
+    id: 'admin123',
+  },
+}

packages/component-invite/src/tests/mocks/User.js

+/* eslint-disable func-names-any */
+
+function User(properties) {
+  this.type = 'user'
+  this.email = properties.email
+  this.username = properties.username
+  this.password = properties.password
+}
+
+User.prototype.save = jest.fn(function saveUser() {
+  this.id = '111222'
+  return Promise.resolve(this)
+})
+
+module.exports = User

packages/component-invite/src/tests/post.test.js

+process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0'
+process.env.SUPPRESS_NO_CONFIG_WARNING = true
+
+const httpMocks = require('node-mocks-http')
+const random = require('lodash/random')
+const fixtures = require('./fixtures/fixtures')
+const UserMock = require('./mocks/User')
+
+const roles = ['editorInChief', 'author', 'admin']
+const buildModels = (collection, findUser, emailUser) => {
+  const models = {
+    User: {},
+    Collection: {
+      find: jest.fn(
+        () =>
+          collection instanceof Error
+            ? Promise.reject(collection)
+            : Promise.resolve(collection),
+      ),
+    },
+  }
+
+  UserMock.find = jest.fn(
+    () =>
+      findUser instanceof Error
+        ? Promise.reject(findUser)
+        : Promise.resolve(findUser),
+  )
+  UserMock.findByEmail = jest.fn(
+    () =>
+      emailUser instanceof Error
+        ? Promise.reject(emailUser)
+        : Promise.resolve(emailUser),
+  )
+
+  models.User = UserMock
+  return models
+}
+
+describe('Post invite route handler', () => {
+  it('should return success when the admin invites an Editor in Chief, Author or Admin', async () => {
+    const body = {
+      email: 'sebi.mihalache@gmail.com',
+      role: roles[random(0, roles.length - 1)],
+      firstName: 'john',
+      lastName: 'smith',
+      title: 'professor',
+      affiliation: 'MIT',
+    }
+    const req = httpMocks.createRequest({
+      body,
+    })
+    req.user = fixtures.users.admin
+    const res = httpMocks.createResponse()
+    const error = new Error()
+    error.name = 'NotFoundError'
+    error.status = 404
+    const models = buildModels(error, fixtures.users.admin, error)
+    await require('../routes/post')(models)(req, res)
+    expect(res.statusCode).toBe(200)
+    const data = JSON.parse(res._getData())
+  })
+})