@zohodesk/testinglibrary 0.0.64-n20-experimental → 0.0.66-n20-experimental

package/build/test/core/dataGenerator/authenticator/__test__/JWTauthenticator.test.js

@@ -0,0 +1,134 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _JWTauthenticator = _interopRequireDefault(require("../../../../../../src/core/dataGenerator/authenticator/JWTauthenticator"));
+describe('JWTauthenticator', () => {
+  let fetchMock;
+  beforeEach(() => {
+    fetchMock = jest.fn();
+    global.fetch = fetchMock;
+    process.env.DG_JWT_AUTH_URL = 'https://jwt-auth.example.com';
+    process.env.DG_JWT_TOKEN_URL = 'https://token.example.com/{ZSOID}/oauth';
+    process.env.DG_DOMAIN_URL = 'https://domain.example.com';
+    process.env.DG_JWT_AUTHENTICATOR_API = 'https://authenticator.example.com/jwtToken';
+  });
+  afterEach(() => {
+    delete global.fetch;
+    delete process.env.DG_JWT_AUTH_URL;
+    delete process.env.DG_JWT_TOKEN_URL;
+    delete process.env.DG_DOMAIN_URL;
+    delete process.env.DG_JWT_AUTHENTICATOR_API;
+  });
+  it('should return unchanged payload when jwt config is missing', async () => {
+    const jwtAuthenticator = new _JWTauthenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      email: 'user@example.com',
+      'data-generator': {
+        account: {}
+      }
+    };
+    const result = await jwtAuthenticator.constructPayload(apiPayload, actorInfo);
+    expect(result).toEqual(apiPayload);
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+  it('should fetch jwt access token and attach it to payload', async () => {
+    fetchMock.mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        access_token: 'access-token-123'
+      })
+    });
+    const jwtAuthenticator = new _JWTauthenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      email: 'user.one@example.com',
+      'data-generator': {
+        account: {
+          jwt: {
+            jwt_secret: 'jwt-secret',
+            response_type: 'token',
+            client_id: '12345.client-id'
+          }
+        }
+      }
+    };
+    const result = await jwtAuthenticator.constructPayload(apiPayload, actorInfo);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock).toHaveBeenCalledWith('https://authenticator.example.com/jwtToken', expect.objectContaining({
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    }));
+    const requestBody = JSON.parse(fetchMock.mock.calls[0][1].body);
+    expect(requestBody).toEqual(expect.objectContaining({
+      user_token: encodeURIComponent('user.one@example.com'),
+      jwt_secret: 'jwt-secret',
+      jwt_auth_url: 'https://jwt-auth.example.com',
+      response_type: 'token',
+      client_id: '12345.client-id',
+      token_url: 'https://token.example.com/12345/oauth',
+      domain_url: 'https://domain.example.com'
+    }));
+    expect(result.account.jwt).toEqual(expect.objectContaining({
+      jwt_secret: 'jwt-secret',
+      response_type: 'token',
+      client_id: '12345.client-id',
+      access_token: 'access-token-123'
+    }));
+  });
+  it('should throw a descriptive error when authenticator API returns non-ok response', async () => {
+    fetchMock.mockResolvedValue({
+      ok: false,
+      status: 500,
+      text: async () => 'internal error'
+    });
+    const jwtAuthenticator = new _JWTauthenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      email: 'user@example.com',
+      'data-generator': {
+        account: {
+          jwt: {
+            jwt_secret: 'jwt-secret',
+            response_type: 'token',
+            client_id: '12345.client-id'
+          }
+        }
+      }
+    };
+    await expect(jwtAuthenticator.constructPayload(apiPayload, actorInfo)).rejects.toThrow('JWT authenticator error! status: 500, body: internal error');
+  });
+  it('should throw when authenticator response has no access_token', async () => {
+    fetchMock.mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        token_type: 'Bearer'
+      })
+    });
+    const jwtAuthenticator = new _JWTauthenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      email: 'user@example.com',
+      'data-generator': {
+        account: {
+          jwt: {
+            jwt_secret: 'jwt-secret',
+            response_type: 'token',
+            client_id: '12345.client-id'
+          }
+        }
+      }
+    };
+    await expect(jwtAuthenticator.constructPayload(apiPayload, actorInfo)).rejects.toThrow('JWT authenticator did not return access_token');
+  });
+});

