@getjones/test-infra 1.0.3

package/README.md

@@ -0,0 +1,264 @@
+# Package Name: @getjones/test-infra
+
+## Package Goal
+
+* Providing an easy and reusable interface for the backend system. Means, both by the OpenAPI, and the internal API.
+
+## Interface
+
+### init
+
+* require the package with settled up configuration json
+
+```node
+const { internalAPI } = require('@getjones/test-infra')(conf);
+```
+
+* configuration example
+
+```node
+const dotenv = require('dotenv');
+
+dotenv.config();
+
+module.exports = {
+  backendUrl: process.env.BACKEND_URL,
+  credentials: {
+    superUser: process.env.CREDENTIALS_SUPER_USER,
+    superUserPassword: process.env.CREDENTIALS_SUPER_USER_PASSWORD,
+    strongPassword: process.env.CREDENTIALS_STRONG_PASSWORD,
+  },
+  accountCreationSecret: process.env.ACCOUNT_CREATION_SECRET,
+  environment: process.env.ENVIRONMENT,
+  email: process.env.EMAIL,
+};
+```
+
+### internalAPI
+
+* internalAPI contains the next services:
+    * auth
+    * accounts
+    * accountSettings
+    * projects
+
+```node
+const { auth, accounts, accountSettings, projects } = internalAPI;
+```
+
+### auth
+
+```node
+
+/**
+ *
+ * @param email (string)
+ * @param password (string)
+ * @return Auth cookie (string) with given email privileges.
+ */
+const getAuthCookie = async (email, password) => {
+};
+
+/**
+ *
+ * Required Configuration: {
+ * credentials.superUser,
+ * credentials.superUserPassword 
+ * }
+ * @return ICS cookie (String)
+ */
+const getIcsCookie = async () => {
+};
+```
+
+### accounts
+
+```node
+
+/**
+ *
+ * Required Configuration: {
+ *  accountCreationSecret: accountCreationSecret,
+ * }
+ *
+ * If you want to use default password so
+ * 'credentials.strongPassword' is needed
+ * to be a part of the configuration.
+ *
+ * @param email (string)
+ * @param accountName (string)
+ * @param context (string): Should contain ICS cookie
+ * @return Account (object)
+ */
+
+const createAccount = async (email, accountName, context,
+  password = credentials.strongPassword,
+  propertyType = PROPERTY_TYPE) => {
+};
+
+/**
+ *
+ * @param accountName (string)
+ * @param context (string): Should contains ICS cookie
+ * @return Account (object)
+ */
+const getAccount = async (accountName, context) => {
+};
+
+/**
+ *
+ * @param email (string)
+ * @param accountName (string)
+ * @param context (string): Should contain ICS cookie
+ * @param password (string)
+ * @return Account (object)
+ */
+const getOrCreateAccount = async (email, accountName, context, password = credentials.strongPassword) => {
+};
+
+/**
+ *
+ * @param accountName (string)
+ * @param context (string): Should contain ICS cookie
+ * @return Account ID (String)
+ */
+const getAccountId = async (accountName, context) => {
+};
+
+/**
+ *
+ * @param accountName (string)
+ * @param context (string): Should contains ICS cookie
+ * @return Http Response
+ */
+const deleteAccountByName = async (accountName, context) => {
+};
+
+/**
+ *
+ * @param accountId (string)
+ * @param context (string): Should contain ICS cookie
+ * @return Http Response
+ */
+const deleteAccountById = async (accountId, context) => {
+};
+```
+
+### accountSettings
+
+```node
+
+/**
+ *
+ * @param accountId (string)
+ * @param context (string): Should contain ICS cookie
+ * @return Account Settings (object)
+ */
+const getAccountSettings = async (accountId, context) => {
+};
+
+/**
+ *
+ * @param accountId (string)
+ * @param AccountSettings (object) Should Contain:
+ * isMultiPropertyTenants (boolean)
+ * isHighPriority (boolean)
+ * @param context (string): Should contain ICS cookie
+ * @return Http Response
+ */
+const updateAccountSettings = async (accountId, isMultiPropertyTenants, isHighPriority, context) => {
+};
+
+/**
+ * Summary: Change account settings to default
+ * Description:
+ * Update The Next Account Settings:
+ * isMultiPropertyTenants: false
+ * isHighPriority: false
+ * @param accountId (string)
+ * @param context (string): Should Contain ICS cookie
+ * @return Http Response
+ */
+const restoreAccountSettings = async (accountId, context) => {
+};
+
+```
+
+### projects
+
+```node
+
+/**
+ *
+ * @param accountName (string)
+ * @param context (string): Should contain cookie
+ * User's cookie that is related to this account or ICS cookie
+ * @return List of projects ([objects])
+ */
+const getProjectsByAccountName = async (accountName, context) => {
+};
+
+/**
+ *
+ * @param accountId (String)
+ * @param context (string): Should contain cookie
+ * User's cookie that is related to this account or ICS cookie
+ * @return List of projects ([objects])
+ */
+const getProjectsByAccountId = async (accountId, context) => {
+};
+
+/**
+ *
+ * @param accountId (string)
+ * @param projectName (string)
+ * @param context (string): Should contain cookie
+ * User's cookie that is related to this account or ICS cookie
+ * @return List of projects ([objects])
+ */
+const getProjectsByName = async (accountId, projectName, context) => {
+};
+
+/**
+ * Summary: Delete project by given details
+ * @param accountId (string)
+ * @param projectName (string)
+ * @param context (string): Should contain cookie
+ * User's cookie that is related to this account or ICS cookie
+ * @return List of projects ([objects])
+ */
+const deleteProjectByName = async (accountId, projectName, context) => {
+};
+
+/**
+ *
+ * @param project (object)
+ * @param accountName (string)
+ * @param context (string): Should contain cookie
+ * User's cookie that is related to this account or ICS cookie
+ * @return object contains generated projectId
+ */
+
+// Example for project input (Not all of them are required):
+const createProjectInput = {
+  'projectName': project.name,
+  'userId': '',
+  'projectDescription': project.description,
+  'address': project.address,
+  'projectNumber': project.number,
+  'projectStartDate': project.startDate,
+  'projectEndDate': project.endDate,
+  'city': project.city,
+  'state': project.state,
+  'zipCode': project.zipCode,
+  'companyNameForProject': project.companyNameForProject,
+  'certificateHolder': '',
+  'additionalInsured': '',
+  'tenantSolutionEnabled': '',
+  'onboardingEnabled': '',
+  'automaticRenewalEnabled': ''
+};
+
+const createProject = async (project, accountName, context) => {
+};
+```

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@getjones/test-infra",
+  "version": "1.0.3",
+  "description": "Providing internal and openapi interface",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "mocha  \"./tests/**/*.test.js\" --slow 3000 --timeout 10000 --exit --inlineDiffs --bail"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^0.21.1",
+    "dotenv": "^8.2.0",
+    "mocha": "^8.3.2",
+    "chai": "^4.3.4",
+    "http-status-code": "^2.1.0"
+  },
+  "devDependencies": {
+    "eslint": "^7.22.0",
+    "eslint-plugin-import": "^2.22.1",
+    "eslint-plugin-node": "^11.1.0"
+  },
+  "directories": {
+    "test": "tests"
+  }
+}

