test; modifying unittest.test.ts

Signed-off-by: sekhar kumar dash <sekharkumardash229@gmail.com>

Author: Sekhar-Kumar-Dash

newtest/unittest.test.ts

@@ -1,35 +1,61 @@
 import { wrappedNodeFetch } from '../integrations/octokit/require';
 import { Response } from 'node-fetch';
 import fetch from 'node-fetch';
-import { createExecutionContext, getExecutionContext} from '../src/context';
+import { createExecutionContext, getExecutionContext } from '../src/context';
 import { HTTP } from '../src/keploy';
 
 describe('wrappedNodeFetch', () => {
-  it('should call fetch function with correct arguments in record mode', async () => {
+  it('should return mocked response in test mode - case 1', async () => {
+    const mockResponse = new Response('mocked response');
     const ctx = {
-      mode: 'record',
+      mode: 'test',
       testId: 'testId',
-      mocks: [],
-      deps: [],     
+      mocks: [
+        {
+          Version: 'V1_BETA2',
+          Name: 'testId',
+          Kind: HTTP,
+          Spec: {
+            Metadata: {
+              name: 'node-fetch',
+              url: 'https://api.keploy.io/healthz',
+              options: { method: 'GET' },
+              type: 'HTTP_CLIENT',
+            },
+            Req: {
+              URL: 'https://api.keploy.io/healthz',
+              Body: '',
+              Header: {},
+              Method: 'GET',
+            },
+            Res: {
+              StatusCode: 200,
+              Header: { 'content-type': { Value: ['text/plain'] } },
+              Body: 'mocked response',
+            },
+          },
+        },
+      ],
+      deps: [],
+    
     };
     createExecutionContext(ctx)
+
     const wrappedFetch = (wrappedNodeFetch(fetch) as any).bind({ fetch });
     const url = 'https://api.keploy.io/healthz';
     const options = {
       method: 'GET',
     };
     const response = await wrappedFetch(url, options);
     const updatedctx= getExecutionContext().context;
-    const responseBody = await response.text();
-    const recordedOutput = updatedctx.mocks[0].Spec.Res.Body;
-    expect(response).toBeInstanceOf(Response);
-    expect(updatedctx.mocks.length).toBeGreaterThan(0);
-    expect(updatedctx.deps.length).toBeGreaterThan(0);
-    expect(response).toHaveProperty('body');
-    expect(responseBody).toEqual(recordedOutput);
+    expect(response.status).toEqual(mockResponse.status);
+    expect(response.statusText).toEqual(mockResponse.statusText);
+
+    const mocks=updatedctx.mocks.length;
+    expect(mocks).toBe(0);
   });
 
-   it('should return mocked response in test mode', async () => {
+  it('should return mocked response in test mode - case 2', async () => {
     const mockResponse = new Response('mocked response');
     const ctx = {
       mode: 'test',
@@ -42,12 +68,12 @@ describe('wrappedNodeFetch', () => {
           Spec: {
             Metadata: {
               name: 'node-fetch',
-              url: 'https://api.keploy.io/healthz',
+              url: 'https://api.keploy.io/status',
               options: { method: 'GET' },
               type: 'HTTP_CLIENT',
             },
             Req: {
-              URL: 'https://api.keploy.io/healthz',
+              URL: 'https://api.keploy.io/status',
               Body: '',
               Header: {},
               Method: 'GET',
@@ -61,12 +87,13 @@ describe('wrappedNodeFetch', () => {
         },
       ],
       deps: [],
+      
 
     };
     createExecutionContext(ctx)
 
     const wrappedFetch = (wrappedNodeFetch(fetch) as any).bind({ fetch });
-    const url = 'https://api.keploy.io/healthz';
+    const url = 'https://api.keploy.io/status';
     const options = {
       method: 'GET',
     };
@@ -78,20 +105,58 @@ describe('wrappedNodeFetch', () => {
     const mocks=updatedctx.mocks.length;
     expect(mocks).toBe(0);
   });
-
-  it('should return undefined if execution context is not present in record mode', async () => {
-    const mockFetch = jest.fn().mockResolvedValue(new Response());
-    const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
-    const wrappedFetch = (wrappedNodeFetch(mockFetch) as any).bind({ fetch: mockFetch });
-    const url = 'https://api.keploy.io/healthz';
+  it('should record an HTTP request in record mode', async () => {
+    const ctx = {
+      mode: 'record',
+      testId: 'testId',
+      mocks: [],
+      deps: [],     
+    };
+    createExecutionContext(ctx)
+    const wrappedFetch = (wrappedNodeFetch(fetch) as any).bind({ fetch });
+    const url = 'https://jsonplaceholder.typicode.com/posts';
+    const options = {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ data: 'test' }),
+    };
+    const response = await wrappedFetch(url, options);
+    const updatedctx = getExecutionContext().context;
+    const responseBody = await response.text();
+    const recordedOutput = updatedctx.mocks[0].Spec.Res.Body;
+    expect(response).toBeInstanceOf(Response);
+    expect(updatedctx.mocks.length).toBeGreaterThan(0);
+    expect(updatedctx.deps.length).toBeGreaterThan(0);
+    expect(response).toHaveProperty('body');
+    expect(responseBody).toEqual(recordedOutput);
+  });
+  it('should record a successful HTTP response with JSON body in record mode', async () => {
+    const ctx = {
+      mode: 'record',
+      testId: 'testId',
+      mocks: [],
+      deps: [],
+    };
+    createExecutionContext(ctx);
+    const wrappedFetch = (wrappedNodeFetch(fetch) as any).bind({ fetch });
+    const url = 'https://jsonplaceholder.typicode.com/todos/1';
     const options = {
       method: 'GET',
     };
     const response = await wrappedFetch(url, options);
-    expect(consoleSpy).toHaveBeenCalledWith('keploy context is not present to mock dependencies');
-    expect(response).toBeUndefined();
+    const json = await response.json();
+    expect(response.status).toBe(200);
+    expect(json.userId).toBeDefined();
+    expect(json.id).toBeDefined();
+    expect(json.title).toBeDefined();
+    expect(json.completed).toBeDefined();
+    const updatedctx = getExecutionContext().context;
+    expect(updatedctx.mocks.length).toBeGreaterThan(0);
+    expect(updatedctx.deps.length).toBeGreaterThan(0);
   });
-
+  
   it('should call fetch function with correct arguments in off mode', async () => {
     const mockFetch = jest.fn().mockResolvedValueOnce(new Response());
     const ctx = {
@@ -112,4 +177,29 @@ describe('wrappedNodeFetch', () => {
     expect(mockFetch).toHaveBeenCalledWith(url, options);
     expect(response).toBeInstanceOf(Response);
   });
-});
+
+  it('should call fetch function with correct arguments in off mode', async () => {
+    const mockFetch = jest.fn().mockResolvedValueOnce(new Response());
+    const ctx = {
+      mode: 'off',
+      testId: 'testId',
+      mocks: [],
+      deps: [],
+    };
+    createExecutionContext(ctx);
+  
+    const wrappedFetch = (wrappedNodeFetch(mockFetch) as any).bind({ fetch: mockFetch });
+    const url = 'https://api.example.com/test';
+    const options = {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ data: 'test' }),
+    };
+    const response = await wrappedFetch(url, options);
+  
+    expect(mockFetch).toHaveBeenCalledWith(url, options);
+    expect(response).toBeInstanceOf(Response);
+  });
+});