$ nvm install --lts

$ npm i -g @nestjs/cli

$ nest new <アプリケーション名>

# 今回は以下のようにbackendという名前でプロジェクトを作成
$ nest new backend
✨ We will scaffold your app in a few seconds..

# 十字キーでカーソルを合わせてEnterを押すと次に進む
? Which package manager would you ❤️ to use? (Use arrow keys)
❯ npm
  yarn
  pnpm

# 今回はnpmを選択
✔ Which package manager would you ❤️  to use? npm
CREATE backend/.prettierrc (51 bytes)
CREATE backend/README.md (5028 bytes)
CREATE backend/eslint.config.mjs (836 bytes)
CREATE backend/nest-cli.json (171 bytes)
CREATE backend/package.json (1978 bytes)
CREATE backend/tsconfig.build.json (97 bytes)
CREATE backend/tsconfig.json (677 bytes)
CREATE backend/src/app.controller.ts (274 bytes)
CREATE backend/src/app.module.ts (249 bytes)
CREATE backend/src/app.service.ts (142 bytes)
CREATE backend/src/main.ts (228 bytes)
CREATE backend/src/app.controller.spec.ts (617 bytes)
CREATE backend/test/jest-e2e.json (183 bytes)
CREATE backend/test/app.e2e-spec.ts (674 bytes)

✔ Installation in progress... ☕

🚀  Successfully created project backend
👉  Get started with the following commands:

$ cd backend
$ npm run start

                                         
                          Thanks for installing Nest 🙏
                 Please consider donating to our open collective
                        to help us maintain this package.
                                         
                                         
               🍷  Donate: https://opencollective.com/nest

$ npm install --save @nestjs/typeorm typeorm pg

import { DataSource } from 'typeorm';

export default new DataSource({
  type: 'postgres',
  host: 'localhost',
  port: 5432,
  database: '<データベース名>',
  username: '<ユーザー名>',
  password: '<パスワード>',
  entities: ['dist/**/entities/**/*.entity.js'],
  migrations: ['dist/**/migrations/**/*.js'],
  logging: true,
  synchronize: false,
});

$ npm install --save @nestjs/config

export default () => ({
  database: {
    host: process.env.DATABASE_HOST || 'localhost',
    port: parseInt(process.env.DATABASE_PORT ?? '5432', 10),
    username: process.env.DATABASE_USER || '<ユーザー名>',
    password: process.env.password || '<パスワード>',
    name: process.env.database || '<データベース名>',
  },
});

$ psql -d postgres
psql (16.9 (Ubuntu 16.9-0ubuntu0.24.04.1))
Type "help" for help.

postgres=> CREATE DATABASE データベース名;

$ npm install @nestjs/passport @nestjs/jwt bcrypt passport passport-local passport-jwt
$ npm i -D @types/passport @types/passport-jwt @types/passport-local

$ nest g resource users

import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common';
import { UsersService } from './users.service';
// import { CreateUserDto } from './dto/create-user.dto';  削除
// import { UpdateUserDto } from './dto/update-user.dto';　削除

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  /* 削除
  @Post()
  create(@Body() createUserDto: CreateUserDto) {
    return this.usersService.create(createUserDto);
  }
  */

  @Get()
  findAll() {
    return this.usersService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.usersService.findOne(+id);
  }

  /* 削除
  @Patch(':id')
  update(@Param('id') id: string, @Body() updateUserDto: UpdateUserDto) {
    return this.usersService.update(+id, updateUserDto);
  }

  @Delete(':id')
  remove(@Param('id') id: string) {
    return this.usersService.remove(+id);
  }
  */
}

import { Injectable } from '@nestjs/common';
// import { CreateUserDto } from './dto/create-user.dto';  削除
// import { UpdateUserDto } from './dto/update-user.dto';　削除

@Injectable()
export class UsersService {
  /* 削除
  create(createUserDto: CreateUserDto) {
    return 'This action adds a new user';
  }
  */

  findAll() {
    return `This action returns all users`;
  }

  findOne(id: number) {
    return `This action returns a #${id} user`;
  }

