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

Question

在我的第一个快速应用程序中，我试图为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');
          });
      });
  });
});

​

谁能解释一下原因吗？P.S :我更新了这个问题，以显示我的api端点、测试和数据库的位置保持器，实际上我需要关于如何处理涉及和id的请求的提示。

Answer 1

你有两个问题：

您的测试不会失败，尽管您得到了断言错误。

这是因为在第14行中，您缺少了一个return。由于您在第12行中注册的函数不返回任何内容，承诺就会解决。因此，您在第8行中返回的承诺也会得到解决，并且您的测试不会失败，尽管它应该会失败。

因为您没有返回被拒绝的承诺，所以错误不会被传播。这就是为什么你会收到错误信息。

断言错误本身

您正在创建一个资源，然后假设其id为2，然后请求该资源。您将得到一个404响应，这意味着要么根本没有创建该资源，要么它有一个不同的id。

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