package/src/env.js

@@ -0,0 +1,30 @@
+let privateMembers = {
+    backendUrl: null,
+    credentials: null,
+    environment: null,
+    accountCreationSecret: null,
+};
+
+const init = conf => {
+    privateMembers = Object.assign(privateMembers, conf);
+    requiredValidation({ backendUrl: privateMembers.backendUrl, environment: privateMembers.environment });
+};
+
+const requiredValidation = object => {
+    const invalidKeys = [];
+    Object.keys(object).forEach(key => {
+        if (!object[key]) {
+            invalidKeys.push(key);
+        }
+    });
+
+    if (invalidKeys.length > 0) {
+        throw `Missing required configuration on your environment variables. The missing env-vars are "${invalidKeys}".`;
+    }
+};
+
+module.exports = {
+    init,
+    getEnv: () => privateMembers,
+    requiredValidation
+};

package/src/exceptions/notFoundError.js

@@ -0,0 +1,9 @@
+const { StatusCodes } = require('http-status-code');
+
+class NotFoundError extends Error {
+    constructor(message) {
+        super(message, StatusCodes.NOT_FOUND);
+    }
+}
+
+module.exports = { NotFoundError };

package/src/index.js

@@ -0,0 +1,16 @@
+const env = require('./env');
+
+const init = conf => {
+    env.init(conf);
+
+    const auth = require('./internal-api/auth/auth.setup');
+
+    const accounts = require('./internal-api/accounts/accounts.setup');
+    const accountSettings = require('./internal-api/accounts/settings/settings.setup');
+    const projects = require('./internal-api/projects/projects.setup');
+
+    const internalAPI = { auth, accounts, accountSettings, projects };
+    return { internalAPI };
+};
+
+module.exports = init;

