create.test.js

import express from "express"
import request from "supertest"
import { jest } from "@jest/globals"

import createRoute from "../create.js"
import { messenger } from "../../error-messenger.js"
//import app from "../../app.js"

const routeTester = new express()
routeTester.use(express.json())
routeTester.use(express.urlencoded({ extended: false }))
routeTester.use("/create", createRoute)
routeTester.use("/app/create", createRoute)
routeTester.use(messenger)

const rerum_uri = `${process.env.RERUM_ID_PATTERN}_not_`

beforeEach(() => {
  /** 
   * Request/Response Mock Using manual fetch replacement
   * This is overruling the fetch(store.rerum.io/v1/api/create) call in create.js
   */
  global.fetch = jest.fn(() =>
    Promise.resolve({
      json: () => Promise.resolve({ "@id": rerum_uri, "test": "item", "__rerum": { "stuff": "here" } }),
      ok: true,
      text: () => Promise.resolve("Descriptive Error Here")
    })
  )
})

afterEach(() => {
  /**
   * Food for thought: delete data generated by tests?  
   * Make a test.store available that uses the same annotationStoreTesting as RERUM tests?
   */
})

/**
 * This test suite runs the logic of the route file 'create.js' but does not actually communicate with RERUM.
 * It will confirm the following:
 *   - Is the express req/resp sent into the route
 *   - Can the route read the JSON body
 *   - Does the route add @id and __rerum
 *   - Does the route respond 201
 *   - Does the route respond with the object that was in the request body
 *   - Does the route respond with the proper 'Location' header
 * 
 * Note: /app/create uses the same logic and would be a redundant test.
 */
describe("Check that the request/response behavior of the TinyNode create route functions.  Mock the connection to RERUM.  __mock_functions", () => {
  it("'/create' route request and response behavior is functioning.", async () => {

    const response = await request(routeTester)
      .post("/create")
      .send({ "test": "item" })
      .set("Content-Type", "application/json")
      .then(resp => resp)
      .catch(err => err)
    expect(response.header.location).toBe(rerum_uri)
    expect(response.statusCode).toBe(201)
    expect(response.body.test).toBe("item")
  })
})

/**
 * This test suite checks the RESTful responses when using the TinyNode create endpoint incorrectly.
 *
 *  - Incorrect HTTP method
 *  - Invalid JSON body
 * 
 * Note: /app/create uses the same logic and would be a redundant test
 */
describe("Check that incorrect TinyNode create route usage results in expected RESTful responses from RERUM.  __rest __core", () => {
  it("Incorrect '/create' route usage has expected RESTful responses.", async () => {
    let response = null

    response = await request(routeTester)
      .get("/create")
      .then(resp => resp)
      .catch(err => err)
    expect(response.statusCode).toBe(405)

    response = await request(routeTester)
      .put("/create")
      .then(resp => resp)
      .catch(err => err)
    expect(response.statusCode).toBe(405)

    response = await request(routeTester)
      .patch("/create")
      .then(resp => resp)
      .catch(err => err)
    expect(response.statusCode).toBe(405)

    response = await request(routeTester)
      .delete("/create")
      .then(resp => resp)
      .catch(err => err)
    expect(response.statusCode).toBe(405)

    response = await request(routeTester)
      .post("/create")
      .set("Content-Type", "application/json")
      .send("not json")
      .then(resp => resp)
      .catch(err => err)
    expect(response.statusCode).toBe(400)

  })
})

describe("Check that TinyNode create route propagates upstream and network errors predictably.  __rest __core", () => {
  it("Preserves upstream text errors and maps network failures to 502.", async () => {
    global.fetch = jest.fn(() =>
      Promise.resolve({
        ok: false,
        status: 503,
        headers: {
          get: () => "text/plain; charset=utf-8"
        },
        text: () => Promise.resolve("Upstream create failure")
      })
    )

    let response = await request(routeTester)
      .post("/create")
      .set("Content-Type", "application/json")
      .send({ "test": "item" })
      .then(resp => resp)
      .catch(err => err)
    expect(response.statusCode).toBe(502)
    expect(response.text).toContain("Upstream create failure")

    global.fetch = jest.fn(() => Promise.reject(new Error("socket hang up")))

    response = await request(routeTester)
      .post("/create")
      .set("Content-Type", "application/json")
      .send({ "test": "item" })
      .then(resp => resp)
      .catch(err => err)
    expect(response.statusCode).toBe(502)
    expect(response.text).toContain("A RERUM error occurred")
  })
})

/**
 * Full integration test.  Checks the TinyNode app create endpoint functionality and RERUM connection.
 * 
 * Note: /app/create uses the same logic and would be a redundant test
 */
describe("Check that the properly used create endpoints function and interact with RERUM.  __e2e", () => {
  it("'/create' route can save an object to RERUM.", async () => {
    const response = await request(routeTester)
      .post("/create")
      .send({ "test": "item" })
      .set("Content-Type", "application/json")
      .then(resp => resp)
      .catch(err => err)
    expect(response.header).toHaveProperty('location')
    expect(response.statusCode).toBe(201)
    expect(response.body.test).toBe("item")
  })
})