package/build/test/core/dataGenerator/authenticator/__test__/OAuthAuthenticator.test.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _OAuthAuthenticator = _interopRequireDefault(require("../../../../../../src/core/dataGenerator/authenticator/OAuthAuthenticator"));
+describe('OAuthAuthenticator', () => {
+  it('should merge oauth2 from actor info into payload account', async () => {
+    const oauthAuthenticator = new _OAuthAuthenticator.default();
+    const apiPayload = {
+      account: {
+        oauth2: {
+          existing_key: 'existing-value'
+        }
+      }
+    };
+    const actorInfo = {
+      'data-generator': {
+        account: {
+          oauth2: {
+            client_id: 'new-client',
+            scope: 'tickets.read'
+          }
+        }
+      }
+    };
+    const result = await oauthAuthenticator.constructPayload(apiPayload, actorInfo);
+    expect(result.account.oauth2).toEqual({
+      existing_key: 'existing-value',
+      client_id: 'new-client',
+      scope: 'tickets.read'
+    });
+  });
+  it('should initialize account when missing and keep payload unchanged if oauth2 is absent', async () => {
+    const oauthAuthenticator = new _OAuthAuthenticator.default();
+    const apiPayload = {};
+    const actorInfo = {
+      'data-generator': {
+        account: {}
+      }
+    };
+    const result = await oauthAuthenticator.constructPayload(apiPayload, actorInfo);
+    expect(result).toEqual({
+      account: {}
+    });
+    expect(result.account.oauth2).toBeUndefined();
+  });
+});

package/build/test/core/dataGenerator/authenticator/__test__/OrgOAuthAuthenticator.test.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _OrgOAuthAuthenticator = _interopRequireDefault(require("../../../../../../src/core/dataGenerator/authenticator/OrgOAuthAuthenticator"));
+describe('OrgOAuthAuthenticator', () => {
+  it('should merge org_oauth from actor info into payload account', async () => {
+    const orgOAuthAuthenticator = new _OrgOAuthAuthenticator.default();
+    const apiPayload = {
+      account: {
+        org_oauth: {
+          existing_key: 'existing-value'
+        }
+      }
+    };
+    const actorInfo = {
+      'data-generator': {
+        account: {
+          org_oauth: {
+            org_id: 'org-1001',
+            region: 'us'
+          }
+        }
+      }
+    };
+    const result = await orgOAuthAuthenticator.constructPayload(apiPayload, actorInfo);
+    expect(result.account.org_oauth).toEqual({
+      existing_key: 'existing-value',
+      org_id: 'org-1001',
+      region: 'us'
+    });
+  });
+  it('should initialize account when missing and keep payload unchanged if org_oauth is absent', async () => {
+    const orgOAuthAuthenticator = new _OrgOAuthAuthenticator.default();
+    const apiPayload = {};
+    const actorInfo = {
+      'data-generator': {
+        account: {}
+      }
+    };
+    const result = await orgOAuthAuthenticator.constructPayload(apiPayload, actorInfo);
+    expect(result).toEqual({
+      account: {}
+    });
+    expect(result.account.org_oauth).toBeUndefined();
+  });
+});

package/build/test/core/dataGenerator/authenticator/__tests__/JWTauthenticator.test.js