  /* 削除
  update(id: number, updateUserDto: UpdateUserDto) {
    return `This action updates a #${id} user`;
  }

  remove(id: number) {
    return `This action removes a #${id} user`;
  }
  */
}

import {
  BaseEntity,
  Column,
  CreateDateColumn,
  Entity,
  PrimaryGeneratedColumn,
  UpdateDateColumn,
} from 'typeorm';

@Entity('users')
export class User extends BaseEntity {
  @PrimaryGeneratedColumn({
    comment: 'ユーザーID',
  })
  readonly id: number;

  @Column('varchar', { comment: 'ユーザー名' })
  name: string;

  @Column('varchar', { comment: 'メールアドレス' })
  email: string;

  @Column('uuid', {
    name: 'image_id',
    nullable: true,
    comment: 'プロフィール画像'
  })
  imageId: string | null;

  @Column('text', { default: '', comment: '自己紹介' })
  introduction: string;

  @Column('text', {
    name: 'hashed_password',
    nullable: true,
    comment: 'パスワード',
  })
  hashedPassword: string | null;

  @Column('text', {
    name: 'image_url',
    nullable: true,
    comment: '外部プロフィール画像URL',
  })
  imageUrl: string | null;

  @CreateDateColumn({ name: 'created_at', comment: '作成日時' })
  createdAt: Date;

  @UpdateDateColumn({ name: 'updated_at', comment: '更新日時' })
  updatedAt: Date;

  constructor(name: string) {
    super();
    this.name = name;
  }
}

import { Module } from '@nestjs/common';
import { UsersService } from './users.service';
import { UsersController } from './users.controller';
// 以下2つ追加
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './entities/user.entity';

@Module({
  controllers: [UsersController],
  providers: [UsersService],
  // 追加
  imports: [TypeOrmModule.forFeature([User])],
})
export class UsersModule {}

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
// 追加
import { UsersModule } from './users/users.module';
import { ConfigModule, ConfigService } from '@nestjs/config';
import configuration from '../config/configuration';
import { TypeOrmModule } from '@nestjs/typeorm';
// ここまで

