Add Test Cases

const cds = require('@sap/cds/lib')
const { default: axios } = require('axios')
const { GET, POST, DELETE, PATCH, expect } = cds.test(__dirname + '../../')

axios.defaults.auth = { username: 'alice' }

jest.setTimeout(11111)

describe('Test The GET Endpoints', () => {
  it('Should check Processor Service', async () => {
    const processorService = await cds.connect.to('ProcessorService')
    const { Incidents } = processorService.entities
    expect(await SELECT.from(Incidents)).to.have.length(4)
  })

  it('Should check Customers', async () => {
    const processorService = await cds.connect.to('ProcessorService')
    const { Customers } = processorService.entities
    expect(await SELECT.from(Customers)).to.have.length(3)
  })

  it('Test Expand Entity Endpoint', async () => {
    const { data } = await GET`/odata/v4/processor/Customers?$select=firstName&$expand=incidents`
    expect(data).to.be.an('object')
  })
})

describe('Draft Choreography APIs', () => {
  let draftId, incidentId

  it('Create an incident ', async () => {
    const { status, statusText, data } = await POST(`/odata/v4/processor/Incidents`, {
      title: 'Urgent attention required !',
      status_code: 'N'
    })
    draftId = data.ID
    expect(status).to.equal(201)
    expect(statusText).to.equal('Created')
  })

  it('+ Activate the draft & check Urgency code as H using custom logic', async () => {
    const response = await POST(
      `/odata/v4/processor/Incidents(ID=${draftId},IsActiveEntity=false)/ProcessorService.draftActivate`
    )
    expect(response.status).to.eql(201)
    expect(response.data.urgency_code).to.eql('H')
  })

  it('+ Test the incident status', async () => {
    const {
      status,
      data: { status_code, ID }
    } = await GET(`/odata/v4/processor/Incidents(ID=${draftId},IsActiveEntity=true)`)
    incidentId = ID
    expect(status).to.eql(200)
    expect(status_code).to.eql('N')
  })

  describe('Close Incident and Open it again to check Custom logic', () => {
    it(`Should Close the Incident-${draftId}`, async () => {
      const { status } = await POST(
        `/odata/v4/processor/Incidents(ID=${incidentId},IsActiveEntity=true)/ProcessorService.draftEdit`,
        {
          PreserveChanges: true
        }
      )
      expect(status).to.equal(201)
    })
    it(`Should Close the Incident-${draftId}`, async () => {
      const { status } = await PATCH(`/odata/v4/processor/Incidents(ID=${incidentId},IsActiveEntity=false)`, {
        status_code: 'C'
      })
      expect(status).to.equal(200)
    })
    it('+ Activate the draft & check Status code as C using custom logic', async () => {
      const response = await POST(
        `/odata/v4/processor/Incidents(ID=${incidentId},IsActiveEntity=false)/ProcessorService.draftActivate`
      )
      expect(response.status).to.eql(200)
    })
    it('+ Test the incident status to be closed', async () => {
      const {
        status,
        data: { status_code }
      } = await GET(`/odata/v4/processor/Incidents(ID=${incidentId},IsActiveEntity=true)`)
      expect(status).to.eql(200)
      expect(status_code).to.eql('C')
    })
    describe('should fail to re-open closed incident', () => {
      it(`Should Open Closed Incident-${draftId}`, async () => {
        const { status } = await POST(
          `/odata/v4/processor/Incidents(ID=${incidentId},IsActiveEntity=true)/ProcessorService.draftEdit`,
          {
            PreserveChanges: true
          }
        )
        expect(status).to.equal(201)
      })
      it(`Should re-open the Incident-${draftId} but fail`, async () => {
        const { status } = await PATCH(`/odata/v4/processor/Incidents(ID=${incidentId},IsActiveEntity=false)`, {
          status_code: 'N'
        })
        expect(status).to.equal(200)
      })
      it(' `Should fail to activate draft trying to re-open the incidentt', async () => {
        try {
          const response = await POST(
            `/odata/v4/processor/Incidents(ID=${incidentId},IsActiveEntity=false)/ProcessorService.draftActivate`
          )
        } catch (error) {
          expect(error.response.status).to.eql(500)
          expect(error.response.data.error.message).to.include(`Can't modify a closed incident`)
        }
      })
    })
  })
  it('- Delete the Draft', async () => {
    const response = await DELETE(`/odata/v4/processor/Incidents(ID=${draftId},IsActiveEntity=false)`)
    expect(response.status).to.eql(204)
  })
  it('- Delete the Incident', async () => {
    const response = await DELETE(`/odata/v4/processor/Incidents(ID=${draftId},IsActiveEntity=true)`)
    expect(response.status).to.eql(204)
  })
})

package customer.incident_management;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.security.test.context.support.WithMockUser;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import static org.hamcrest.Matchers.hasSize;
import com.jayway.jsonpath.JsonPath;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@SpringBootTest
@AutoConfigureMockMvc
class IncidentsODataTests {

  private static final String incidentsURI = "/odata/v4/ProcessorService/Incidents";
    private static final String customerURI = "/odata/v4/ProcessorService/Customers";
    private static final String expandEntityURI = "/odata/v4/ProcessorService/Customers?$select=firstName&$expand=incidents";

    @Autowired
    private MockMvc mockMvc;