@@ -0,0 +1,165 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _JWTauthenticator = _interopRequireDefault(require("../../../../../core/dataGenerator/authenticator/JWTauthenticator.js"));
+const MOCK_ACCESS_TOKEN = '1026812030.abc123.def456';
+const makeActorInfo = (overrides = {}) => ({
+  email: 'anitha.m+uatagent@zohotest.com',
+  'data-generator': {
+    account: {
+      authentications: ['jwt-auth'],
+      'jwt-oauth': {
+        jwt_secret: 'PZkhUzx0ruJQNU4QRagh0u13uuKk9s0m5EU1pUbD',
+        response_type: 'remote_token',
+        client_id: '1026812030.WKK443JMM12S4ZVR23C3HUK66PFUSG',
+        token_url: 'https://accounts-portal.csez.zohocorpin.com/clientoauth/v2/1026812030/remote/auth',
+        domain_url: 'https://zdesk-devops08.csez.zohocorpin.com:31000'
+      },
+      ...overrides
+    }
+  }
+});
+const makeApiPayload = (overrides = {}) => ({
+  scenario_name: 'verify the Department page is loaded',
+  account: {
+    storeVariables: {
+      orgId: '20408511'
+    },
+    authentications: ['jwt-auth']
+  },
+  ...overrides
+});
+const mockFetchSuccess = () => {
+  global.fetch = jest.fn().mockResolvedValue({
+    ok: true,
+    json: jest.fn().mockResolvedValue({
+      access_token: MOCK_ACCESS_TOKEN
+    })
+  });
+};
+describe('JWTauthenticator.constructPayload', () => {
+  let authenticator;
+  beforeEach(() => {
+    authenticator = new _JWTauthenticator.default();
+    process.env.DG_JWT_AUTHENTICATOR_API = 'https://authenticator.zdesk.csez.zohocorpin.com/jwtToken';
+    process.env.DG_JWT_AUTH_URL = 'https://jwt.zdesk.csez.zohocorpin.com/JWTAuth';
+    delete process.env.DG_JWT_TOKEN_URL;
+    delete process.env.DG_DOMAIN_URL;
+    jest.clearAllMocks();
+  });
+  describe('no-op cases', () => {
+    it('returns apiPayload unchanged when jwt-oauth config is absent in actorInfo', async () => {
+      const actorInfo = {
+        email: 'anitha.m+uatagent@zohotest.com',
+        'data-generator': {
+          account: {
+            authentications: ['jwt-auth']
+          }
+        }
+      };
+      const apiPayload = makeApiPayload();
+      const result = await authenticator.constructPayload(apiPayload, actorInfo);
+      expect(result).toBe(apiPayload);
+      expect(result.account.authHeaders).toBeUndefined();
+    });
+    it('returns apiPayload unchanged when actorInfo has no data-generator', async () => {
+      const apiPayload = makeApiPayload();
+      const result = await authenticator.constructPayload(apiPayload, {});
+      expect(result).toBe(apiPayload);
+    });
+  });
+  describe('successful token fetch', () => {
+    it('sets authHeaders.Authorization with Zoho-oauthtoken prefix', async () => {
+      mockFetchSuccess();
+      const result = await authenticator.constructPayload(makeApiPayload(), makeActorInfo());
+      expect(result.account.authHeaders.Authorization).toBe(`Zoho-oauthtoken ${MOCK_ACCESS_TOKEN}`);
+    });
+    it('URL-encodes email with + and @ characters as user_token', async () => {
+      mockFetchSuccess();
+      await authenticator.constructPayload(makeApiPayload(), makeActorInfo());
+      const body = JSON.parse(global.fetch.mock.calls[0][1].body);
+      expect(body.user_token).toBe('anitha.m%2Buatagent%40zohotest.com');
+    });
+    it('posts to DG_JWT_AUTHENTICATOR_API with correct payload fields', async () => {
+      mockFetchSuccess();
+      await authenticator.constructPayload(makeApiPayload(), makeActorInfo());
+      const [url, options] = global.fetch.mock.calls[0];
+      const body = JSON.parse(options.body);
+      expect(url).toBe(process.env.DG_JWT_AUTHENTICATOR_API);
+      expect(options.method).toBe('POST');
+      expect(options.headers['Content-Type']).toBe('application/json');
+      expect(body.jwt_secret).toBe('PZkhUzx0ruJQNU4QRagh0u13uuKk9s0m5EU1pUbD');
+      expect(body.response_type).toBe('remote_token');
+      expect(body.client_id).toBe('1026812030.WKK443JMM12S4ZVR23C3HUK66PFUSG');
+      expect(body.jwt_auth_url).toBe(process.env.DG_JWT_AUTH_URL);
+      expect(body.token_url).toBe('https://accounts-portal.csez.zohocorpin.com/clientoauth/v2/1026812030/remote/auth');
+      expect(body.domain_url).toBe('https://zdesk-devops08.csez.zohocorpin.com:31000');
+    });
+    it('does not overwrite existing authHeaders fields other than Authorization', async () => {
+      mockFetchSuccess();
+      const apiPayload = makeApiPayload();
+      apiPayload.account.authHeaders = {
+        'X-Custom-Header': 'custom-value'
+      };
+      const result = await authenticator.constructPayload(apiPayload, makeActorInfo());
+      expect(result.account.authHeaders['X-Custom-Header']).toBe('custom-value');
+      expect(result.account.authHeaders.Authorization).toBe(`Zoho-oauthtoken ${MOCK_ACCESS_TOKEN}`);
+    });
+    it('resolves token_url from DG_JWT_TOKEN_URL env when not in config', async () => {
+      mockFetchSuccess();
+      process.env.DG_JWT_TOKEN_URL = 'https://accounts-portal.csez.zohocorpin.com/clientoauth/v2/{ZSOID}/remote/auth';
+      const actorInfo = makeActorInfo({
+        'jwt-oauth': {
+          ...makeActorInfo()['data-generator'].account['jwt-oauth'],
+          token_url: undefined
+        }
+      });
+      await authenticator.constructPayload(makeApiPayload(), actorInfo);
+      const body = JSON.parse(global.fetch.mock.calls[0][1].body);
+      expect(body.token_url).toBe('https://accounts-portal.csez.zohocorpin.com/clientoauth/v2/1026812030/remote/auth');
+    });
+    it('resolves domain_url from DG_DOMAIN_URL env when not in config', async () => {
+      mockFetchSuccess();
+      process.env.DG_DOMAIN_URL = 'https://zdesk-env-domain.csez.zohocorpin.com:31000';
+      const jwtOauth = {
+        ...makeActorInfo()['data-generator'].account['jwt-oauth'],
+        domain_url: undefined
+      };
+      const actorInfo = {
+        ...makeActorInfo(),
+        'data-generator': {
+          account: {
+            authentications: ['jwt-auth'],
+            'jwt-oauth': jwtOauth
+          }
+        }
+      };
+      await authenticator.constructPayload(makeApiPayload(), actorInfo);
+      const body = JSON.parse(global.fetch.mock.calls[0][1].body);
+      expect(body.domain_url).toBe('https://zdesk-env-domain.csez.zohocorpin.com:31000');
+    });
+  });
+  describe('authenticator service errors', () => {
+    it('throws when authenticator responds with non-ok status', async () => {
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: false,
+        status: 401,
+        text: jest.fn().mockResolvedValue('Unauthorized')
+      });
+      await expect(authenticator.constructPayload(makeApiPayload(), makeActorInfo())).rejects.toThrow('status: 401');
+    });
+    it('throws when authenticator response has no access_token', async () => {
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: jest.fn().mockResolvedValue({
+          error: 'invalid_grant'
+        })
+      });
+      await expect(authenticator.constructPayload(makeApiPayload(), makeActorInfo())).rejects.toThrow('access_token');
+    });
+    it('throws when fetch fails due to network error', async () => {
+      global.fetch = jest.fn().mockRejectedValue(new Error('ECONNREFUSED'));
+      await expect(authenticator.constructPayload(makeApiPayload(), makeActorInfo())).rejects.toThrow('ECONNREFUSED');
+    });
+  });
+});

package/jest.config.js

@@ -35,7 +35,7 @@ module.exports = {
     '^.+\\.jsx?$': 'babel-jest'
   },
   
-  testMatch: ['**/__tests__/**/*.test.js'],
+  testMatch: ['**/__tests__/**/*.test.js', '**/__test__/**/*.test.js'],
 
   modulePathIgnorePatterns: ['/build/'],