package/src/internal-api/accounts/accounts.api.js

@@ -0,0 +1,28 @@
+const requests = require('../common/requests');
+const { backendUrl } = require('../../env').getEnv();
+
+const Endpoints = {
+    getAccount: `${backendUrl}/saas/accounts`,
+    create: `${backendUrl}/saas/createaccount`,
+    delete: `${backendUrl}/saas/account`,
+    edit: accountId => `${backendUrl}/saas/account/${accountId}/settings`
+};
+
+const create = async (account, context) => {
+    return requests.postRequestHandler(Endpoints.create, account, context).then(res => res.data);
+};
+
+const deleteAccount = async (accountId, context) => {
+    return requests.deleteRequestHandler(Endpoints.delete, context, {}, { 'userId': accountId });
+};
+
+const updateAccountSettings = async (accountId, settings, context) => {
+    return requests.putRequestHandler(Endpoints.edit(accountId), { accountId, ...settings }, context);
+};
+
+const getByName = async (accountName, context) => {
+    const params = { name: accountName };
+    return await requests.getRequestHandler(Endpoints.getAccount, params, context).then(res => res.data);
+};
+
+module.exports = { create, getByName, deleteAccount, updateAccountSettings };

package/src/internal-api/accounts/accounts.setup.js

@@ -0,0 +1,79 @@
+const env = require('../../env');
+const accountsAPI = require('./accounts.api');
+
+const { credentials, accountCreationSecret } = env.getEnv();
+const { NotFoundError } = require('../../exceptions/notFoundError');
+const PROPERTY_TYPE = 'Property Management';
+
+const createAccount = async (email, accountName, context,
+    password = credentials.strongPassword,
+    propertyType = PROPERTY_TYPE) => {
+    env.requiredValidation({
+        accountCreationSecret: accountCreationSecret,
+        'credentials.strongPassword': password
+    });
+
+    const newAccount = {
+        companyName: accountName,
+        email: email,
+        password: password,
+        verifyPassword: password,
+        secret: accountCreationSecret,
+        userType: propertyType
+    };
+
+    return await accountsAPI.create(newAccount, context);
+};
+
+const getAccount = async (accountName, context) => {
+    const existingAccounts = await accountsAPI.getByName(accountName, context);
+
+    if (!existingAccounts || existingAccounts.length === 0) {
+        return null;
+    }
+
+    if (existingAccounts.length > 1) {
+        throw new Error(`Got more than one account with the name: ${accountName}. IDs: ${existingAccounts.map(item => item.userId).join(', ')}`);
+    }
+
+    return existingAccounts[0];
+};
+
+const getOrCreateAccount = async (email, accountName, context, password = credentials.strongPassword) => {
+    const existingAccount = await getAccount(accountName, context);
+
+    if (existingAccount) {
+        return existingAccount;
+    }
+
+    return await createAccount(email, accountName, context, password);
+};
+
+const getAccountId = async (accountName, context) => {
+    const account = await getAccount(accountName, context);
+
+    if (!account) {
+        throw NotFoundError(`Account ${accountName} does not exist`);
+    }
+
+    return account.userId;
+};
+
+const deleteAccountByName = async (accountName, context) => {
+    const accountId = await getAccountId(accountName, context);
+    return accountsAPI.deleteAccount(accountId, context);
+};
+
+const deleteAccountById = async (accountId, context) => {
+    return accountsAPI.deleteAccount(accountId, context);
+};
+
+module.exports = {
+    getAccount,
+    getOrCreateAccount,
+    getAccountId,
+    createAccount,
+    deleteAccountByName,
+    deleteAccountById
+};
+