    /**
    * Test GET Api for Incidents
    * @throws Exception
    */
    @Test
    @WithMockUser(username = "alice")
    void incidentReturned(@Autowired MockMvc mockMvc) throws Exception {
        mockMvc.perform(get(incidentsURI))
            .andExpect(status().isOk())
                .andExpect(jsonPath("$.value", hasSize(4)));

    }

    /**
    * Test GET Api for Customers
    * @throws Exception
    */
    @Test
    @WithMockUser(username = "alice")
    void customertReturned() throws Exception {
        mockMvc.perform(get(customerURI))
            .andExpect(status().isOk())
                .andExpect(jsonPath("$.value", hasSize(3)));

    }

    /**
    * Test to ensure there is an Incident created by each Customer.
    * @throws Exception
    */

    @Test
    @WithMockUser(username = "alice")
    void expandEntityEndpoint() throws Exception {
        mockMvc.perform(get(expandEntityURI))
        .andExpect(jsonPath("$.value[0].incidents[0]").isMap())
        .andExpect(jsonPath("$.value[0].incidents[0]").isNotEmpty());

    }


    /**
    * Test for creating an Draft Incident
    * Activating the draft Incident and check Urgency code as H using custom logic
    * Delete the Incident
    */

    @Test
    @WithMockUser(username = "alice")
    void draftIncident() throws Exception {
        String incidentCreateJson = "{ \"title\": \"Urgent attention required!\", \"status_code\": \"N\",\"urgency_code\": \"M\"}";

                /**
                  * Create a draft Incident
                  */

                MvcResult createResult=  mockMvc.perform(MockMvcRequestBuilders.post("/odata/v4/ProcessorService/Incidents")
                .content(incidentCreateJson)
                .contentType("application/json")
                .accept("application/json"))
                .andExpect(status().isCreated())
                .andExpect(jsonPath("$.title").value("Urgent attention required!"))
                .andExpect(jsonPath("$.status_code").value("N"))
                .andExpect(jsonPath("$.urgency_code").value("M"))
                .andReturn();

                String createResponseContent = createResult.getResponse().getContentAsString();
                String ID = JsonPath.read(createResponseContent, "$.ID");
                System.out.println("Incident ID : " + ID);

                /**
                  * Activating the draft Incident
                  */

                mockMvc.perform(MockMvcRequestBuilders.post("/odata/v4/ProcessorService/Incidents(ID="+ID+",IsActiveEntity=false)/ProcessorService.draftActivate")
                .contentType("application/json")
                .accept("application/json"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$").isMap())
                .andExpect(jsonPath("$.title").value("Urgent attention required!"))
                .andExpect(jsonPath("$.status_code").value("N"))
                .andExpect(jsonPath("$.urgency_code").value("H"));  

                /**
                * Deleting an Incident
                */

                mockMvc.perform(MockMvcRequestBuilders.delete("/odata/v4/ProcessorService/Incidents(ID="+ID+",IsActiveEntity=true)"))
                .andExpect(status().is(204));
    }


    /**
    * Test for creating an Active Incident
    * Test for closing the Active Incident
    * Test for custom handler ensuing prevent users from modifying a closed Incident
    */

    @Test
    @WithMockUser(username = "alice")
    void updateIncident() throws Exception {
        String incidentCreateJson = "{ \"title\": \"Urgent attention required!\", \"status_code\": \"N\", \"IsActiveEntity\": true }";
        String incidentUpdateJson = "{\"status_code\": \"C\"}";
        String closedIncidentUpdateJson = "{\"status_code\": \"I\"}";

        MvcResult createResult=  mockMvc.perform(MockMvcRequestBuilders.post("/odata/v4/ProcessorService/Incidents")
                .content(incidentCreateJson)
                .contentType("application/json")
                .accept("application/json"))
                .andExpect(status().isCreated())
                .andExpect(jsonPath("$.title").value("Urgent attention required!"))
                .andExpect(jsonPath("$.status_code").value("N"))
                .andReturn();

                String createResponseContent = createResult.getResponse().getContentAsString();
                String ID = JsonPath.read(createResponseContent, "$.ID");
                System.out.println("Incident ID : " + ID);
                /**
                * Closing an open Incident
                */
                MvcResult updateResult=  mockMvc.perform(MockMvcRequestBuilders.patch("/odata/v4/ProcessorService/Incidents(ID="+ID+",IsActiveEntity=true)")
                .content(incidentUpdateJson)
                .contentType("application/json")
                .accept("application/json"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.title").value("Urgent attention required!"))
                .andExpect(jsonPath("$.status_code").value("C"))
                .andReturn();

                String updateResponseContent = updateResult.getResponse().getContentAsString();
                String statusCode = JsonPath.read(updateResponseContent, "$.status_code");
                System.out.println("status code : " + statusCode);

                /**
                * Updating a Closed Incident will throw an error with error message "Can't modify a closed incident"
                */
                mockMvc.perform(MockMvcRequestBuilders.patch("/odata/v4/ProcessorService/Incidents(ID="+ID+",IsActiveEntity=true)")
                .content(closedIncidentUpdateJson)
                .contentType("application/json")
                .accept("application/json"))
                .andExpect(status().isConflict())
                .andExpect(jsonPath("$.error.message").value("Can't modify a closed incident"));



    }

}