@Module({
  // 追加  >>>>>>>>>>>>>>>>>>>>>>>>>>
  imports: [
    UsersModule,
    ConfigModule.forRoot({ isGlobal: true, load: [configuration] }),
    TypeOrmModule.forRootAsync({
      imports: [ConfigModule],
      useFactory: async (configService: ConfigService) => ({
        type: 'postgres',
        host: configService.get('database.host'),
        port: configService.get('database.port'),
        username: configService.get('database.username'),
        password: configService.get('database.password'),
        database: configService.get('database.name'),
        entities: ['dist/**/entities/**/*.entity.js'],
        synchronize: false,
      }),
      inject: [ConfigService],
    }),
  ],
  // ここまで  >>>>>>>>>>>>>>>>>>>>>>>
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

{
  ...
  "scripts": {
    "build": "nest build",
    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
    "start": "nest start",
    "start:dev": "nest start --watch",
    "start:debug": "nest start --debug --watch",
    "start:prod": "node dist/main",
    // ここから
    "typeorm": "ts-node ./node_modules/typeorm/cli",
    "typeorm:run-migrations": "npm run typeorm migration:run -- -d ./config/typeorm.config.ts",
    "typeorm:generate-migration": "npm run typeorm -- -d ./config/typeorm.config.ts migration:generate ./migrations/$npm_config_name",
    "typeorm:revert-migration": "npm run typeorm -- -d ./config/typeorm.config.ts migration:revert",
    // ここまで
    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
    "test": "jest",
    "test:watch": "jest --watch",
    "test:cov": "jest --coverage",
    "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
    "test:e2e": "jest --config ./test/jest-e2e.json"
  },
  ...
}

$ npm run start:dev
$ npm run typeorm:generate-migration --name=CreateUsers

$ npm run typeorm:run-migrations
query: SELECT version()
query: SELECT * FROM current_schema()
query: SELECT * FROM "information_schema"."tables" WHERE "table_schema" = 'public' AND "table_name" = 'migrations'
query: CREATE TABLE "migrations" ("id" SERIAL NOT NULL, "timestamp" bigint NOT NULL, "name" character varying NOT NULL, CONSTRAINT "PK_8c82d7f526340ab734260ea46be" PRIMARY KEY ("id"))
query: SELECT * FROM "migrations" "migrations" ORDER BY "id" DESC
0 migrations are already loaded in the database.
1 migrations were found in the source code.
1 migrations are new migrations must be executed.
query: START TRANSACTION
query: CREATE TABLE "users" ("id" SERIAL NOT NULL, "name" character varying NOT NULL, "email" character varying NOT NULL, "image_id" uuid NOT NULL, "introduction" text, "hashed_password" character varying NOT NULL, "image_url" text, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), CONSTRAINT "PK_a3ffb1c0c8416b9fc6f907b7433" PRIMARY KEY ("id")); COMMENT ON COLUMN "users"."id" IS 'ユーザーID'; COMMENT ON COLUMN "users"."name" IS 'ユーザー名'; COMMENT ON COLUMN "users"."email" IS 'メールアドレス'; COMMENT ON COLUMN "users"."image_id" IS 'プロフィール画像'; COMMENT ON COLUMN "users"."introduction" IS '自己紹介'; COMMENT ON COLUMN "users"."hashed_password" IS 'パスワード'; COMMENT ON COLUMN "users"."image_url" IS '外部プロフィール画像URL'; COMMENT ON COLUMN "users"."created_at" IS '作成日時'; COMMENT ON COLUMN "users"."updated_at" IS '更新日時'
query: INSERT INTO "migrations"("timestamp", "name") VALUES ($1, $2) -- PARAMETERS: [1753943067672,"CreateUsers1753943067672"]
Migration CreateUsers1753943067672 has been executed successfully.
query: COMMIT

$ psql -d postgres 
psql (16.9 (Ubuntu 16.9-0ubuntu0.24.04.1))
Type "help" for help.

postgres=> \c <データベース名> 
You are now connected to database "<データベース名>" as user "<ユーザー名>".
<データベース名>=> \d
                List of relations
 Schema |       Name        |   Type   |  Owner   
--------+-------------------+----------+----------
 public | migrations        | table    | <ユーザー名>
 public | migrations_id_seq | sequence | <ユーザー名>
 public | users             | table    | <ユーザー名>
 public | users_id_seq      | sequence | <ユーザー名>
(4 rows)

<データベース名>=> select * from users;
 id | name | email | image_id | introduction | hashed_password | image_url | created_at | updated_at 
----+------+-------+----------+--------------+-----------------+-----------+------------+------------
(0 rows)

$ nest g resource auth

$ npm i --save class-validator class-transformer

import { IsEmail, IsNotEmpty, IsOptional, IsString, MinLength } from 'class-validator';
import { Match } from '../../common/decorators/match.decorator';

export class SignupDto {
  @IsString()
  @IsNotEmpty({ message: '入力必須です' })
  name: string;

  @IsEmail({}, { message: 'メールアドレスが無効です' })
  @IsNotEmpty({ message: '入力必須です' })
  email: string;

  @IsNotEmpty()
  @IsString()
  imageId: string | null;

  @IsString()
  @IsNotEmpty({ message: '入力必須です' })
  @MinLength(6)
  password: string;

  @IsString()
  @IsNotEmpty({ message: '入力必須です' })
  @Match('password', { message: 'パスワードが一致していません' })
  confirmPassword: string;

  @IsOptional()
  @IsString()
  introduction: string;
}

import {
  registerDecorator,
  ValidationArguments,
  ValidationOptions,
} from 'class-validator';

export function Match(property: string, validationOptions?: ValidationOptions) {
  return function (object: Object, propertyName: string) {
    registerDecorator({
      name: 'Match',
      target: object.constructor,
      propertyName: propertyName,
      options: validationOptions,
      constraints: [property],
      validator: {
        validate(value: any, args: ValidationArguments) {
          const [relatedPropertyName] = args.constraints;
          const relatedValue = (args.object as any)[relatedPropertyName];
          return value === relatedValue;
        },
        defaultMessage(args: ValidationArguments) {
          const [relatedPropertyName] = args.constraints;
          return `${args.property} must match ${relatedPropertyName}`;
        },
      },
    });
  };
}

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { ValidationPipe } from '@nestjs/common';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  // 追加＞＞＞＞＞
  app.useGlobalPipes(new ValidationPipe())
  // ＜＜＜＜＜
  await app.listen(process.env.PORT ?? 3000);
}
bootstrap();

