Javascript 不推荐使用节点/Express未处理的承诺拒绝

我一直在努力解决代码中不断出现的这些未经处理的拒绝承诺问题

目前我得到的结果如下：

[nodemon]启动

mocha--recursive-rmin

（节点：35286） 未经处理的PromisejectionWarning:AssertionError[ERR_ASSERTION]： 表达式计算为falsy值：

断言（计数+1==newCount）

拒绝。此错误源于在异步 函数没有catch块，或者拒绝了 未使用.catch（）处理。（拒绝id:1）（节点：35286）[DEP0018] 弃用警告：未处理的承诺拒绝被弃用。在里面 未来，未经处理的拒绝承诺将终止合同 具有非零退出代码的Node.js进程

应该通过的测试是：

const assert = require("assert");
const request = require("supertest");
const mongoose = require("mongoose");
const app = require("../../app");

const Driver = mongoose.model("driver");

describe("Drivers controller", () => {
  it("Post to /api/drivers create a new driver", done => {
    Driver.count().then(count => {
      request(app)
        .post("api/drivers")
        .send({ email: "test@test.com" })
        .end(() => {
          Driver.count().then(newCount => {
            assert(count + 1 === newCount);
            done();
          });
        });
    });
  });
});

为了应对我早些时候遭到的拒绝承诺，我做了以下几点：

const express = require("express");
const bodyParser = require("body-parser");
const mongoose = require("mongoose");
const routes = require("./routes/routes");
const app = express();

mongoose.Promise = global.Promise;
mongoose.connect("mongodb://localhost/muber", { useMongoClient: true });

app.use(bodyParser.json());
routes(app);

module.exports = app;

我尝试测试的控制器是：

const Driver = require("../models/driver");

module.exports = {
  greeting(req, res) {
    res.send({ hi: "there" });
  },

  create(req, res) {
    console.log(req.body);
    const driverProps = req.body;

    Driver.create(driverProps).then(driver => res.send(driver));
  }
};

我确实尝试将

catch（）

添加到测试中，如下所示：

describe("Drivers controller", () => {
  it("Post to /api/drivers create a new driver", done => {
    Driver.count()
      .then(count => {
        request(app)
          .post("api/drivers")
          .send({ email: "test@test.com" })
          .end((err, res) => {
            Driver.count().then(newCount => {
              assert(count + 1 === newCount);
              done();
            });
          });
      })
      .catch(error => console.log(error));
  });
});

但它并没有解决这个错误

这是我的路线处理程序：

const DriversController = require("../controllers/drivers_controller");

module.exports = app => {
  // Watch for incoming requests of method GET to the route http://localhost:3050/api
  app.get("/api", DriversController.greeting);

  app.post("/api/drivers", DriversController.create);
};

---

我可能错了，但您正在进行比较和计算，而没有先进行计数+1。解决这个问题的办法是：

assert((count + 1) === newCount)

因此，在上面的示例中，您将计算从比较值中分离出来

---

请参见下面的评论

我可能错了，但您在进行比较和计算时没有先进行计数+1。解决这个问题的办法是：

assert((count + 1) === newCount)

因此，在上面的示例中，您将计算从比较值中分离出来

---

请参阅下面的评论

如果您正确地链接您的承诺，您将能够发现错误：

describe("Drivers controller", () => {
    it("Post to /api/drivers create a new driver", () => {
        let oldCount;
        return Driver.count()
            .then(count => {
                oldCount = count;
                return new Promise((resolve, reject) => {
                    request(app)
                        .post("api/drivers")
                        .send({ email: "test@test.com" })
                        .end((err, res) => {
                            if (err) {
                                reject(err);
                            } else {
                                resolve(res);
                            }
                        });
                });
            }).then(() => {
                return Driver.count();
            }).then(newCount => {
                assert(oldCount + 1 === newCount);
            });
    });
});

---

在您的示例中，您在承诺中包含承诺，但没有返回/等待这些承诺。如果assert语句抛出错误，错误将不会转发到外部承诺。

如果正确链接承诺，您将能够捕获错误：

describe("Drivers controller", () => {
    it("Post to /api/drivers create a new driver", () => {
        let oldCount;
        return Driver.count()
            .then(count => {
                oldCount = count;
                return new Promise((resolve, reject) => {
                    request(app)
                        .post("api/drivers")
                        .send({ email: "test@test.com" })
                        .end((err, res) => {
                            if (err) {
                                reject(err);
                            } else {
                                resolve(res);
                            }
                        });
                });
            }).then(() => {
                return Driver.count();
            }).then(newCount => {
                assert(oldCount + 1 === newCount);
            });
    });
});

---

在您的示例中，您在承诺中包含承诺，但没有返回/等待这些承诺。如果assert语句抛出错误，错误将不会转发到外部承诺。

为了向可能遇到此问题的未来读者明确说明，当Mocha测试中出现错误/不正确的断言时，承诺内部会出现错误：

---

根据corschdi进行重构后，我在link中添加了解决方案，这绕过了关于

done（）

回调的错误，直接将您带到了问题的核心，即异步测试确实失败了。

为了向可能遇到此问题的未来读者澄清，当Mocha测试中出现错误/不正确的断言时，承诺中会出现错误：

---

根据corschdi进行重构后，我在link中添加了解决方案，这绕过了关于

done（）的错误

回调并直接将您带到问题的核心，即异步测试确实失败。

===运算符在比较之前执行两边===运算符在比较之前执行两边===您是否尝试捕捉示例并将其记录到测试用例中？@DoğancanArabacı，是的，我发布了我如何添加

catch（）

以上。您是否尝试捕获该示例并将其记录到测试用例中？@DoğancanArabacı，是的，我发布了如何添加上面的

catch（）

。使用您的解决方案，我仍然得到一个失败的测试：

错误：超时超过2000ms。对于异步测试和挂钩，确保调用“done（）”；如果返回承诺，请确保它已解决。

您为我带来了最接近答案的答案，这让我找到了这个答案：，这有助于在测试时解决承诺，这个答案也帮助我理解测试是问题所在。我已更新代码，通过向摩卡返回承诺来解决问题。如果出现任何异常情况，摩卡实际上应该不会通过测试。这就是你不再需要catch子句的原因。你以前的解决方案奏效了。这个给了我一个连接。测试确实失败了，感谢您提供的早期解决方案，我会将该解决方案放回原处，以便它可以帮助其他人。如果对

api/驱动程序的请求导致
连接被拒绝
错误，那么测试不应该失败吗？使用您的解决方案，我仍然会得到一个失败的测试：
错误：超过2000ms的超时。对于异步测试和挂钩，确保调用“done（）”；如果返回承诺，请确保它已解决。
您为我带来了最接近答案的答案，这让我找到了这个答案：，这有助于在测试时解决承诺，这个答案也帮助我理解测试是问题所在。我已更新代码，通过向摩卡返回承诺来解决问题。如果出现任何异常情况，摩卡实际上应该不会通过测试。这就是你不再需要catch子句的原因。你以前的解决方案奏效了。这个给了我一个连接。测试确实失败了，感谢您提供了早期的解决方案，我会将该解决方案放回原处，以便它可以帮助其他人。如果对
api/drivers
的请求导致
连接被拒绝
错误，测试不应该失败吗？