describe('AuthController (e2e)', () => {
   //e2e test에 사용될 backend app 및 service 객체 선언

  beforeAll(async () => {
    // 테스트 전
    // 테스트 프레임워크 환경 구축
    // backend app 환경 구축
  })

  afterAll(async () => {
    // 테스트 종료 후
    // db 연결 종료, app 종료
  })

  it('<url> <Method> : <Scenario>  ', async () => {
      //1.Arrange
      // 테스트 환경 설정 단계. ex) db 데이터 삽입, 서비스 또는 시스템 상태 설정, dto 생성, 클라이언트 상태 설정 ...

      //2.Act
      // 테스트 수행 단계. ex) http api 요청, 서비스 로직 호출 ...

      //3.Assert
      //validate response like status,body data, body schema ... etc
      //Or validate db Records
      //테스트 결과 검증. ex) http 응답 데이터( 바디, 상태, 헤더, 쿠기 등) 검증, DB entity(record) 검증, 시스템 상태 검증
  })

  	it('/auth/sign-in (POST) : 성공  ', async () => {
      //1.Arrange
      create user for test

      //2.Act
		const res = await client.POST(ApiPaths.AuthController_signin, {
			params: {
				header: {
					authorization: testService.getBasicAuthCredential(
						user.email,
						user.password,
					),
				},
			},
		});

      //3.Assert
		expect(res.response.status).toBe(HttpStatus.CREATED);
		const body = res.data;

		expect(body).toBeTruthy();
		expect(body!.user.id).toBe(userStub.id);

		expectResponseBody(zSignInResponse, body);

	});

   it('/auth/sign-in (POST) : (실패, 유효치 않은 비밀번호)  ', async () => {

      //1.Arrange
      create user for test
      const invalidPW = user.password + '12';

      //2.Act
      const res = await client.POST(ApiPaths.AuthController_signin, {
			params: {
				header: {
					authorization: testService.getBasicAuthCredential(
						user.email,
                  invalidPW,
					),
				},
			},
		});

      //3.Assert
		expect(res.response.status).toBe(HttpStatus.UNAUTHORIZED);
   })

   it('/auth/sign-in (POST) : (실패, 생성되지 않은 계정)  ', async () => {
      //1.Arrange
      const notExistEmail = faker.internet.email();
      const invalidPW = '12';


      //2.Act
      const res = await client.POST(ApiPaths.AuthController_signin, {
			params: {
				header: {
					authorization: testService.getBasicAuthCredential(
						notExistEmail,
						invalidPW
					),
				},
			},
		});

      //3.Assert
		expect(res.response.status).toBe(HttpStatus.UNAUTHORIZED);
   })
})

describe('AuthController (e2e)', () => {
   //e2e test에 사용될 backend app 및 service 객체 선언

  beforeAll(async () => {
    // 테스트 전
    // 테스트 프레임워크 환경 구축
    // backend app 환경 구축
  })

  afterAll(async () => {
    // 테스트 종료 후
    // db 연결 종료, app 종료
  })

   // Http API 기준으로 테스트 그룹화
   describe('/auth/sign-in (POST)',()=>{

      // 공통 로직 정의
      async function seedUser(){
         create user for test

         return user;
      }

      async function requestAuthSignIn( email : string, password : string){
         const res = await client.POST(ApiPaths.AuthController_signin, {
            params: {
               header: {
                  authorization: testService.getBasicAuthCredential(
                     email,
                     password,
                  ),
               },
            },
         });
         return res;
      }

      it('성공 ', async () => {
         //1.Arrange
         const user = await seedUser();
         const {email, password } = user;

         //2.Act
         const res = await requestAuthSignIn(email,password );

         //3.Assert
         expect(res.response.status).toBe(HttpStatus.CREATED);
         const body = res.data;

         expect(body).toBeTruthy();
         expect(body!.user.id).toBe(userStub.id);

         expectResponseBody(zSignInResponse, body);

      });

      it('실패, 유효치 않은 비밀번호', async () => {

         //1.Arrange
         const user = await seedUser();
         const invalidPW = user.password + '12';
         const { email } = user;

         //2.Act
         const res = await requestAuthSignIn(email,invalidPW);

         //3.Assert
         expect(res.response.status).toBe(HttpStatus.UNAUTHORIZED);
      })

      it('실패, 생성되지 않은 계정', async () => {
         //1.Arrange
         const invalidPW = '12';
         const notExistEmail = faker.internet.email();

         //2.Act
         const res = await requestAuthSignIn(notExistEmail,invalidPW);

         //3.Assert
         expect(res.response.status).toBe(HttpStatus.UNAUTHORIZED);
      })
   });
})

