Functional Testing

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

// Jest와 Supertest를 사용한 사용자 생성 API 테스트
const request = require('supertest');
const app = require('../app');

describe('사용자 API 기능 테스트', () => {
  // 유효한 데이터로 사용자 생성 테스트
  test('유효한 데이터로 사용자 생성 시 201 상태코드와 생성된 사용자 정보를 반환해야 함', async () => {
    const userData = {
      username: 'testuser',
      email: 'test@example.com',
      password: 'Password123!'
    };
    
    const response = await request(app)
      .post('/api/users')
      .send(userData)
      .expect('Content-Type', /json/)
      .expect(201);
    
    // 응답 본문 검증
    expect(response.body).toHaveProperty('id');
    expect(response.body.username).toBe(userData.username);
    expect(response.body.email).toBe(userData.email);
    // 비밀번호는 응답에 포함되지 않아야 함
    expect(response.body).not.toHaveProperty('password');
  });
  
  // 이미 존재하는 이메일로 사용자 생성 테스트
  test('이미 존재하는 이메일로 사용자 생성 시 409 상태코드를 반환해야 함', async () => {
    // 먼저 사용자 생성
    const userData = {
      username: 'existinguser',
      email: 'existing@example.com',
      password: 'Password123!'
    };
    
    await request(app)
      .post('/api/users')
      .send(userData);
    
    // 같은 이메일로 다시 생성 시도
    const response = await request(app)
      .post('/api/users')
      .send(userData)
      .expect('Content-Type', /json/)
      .expect(409);
    
    // 오류 메시지 검증
    expect(response.body).toHaveProperty('error');
    expect(response.body.error).toContain('already exists');
  });
  
  // 유효하지 않은 이메일 형식 테스트
  test('유효하지 않은 이메일 형식으로 사용자 생성 시 400 상태코드를 반환해야 함', async () => {
    const userData = {
      username: 'invaliduser',
      email: 'invalid-email',  // 잘못된 이메일 형식
      password: 'Password123!'
    };
    
    const response = await request(app)
      .post('/api/users')
      .send(userData)
      .expect('Content-Type', /json/)
      .expect(400);
    
    // 오류 메시지 검증
    expect(response.body).toHaveProperty('error');
    expect(response.body.error).toContain('email');
  });
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

// Jest와 Apollo Server Testing을 사용한 GraphQL API 테스트
const { createTestClient } = require('apollo-server-testing');
const { ApolloServer, gql } = require('apollo-server');
const { typeDefs, resolvers } = require('../schema');

describe('상품 GraphQL API 기능 테스트', () => {
  let query, mutate;
  
  beforeAll(() => {
    // 테스트용 Apollo 서버 설정
    const server = new ApolloServer({
      typeDefs,
      resolvers,
      context: () => ({ currentUser: { id: 'admin', role: 'ADMIN' } })
    });
    
    const testClient = createTestClient(server);
    query = testClient.query;
    mutate = testClient.mutate;
  });
  
  // 상품 조회 테스트
  test('ID로 상품을 조회할 수 있어야 함', async () => {
    const GET_PRODUCT = gql`
      query GetProduct($id: ID!) {
        product(id: $id) {
          id
          name
          price
          description
          category
        }
      }
    `;
    
    // 기존 상품 ID로 조회
    const response = await query({
      query: GET_PRODUCT,
      variables: { id: 'product-1' }
    });
    
    // 응답 검증
    expect(response.errors).toBeUndefined();
    expect(response.data.product).toBeDefined();
    expect(response.data.product.id).toBe('product-1');
    expect(response.data.product.name).toBeDefined();
    expect(response.data.product.price).toBeGreaterThan(0);
  });
  
  // 상품 생성 테스트
  test('새 상품을 생성할 수 있어야 함', async () => {
    const CREATE_PRODUCT = gql`
      mutation CreateProduct($input: ProductInput!) {
        createProduct(input: $input) {
          id
          name
          price
          description
          category
        }
      }
    `;
    
    const newProduct = {
      name: '새 상품',
      price: 1000,
      description: '새로운 테스트 상품입니다',
      category: 'TEST'
    };
    
    const response = await mutate({
      mutation: CREATE_PRODUCT,
      variables: { input: newProduct }
    });
    
    // 응답 검증
    expect(response.errors).toBeUndefined();
    expect(response.data.createProduct).toBeDefined();
    expect(response.data.createProduct.id).toBeDefined();
    expect(response.data.createProduct.name).toBe(newProduct.name);
    expect(response.data.createProduct.price).toBe(newProduct.price);
  });
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

// gRPC API 테스트 예제 (Node.js)
const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');
const { expect } = require('chai');

// Proto 파일 로드
const packageDefinition = protoLoader.loadSync('path/to/inventory.proto');
const inventoryProto = grpc.loadPackageDefinition(packageDefinition).inventory;

describe('재고 gRPC API 기능 테스트', () => {
  let client;
  
  before(() => {
    // gRPC 클라이언트 설정
    client = new inventoryProto.InventoryService(
      'localhost:50051',
      grpc.credentials.createInsecure()
    );
  });
  
  // 상품 재고 조회 테스트
  it('상품 ID로 재고를 조회할 수 있어야 함', (done) => {
    client.getStock({ productId: 'product-1' }, (err, response) => {
      expect(err).to.be.null;
      expect(response).to.have.property('quantity');
      expect(response.quantity).to.be.a('number');
      done();
    });
  });
  
  // 재고 업데이트 테스트
  it('상품 재고를 업데이트할 수 있어야 함', (done) => {
    const newQuantity = 100;
    
    client.updateStock({
      productId: 'product-1',
      quantity: newQuantity
    }, (err, response) => {
      expect(err).to.be.null;
      expect(response).to.have.property('success');
      expect(response.success).to.be.true;
      
      // 업데이트된 재고 확인
      client.getStock({ productId: 'product-1' }, (err, response) => {
        expect(err).to.be.null;
        expect(response.quantity).to.equal(newQuantity);
        done();
      });
    });
  });
  
  // 존재하지 않는 상품 재고 조회 테스트
  it('존재하지 않는 상품 ID로 재고 조회 시 오류를 반환해야 함', (done) => {
    client.getStock({ productId: 'non-existent' }, (err, response) => {
      expect(err).to.not.be.null;
      expect(err.code).to.equal(grpc.status.NOT_FOUND);
      done();
    });
  });
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// Postman 테스트 스크립트 예제
pm.test("상태 코드는 200이어야 함", function () {
    pm.response.to.have.status(200);
});

pm.test("응답 시간은 500ms 이하여야 함", function () {
    pm.expect(pm.response.responseTime).to.be.below(500);
});

pm.test("응답에 필수 필드가 있어야 함", function () {
    const responseData = pm.response.json();
    pm.expect(responseData).to.have.property('id');
    pm.expect(responseData).to.have.property('name');
    pm.expect(responseData).to.have.property('price');
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// REST Assured 테스트 예제
@Test
public void testGetUser() {
    given()
        .pathParam("id", 1)
    .when()
        .get("/api/users/{id}")
    .then()
        .statusCode(200)
        .contentType(ContentType.JSON)
        .body("id", equalTo(1))
        .body("name", notNullValue())
        .body("email", matchesPattern("^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,6}$"));
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

// 비동기 API 테스트 예제 (JavaScript)
test('비동기 주문 처리 테스트', async () => {
  // 주문 생성 요청
  const orderResponse = await request(app)
    .post('/api/orders')
    .send({ productId: 'product-1', quantity: 2 })
    .expect(202); // 비동기 처리를 위한 Accepted 상태코드
  
  const orderId = orderResponse.body.orderId;
  
  // 주문 처리 완료까지 폴링
  let orderStatus = 'PROCESSING';
  let attempts = 0;
  const maxAttempts = 10;
  
  while (orderStatus === 'PROCESSING' && attempts < maxAttempts) {
    await new Promise(resolve => setTimeout(resolve, 500)); // 0.5초 대기
    
    const statusResponse = await request(app)
      .get(`/api/orders/${orderId}/status`)
      .expect(200);
    
    orderStatus = statusResponse.body.status;
    attempts++;
  }
  
  expect(orderStatus).toBe('COMPLETED');
  
  // 완료된 주문 검증
  const orderDetails = await request(app)
    .get(`/api/orders/${orderId}`)
    .expect(200);
  
  expect(orderDetails.body.status).toBe('COMPLETED');
  expect(orderDetails.body.items).toHaveLength(1);
  expect(orderDetails.body.items[0].productId).toBe('product-1');
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// Swagger 기반 API 테스트 자동 생성 예제 (openapi-validator 사용)
const { expect } = require('chai');
const OpenApiValidator = require('openapi-validator').default;

describe('API 계약 기반 기능 테스트', () => {
  let validator;
  
  before(() => {
    validator = new OpenApiValidator({
      apiSpec: './openapi.yaml'
    });
  });
  
  it('사용자 생성 API가 명세를 준수해야 함', async () => {
    const response = await request(app)
      .post('/api/users')
      .send({
        username: 'testuser',
        email: 'test@example.com',
        password: 'Password123!'
      });
    
    expect(validator.validateResponse(
      response.statusCode,
      response.body,
      '/api/users',
      'post'
    )).to.be.undefined;
  });
});