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
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209

const productController = require("../../controller/product");
const productModel = require('../../models/Product')
const httpMocks = require('node-mocks-http')
const newProduct = require('../data/new-product.json')
const {Promise} = require("mongoose");

//단위테스트이기 때문에 의존성이 있는 것을 mock function으로 만들어준다.
//이 함수가 뭘 사용하는지 어떤것을 리턴하는지 추적이 가능해진다.
productModel.create = jest.fn();
productModel.find = jest.fn();
productModel.findById = jest.fn();
productModel.findByIdAndUpdate = jest.fn();

//전역으로 쓰일 변수이기 때문에 다음과 같이 선언해준다.
let req, res, next;

const productId = '618761fd1febbe2fe466a211';

//각 test마다 공통적으로 쓰이는 부분이기에 beforeEach를 사용하여 처리한다.
beforeEach(() => {
    req = httpMocks.createRequest();
    res = httpMocks.createResponse();
    next = jest.fn();
})

describe("Product Controller Create", () => {

    beforeEach(() => {
        req.body = newProduct;
    })

    it('should have a createProduct function', () => {
        expect(typeof productController.createProduct).toBe("function");
    });

    it('should call ProductModel.create', async () => {
        req.body = newProduct;
        await productController.createProduct(req, res, next);
        expect(productModel.create).toBeCalledWith(newProduct);
    })

    it('should return 201 response code', async () => {
        await productController.createProduct(req, res, next);
        expect(res.statusCode).toBe(201);
        //값이 무엇인지 신경 쓰지 않고 Boolean 컨텍스트에서 값이 참인지 확인
        expect(res._isEndCalled()).toBeTruthy();
    })

    it('should return json body in response', async () => {
        productModel.create.mockReturnValue(newProduct)
        await productController.createProduct(req, res, next);
        expect(res._getJSONData()).toStrictEqual(newProduct)
    })

    it('should handle errors', async () => {
        //에러메시지 선언
        const errorMessage = {message : 'description property missing'};
        //Promise.reject(reason) 메서드는 주어진 이유(reason)로 거부된 Promise 객체를 반환
        //따라서 아래의 코드는 errorMessage를 이유로 reject된 상황을 만들기위함이다.
        const rejectedPromise = Promise.reject(errorMessage);
        //위 상황으로 returnValue를 만들어준다.
        productModel.create.mockReturnValue(rejectedPromise);
        //아래 메소드를 실행하면 create에서 위의 에러가 발생할 것이다.
        await productController.createProduct(req,res,next);
        //해당 에러메시지가 발생하였는지 확인한다.
        expect(next).toBeCalledWith(errorMessage);
    });
});

describe("Product Controller Get", () => {
    it('should have a getProducts function', function () {
        expect(typeof productController.getProducts).toBe("function");
    });

    it('should call ProductModel.find({})', async () => {
        await productController.getProducts(req,res,next);
        expect(productModel.find).toHaveBeenCalledWith({})
    });

    it('should return 200 response',async function () {
        await productController.getProducts(req,res,next);
        expect(res.statusCode).toBe(200);
        //값이 무엇인지 신경 쓰지 않고 Boolean 컨텍스트에서 값이 참인지 확인
        expect(res._isEndCalled).toBeTruthy()
    });

    // it('should return json boyd in response',async function () {
    //     productModel.find.mockReturnValue()
    // });

    it('should handle errors', async function () {
        const errorMessage = {message : "Error finding product data"};
        const rejectedPromise = Promise.reject(errorMessage);
        productModel.find.mockReturnValue(rejectedPromise);
        await productController.getProducts(req,res,next);
        expect(next).toBeCalledWith(errorMessage);
    });
})

describe('Product Controller GetById', () => {
    it('should have a getProductById', function () {
        expect(typeof productController.getProductById).toBe("function");
    });
    it('should call productModel findById', async function () {
        req.params.productId = productId;
        await productController.getProductById(req,res,next);
        expect(productModel.findById).toBeCalledWith(productId)
    });
    it('should return json body and response code 200', async function () {
        productModel.findById.mockReturnValue(newProduct);
        await productController.getProductById(req,res,next);
        expect(res.statusCode).toBe(200)
        expect(res._getJSONData()).toStrictEqual(newProduct);
        expect(res._isEndCalled()).toBeTruthy();
    });
    it('should return 404 when item doesnt exist', async function () {
        productModel.findById.mockReturnValue(null);
        await productController.getProductById(req,res,next);
        expect(res.statusCode).toBe(404);
        expect(res._isEndCalled()).toBeTruthy();
    });
    it('should handle errors', async function () {
        const errorMessage = {message : 'error'};
        const rejectPromise = Promise.reject(errorMessage);
        productModel.findById.mockReturnValue(rejectPromise);
        await productController.getProductById(req,res,next);
        expect(next).toHaveBeenCalledWith(errorMessage);
    });
})

