使用chai-http与mocha-chai进行测试期间的UnhandledPromiseRejectionWarning

Question

做我的第一个Express应用程序，我试图编写一个针对api端点的测试，并使用数据结构作为数据库的占位符，但是即使测试通过了，也仍然在控制台中出现错误，如图所示。 '

  import chai from 'chai';
import { app } from '../app';
import http from 'chai-http';

let expect = chai.expect;
  
  //test I am having problems with
  it('should get a single todo at "/api/v1/todos/:id" with GET/id', () => {
    return chai
      .request(app)
      .post('/api/v1/todos')
      .send({ title: 'Breakfast', description: 'Breakfast alone' })
      .then(resPost => {
        expect(resPost).to.have.status(201);
        chai
          .request(app)
          .get('/api/v1/todos/2')
          .then(res => {
            expect(res).to.have.status(200);
            expect(res).to.be.json;
            expect(res.body).to.be.an('object');
            expect(res.body)
              .to.have.property('success')
              .eql('true');
            expect(res.body)
              .to.have.property('message')
              .equal('todo retrieved successfully');
            expect(res.body.todo).to.be.an('object');
            expect(res.body.todo)
              .to.have.property('id')
              .equal(1);
            expect(res.body.todo)
              .to.have.property('title')
              .equal('Breakfast');
            expect(res.body.todo)
              .to.have.property('description')
              .equal('Breakfast alone');
          });
      });
  });



//api endpoints
//import and define express framework
import express from 'express';

import todoController from '../todoControllers/todo';

//create router handler
const router = express.Router();

router.get('/api/v1/todos', todoController.getAllTodos);
router.get('api/v1/todos/:id', todoController.getTodo);
router.post('/api/v1/todos', todoController.createTodo);
router.put('/api/v1/todos/:id', todoController.updateTodo);
router.delete('/api/v1/todos/:id', todoController.deleteTodo);

export default router;

//controllers for api endpoints
import db from '../db/db';

class todosController {
  getAllTodos(req, res) {
    return res.status(200).send({
      success: 'true',
      message: 'todos retrieved successfully',
      todos: db
    });
  }

  getTodo(req, res) {
    const id = parseInt(req.params.id, 10);
    db.map(todo => {
      if (todo.id === id) {
        return res.status(200).send({
          success: 'true',
          message: 'todo retrieved successfully',
          todo
        });
      }
    });
    return res.status(400).send({
      success: 'false',
      message: 'todo does not exist'
    });
  }

  createTodo(req, res) {
    if (!req.body.title) {
      return res.status(400).send({
        success: 'false',
        message: 'title is required'
      });
    } else if (!req.body.description) {
      return res.status(400).send({
        success: 'false',
        message: 'description is required'
      });
    }

    const todo = {
      id: db.length + 1,
      title: req.body.title,
      description: req.body.description
    };

    db.push(todo);
    return res.status(201).send({
      success: 'true',
      message: 'todo added successfully',
      todo
    });
  }

  updateTodo(req, res) {
    const id = parseInt(req.params.id, 10);
    let todoFound;
    let itemIndex;
    db.map((todo, index) => {
      if (todo.id === id) {
        todoFound = todo;
        itemIndex = index;
      }
    });

    if (!todoFound) {
      return res.status(404).send({
        success: 'true',
        message: 'todo not found'
      });
    }

    if (!req.body.title) {
      return res.status(400).send({
        success: 'false',
        message: 'title is required'
      });
    } else if (!req.body.description) {
      return res.status(400).send({
        success: 'false',
        message: 'description is required'
      });
    }

    const editedTodo = {
      // @ts-ignore
      id: todoFound.id,
      // @ts-ignore
      title: req.body.title || todoFound.title,
      // @ts-ignore
      description: req.body.description || todoFound.description
    };

    db.splice(itemIndex, 1, editedTodo);

    return res.status(200).send({
      success: 'true',
      message: 'todo updated successfully',
      editedTodo
    });
  }

  deleteTodo(req, res) {
    const id = parseInt(req.params.id, 10);
    let todoFound;
    let itemIndex;
    db.map((todo, index) => {
      if (todo.id === id) {
        todoFound = todo;
        itemIndex = index;
      }
    });

    if (!todoFound) {
      return res.status(404).send({
        success: 'true',
        message: 'todo not found'
      });
    }

    db.splice(itemIndex, 1);

    return res.status(200).send({
      success: 'true',
      message: 'todo deleted successfully'
    });
  }
}

