OMDSCloud/dictation_server/src/features/accounts/accounts.controller.spec.ts

import { Test, TestingModule } from '@nestjs/testing';
import { AccountsController } from './accounts.controller';
import { AccountsService } from './accounts.service';
import { ConfigModule } from '@nestjs/config';
import { AuthService } from '../auth/auth.service';
import {
  SwitchParentRequest,
  DeletePartnerAccountRequest,
  GetPartnerUsersRequest,
  UpdatePartnerInfoRequest,
} from './types/types';
import { plainToClass } from 'class-transformer';
import { validate } from 'class-validator';

describe('AccountsController', () => {
  let controller: AccountsController;
  const mockAccountService = {};
  const mockAuthService = {};

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      imports: [
        ConfigModule.forRoot({
          envFilePath: ['.env.test', '.env'],
          isGlobal: true,
        }),
      ],
      controllers: [AccountsController],
      providers: [AccountsService, AuthService],
    })
      .overrideProvider(AccountsService)
      .useValue(mockAccountService)
      .overrideProvider(AuthService)
      .useValue(mockAuthService)
      .compile();

    controller = module.get<AccountsController>(AccountsController);
  });

  it('should be defined', () => {
    expect(controller).toBeDefined();
  });

  describe('valdation switchParentRequest', () => {
    it('最低限の有効なリクエストが成功する', async () => {
      const request = new SwitchParentRequest();
      request.to = 1;
      request.children = [2];

      const valdationObject = plainToClass(SwitchParentRequest, request);

      const errors = await validate(valdationObject);
      expect(errors.length).toBe(0);
    });

    it('子アカウントが指定されていない場合、リクエストが失敗する', async () => {
      const request = new SwitchParentRequest();
      request.to = 1;
      request.children = [];

      const valdationObject = plainToClass(SwitchParentRequest, request);

      const errors = await validate(valdationObject);
      expect(errors.length).toBe(1);
    });

    it('子アカウントが重複指定されている場合、リクエストが失敗する', async () => {
      const request = new SwitchParentRequest();
      request.to = 1;
      request.children = [2, 2];

      const valdationObject = plainToClass(SwitchParentRequest, request);

      const errors = await validate(valdationObject);
      expect(errors.length).toBe(1);
    });
  });

  describe('valdation deletePartnerAccount', () => {
    it('最低限の有効なリクエストが成功する', async () => {
      const request = new DeletePartnerAccountRequest();
      request.targetAccountId = 1;

      const valdationObject = plainToClass(
        DeletePartnerAccountRequest,
        request,
      );

      const errors = await validate(valdationObject);
      expect(errors.length).toBe(0);
    });

    it('削除対象アカウントが指定されていない場合、リクエストが失敗する', async () => {
      const request = new DeletePartnerAccountRequest();

      const valdationObject = plainToClass(
        DeletePartnerAccountRequest,
        request,
      );

      const errors = await validate(valdationObject);
      expect(errors.length).toBe(1);
    });

    it('削除対象アカウントが0の場合、リクエストが失敗する', async () => {
      const request = new DeletePartnerAccountRequest();
      request.targetAccountId = 0;

      const valdationObject = plainToClass(
        DeletePartnerAccountRequest,
        request,
      );

      const errors = await validate(valdationObject);
      expect(errors.length).toBe(1);
    });

    it('削除対象アカウントが文字列（数値以外）の場合、リクエストが失敗する', async () => {
      class DeletePartnerAccountRequestString {
        targetAccountId: string;
      }
      const request = new DeletePartnerAccountRequestString();
      request.targetAccountId = 'a';

      const valdationObject = plainToClass(
        DeletePartnerAccountRequest,
        request,
      );

      const errors = await validate(valdationObject);
      expect(errors.length).toBe(1);
    });
  });
  describe('valdation getPartnerUsers', () => {
    it('最低限の有効なリクエストが成功する', async () => {
      const request = {
        targetAccountId: 1,
      };

      const valdationObject = plainToClass(GetPartnerUsersRequest, request);

      const errors = await validate(valdationObject);
      expect(errors.length).toBe(0);
    });

    it('取得対象アカウントが指定されていない場合、リクエストが失敗する', async () => {
      const request = {};

      const valdationObject = plainToClass(GetPartnerUsersRequest, request);

      const errors = await validate(valdationObject);
      expect(errors.length).toBe(1);
    });

    it('取得対象アカウントが0の場合、リクエストが失敗する', async () => {
      const request = {
        userId: 0,
      };

      const valdationObject = plainToClass(GetPartnerUsersRequest, request);

      const errors = await validate(valdationObject);
      expect(errors.length).toBe(1);
    });

    it('取得対象アカウントが文字列（数値以外）の場合、リクエストが失敗する', async () => {
      const request = {
        userId: 'a',
      };

      const valdationObject = plainToClass(GetPartnerUsersRequest, request);

      const errors = await validate(valdationObject);
      expect(errors.length).toBe(1);
    });
  });
  describe('valdation updatePartnerInfo', () => {
    it('最低限の有効なリクエストが成功する', async () => {
      const request = {
        targetAccountId: 1,
        primaryAdminUserId: 2,
        companyName: 'test',
      };

      const valdationObject = plainToClass(UpdatePartnerInfoRequest, request);

      const errors = await validate(valdationObject);
      expect(errors.length).toBe(0);
    });

    it('更新対象アカウントが指定されていない場合、リクエストが失敗する', async () => {
      const request = {
        targetAccountId: undefined,
        primaryAdminUserId: 2,
        companyName: 'test',
      };

      const valdationObject = plainToClass(UpdatePartnerInfoRequest, request);

      const errors = await validate(valdationObject);
      expect(errors.length).toBe(1);
    });

    it('更新対象アカウントが0の場合、リクエストが失敗する', async () => {
      const request = {
        targetAccountId: 0,
        primaryAdminUserId: 2,
        companyName: 'test',
      };

      const valdationObject = plainToClass(UpdatePartnerInfoRequest, request);

      const errors = await validate(valdationObject);
      expect(errors.length).toBe(1);
    });

    it('更新対象アカウントが文字列（数値以外）の場合、リクエストが失敗する', async () => {
      const request = {
        targetAccountId: 'a',
        primaryAdminUserId: 2,
        companyName: 'test',
      };

      const valdationObject = plainToClass(UpdatePartnerInfoRequest, request);

      const errors = await validate(valdationObject);
      expect(errors.length).toBe(1);
    });
  });
  // primaryAdminUserIdのテスト
  it('更新対象アカウントが指定されていない場合、リクエストが失敗する', async () => {
    const request = {
      targetAccountId: 1,
      primaryAdminUserId: undefined,
      companyName: 'test',
    };

    const valdationObject = plainToClass(UpdatePartnerInfoRequest, request);

    const errors = await validate(valdationObject);
    expect(errors.length).toBe(1);
  });
  it('更新対象アカウントが0の場合、リクエストが失敗する', async () => {
    const request = {
      targetAccountId: 1,
      primaryAdminUserId: 0,
      companyName: 'test',
    };

    const valdationObject = plainToClass(UpdatePartnerInfoRequest, request);

    const errors = await validate(valdationObject);
    expect(errors.length).toBe(1);
  });
  it('更新対象アカウントが文字列（数値以外）の場合、リクエストが失敗する', async () => {
    const request = {
      targetAccountId: 1,
      primaryAdminUserId: 'a',
      companyName: 'test',
    };

    const valdationObject = plainToClass(UpdatePartnerInfoRequest, request);

    const errors = await validate(valdationObject);
    expect(errors.length).toBe(1);
  });
  // companyNameのテスト
  it('更新対象アカウントが文字列以外場合、リクエストが失敗する', async () => {
    const request = {
      targetAccountId: 1,
      primaryAdminUserId: 2,
      companyName: 1,
    };

    const valdationObject = plainToClass(UpdatePartnerInfoRequest, request);

    const errors = await validate(valdationObject);
    expect(errors.length).toBe(1);
  });
});