sub-manager-backend/test/endpoints.test.mjs

import { describe } from "mocha";
import chai, { expect } from "chai";
import bodyParser from "body-parser";
import express from "express";
import chaiHttp from "chai-http";
import { testDb as db } from "../db.mjs";
import { Data } from "../objects/Data.mjs";
import { beforeEach, afterEach } from "mocha";
import { protectedEndpoints, getEndpoints } from "../objects/Endpoints.mjs";

chai.use(chaiHttp);
const app = express();
const data = new Data(db);
await data.init();
app.use(bodyParser.json());
app.use("/api", getEndpoints(data));
app.use("/api", protectedEndpoints(db, data));

describe("testing endpoints...", async function () {
  describe("Testing GET endpoints", async function () {
    describe("GET stories", async function () {
      it("should return a status code of 200 and an array", async function () {
        const res = await chai.request(app).get("/api/stories");
        expect(res).to.have.status(200);
        expect(res.body).to.be.a("array");
      });
    });
    describe("GET submissions", async function () {
      it("should return a status code of 200 and an array", async function () {
        const res = await chai.request(app).get("/api/submissions");
        expect(res).to.have.status(200);
        expect(res.body).to.be.a("array");
      });
    });
    describe("GET publications", async function () {
      it("should return a status code of 200 and an array", async function () {
        const res = await chai.request(app).get("/api/publications");
        expect(res).to.have.status(200);
        expect(res.body).to.be.a("array");
      });
    });
  });
  describe("testing /create endpoints", async function () {
    describe("/story/create", async function () {
      const goodData = {
        title: "#test",
        word_count: 111,
        deleted: 0,
      };
      const badData = {
        title: 1,
        word_count: "not a number",
      };
      afterEach(async function () {
        await db("stories").where("title", goodData.title).del();
      });
      it("should return 200 if a valid request is made", async function () {
        const res = await chai
          .request(app)
          .post("/api/story/create")
          .send(goodData);
        expect(res).to.have.status(200);
      });
      it("should return 400 if an invalid request is made", async function () {
        const res = await chai
          .request(app)
          .post("/api/story/create")
          .send(badData);
        expect(res).to.have.status(400);
      });
      it("the new entry should exist in the database", async function () {
        await chai.request(app).post("/api/story/create").send(goodData);
        const res = await db("stories")
          .select("*")
          .where("title", goodData.title);
        expect(res[0].title).to.eql(goodData.title);
      });
    });
    describe("/publication/create", async function () {
      const goodData = {
        title: "#test",
        link: "www.internet.com",
        deleted: 0,
      };
      const badData = {
        title: 1,
        link: 1,
      };
      afterEach(async function () {
        await db("pubs").where("title", goodData.title).del();
      });
      it("should return 200 if a valid request is made", async function () {
        const res = await chai
          .request(app)
          .post("/api/publication/create")
          .send(goodData);
        expect(res).to.have.status(200);
      });
      it("should return 400 if an invalid request is made", async function () {
        const res = await chai
          .request(app)
          .post("/api/publication/create")
          .send(badData);
        expect(res).to.have.status(400);
      });
      it("the new entry should exist in the database", async function () {
        await chai.request(app).post("/api/publication/create").send(goodData);
        const res = await db("pubs").select("*").where("title", goodData.title);
        expect(res[0].title).to.eql(goodData.title);
      });
    });
    describe("/submission/create", async function () {
      const goodData = {
        story_id: 1,
        pub_id: 1,
        response_id: 1,
        date_submitted: "1066-01-01",
        date_responded: "1066-01-01",
      };
      const badData = {
        story_id: "string",
        pub_id: 1,
        response_id: 1,
        date_submitted: "1066-01-01",
        date_responded: "1066-01-01",
      };
      afterEach(async function () {
        await db("subs").where("date_submitted", goodData.date_submitted).del();
      });
      it("should return 200 if a valid request is made", async function () {
        const res = await chai
          .request(app)
          .post("/api/submission/create")
          .send(goodData);
        expect(res).to.have.status(200);
      });
      it("should return 400 if an invalid request is made", async function () {
        const res = await chai
          .request(app)
          .post("/api/submission/create")
          .send(badData);
        expect(res).to.have.status(400);
      });
      it("the new entry should exist in the database", async function () {
        await chai.request(app).post("/api/submission/create").send(goodData);
        const res = await db("subs")
          .select("*")
          .where("date_submitted", goodData.date_submitted);
        expect(res[0].date_responded).to.eql(goodData.date_responded);
      });
    });
  });
  describe("testing /edit endpoints", async function () {
    describe("/story/edit", async function () {
      const goodData = {
        id: 1,
        title: "#test",
        word_count: 111,
        deleted: 0,
      };
      const badData = {
        id: "string",
      };
      let prev = {};
      beforeEach(async function () {
        prev = await db("stories").select("*").where("id", 1);
        prev = prev[0];
      });
      afterEach(async function () {
        await db("stories").where("id", 1).update(prev);
      });
      it("should return 200 when sent valid data", async function () {
        const res = await chai
          .request(app)
          .post("/api/story/edit")
          .send(goodData);
        expect(res).to.have.status(200);
      });
      it("should return 400 when sent invalid data", async function () {
        const res = await chai
          .request(app)
          .post("/api/story/edit")
          .send(badData);
        expect(res).to.have.status(400);
      });
      it("the edit should be reflected in the database", async function () {
        await chai.request(app).post("/api/story/edit").send(goodData);
        const res = await db("stories").select("*").where("id", goodData.id);
        expect(res[0]).to.eql(goodData);
      });
    });
    describe("/publication/edit", async function () {
      const goodData = {
        id: 1,
        title: "#test",
        link: "link",
        query_after_days: 90,
        deleted: 0,
      };
      const badData = {
        id: "string",
      };
      let prev = {};
      beforeEach(async function () {
        prev = await db("pubs").select("*").where("id", 1);
        prev = prev[0];
      });
      afterEach(async function () {
        await db("pubs").where("id", 1).update(prev);
      });
      it("should return 200 when sent valid data", async function () {
        const res = await chai
          .request(app)
          .post("/api/publication/edit")
          .send(goodData);
        expect(res).to.have.status(200);
      });
      it("should return 400 when sent invalid data", async function () {
        const res = await chai
          .request(app)
          .post("/api/publication/edit")
          .send(badData);
        expect(res).to.have.status(400);
      });
      it("the edit should be reflected in the database", async function () {
        await chai.request(app).post("/api/publication/edit").send(goodData);
        const res = await db("pubs").select("*").where("id", goodData.id);
        expect(res[0]).to.eql(goodData);
      });
    });
    describe("/submission/edit", async function () {
      const goodData = {
        id: 1,
        story_id: 1,
        pub_id: 1,
        response_id: 1,
        date_submitted: "1066-01-01",
        date_responded: "1066-01-01",
      };
      const badData = {
        story_id: "string",
        pub_id: 1,
        response_id: 1,
        date_submitted: "1066-01-01",
        date_responded: "1066-01-01",
      };
      let prev = {};
      beforeEach(async function () {
        prev = await db("subs").select("*").where("id", 1);
        prev = prev[0];
      });
      afterEach(async function () {
        await db("subs").where("id", 1).update(prev);
      });
      it("should return 200 when sent valid data", async function () {
        const res = await chai
          .request(app)
          .post("/api/submission/edit")
          .send(goodData);
        expect(res).to.have.status(200);
      });
      it("should return 400 when sent invalid data", async function () {
        const res = await chai
          .request(app)
          .post("/api/submission/edit")
          .send(badData);
        expect(res).to.have.status(400);
      });
      it("the edit should be reflected in the database", async function () {
        await chai.request(app).post("/api/submission/edit").send(goodData);
        const res = await db("subs").select("*").where("id", goodData.id);
        expect(res[0]).to.eql(goodData);
      });
    });
  });
});