Merge pull request #106 from aquality-automation/feature/improve_tests_with_admin_api

Feature/improve tests with admin api

Author: VladislavKostyukevich

CHANGELOG.md

@@ -3,9 +3,11 @@
 ## 0.3.10 (unreleased)
 
 Features:
+  - Update Tests to use Admin API to create preconditions -> [View Issue](https://github.com/aquality-automation/aquality-tracking/issues/100)
 
 Bugfixes:
   - Test run View Page performance is bad -> [View Issue](https://github.com/aquality-automation/aquality-tracking/issues/99)
+  - API Token page: Link to Aquality Tracking API leads to null -> [View Issue](https://github.com/aquality-automation/aquality-tracking/issues/84)
   - External Link does not work on Issues List -> [View Issue](https://github.com/aquality-automation/aquality-tracking/issues/97)
 
 ## 0.3.9 (2020-04-21)

e2e/api/base.api.ts

@@ -1,14 +1,25 @@
 import { Project } from '../../src/app/shared/models/project';
 import { ATError } from '../../src/app/shared/models/error';
 import { ApiAssertMessages } from '../specs/api/api.constants';
+import superagent, { SuperAgentRequest } from 'superagent';
+import { environment } from '../../src/environments/environment';
+import { logger } from '../utils/log.util';
+
+enum RequestType {
+    post = 'post',
+    get = 'get',
+    delete = 'delete'
+}
 
 export class BaseAPI {
     project: Project;
     token: string;
+    cookie: string;
 
-    constructor(project: Project, token: string) {
+    constructor(project: Project, token: string, cookie: string = undefined) {
         this.project = project;
         this.token = token;
+        this.cookie = cookie;
     }
 
     public async assertNegativeResponse(promise: Promise<object>, expectedError: string): Promise<void> {
@@ -22,4 +33,87 @@ export class BaseAPI {
         expect(atError).toBeDefined(ApiAssertMessages.errorNotRaised);
         expect(atError).toBe(expectedError, ApiAssertMessages.errorIsWrong);
     }
+
+    protected sendGet = async (endpoint: string, params: object = undefined) => {
+        try {
+            const resp = await this.send(this.getFullURL(endpoint, params), RequestType.get);
+            return resp.body;
+        } catch (error) {
+            logger.error(`Was not able to get ${this.getFullURL(endpoint, params)}:\n${error.response.body.message}`);
+            throw error.response.body.message;
+        }
+    };
+
+    protected sendPost = async (endpoint: string, params: object, body: any) => {
+        try {
+            const resp = await this.send(this.getFullURL(endpoint, params), RequestType.post, body);
+            return resp.body;
+        } catch (error) {
+            logger.error(`Was not able to post ${this.getFullURL(endpoint, params)}`);
+            throw error.response.body.message;
+        }
+    };
+
+    protected sendDelete = async (endpoint: string, params: object, body: any = undefined) => {
+        try {
+            const resp = await this.send(this.getFullURL(endpoint, params), RequestType.delete, body);
+            return resp.body;
+        } catch (error) {
+            logger.error(`Was not able to delete ${this.getFullURL(endpoint, params)}`);
+            throw error.response.body.message;
+        }
+    };
+
+    protected sendPostFiles = (endpoint: string, params: object, filesAsString: string[], filenames: string[],
+        token: string, projectId: number) => {
+        const req = this.send(this.getFullURL(endpoint, params), RequestType.post);
+        for (let i = 0; i < filesAsString.length; i++) {
+            const file = filesAsString[i];
+            const filename = filenames[i];
+            req.attach('file', new Buffer(file), { filename });
+        }
+
+        return req;
+    };
+
+    private createAuthHeaderValue = () => {
+        if (this.cookie) {
+            return `Basic ${this.cookie}`;
+        }
+
+        if (this.project && this.token) {
+            return `Basic ${Buffer.from(`project:${this.project.id}:${this.token}`).toString('base64')}`;
+        }
+
+        throw ('You are trying to make wrong authorization: you should specify project and token, or cookie!')
+    };
+
+    private send = (fullUrl: string, type: RequestType, body?: object): SuperAgentRequest => {
+        const request = superagent[type](fullUrl)
+            .set('Authorization', this.createAuthHeaderValue())
+            .set('Accept', 'application/json');
+
+        if (body) {
+            request.send(body);
+        }
+
+        return request;
+    };
+
+    private serializeToQueryString = (object: object) => {
+        if (!object) {
+            return '';
+        }
+        const str = [];
+        for (const property in object) {
+            if (object.hasOwnProperty(property) && object[property] !== undefined) {
+                str.push(`${encodeURIComponent(property)}=${encodeURIComponent(object[property])}`);
+            }
+        }
+        return `?${str.join('&')}`;
+    };
+
+    private getFullURL = (endpoint: string, params: object) => {
+        return `${environment.host}${endpoint}${this.serializeToQueryString(params)}`;
+    };
 }

e2e/api/editor.api.ts

@@ -3,7 +3,6 @@ import { Test } from '../../src/app/shared/models/test';
 import { Step, StepToTest } from '../../src/app/shared/models/steps';
 import { TestRun } from '../../src/app/shared/models/testRun';
 import { Milestone } from '../../src/app/shared/models/milestone';
-import { sendPost, sendGet, sendDelete } from '../utils/aqualityTrackingAPI.util';
 import { TestResult } from '../../src/app/shared/models/test-result';
 import { BaseAPI } from './base.api';
 import { Issue } from '../../src/app/shared/models/issue';
@@ -24,74 +23,74 @@ export class EditorAPI extends BaseAPI {
 
     public async createSuite(suite: TestSuite): Promise<TestSuite> {
         suite.project_id = this.project.id;
-        return sendPost(Endpoints.suite, undefined, suite, this.token, this.project.id);
+        return this.sendPost(Endpoints.suite, undefined, suite);
     }
 
     public async createTest(test: Test): Promise<Test> {
         test.project_id = this.project.id;
-        return sendPost(Endpoints.test, undefined, test, this.token, this.project.id);
+        return this.sendPost(Endpoints.test, undefined, test);
     }
 
     public async createStep(step: Step): Promise<Step> {
         step.project_id = this.project.id;
-        return sendPost(Endpoints.steps, undefined, step, this.token, this.project.id);
+        return this.sendPost(Endpoints.steps, undefined, step);
     }
 
     public async createTestRun(testrun: TestRun) {
         testrun.project_id = this.project.id;
-        return sendPost(Endpoints.testrun, undefined, testrun, this.token, this.project.id);
+        return this.sendPost(Endpoints.testrun, undefined, testrun);
     }
 
     public async createMilestone(milestone: Milestone) {
         milestone.project_id = this.project.id;
-        return sendPost(Endpoints.milestone, undefined, milestone, this.token, this.project.id);
+        return this.sendPost(Endpoints.milestone, undefined, milestone);
     }
 
     public async createResult(testResult: TestResult): Promise<TestResult> {
         testResult.project_id = this.project.id;
-        return sendPost(Endpoints.testresult, undefined, testResult, this.token, this.project.id);
+        return this.sendPost(Endpoints.testresult, undefined, testResult);
     }
 
     public async addStepToTest(stepToTest: StepToTest): Promise<Step> {
         stepToTest.project_id = this.project.id;
-        return sendPost(Endpoints.testSteps, undefined, stepToTest, this.token, this.project.id);
+        return this.sendPost(Endpoints.testSteps, undefined, stepToTest);
     }
 
     public async addTestToSuite(testId: number, suiteId: number) {
-        return sendPost(Endpoints.testToSuite, { testId, suiteId, project_id: this.project.id }, {}, this.token, this.project.id);
+        return this.sendPost(Endpoints.testToSuite, { testId, suiteId, project_id: this.project.id }, {});
     }
 
     public async getSuites(testSuite: TestSuite): Promise<TestSuite[]> {
         testSuite.project_id = this.project.id;
-        return sendGet(Endpoints.suite, testSuite, this.token, this.project.id);
+        return this.sendGet(Endpoints.suite, testSuite);
     }
 
     public async getTests(test: Test): Promise<Test[]> {
-        return sendGet(Endpoints.test, test, this.token, this.project.id);
+        return this.sendGet(Endpoints.test, test);
     }
 
     public async getResults(testResult: TestResult): Promise<TestResult[]> {
         testResult.project_id = this.project.id;
-        return sendGet(Endpoints.testresult, testResult, this.token, this.project.id);
+        return this.sendGet(Endpoints.testresult, testResult);
     }
 
     public async getTestRuns(testrun: TestRun): Promise<TestRun[]> {
-        return sendGet(Endpoints.testrun, testrun, this.token, this.project.id);
+        return this.sendGet(Endpoints.testrun, testrun);
     }
 
     public async getMilestones(milestone: Milestone): Promise<Milestone[]> {
         milestone.project_id = this.project.id;
-        return sendGet(Endpoints.milestone, milestone, this.token, this.project.id);
+        return this.sendGet(Endpoints.milestone, milestone);
     }
 
     public async removeTestRun(testRunId: number) {
-        return sendDelete(Endpoints.testrun, { id: testRunId, project_id: this.project.id }, null, this.token, this.project.id);
+        return this.sendDelete(Endpoints.testrun, { id: testRunId, project_id: this.project.id }, null);
     }
 
     public async createIssue(issue: Issue): Promise<Issue> {
         issue.project_id = this.project.id;
         issue.creator_id = 1;
-        return sendPost(Endpoints.issue, undefined, issue, this.token, this.project.id);
+        return this.sendPost(Endpoints.issue, undefined, issue);
     }
 
     public async addSuiteToMilestone(milestoneName: string, suiteName: string) {

e2e/api/importer.api.ts

@@ -1,4 +1,3 @@
-import { sendPostFiles } from '../utils/aqualityTrackingAPI.util';
 import { logger } from '../utils/log.util';
 import { Project } from '../../src/app/shared/models/project';
 import { EditorAPI } from './editor.api';
@@ -21,13 +20,7 @@ export enum ImportFormats {
 
 const CHECK_IMPORTED_DELAY = 2000;
 
-export class Importer extends BaseAPI {
-    editorAPI: EditorAPI;
-
-    constructor(project: Project, token: string) {
-        super(project, token);
-        this.editorAPI = new EditorAPI(this.project, this.token);
-    }
+export class Importer extends EditorAPI {
 
     public async executeImport(importParameters: ImportParams, files: string[], fileNames: string[]): Promise<TestRun[]> {
         importParameters.projectId = this.project.id;
@@ -84,7 +77,7 @@ export class Importer extends BaseAPI {
     }
 
     private async isAllBuildsAreImported(buildNames: string[]): Promise<TestRun[]> {
-        const testRuns = await this.editorAPI.getTestRuns({ project_id: this.project.id });
+        const testRuns = await this.getTestRuns({ project_id: this.project.id });
         let imported = true;
         const importedTestRuns: TestRun[] = [];
         buildNames.forEach(buildName => {
@@ -102,7 +95,7 @@ export class Importer extends BaseAPI {
             logger.info(`Start API import with params: ${JSON.stringify(params)}`);
             logger.info(`Files count: ${filesAsString.length}`);
             logger.info(`File Names count: ${filesAsString.length}`);
-            await sendPostFiles('/import', params, filesAsString, fileNames, this.token, this.project.id);
+            await this.sendPostFiles('/import', params, filesAsString, fileNames, this.token, this.project.id);
             return true;
         } catch (err) {
             logger.error(`Import was failed: ${err.message}`);

e2e/api/public.api.ts

@@ -1,9 +1,7 @@
 import { TestSuite } from '../../src/app/shared/models/testSuite';
 import { Test } from '../../src/app/shared/models/test';
 import { TestRun } from '../../src/app/shared/models/testRun';
-import { sendPost, sendGet } from '../utils/aqualityTrackingAPI.util';
 import { TestResult } from '../../src/app/shared/models/test-result';
-import { Project } from '../../src/app/shared/models/project';
 import { BaseAPI } from './base.api';
 
 enum Endpoints {
@@ -18,26 +16,26 @@ enum Endpoints {
 export class PublicAPI extends BaseAPI {
 
     public createOrUpdateSuite(suite: TestSuite): Promise<TestSuite> {
-        return sendPost(Endpoints.suite_create_or_update, undefined, suite, this.token, this.project.id);
+        return this.sendPost(Endpoints.suite_create_or_update, undefined, suite);
     }
 
     public createOrUpdateTest(test: Test): Promise<Test> {
-        return sendPost(Endpoints.test_create_or_update, undefined, test, this.token, this.project.id);
+        return this.sendPost(Endpoints.test_create_or_update, undefined, test);
     }
 
     public startTestrun(testrun: TestRun): Promise<TestRun> {
-        return sendPost(Endpoints.testrun_start, undefined, testrun, this.token, this.project.id);
+        return this.sendPost(Endpoints.testrun_start, undefined, testrun);
     }
 
     public finishTestRun(project_id: number, id: number) {
-        return sendGet(Endpoints.testrun_finish, { project_id, id }, this.token, this.project.id);
+        return this.sendGet(Endpoints.testrun_finish, { project_id, id });
     }
 
     public testResultStart(test_id: number, test_run_id: number, project_id: number) {
-        return sendGet(Endpoints.test_result_start, { test_id, test_run_id, project_id }, this.token, this.project.id);
+        return this.sendGet(Endpoints.test_result_start, { test_id, test_run_id, project_id });
     }
 
     public testResultFinish(testResult: TestResult): Promise<TestResult> {
-        return sendPost(Endpoints.test_result_finish, undefined, testResult, this.token, this.project.id);
+        return this.sendPost(Endpoints.test_result_finish, undefined, testResult);
     }
 }

e2e/api/user.api.ts

@@ -0,0 +1,77 @@
+import { BaseAPI } from './base.api';
+import { Project } from '../../src/app/shared/models/project';
+import { User } from '../../src/app/shared/models/user';
+import { Customer } from '../../src/app/shared/models/customer';
+import { LocalPermissions } from '../../src/app/shared/models/LocalPermissions';
+import { PermissionType } from '../helpers/project.helper';
+import { logger } from '../utils/log.util';
+
+enum Endpoints {
+    project = '/project',
+    customer = '/customer',
+    apiToken = '/project/apiToken',
+    projectPermission = '/users/permissions',
+    users = '/users'
+}
+
+export class UserAPI extends BaseAPI {
+
+    constructor(authCookie: string) {
+        super(null, null, authCookie)
+    }
+
+    public async createProject(project: Project): Promise<Project> {
+        const customers: Customer[] = await this.sendGet(Endpoints.customer);
+        project.customer_id = customers.find(x => x.name === project.customer.name).id;
+        return this.updateProject(project)
+    }
+
+    public updateProject(project: Project): Promise<Project> {
+        return this.sendPost(Endpoints.project, undefined, project)
+    }
+
+    public createUser(user: User): Promise<User> {
+        return this.sendPost(Endpoints.users, undefined, user);
+    }
+
+    public async assigneProjectPermission(project: Project, user: User, permissionType: PermissionType): Promise<void> {
+        let localPermissions: LocalPermissions;
+        let userToAdd = (await this.sendGet(Endpoints.users, { user_name: user.user_name }))[0];
+
+        if (!userToAdd) {
+            logger.info(`User ${user.user_name} does not exist. Creating...`);
+            userToAdd = await this.createUser(user);
+        }
+
+        switch (permissionType) {
+            case PermissionType.localAdmin:
+                localPermissions = { project_id: project.id, user_id: userToAdd.id, admin: 1, manager: 0, engineer: 0 };
+                break;
+            case PermissionType.localEngineer:
+                localPermissions = { project_id: project.id, user_id: userToAdd.id, admin: 0, manager: 0, engineer: 1 };
+                break;
+            case PermissionType.localManager:
+                localPermissions = { project_id: project.id, user_id: userToAdd.id, admin: 0, manager: 1, engineer: 0 };
+                break;
+            case PermissionType.projectTemp:
+            case PermissionType.viewer:
+                localPermissions = { project_id: project.id, user_id: userToAdd.id, admin: 0, manager: 0, engineer: 0 };
+                break;
+            default:
+                logger.info(`Local Permissions for ${permissionType} are not required`);
+        }
+
+        if (localPermissions) {
+            return this.sendPost(Endpoints.projectPermission, undefined, localPermissions);
+        }
+    }
+
+    public async createToken(project: Project): Promise<string> {
+        const resp = await this.sendGet(Endpoints.apiToken, { id: project.id });
+        return (resp).api_token;
+    }
+
+    public removeProject(project: Project): Promise<string> {
+        return this.sendDelete(Endpoints.project, { id: project.id });
+    }
+}