package/src/internal-api/accounts/settings/settings.api.js

@@ -0,0 +1,20 @@
+const requests = require('../../common/requests');
+const { backendUrl } = require('../../../env').getEnv();
+
+const Endpoints = {
+    get: accountId => `${backendUrl}/saas/account/${accountId}/settings`,
+    edit: accountId => `${backendUrl}/saas/account/${accountId}/settings`
+};
+
+const getAccountSettings = async (accountId, context) => {
+    return requests.getRequestHandler(Endpoints.get(accountId), {}, context);
+};
+
+const updateAccountSettings = async (accountId, settings, context) => {
+    return requests.putRequestHandler(Endpoints.edit(accountId), { accountId, ...settings }, context);
+};
+
+module.exports = {
+    getAccountSettings,
+    updateAccountSettings
+};

package/src/internal-api/accounts/settings/settings.setup.js

@@ -0,0 +1,22 @@
+const accountsAPI = require('./settings.api');
+
+const getAccountSettings = async (accountId, context) => {
+    return accountsAPI.getAccountSettings(accountId, context).then(res => res.data);
+};
+
+const updateAccountSettings = async (accountId, { isMultiPropertyTenants, isHighPriority }, context) => {
+    return accountsAPI.updateAccountSettings(accountId, { isMultiPropertyTenants, isHighPriority }, context);
+};
+
+const restoreAccountSettings = async (accountId, context) => {
+    return accountsAPI.updateAccountSettings(accountId, {
+        isMultiPropertyTenants: false,
+        isHighPriority: false
+    }, context);
+};
+
+module.exports = {
+    getAccountSettings,
+    updateAccountSettings,
+    restoreAccountSettings
+};

package/src/internal-api/auth/auth.api.js

@@ -0,0 +1,12 @@
+const requests = require('../common/requests');
+const { backendUrl } = require('../../env').getEnv();
+
+const Endpoints = {
+    login: `${backendUrl}/logincontroller`
+};
+
+const login = async (email, password) => {
+    return await requests.postRequestHandler(Endpoints.login, { email, password }).then(res => res);
+};
+
+module.exports = { login };

package/src/internal-api/auth/auth.setup.js

@@ -0,0 +1,33 @@
+const { getEnv, requiredValidation } = require('../../env');
+const { credentials } = getEnv();
+const authApi = require('./auth.api');
+
+const getAuthCookie = async (email, password) => {
+    try {
+        const res = await authApi.login(email, password);
+        const authCookie = res.headers['set-cookie'].find(item => item.startsWith('JonesToken='));
+
+        return authCookie;
+    } catch (error) {
+        throw new Error(`Failed to login to email:${email}`, error);
+    }
+};
+
+const getIcsCookie = async () => {
+    requiredValidation({
+        'credentials.superUser': credentials.superUser,
+        'credentials.superUserPassword': credentials.superUserPassword
+    });
+    return await getAuthCookie(credentials.superUser, credentials.superUserPassword);
+};
+
+const auth = {
+    getAuthCookie,
+    getIcsCookie
+};
+
+module.exports = {
+    getAuthCookie,
+    getIcsCookie
+};
+

package/src/internal-api/common/requests.js

@@ -0,0 +1,53 @@
+const axios = require('axios');
+
+const getRequestHandler = async (url, params = {}, context = null, headers = {}) => {
+    enrichCookie(headers, context);
+    try {
+        const response = await axios.get(url, { params, headers });
+        return response;
+    } catch (error) {
+        throw Error(JSON.stringify(error.response.data));
+    }
+
+};
+
+const postRequestHandler = async (url, body, context = null, headers = {}) => {
+    enrichCookie(headers, context);
+    try {
+        const response = await axios.post(url, body, { headers });
+        return response;
+    } catch (error) {
+        throw Error(JSON.stringify(error.response.data));
+    }
+
+};
+
+const putRequestHandler = async (url, body, context = null, headers = {}) => {
+    enrichCookie(headers, context);
+    try {
+        const response = await axios.put(url, body, { headers });
+        return response;
+    } catch (error) {
+        throw Error(JSON.stringify(error.response.data));
+    }
+
+};
+
+const deleteRequestHandler = async (url, context = null, headers = {}, params = {}) => {
+    enrichCookie(headers, context);
+    try {
+        const response = await axios.delete(url, { params, headers });
+        return response;
+    } catch (error) {
+        throw Error(JSON.stringify(error.response.data));
+    }
+
+};
+
+const enrichCookie = (headers, context) => {
+    if (context) {
+        headers.Cookie = context;
+    }
+};
+
+module.exports = { getRequestHandler, postRequestHandler, putRequestHandler, deleteRequestHandler };

