Updating tests for getTpaProviders

src/store/store.spec.js

@@ -1964,123 +1964,98 @@ describe('Store', () => {
 
     describe('getTpaProviders method', () => {
         describe('successful method call', () => {
-            it('calls getProviders api endpoint', async () => {
+            it.each([[true, 'Repair'], [false, 'Replace']])(
-                // Arrange
+                'calls getProviders api endpoint',
-                globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({}));
+                async (isRepair, damageType) => {
+                    // Arrange
+                    globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({}));
 
-                // Act
+                    const parentAccountNumber = getRandomString(6, 6);
-                await store.getCoveragePolicyInfo();
+                    store.issConfig.parentAccountNumber = parentAccountNumber;
+                    store.order.damage.isRepair = isRepair;
+                    const zipCode = getRandomString(6, 6);
+                    const radius = getRandomInt(5, 100);
+                    const expectedEndpoint = [
+                        endpoints.GetProviders.url,
+                        zipCode,
+                        damageType,
+                        radius,
+                        parentAccountNumber,
+                        'false'
+                    ].join('/');
 
-                // Asserts
+                    // Act
-                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({
+                    await store.getTpaProviders(zipCode, radius);
-                    method: endpoints.CoveragePolicyInfo.method,
+
-                    endpoint: endpoints.CoveragePolicyInfo.url
+                    // Asserts
-                }));
+                    expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({
-            });
+                        method: endpoints.GetProviders.method,
+                        endpoint: expectedEndpoint
+                    }));
+                }
+            );
             it('Returns expected response object', async () => {
                 // Arrange
                 const response = { ReferralNumber: getRandomString(6, 6) };
                 globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response));
+                const zipCode = getRandomString(6, 6);
+                const radius = getRandomInt(5, 100);
 
                 // Act
-                const result = store.getCoveragePolicyInfo();
+                const result = store.getTpaProviders(zipCode, radius);
 
                 // Asserts
                 await expect(result).resolves.toBe(response);
             });
-            it('calls api with expected data', async () => {
-                // Arrange
-                const accountNumber = getRandomString(6, 6);
-                const policyNumber = getRandomString(6, 6);
-                const dateOfLoss = getRandomString(6, 6);
-                const zipCode = getRandomString(6, 6);
-                const referralCorrelationId = getRandomString(6, 6);
-                store.order.accountNumber = accountNumber;
-                store.order.policy.policyNumber = policyNumber;
-                store.order.policy.dateOfLoss = dateOfLoss;
-                store.order.policy.policyZipCode = zipCode;
-                store.order.referralCorrelationId = referralCorrelationId;
-                globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({}));
-
-                // Act
-                await store.getCoveragePolicyInfo();
-
-                // Asserts
-                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({
-                    payload: expect.objectContaining({
-                        accountNumber,
-                        policyNumber,
-                        dateOfLoss,
-                        zipCode,
-                        referralCorrelationId
-                    })
-                }));
-            });
             it('null response by api => no exceptions thrown', async () => {
                 // Arrange
                 globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(null));
+                const zipCode = getRandomString(6, 6);
+                const radius = getRandomInt(5, 100);
 
                 // Act
-                await store.getCoveragePolicyInfo();
+                await store.getTpaProviders(zipCode, radius);
-
-                // Asserts
-                expect(store.order.policy.policyLookupSuccessful).toBe(false);
             });
             it('no providers returned by api => promise resolves to empty list', async () => {
                 // Arrange
-                const responseNoPolicies = {
+                const responseNoProviders = {
                     data: {
-                        policies: []
+                        shopProviders: []
                     }
                 };
-                globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(responseNoPolicies));
+                globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(responseNoProviders));
+                const zipCode = getRandomString(6, 6);
+                const radius = getRandomInt(5, 100);
 
                 // Act
-                await store.getCoveragePolicyInfo();
+                const result = await store.getTpaProviders(zipCode, radius);
 
                 // Asserts
-                expect(store.order.policy.policyLookupSuccessful).toBe(false);
+                expect(result.data.shopProviders).toHaveLength(0);
             });
             it('multiple providers returned by api => promise resolves to expected', async () => {
                 // Arrange
-                const insured = {
+                const provider1 = {
-                    address: getRandomString(6, 6),
+                    companyName: getRandomString(6, 6)
-                    firstName: getRandomString(6, 6),
-                    lastName: getRandomString(6, 6),
-                    city: getRandomString(6, 6),
-                    state: getRandomString(6, 6),
-                    zipCode: getRandomString(6, 6)
                 };
-                const vehicles = [
+                const provider2 = {
-                    { name: getRandomString(6, 6) },
+                    companyName: getRandomString(6, 6)
-                    { name: getRandomString(6, 6) }
-                ];
-                const policy1 = {
-                    insureds: [insured],
-                    vehicles
                 };
-                const responseNoPolicies = {
+
+                const responseProviders = {
                     data: {
-                        policies: [policy1, {}]
+                        shopProviders: [provider1, provider2]
                     }
                 };
-                globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(responseNoPolicies));
+                globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(responseProviders));
 
                 // Act
-                await store.getCoveragePolicyInfo();
+                const result = await store.getTpaProviders();
 
                 // Asserts
-                expect(store.order.policy.policyLookupSuccessful).toBe(true);
+                expect(result.data.shopProviders).toHaveLength(2);
-
+                expect(result.data.shopProviders[0]).toBe(provider1);
-                expect(store.order.customer.address.streetAddress).toBe(insured.address);
+                expect(result.data.shopProviders[1]).toBe(provider2);
-                expect(store.order.customer.address.city).toBe(insured.city);
-                expect(store.order.customer.address.state).toBe(insured.state);
-                expect(store.order.customer.address.zipCode).toBe(insured.zipCode);
-                expect(store.order.customer.firstName).toBe(insured.firstName);
-                expect(store.order.customer.lastName).toBe(insured.lastName);
-
-                expect(store.order.serviceLocation.zipCode).toBe(insured.zipCode);
-                expect(store.order.policy.vehicles).toEqual(vehicles);
             });
         });
         it('api call throws exception => policyLookupSuccessful false', async () => {