describe('AuthController (e2e)', () => {
  ...

   // Http API 기준으로 테스트 그룹화
   describe('/auth/sign-in (POST)',()=>{

      let user : User

      //Test Collection 단계 이후에 실행됨
      beforeAll(async()=>{
         user = await seedUser();
      });
      ....

      //test case
      it.each([
         {testName : '유효치 않은 비밀번호' ,email : user.email, password : user.password},
         //실제로는 user === undefined
         {testName : '유효치 않은 비밀번호' ,email : undefined.email, password : undefined.password}, // (1) undefined 참조 에러 발생
         //
         {testName : '생성되지 않은 계정' ,email : faker.internet.email(), password : '12'},

      ])('실패, UNAUTHORIZED 상태 응답 수신 : $testName', async ({email, password }) => {

         //2.Act
         const res = await requestAuthSignIn(email,password);

         //3.Assert
         expect(res.response.status).toBe(HttpStatus.UNAUTHORIZED);
      })

   });
})

describe('AuthController (e2e)', () => {
  ...

   // Http API 기준으로 테스트 그룹화
   describe('/auth/sign-in (POST)',()=>{

      describe('실패, UNAUTHORIZED 상태 응답 수신' , ()=>{

         //
         const userStub = factoryUserStub();
         const deletedUserStub = factoryUserStub();

         beforeAll(async () =>{
            //1. Arrange-1 : 유저 생성

            await testService.insertUser(userStub);

            //1. Arrange-2 : 유저 삭제
            const user = await testService.insertUser(userStub);
            await userService.delete(user);
         });

         it.each([
            {testName : '유효치 않은 비밀번호' ,email : userStub.email, password : userStub.password},
            {testName : '생성되지 않은 계정' ,email : faker.internet.email(), password : '12'},
            {testName : '삭제된 계정' ,email : deletedUserStub.email, password : deletedUserStub.password}, // 새로운 테스트 케이스 추가

         ])('test: $testName', async ({email, password }) => {

            //2.Act
            const res = await requestAuthSignIn(email,password);

            //3.Assert
            expect(res.response.status).toBe(HttpStatus.UNAUTHORIZED);
         })
      });

   });
})

describe('<e2e test description >', () => {
  ...

   // Http API 기준으로 테스트 그룹화
   describe('<url> <METHOD>',()=>{

      //Arrange, Act, Assert에서 사용할 로직 정의.
      async function setTestScenario(){}

      async function requestHttpApi(){}

      async function readEntity(){}
      async function expectResponseBody(){}

      // 테스트 시나리오 기준으로 테스트 케이스 그룹화
      describe('<test scenario description>' , ()=>{
         // test case로 전달한 데이터 정의
         const dataStub1 = factoryDataStub();
         const dataStub2 = factoryDataStub();

         // 또는 해당 시나리오의 Arrange, Act, Assert에서 사용할 변수, 함수 정의
         async function setTestCase1(){}
         async function setTestCase2(){}

         async function expectServiceStatus(){};

         //test 환경 설정
         beforeAll(async () =>{
            //1. Arrange-1 : 테스트 케이스 1을 위한 환경 동작
            await setTestCase1(dataStub1);

            //1. Arrange-2 : 테스트 케이스 2을 위한 환경 조성
            await setTestCase2(dataStub2);

         });

         describe.each([
            {testName : '테스트 케이스 1' , data : dataStub1},
            {testName : '테스트 케이스 2' , data : dataStub2},

         ])('test: $testName', async ({data }) => {
            //Assert에서 사용할 공유 변수만 정의
            let receivedRes : Awaited<ReturnType<typeof requestAuthSignIn>>;

            beforeAll(async ()=>{
               //2.Act
               receivedRes = await requestHttpApi(email,password);
            });

            it("response should match openapi spec",async ()=>{
               //3.Assert-1
               const receivedStatus = received.status;
               const expectedStatus = 200;

               expect(receivedStatus).toBe(expectedStatus);
               const receivedBody = receivedRes.body;
               await expectResponseBody(receivedBody);
            });

            it("db entities should not changed",async ()=>{
               //3.Assert-2

               const receivedEntity = await readEntity(data);
               const expectedEntity = null;
               expect(receivedEntity).toBe(expectedEntity);

            });

            it("service status should updated",async ()=>{
               //3.Assert-3
               await expectServiceStatus();

            });
         })
      });

   });
})