const todoController = new todosController();
export default todoController;

//place-holder database in the form of datasctructures


const todos = [
  {
    id: 1,
    title: 'lunch',
    description: 'Go for lunch by 2pm'
  }
];

//Creating module from data structure and exposing it to be used by parts of the server
export default todos;

//tests written so far including the initial snippet
import chai from 'chai';
import { app } from '../app';
import http from 'chai-http';
import db from '../db/db';

let expect = chai.expect;


chai.use(http);

describe('Test all todo endpoints at "/api/v1/todos and "/api/v1/todo/:id" with (GET, POST, GET/id, PUT)', () => {
  before(() => {});
  after(() => {});

  //GET all todos
  it('should get all todos at "/ap1/v1/todos" with GET', () => {
    return chai
      .request(app)
      .get('/api/v1/todos')
      .then(res => {
        expect(res).to.have.status(200);
        expect(res).to.be.json;
        expect(res.body).to.be.an('object');
        expect(res.body)
          .to.have.property('success')
          .eql('true');
        expect(res.body)
          .to.have.property('message')
          .eql('todos retrieved successfully');
        expect(res.body.todos).to.be.an('array');
        expect(
          res.body.todos[Math.floor(Math.random() * res.body.todos.length)]
        ).to.have.property('id' && 'title' && 'description');
      });
  });

  //POST a todo
  it('should add a todo at "/api/v1/todos" with POST', () => {
    return chai
      .request(app)
      .post('/api/v1/todos')
      .send({ title: 'Dinner', description: 'Dinner with bae' })
      .then(res => {
        expect(res).to.have.status(201);
        expect(res).to.be.json;
        expect(res.body).to.be.an('object');
        expect(res.body)
          .to.have.property('success')
          .eql('true');
        expect(res.body)
          .to.have.property('message')
          .equal('todo added successfully');
        expect(res.body.todo).to.be.an('object');
        expect(res.body.todo)
          .to.have.property('id')
          .equal(db.length);
        expect(res.body.todo)
          .to.have.property('title')
          .equal('Dinner');
        expect(res.body.todo)
          .to.have.property('description')
          .equal('Dinner with bae');
      });
  });

  //corrected test still giving an 'AssertionError'
  it('should get a single todo at "/api/v1/todos/:id" with GET/id', () => {
    return chai
      .request(app)
      .post('/api/v1/todos')
      .send({ title: 'Breakfast', description: 'Breakfast alone' })
      .then(resPost => {
        expect(resPost).to.have.status(201);
        return chai
          .request(app)
          .get('/api/v1/todos/2')
          .then(res => {
            expect(res).to.have.status(200);
            expect(res).to.be.json;
            expect(res.body).to.be.an('object');
            expect(res.body)
              .to.have.property('success')
              .eql('true');
            expect(res.body)
              .to.have.property('message')
              .equal('todo retrieved successfully');
            expect(res.body.todo).to.be.an('object');
            expect(res.body.todo)
              .to.have.property('id')
              .equal(1);
            expect(res.body.todo)
              .to.have.property('title')
              .equal('Breakfast');
            expect(res.body.todo)
              .to.have.property('description')
              .equal('Breakfast alone');
          });
      });
  });
});

有人可以解释为什么吗？  附注：我更新了问题，以显示数据库的api端点，测试和占位符，从本质上讲，我需要有关如何处理涉及ID和ID的请求的提示。

Answer 1

您有两个问题：

尽管您遇到断言错误，您的测试也不会失败

这是因为在第14行中您缺少return。由于您在第12行中注册的函数不会返回任何内容，因此Promise会解决。结果，您返回到第8行的promise也得以解决，并且您的测试也没有失败，尽管应该成功。

由于您不返回被拒绝的承诺，因此不会传播错误。这就是为什么您收到错误消息的原因。

断言错误本身

您正在创建资源，然后假设该资源的ID为2，然后请求该资源。您将收到404响应，这意味着该资源根本没有创建，或者它具有不同的ID。

在创建资源时，您会以某种方式为其分配一个ID（看起来您只是为此使用了一个计数器，但是我无法确定是否看到您的实现）。 POST响应应提供有关此ID的一些信息。理想情况下，它将id作为Location标头发送，但通常将完整创建的资源作为响应正文发送。因此，在发出GET请求之前，您需要从POST响应中提取ID。