import {
  Body,
  Controller,
  Post,
} from '@nestjs/common';
import { AuthService } from './auth.service';
import { SignupDto } from './dto/signup.dto';

@Controller('api/auth')
export class AuthController {
  constructor(private readonly authService: AuthService) {}

  @Post('signup')
  signUp(@Body() dto: SignupDto) {
    return this.authService.signUp(dto);
  }
}

import {
  ForbiddenException,
  Injectable,
} from '@nestjs/common';
import * as bcrypt from 'bcrypt';
import { InjectRepository } from '@nestjs/typeorm';
import { User } from '../users/entities/user.entity';
import { Repository } from 'typeorm';
import { SignupDto } from './dto/signup.dto';

@Injectable()
export class AuthService {
  constructor(
    @InjectRepository(User)
    private readonly userRepo: Repository<User>,
  ) {}

  async signUp(dto: SignupDto) {
    const hashed = await bcrypt.hash(dto.password, 12);
    try {
      const user = this.userRepo.create({
        name: dto.name,
        email: dto.email,
        imageId: dto.imageId,
        hashedPassword: hashed,
        introduction: dto.introduction,
      });

      await this.userRepo.save(user);
      return user;
    } catch (error) {
      if (error.code === '23505') {
        throw new ForbiddenException(
          'このメールアドレスは既に登録されています',
        );
      }
      throw error;
    }
  }
}

import { UsersModule } from './users/users.module';
// 追加
import { AuthModule } from './auth/auth.module';　　// ←ここ！
import { ConfigModule, ConfigService } from '@nestjs/config';
import configuration from '../config/configuration';
import { TypeOrmModule } from '@nestjs/typeorm';