describe('Product Controller Update',() => {
    it('should have an updateProduct function', function () {
        expect(typeof productController.updateProduct).toBe("function");
    });

    it('should call productModel findByIdAndUpadte', async () => {
        //검색할 아이디를 선언한다.
        req.params.productId = productId;
        //업데이트할 객체와 option을 선언한다.
        //option은 리턴하는 객체가 업데이트 되기전 객체인지 새로운 객체인지를 결정하는 것이다. true를 입력하였으므로 업데이트 된 객체를 리턴한다.
        req.body = {name:"updated name"},{new : true};
        await productController.updateProduct(req,res,next);
        expect(productModel.findByIdAndUpdate).toHaveBeenCalledWith(productId,{name:"updated name"},{new : true})
    })

    it('should return json body and response code 200', async function () {
        req.params.productId = productId;
        req.body = {name:"updated name",description: "updated description"};
        productModel.findByIdAndUpdate.mockReturnValue({name:"updated name",description: "updated description"})
        await productController.updateProduct(req,res,next);
        expect(res._isEndCalled()).toBeTruthy();
        expect(res.statusCode).toBe(200);
        expect(res._getJSONData()).toStrictEqual({name:"updated name",description: "updated description"});
    });

    it('should handle 404 when item doesnt exist',async function () {
        productModel.findByIdAndUpdate.mockReturnValue(null);
        await productController.updateProduct(req,res,next);
        expect(res.statusCode).toBe(404);
        expect(res._isEndCalled()).toBeTruthy();
    });

    it('should handle errors',async function () {
        const errorMessage = {"message" : "error"};
        const rejectPromise = Promise.reject(errorMessage);
        productModel.findByIdAndUpdate.mockReturnValue(rejectPromise);
        await productController.updateProduct(req,res,next);
        expect(next).toHaveBeenCalledWith(errorMessage);
    });
})

describe('Product Controller Delete', () => {
    it('should have a delete product funciton', function () {
        expect(typeof productController.deleteProduct).toBe("function");
    });

    it('should call productmodel.findByIdAndDelete',async function () {
        req.params.productId = productId;
        await productController.deleteProduct(req);
        expect(productModel.findByIdAndDelete).toBeCalledWith(productId);
    });

    it('should return 200 response', async function () {
        let deletedProduct = {
            name : "deleteProduct",
            description:  "test"
        }
        productModel.findByIdAndDelete.mockReturnValue(deletedProduct);
        await productController.deleteProduct(req,res,next);
        expect(res.statusCode).toBe(200);
        expect(res._getJSONData()).toStrictEqual(deletedProduct);
        expect(res._isEndCalled()).toBeTruthy();
    });

    it('should handle 404 when item doesnt exist', async function () {
        productModel.findByIdAndDelete.mockReturnValue(null);
        await productController.deleteProduct(req,res,next);
        expect(res.statusCode).toBe(404);
        expect(res._isEndCalled()).toBeTruthy();
    });

    it('should handle errors', async function () {
        const errorMessage = {message : "Error deleting"}
        const rejectPromise = Promise.reject(errorMessage);
        productModel.findByIdAndDelete.mockReturnValue(rejectPromise);
        await productController.deleteProduct(req,res,next);
        expect(next).toHaveBeenCalledWith(errorMessage);
    });
})

 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
84
85
86
87
88
89

//통합테스트를 위하여 supertest 사용
const request = require('supertest')
//통합테스트를 위한 server.js를 import한다.
const app = require('../../server');
const newProduct = require('../data/new-product.json');
const {response} = require("express");

const productId = '618761fd1febbe2fe466a211';


it('POST /api/products', async () => {
    //superttest에 server.js를 넣어줌
    const response = await request(app)
        .post('/api/products')
        .send(newProduct);
    expect(response.statusCode).toBe(201)
    expect(response.body.name).toBe(newProduct.name)
    expect(response.body.description).toBe(newProduct.description)
});

it('should error', async function () {
    const errorProduct = {
        "name" : "oh",
        "price" : 15
    };

    const response = await request(app)
        .post('/api/products')
        .send(errorProduct);
    expect(response.statusCode).toBe(500)
});

it('should return 500 on POST /api/products', async function () {
    const response = await request(app)
        .post('/api/products')
        .send({name : "name"})
    expect(response.statusCode).toBe(500)
    expect(response.body).toStrictEqual({message : 'Product validation failed: description: Path `description` is required.'})

});

// it('GET /api/products', async () =>{
//     const response = await request(app).get('/api/products');
//     expect(response.statusCode).toBe(200)
//     expect(Array.isArray(response.body)).toBeTruthy()
//     expect(response.body[0].name).toBeDefined();
//     expect(response.body[0].description).toBeDefined();
// });

it('GET /api/product/:productId', async function () {
    const response = await request(app).get(`/api/products/${productId}`)
    expect(response.statusCode).toBe(200)
    console.log(response)
});

it('GET id doesnt exist /api/products/:productId', async function () {
    //id값을 많이 바꾸면 mongodb자체에서 없는 id값이라고 404를 주기때문에 살짝만 바꿔줘야함
    const response = await request(app).get('/api/products/618761fd1f12be2fe466a211')
    expect(response.statusCode).toBe(404)
});

it("PUT /api/products", async () => {
    const res = await request(app)
        .put(`/api/products/${productId}`)
        .send({name : "updated name", description : "updated description"});
    expect(res.statusCode).toBe(200)
    expect(res.body.name).toBe("updated name");
})

it('should return 404 on PUT /api/products', async function () {
    const res = await request(app)
        .put(`/api/products/618761fd1febbe2fe466a312`)
        .send({name : "updated name", description : "updated description"});
    expect(res.statusCode).toBe(404)
});

it('DELETE /api/products', async function () {
    const res = await request(app)
        .delete(`/api/products/${productId}` )
        .send();
    expect(res.statusCode).toBe(200);
});

it('DELETE id doesnt exit /api/products/:productId', async function () {
    const res = await request(app)
        .delete("/api/products/123123123123")
        .send();
    expect(res.statusCode).toBe(404);
});