package/src/internal-api/projects/projects.api.js

@@ -0,0 +1,23 @@
+const requests = require('../common/requests');
+const { backendUrl } = require('../../env').getEnv();
+
+const Endpoints = {
+    create: `${backendUrl}/saas/project`,
+    delete: projectId => `${backendUrl}/saas/project/${projectId}`,
+    getByAccountId: `${backendUrl}/saas/project/list`
+};
+
+const create = async (project, context) => {
+    return requests.putRequestHandler(Endpoints.create, project, context);
+};
+
+const getProjectsByAccountId = async (accountId, context) => {
+    const params = { userId: accountId };
+    return requests.getRequestHandler(Endpoints.getByAccountId, params, context).then(res => res.data);
+};
+
+const deleteProjectById = async (projectId, context) => {
+    return requests.deleteRequestHandler(Endpoints.delete(projectId), context);
+};
+
+module.exports = { create, getProjectsByAccountId, deleteProjectById };

package/src/internal-api/projects/projects.setup.js

@@ -0,0 +1,35 @@
+const projectsApi = require('./projects.api');
+const accounts = require('../accounts/accounts.setup');
+
+const getProjectsByAccountName = async (accountName, context) => {
+    const accountId = accounts.getAccountId(accountName, context);
+    return getProjectsByAccountId(accountId, context);
+};
+
+const getProjectsByAccountId = async (accountId, context) => {
+    return projectsApi.getProjectsByAccountId(accountId, context);
+};
+
+const getProjectsByName = async (accountId, projectName, context) => {
+    const projects = await getProjectsByAccountId(accountId, context);
+    const filteredProjects = projects && projects.filter(project => project.projectName === projectName) || [];
+    return filteredProjects;
+};
+
+const deleteProjectByName = async (accountId, projectName, context) => {
+    const projects = await getProjectsByName(accountId, projectName, context);
+    projects.map(async project => await projectsApi.deleteProjectById(project.projectId, context)
+    );
+};
+
+const createProject = async (project, accountName, context) => {
+    const accountId = await accounts.getAccountId(accountName, context);
+    return await projectsApi.create({ ...project, userId: accountId }, context);
+};
+
+module.exports = {
+    getProjectsByAccountName,
+    getProjectsByAccountId,
+    createProject,
+    deleteProjectByName
+};

package/tests/env.test.js

@@ -0,0 +1,39 @@
+const chai = require('chai');
+
+const { expect } = chai;
+
+const env = require('../src/env');
+
+describe('Env | Test Core Logic', async function() {
+    const expectedSanityAssignVariables = {
+        'backendUrl': 'Test',
+        'credentials': {
+            'superUser': 'TestSuperUser',
+            'superUserPassword': 'TestSuperUserPassword'
+        },
+        'environment': 'dev',
+        'accountCreationSecret': null
+    };
+
+    const expectedValidationError = 'Missing required configuration on your environment variables. The missing env-vars are "backendUrl,environment".';
+
+    it('Missing Configuration', async function() {
+        const badInput = {
+            credentials: { superUser: 'TestSuperUser', superUserPassword: 'TestSuperUserPassword' }
+        };
+
+        expect(() => env.init(badInput)).to.throw(expectedValidationError);
+    });
+
+    it('Assign Configuration', async function() {
+        env.init({
+            backendUrl: 'Test',
+            environment: 'dev',
+            credentials: { superUser: 'TestSuperUser', superUserPassword: 'TestSuperUserPassword' }
+        });
+
+        const envVariables = env.getEnv();
+        expect(envVariables).to.deep.equal(expectedSanityAssignVariables, 'Assign configuration did not work properly');
+    });
+
+});