@Module({
  // AuthModuleを追加
  imports: [
    UsersModule,
    AuthModule,　　// ←ここ！
    ConfigModule.forRoot({ isGlobal: true, load: [configuration] }),
    TypeOrmModule.forRootAsync({
      imports: [ConfigModule],
      useFactory: async (configService: ConfigService) => ({
        type: 'postgres',
        host: configService.get('database.host'),
        port: configService.get('database.port'),
        username: configService.get('database.username'),
        password: configService.get('database.password'),
        database: configService.get('database.name'),
        entities: ['dist/**/entities/**/*.entity.js'],
        synchronize: false,
      }),
      inject: [ConfigService],
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

import { Module } from '@nestjs/common';
import { AuthService } from './auth.service';
import { AuthController } from './auth.controller';
// 👇 この2行を追加
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from '../users/entities/user.entity';

@Module({
  // 👇 importとTypeOrmModuleを追加
  imports: [
    TypeOrmModule.forFeature([User]),
  ],
  controllers: [AuthController],
  providers: [AuthService],
})
export class AuthModule {}

import { Test, TestingModule } from '@nestjs/testing';
import { AuthService } from './auth.service';
import { AuthController } from './auth.controller';
import { getRepositoryToken } from '@nestjs/typeorm';
import { User } from '../users/entities/user.entity';
import * as bcrypt from 'bcrypt';
import { Repository } from 'typeorm';
import { SignupDto } from './dto/signup.dto';

// --- 準備 (beforeEach の方針) ---
// - bcrypt をモック化する（hash を jest.fn() に差し替え）
// - AuthService をテスト対象として利用する
// - UserRepository をモックして DI する
// - TestingModule を作成し、AuthController と AuthService を登録
// - service (AuthService のインスタンス) を取り出す

jest.mock('bcrypt', () => ({
  hash: jest.fn(), // bcrypt.hash をモック化
}));

describe('AuthService', () => {
  let service: AuthService;
  let userRepo: jest.Mocked<Repository<User>>;

  beforeEach(async () => {
    // 各依存サービスのモック定義（Repository の代替実装）
    userRepo = {
      create: jest.fn(), // User エンティティ作成のモック
      save: jest.fn(), // User 保存処理のモック
    } as any;

    // テスト用のモジュールを作成する
    const module: TestingModule = await Test.createTestingModule({
      controllers: [AuthController], // AuthController をテスト対象に含める
      providers: [
        AuthService, // テスト対象のサービス
        { provide: getRepositoryToken(User), useValue: userRepo }, // UserRepository をモックで差し替え
      ],
    }).compile();

    // AuthService のインスタンスを取得
    service = module.get<AuthService>(AuthService);
  });

  // AuthService が正しくインスタンス化されているかの確認
  it('should be defined', () => {
    expect(service).toBeDefined();
  });

  const now = new Date();
  const tomorrow = new Date(now);
  tomorrow.setDate(now.getDate() + 1);

  describe('signUp()', () => {
    // - 共通で使う dto を用意（name, email, password, confirmPassword, imageId, introduction）
    const dto: SignupDto = {
      name: 'dummy',
      email: 'test@dummy.com',
      imageId: '5d78f017-ef80-fbbf-3aad-f3f5d6c10043',
      password: 'dummy123',
      confirmPassword: 'dummy123',
      introduction: 'Hello',
    };

    const createdUser = {
      id: 1,
      name: dto.name,
      email: dto.email,
      imageId: dto.imageId,
      introduction: dto.introduction,
      hashedPassword: 'hashed',
      imageUrl: null,
      createdAt: now,
      updatedAt: now,
    };

    // --- 正常系テスト ---
    it('正常にユーザー登録ができ、登録したユーザーを返す', async () => {
      // 1. bcrypt.hash が呼ばれていることを spy で確認する（jest.mockを使ってモックしているのでspyOnは利用しない）
      const jestHash = (bcrypt.hash as jest.Mock).mockResolvedValue('hashed');

      // 2. userRepo.create が呼ばれていることを spy で確認する（userRepo を as any でモックしているのでspyOnは利用しない）
      (userRepo.create as jest.Mock).mockReturnValue(createdUser);

      // 3. userRepo.save が呼ばれていることを spy で確認する（userRepo を as any でモックしているのでspyOnは利用しない）
      //    - 戻り値として user オブジェクトを返すよう mock しておく
      (userRepo.save as jest.Mock).mockResolvedValue(createdUser);

      const result = await service.signUp(dto);

      //    - 引数が (dto.password, 12) で渡されていることを期待する
      expect(jestHash).toHaveBeenCalledWith(dto.password, 12);

      // --- 追加観点 ---
      // bcrypt.hash が正しい回数呼ばれているか確認する
      expect(jestHash).toHaveBeenCalledTimes(1);
      // bcrypt.hash の戻り値が正しく hashedPassword として保存されているか確認する
      expect(result.hashedPassword).toBe('hashed');

      //    - 渡された引数が dto の値＋ hashedPassword であることを期待する
      expect(userRepo.create).toHaveBeenCalled();
      expect(userRepo.create).toHaveBeenCalledWith(
        expect.objectContaining({
          name: dto.name,
          email: dto.email,
          imageId: dto.imageId,
          introduction: dto.introduction,
          hashedPassword: 'hashed',
        }),
      );

      // --- 追加観点 ---
      // userRepo.create が正しい回数呼ばれているか確認する
      expect(userRepo.create).toHaveBeenCalledTimes(1);

      // 4. signUp メソッドの戻り値が user オブジェクトであることを確認する
      expect(userRepo.save).toHaveBeenCalledWith(createdUser);
      expect(result).toEqual(createdUser);

      // --- 追加観点 ---
      // - userRepo.save が正しい回数呼ばれているか確認する
      // - save 後の戻り値が正しく返却されるか確認する
      expect(userRepo.save).toHaveBeenCalledTimes(1);
      expect(result).toMatchObject({
        id: 1,
        email: dto.email,
        hashedPassword: 'hashed',
      });
    });

    // --- 異常系テスト（ユニーク制約違反） ---
    it('メールアドレスが重複しており、登録できないかつエラーメッセージが表示される', async () => {
      (userRepo.create as jest.Mock).mockReturnValue(createdUser);

      // 1. userRepo.save が error.code = '23505' を投げるように mock する
      (userRepo.save as jest.Mock).mockRejectedValue({ code: '23505' });

      // 2. signUp 呼び出し時に ForbiddenException が throw されることを確認する
      // 3. 例外メッセージが「このメールアドレスは既に登録されています」であることを確認する
      await expect(service.signUp(dto)).rejects.toThrow(
        'このメールアドレスは既に登録されています',
      );

      // --- その他の例外 ---
      // 1. userRepo.save が '23505' 以外のエラーを投げるように mock する
      // 2. signUp 呼び出し時にそのまま同じエラーが throw されることを確認する
      (userRepo.save as jest.Mock).mockRejectedValue(new Error('DB error'));
      await expect(service.signUp(dto)).rejects.toThrow('DB error');
    });
  });
});

$ npm run test

import { Test, TestingModule } from '@nestjs/testing';
import { AuthController } from './auth.controller';
import { AuthService } from './auth.service';
import { SignupDto } from './dto/signup.dto';
import { ForbiddenException, RequestMethod } from '@nestjs/common';
import 'reflect-metadata';
import { METHOD_METADATA, PATH_METADATA } from '@nestjs/common/constants';

describe('AuthController', () => {
  let controller: AuthController;
  let service: jest.Mocked<AuthService>;

  // --- 準備（beforeEach の方針）---
  beforeEach(async () => {
    // 各依存サービスのモック定義
    // - AuthService をモックして DI する（signUp を jest.fn()）
    const serviceMock: Partial<jest.Mocked<AuthService>> = {
      // コントローラ内で呼ばれるメソッドだけ形だけ用意
      signUp: jest.fn(),
      // ほか必要なら追加
    };

    // テスト用のモジュールを作成する
    // - TestingModule に controller: [AuthController], providers: [{ provide: AuthService, useValue: mock }] を登録
    const module: TestingModule = await Test.createTestingModule({
      controllers: [AuthController],
      providers: [{ provide: AuthService, useValue: serviceMock }],
    }).compile();

    // - controller と service を取り出す
    controller = module.get<AuthController>(AuthController);
    service = module.get(AuthService) as jest.Mocked<AuthService>;
  });

  afterEach(() => {
    jest.clearAllMocks();
  });

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

  const now = new Date();
  const tomorrow = new Date(now);
  tomorrow.setDate(now.getDate() + 1);

  describe("@Post('signup')", () => {
    // - 共通で使う dto を用意（name, email, password, confirmPassword, imageId, introduction）
    const dto: SignupDto = {
      name: 'dummy',
      email: 'test@dummy.com',
      password: 'dummy123',
      confirmPassword: 'dummy123',
      imageId: '5d78f017-ef80-fbbf-3aad-f3f5d6c10043',
      introduction: 'Hello, Elden',
    };

    // - 共通で使う user を用意（id, email, ...）
    const user = {
      id: 1,
      name: dto.name,
      email: dto.email,
      imageId: dto.imageId,
      introduction: dto.introduction,
      hashedPassword: 'hashed',
      imageUrl: null,
      createdAt: now,
      updatedAt: now,
    };

    // --- 正常系テスト ---
    it('Controllerが正しくServiceを呼び、正しい戻り値を返すか', async () => {
      // 3) dto の改変をしないこと（必要なら）
      //    - signUp 呼び出し前後で dto が変更されていないことを確認（オブジェクトの一部を検査）
      const before = structuredClone(dto);

      // 1) service.signUp の戻り値（例: user or { id, email, ... }）をそのまま返すこと
      //    - mockResolvedValueOnce した値と toEqual / toMatchObject で一致確認
      (service.signUp as jest.Mock).mockResolvedValueOnce(user);
      const result = await controller.signUp(dto);
      expect(result).toEqual(expect.objectContaining(user));

      // 2) controller.signUp(dto) を呼ぶと、service.signUp が一度だけ呼ばれること
      //    - 引数が dto（そのままの参照 or 値）であることを toHaveBeenCalledWith で確認
      //    - 呼び出し回数 toHaveBeenCalledTimes(1)
      expect(service.signUp).toHaveBeenCalledWith(
        expect.objectContaining({
          name: 'dummy',
          email: 'test@dummy.com',
          password: 'dummy123',
          confirmPassword: 'dummy123',
          imageId: '5d78f017-ef80-fbbf-3aad-f3f5d6c10043',
          introduction: 'Hello, Elden',
        }),
      );
      expect(service.signUp).toHaveBeenCalledTimes(1);

      // 3) dto の改変をしないこと（必要なら）
      //    - signUp 呼び出し前後で dto が変更されていないことを確認（オブジェクトの一部を検査）
      expect(dto).toEqual(before);
    });

    // 異常系テスト
    it('service.signUpの例外（ForbiddenExceptionなど）と同じ例外を返すか', async () => {
      // 4) service.signUp が ForbiddenException を投げた場合
      //    - controller.signUp も同じ例外を reject すること（rejects.toThrow(ForbiddenException)）
      //    - メッセージが一致するならメッセージも確認
      (service.signUp as jest.Mock).mockRejectedValue(
        new ForbiddenException('このメールアドレスは既に登録されています'),
      );
      await expect(controller.signUp(dto)).rejects.toThrow(
        'このメールアドレスは既に登録されています',
      );
      // 6) 異常時に余計な呼び出しが発生していないこと（必要なら）
      //    - 失敗後に他のメソッドが呼ばれていないことを確認（今回は signUp だけなので回数確認で十分）
      expect(service.signUp).toHaveBeenCalledTimes(1);
    });

    it('service.signUp が汎用的な Error を投げた場合、 controller.signUp も同じエラーをそのまま投げるか', async () => {
      // 5) service.signUp が汎用的な Error を投げた場合
      //    - controller.signUp も同じエラーをそのまま投げること（変換や握りつぶしをしない）
      (service.signUp as jest.Mock).mockRejectedValue(new Error('DB error'));
      await expect(controller.signUp(dto)).rejects.toThrow('DB error');
      // 6) 異常時に余計な呼び出しが発生していないこと（必要なら）
      //    - 失敗後に他のメソッドが呼ばれていないことを確認（今回は signUp だけなので回数確認で十分）
      expect(service.signUp).toHaveBeenCalledTimes(1);
    });

    // 追加観点
    // 7) 返却 shape の柔軟性（toMatchObject で主要項目だけ確認）
    it('Service が追加フィールドを返しても Controller は素通しで返すか', async () => {
      (service.signUp as jest.Mock).mockResolvedValue({
        id: 1,
        name: dto.name,
        email: dto.email,
        imageId: dto.imageId,
        introduction: dto.introduction,
        hashedPassword: 'hashed',
        imageUrl: null,
        createdAt: now,
        updatedAt: now,
        // 以下の余計なフィールドを含めてモックする
        extra: 'extra',
      });
      const result = await controller.signUp(dto);
      expect(result).toMatchObject(user);
      expect(result).toHaveProperty('extra', 'extra');
    });

    // 8) デコレーターの存在確認（軽め）
    it("@Post('signup') が付いているか", async () => {
      // AuthController.prototype から signUp メソッドを参照
      const target = AuthController.prototype;
      const propertyKey = 'signUp';

      // Reflect.getMetadata を使って Nest が定義しているメタデータを取得
      const routePath = Reflect.getMetadata(PATH_METADATA, target[propertyKey]);
      const requestMethod = Reflect.getMetadata(
        METHOD_METADATA,
        target[propertyKey],
      );

      // パスが'signup'であることを確認
      expect(routePath).toBe('signup');
      // HTTPメソッドが POST であることを確認
      expect(requestMethod).toBe(RequestMethod.POST);
    });

    // 8) デコレーターの存在確認（軽め）
    it("@Controller('api/auth')が付いているか", async () => {
      // クラスレベルの PATH=METADATA を取得
      const controllerPath = Reflect.getMetadata(PATH_METADATA, AuthController);

      // 'api/auth'であることを確認
      expect(controllerPath).toBe('api/auth');
    });
  });
});

$ npm run test