자동화 테스트 1차 완성

1차적으로 ui 테스트를 위한 코드를 작성 완료하였다.

strapi 로 logging 기능을 개발하여 프론트에서 테스트 실행 시, 백엔드쪽에서 테스트가 돌아가고 만약 오류가 생기게 된다면 validation 처리를 하여 로그에 쌓이도록 개발완료한 상태이다.

이번에 logging 기능을 개발하면서 strapi 의 relation 에 대해 공부를 하였는데 relation에 대해서는 따로 기술하도록 하겠다.

이번 포스팅은 내가 작성한 코드에 대해서만 기록하도록 하겠다.

'use strict';

/**
 * testcase controller
 */

const { createCoreController } = require('@strapi/strapi').factories;
const {
  errorLog,
  testResultLog,
} = require('../../../modules/logging/loggingInfo');
const {
  userInfoService,
  createOrUpdatedUser,
} = require('../../../modules/logging/userlog');

const populateInfo = {
  TESTCASE_ELEMENTS: { filters: { USE_YN: 'Y' } },
  LOGGINGS: '*',
  CREATED_USER: '*',
  UPDATED_USER: '*',
};

module.exports = createCoreController(
  'api::testcase.testcase',
  ({ strapi }) => ({
    async catchUpdateStatusAndRuntime(ctx, runtimeDate) {
      const testcaseId = ctx.request.query;
      await strapi
        .service('api::testcase.testcase')
        .update(`${testcaseId.id}`, {
          data: {
            LAST_RUNTIME: runtimeDate,
            LAST_STATUS: 'F',
          },
        });
    },
    async tryUpdateStatusAndRuntime(ctx, runtimeDate, result) {
      const testcaseId = ctx.request.query;
      await strapi
        .service('api::testcase.testcase')
        .update(`${testcaseId.id}`, {
          data: {
            LAST_RUNTIME: runtimeDate,
            LAST_STATUS:
              String(result).includes('success') === true ? 'S' : 'F',
          },
        });
    },
    async testcaseList(ctx) {
      const entity = await strapi.entityService.findMany(
        'api::testcase.testcase',
        {
          filters: { USE_YN: 'Y' },
          sort: { id: 'DESC' },
          populate: populateInfo,
        }
      );
      const data = await this.sanitizeOutput(entity, ctx);
      return { data };
    },
    async findTestcase(ctx) {
      const requestParams = ctx.request.params;
      const testcaseId = requestParams.id;
      const entity = await strapi.entityService.findMany(
        'api::testcase.testcase',
        {
          filters: { id: `${testcaseId}`, USE_YN: 'Y' },
          populate: populateInfo,
        }
      );
      const data = await this.sanitizeOutput(entity, ctx);
      return { data };
    },

    // [1] : 테스트케이스 생성 api
    async createTestcase(ctx) {
      const userInfo = await userInfoService();
      try {
        const request_body = ctx.request.body.data;
        // 항상 data로 감싸야함.
        const reqeust_data = {
          data: {
            SERVICE_NM: request_body.SERVICE_NM,
            SELECT_SUB: request_body.SELECT_SUB,
            TEST_NM: request_body.TEST_NM,
          },
        };
        const entity = await strapi
          .service('api::testcase.testcase')
          .create(reqeust_data);
        // DB에 저장될 때 sanitizedEntity 사용
        // const sanitizedEntity = await this.sanitizeInput(entity, ctx);
        // DB에 저장된 값
        const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
        // 테스트케이스 생성한 유져 정보 삽입
        await createOrUpdatedUser(sanitizedEntity, userInfo, ctx);
        const result = sanitizedEntity;
        // ctx.send({ result });
        return { result };
      } catch (error) {
        // return { data, meta };
        console.log(error);
        return { error };
      }
    },

    // [2] : 테스트케이스 수정 api
    async update(ctx) {
      const userInfo = await userInfoService();
      const requestParams = ctx.request.params;
      const testcaseId = requestParams.id;

      try {
        const request_body = ctx.request.body.data;
        const update_data = {
          SERVICE_NM: request_body.SERVICE_NM,
          SELECT_SUB: request_body.SELECT_SUB,
          TEST_NM: request_body.TEST_NM,
        };
        // 정의되지 않은 필드값 들어올 시 Validation
        if (
          JSON.stringify(Object.keys(request_body)) !==
          JSON.stringify(Object.keys(update_data))
        ) {
          return ctx.response.badRequest('정의되지 않은 필드가 존재합니다.');
        }
        // 테스트케이스가 존재하지 않을 경우
        const findTestCase = await strapi
          .service('api::testcase.testcase')
          .findOne(`${testcaseId}`);
        if (!findTestCase) {
          return ctx.response.badRequest('테스트케이스가 존재하지 않습니다.');
        }
        // 업데이트
        const entity = await strapi
          .service('api::testcase.testcase')
          .update(`${testcaseId}`, { data: update_data });

        const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
        await createOrUpdatedUser(sanitizedEntity, userInfo, ctx);
        const result = sanitizedEntity;
        return { result };
      } catch (error) {
        console.log(error);
        return { error };
      }
    },

    // [3] : 테스트케이스 삭제 api
    async delete(ctx) {
      // const findUser = await userModule.findUser(ctx);
      userInfoService();
      const requestParams = ctx.request.params;
      const testcaseId = requestParams.id;
      const { meta } = await super.find(ctx);
      try {
        const findTestCase = await strapi
          .service('api::testcase.testcase')
          .findOne(`${testcaseId}`);
        if (!findTestCase) {
          return ctx.response.badRequest('테스트케이스가 존재하지 않습니다.');
        }
        const entity = await strapi
          .service('api::testcase.testcase')
          .delete(testcaseId);
        const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
        meta.result = `${sanitizedEntity.SERVICE_NM}이(가) 정상적으로 삭제되었습니다.`;
        // loggerModule.createLogger(ctx, testcaseId, findUser);
        return { meta };
      } catch (error) {
        return { error };
      }
    },

    async deleteTestcase(ctx) {
      const userInfo = await userInfoService();
      const requestParams = ctx.request.params;
      const testcaseId = requestParams.id;
      const { meta } = await super.find(ctx);
      try {
        const findTestCase = await strapi
          .service('api::testcase.testcase')
          .findOne(`${testcaseId}`);
        if (!findTestCase) {
          return ctx.response.badRequest('테스트케이스가 존재하지 않습니다.');
        }
        const entity = await strapi
          .service('api::testcase.testcase')
          .update(`${testcaseId}`, { data: { USE_YN: 'N' } });
        const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
        await createOrUpdatedUser(sanitizedEntity, userInfo, ctx);
        meta.result = `${sanitizedEntity.SERVICE_NM}이(가) 정상적으로 삭제되었습니다.`;
        return { meta };
      } catch (error) {
        return { error };
      }
    },

    /* 커스텀 테스트케이스 목록들*/

    // [1] : 마켓봄 테스트 api
    async bomOrderTest(ctx) {
      const userInfo = await userInfoService();
      const { meta } = await super.find(ctx);
      try {
        const requestQuery = ctx.request.query;
        const result = await strapi
          .service('api::testcase.testcase')
          .bomOrderTest(requestQuery);
        if (result === 'error') {
          return ctx.response.badRequest('오우쉣');
        }
        const sanitizedEntity = await this.sanitizeOutput(result, ctx);
        meta.result = sanitizedEntity;
        await createOrUpdatedUser(sanitizedEntity, userInfo, ctx);
        ctx.send({ sanitizedEntity });
        await testResultLog(sanitizedEntity, userInfo, ctx, result);
        return { meta };
      } catch (error) {
        const testcaseId = ctx.request.query;
        ctx.response.status === 404
          ? ctx.response.notFound('실패', `${error}`)
          : ctx.response.badRequest('실패', `${error}`);
        const date = new Date().toString().slice(0, -32);
        const path = `./src/screenshot/${date}.png`;
        await errorLog(testcaseId, userInfo, ctx, path);
        return error;
      }
    },

    // [2] : 마켓봄프로 테스트 api
    async proEnroll(ctx) {
      const userInfo = await userInfoService();
      const testcaseId = ctx.request.query;
      try {
        const result = await strapi
          .service('api::testcase.testcase')
          .proEnroll(ctx, testcaseId);
        //ctx.send({ result });
        const runtimeDate = new Date(new Date().getTime());
        //const sanitizedEntity = await this.sanitizeOutput(result, ctx);
        await this.tryUpdateStatusAndRuntime(ctx, runtimeDate, result);
        await createOrUpdatedUser(testcaseId, userInfo, ctx);
        await testResultLog(testcaseId, userInfo, ctx, result);

        return { result };
      } catch (error) {
        const testcaseId = ctx.request.query;
        const screenshotName = new Date().getTime();
        const path = `./src/screenshot/${ctx.response.body.error.message}.png`;
        const runtimeDate = new Date(screenshotName);
        await this.catchUpdateStatusAndRuntime(ctx, runtimeDate);
        await errorLog(testcaseId, userInfo, ctx, path);
        return error;
      }
    },
  })
);