Bump chai from 4.3.10 to 5.0.0

integration/test/admin/createAdminToken.ts

@@ -1,11 +1,8 @@
-import { expect } from "chai";
 import { retracedUp } from "../pkg/retracedUp";
 import adminUser from "../pkg/adminUser";
 import * as Env from "../env";
-
-const chai = require("chai"),
-  chaiHttp = require("chai-http");
-chai.use(chaiHttp);
+import assert from "assert";
+import axios from "axios";
 
 describe("Admin create admin token", function () {
   if (!Env.AdminRootToken) {
@@ -29,27 +26,21 @@ describe("Admin create admin token", function () {
       context("When an admin token is created", function () {
         let resp;
         beforeEach(async () => {
-          resp = await new Promise<any>((resolve, reject) => {
-            chai
-              .request(Env.Endpoint)
-              .post(`/admin/v1/token`)
-              .set("Authorization", jwt)
-              .end((err, res) => {
-                if (err) {
-                  reject(err);
-                }
-                resolve(res);
-              });
+          resp = await axios.post(`${Env.Endpoint}/admin/v1/token`, null, {
+            headers: {
+              Authorization: jwt,
+            },
           });
+          assert(resp);
         });
 
         let id;
         let token;
         specify("Then the response should have a token and id", () => {
-          id = resp.body.id;
-          token = resp.body.token;
-          expect(id).not.to.be.empty;
-          expect(token).not.to.be.empty;
+          id = resp.data.id;
+          token = resp.data.token;
+          assert(id);
+          assert(token);
         });
 
         context(
@@ -63,24 +54,20 @@ describe("Admin create admin token", function () {
             };
 
             beforeEach(async () => {
-              templateResponse = await new Promise<any>((resolve, reject) => {
-                chai
-                  .request(Env.Endpoint)
-                  .post(`/admin/v1/project/${project.id}/templates?environment_id=${env.id}`)
-                  .set("Authorization", `id=${id} token=${token}`)
-                  .send(reqBody)
-                  .end((err, res) => {
-                    if (err) {
-                      reject(err);
-                      return;
-                    }
-                    resolve(res);
-                  });
-              });
+              templateResponse = await axios.post(
+                `${Env.Endpoint}/admin/v1/project/${project.id}/templates?environment_id=${env.id}`,
+                reqBody,
+                {
+                  headers: {
+                    Authorization: `id=${id} token=${token}`,
+                  },
+                }
+              );
+              assert(templateResponse);
             });
 
             specify("Then the response should have a 2xx status", () => {
-              expect(templateResponse).to.have.property("status", 201);
+              assert.strictEqual(templateResponse.status, 201);
             });
           }
         );

integration/test/admin/createApiToken.ts

@@ -1,13 +1,10 @@
-import { expect } from "chai";
 import { Client } from "@retracedhq/retraced";
 import { retracedUp } from "../pkg/retracedUp";
 import adminUser from "../pkg/adminUser";
 import * as Env from "../env";
 import { sleep } from "../pkg/util";
-
-const chai = require("chai"),
-  chaiHttp = require("chai-http");
-chai.use(chaiHttp);
+import assert from "assert";
+import axios from "axios";
 
 describe("Admin create API token", function () {
   if (!Env.AdminRootToken) {
@@ -39,37 +36,36 @@ describe("Admin create API token", function () {
       context("When a new API token is created", function () {
         let resp;
 
-        before(function (done) {
-          chai
-            .request(Env.Endpoint)
-            .post(`/admin/v1/project/${project.id}/token?environment_id=${env.id}`)
-            .set("Authorization", jwt)
-            .send({
+        before(async function () {
+          resp = await axios.post(
+            `${Env.Endpoint}/admin/v1/project/${project.id}/token?environment_id=${env.id}`,
+            {
               name,
               disabled: false,
-            })
-            .end((err, res) => {
-              expect(err).to.be.null;
-              resp = res;
-              done();
-            });
+            },
+            {
+              headers: {
+                Authorization: jwt,
+              },
+            }
+          );
+          assert(resp);
         });
 
         specify("The token resource is returned with status 201.", function () {
-          const token = resp.body;
+          const token = resp.data;
           const tenMinutes = 1000 * 60 * 10;
 
-          expect(resp).to.have.property("status", 201);
-          expect(token.token).to.be.ok;
-          expect(token.created).to.be.ok;
-          expect(new Date(token.created).getTime()).to.be.within(
-            Date.now() - tenMinutes,
-            Date.now() + tenMinutes
-          );
-          expect(token.name).to.equal(name);
-          expect(token.disabled).to.equal(false);
-          expect(token.project_id).to.equal(project.id);
-          expect(token.environment_id).to.equal(env.id);
+          assert.strictEqual(resp.status, 201);
+          assert(token.token);
+          assert(token.created);
+
+          const createdDate = new Date(token.created).getTime();
+          assert.strictEqual(Date.now() - createdDate < tenMinutes, true);
+          assert.strictEqual(token.name, name);
+          assert.strictEqual(token.disabled, false);
+          assert.strictEqual(token.project_id, project.id);
+          assert.strictEqual(token.environment_id, env.id);
         });
 
         if (Env.HeadlessApiKey && Env.HeadlessProjectID) {
@@ -97,14 +93,13 @@ describe("Admin create API token", function () {
             };
             const connection = await headless.query(query, mask, 1);
             const audited = connection.currentResults[0];
-            const token = resp.body;
 
-            expect(audited.action).to.equal("api_token.create");
-            expect(audited.crud).to.equal("c");
-            expect(audited.group!.id).to.equal(project.id);
-            expect(audited.actor!.id).to.equal(adminId);
-            expect(audited.target!.id).to.be.ok;
-            expect(audited.target!.fields).to.deep.equal({
+            assert.strictEqual(audited.action, "api_token.create");
+            assert.strictEqual(audited.crud, "c");
+            assert.strictEqual(audited.group!.id, project.id);
+            assert.strictEqual(audited.actor!.id, adminId);
+            assert(audited.target!.id);
+            assert.deepStrictEqual(audited.target!.fields, {
               name,
               disabled: "false",
             });

integration/test/admin/createEnvironment.ts

@@ -1,13 +1,10 @@
-import { expect } from "chai";
 import { Client } from "@retracedhq/retraced";
 import { retracedUp } from "../pkg/retracedUp";
 import adminUser from "../pkg/adminUser";
 import * as Env from "../env";
 import { sleep } from "../pkg/util";
-
-const chai = require("chai"),
-  chaiHttp = require("chai-http");
-chai.use(chaiHttp);
+import assert from "assert";
+import axios from "axios";
 
 describe("Admin create environment", function () {
   if (!Env.AdminRootToken) {
@@ -39,24 +36,24 @@ describe("Admin create environment", function () {
         const envName = "QA";
         let resp;
 
-        before(function (done) {
-          chai
-            .request(Env.Endpoint)
-            .post(`/admin/v1/project/${project.id}/environment`)
-            .set("Authorization", jwt)
-            .send({ name: envName })
-            .end((err, res) => {
-              expect(err).to.be.null;
-              resp = res;
-              done();
-            });
+        before(async function () {
+          resp = await axios.post(
+            `${Env.Endpoint}/admin/v1/project/${project.id}/environment`,
+            { name: envName },
+            {
+              headers: {
+                Authorization: jwt,
+              },
+            }
+          );
+          assert(resp);
         });
 
         specify("The environment is returned with status 201.", function () {
-          expect(resp.status).to.equal(201);
-          expect(resp.body.id).to.be.ok;
-          expect(resp.body).to.have.property("name", envName);
-          expect(resp.body).to.have.property("project_id", project.id);
+          assert.strictEqual(resp.status, 201);
+          assert(resp.data.id);
+          assert.strictEqual(resp.data.name, envName);
+          assert.strictEqual(resp.data.project_id, project.id);
         });
 
         if (Env.HeadlessApiKey && Env.HeadlessProjectID) {
@@ -83,14 +80,13 @@ describe("Admin create environment", function () {
             };
             const connection = await headless.query(query, mask, 1);
             const audited = connection.currentResults[0];
-            const token = resp.body;
 
-            expect(audited.action).to.equal("environment.create");
-            expect(audited.crud).to.equal("c");
-            expect(audited.group!.id).to.equal(project.id);
-            expect(audited.actor!.id).to.equal(adminId);
-            expect(audited.target!.id).to.equal(resp.body.id);
-            expect(audited.target!.name).to.equal(resp.body.name);
+            assert.strictEqual(audited.action, "environment.create");
+            assert.strictEqual(audited.crud, "c");
+            assert.strictEqual(audited.group!.id, project.id);
+            assert.strictEqual(audited.actor!.id, adminId);
+            assert.strictEqual(audited.target!.id, resp.data.id);
+            assert.strictEqual(audited.target!.name, resp.data.name);
           });
         }
       });

integration/test/admin/createInvite.ts

@@ -1,13 +1,10 @@
-import { expect } from "chai";
 import { Client } from "@retracedhq/retraced";
 import { retracedUp } from "../pkg/retracedUp";
 import adminUser from "../pkg/adminUser";
 import * as Env from "../env";
 import { sleep } from "../pkg/util";
-
-const chai = require("chai"),
-  chaiHttp = require("chai-http");
-chai.use(chaiHttp);
+import assert from "assert";
+import axios from "axios";
 
 describe("Admin create invite", function () {
   if (!Env.AdminRootToken) {
@@ -39,25 +36,25 @@ describe("Admin create invite", function () {
         const email = "newperson@retraced.io";
         let resp;
 
-        before(function (done) {
-          chai
-            .request(Env.Endpoint)
-            .post(`/admin/v1/project/${project.id}/invite`)
-            .set("Authorization", jwt)
-            .send({ email })
-            .end((err, res) => {
-              expect(err).to.be.null;
-              resp = res;
-              done();
-            });
+        before(async function () {
+          resp = await axios.post(
+            `${Env.Endpoint}/admin/v1/project/${project.id}/invite`,
+            { email },
+            {
+              headers: {
+                Authorization: jwt,
+              },
+            }
+          );
+          assert(resp);
         });
 
         specify("The invite is returned with status 201.", function () {
-          expect(resp.status).to.equal(201);
-          expect(resp.body.id).to.be.ok;
-          expect(resp.body).to.have.property("project_id", project.id);
-          expect(resp.body).to.have.property("email", email);
-          expect(resp.body).to.have.property("created");
+          assert.strictEqual(resp.status, 201);
+          assert(resp.data.id);
+          assert.strictEqual(resp.data.project_id, project.id);
+          assert.strictEqual(resp.data.email, email);
+          assert(resp.data.created);
         });
 
         if (Env.HeadlessApiKey && Env.HeadlessProjectID) {
@@ -84,14 +81,13 @@ describe("Admin create invite", function () {
             };
             const connection = await headless.query(query, mask, 1);
             const audited = connection.currentResults[0];
-            const token = resp.body;
 
-            expect(audited.action).to.equal("invite.create");
-            expect(audited.crud).to.equal("c");
-            expect(audited.group!.id).to.equal(project.id);
-            expect(audited.actor!.id).to.equal(adminId);
-            expect(audited.target!.id).to.equal(resp.body.id);
-            expect(audited.target!.name).to.equal(email);
+            assert.strictEqual(audited.action, "invite.create");
+            assert.strictEqual(audited.crud, "c");
+            assert.strictEqual(audited.group!.id, project.id);
+            assert.strictEqual(audited.actor!.id, adminId);
+            assert.strictEqual(audited.target!.id, resp.data.id);
+            assert.strictEqual(audited.target!.name, email);
           });
         }
       });