Testing Integrations

public class ShippingRateService {
    public Decimal getRate(String postalCode) {
        HttpRequest request = new HttpRequest();
        request.setEndpoint('callout:Shipping_API/rates?postal=' + postalCode);
        request.setMethod('GET');

        HttpResponse response = new Http().send(request);

        if (response.getStatusCode() != 200) {
            throw new CalloutException('Shipping API returned status ' + response.getStatusCode());
        }

        Map<String, Object> parsed = (Map<String, Object>) JSON.deserializeUntyped(response.getBody());
        return (Decimal) parsed.get('rate');
    }
}

1. public class ShippingRateService { — the service class.
2. public Decimal getRate(String postalCode) { — one focused method.
3. HttpRequest request = new HttpRequest(); — Lesson 4's request-building.
4. request.setEndpoint('callout:Shipping_API/rates?postal=' + postalCode); — Lesson 5's Named Credential endpoint.
5. request.setMethod('GET'); — the verb.
6. (blank line)
7. HttpResponse response = new Http().send(request); — sends it.
8. (blank line)
9. if (response.getStatusCode() != 200) { — checks for failure before trusting the body.
10. throw new CalloutException('Shipping API returned status ' + response.getStatusCode()); — a real, catchable exception on failure.
11. } — closes the if.
12. (blank line)
13. Map<String, Object> parsed = (Map<String, Object>) JSON.deserializeUntyped(response.getBody()); — Lesson 2's parsing.
14. return (Decimal) parsed.get('rate'); — the extracted value.
15. } — closes the method.
16. } — closes the class.

This combines nearly every lesson from this module: a Named Credential endpoint (Lesson 5), an HttpRequest/HttpResponse callout (Lesson 4), and JSON parsing (Lesson 2) — a genuinely realistic integration, ready to test.

@isTest
public class ShippingRateMock implements HttpCalloutMock {
    public HttpResponse respond(HttpRequest request) {
        HttpResponse response = new HttpResponse();
        response.setStatusCode(200);
        response.setBody('{"rate": 45.50}');
        return response;
    }
}

@isTest
private class ShippingRateServiceTest {
    @isTest
    static void getRateReturnsParsedValue() {
        Test.setMock(HttpCalloutMock.class, new ShippingRateMock());

        Test.startTest();
        Decimal rate = new ShippingRateService().getRate('8001');
        Test.stopTest();

        System.assertEquals(45.50, rate);
    }
}

1. @isTest — marks the mock class.
2. public class ShippingRateMock implements HttpCalloutMock { — Module 31's mocking interface.
3. public HttpResponse respond(HttpRequest request) { — the one method the interface requires.
4. HttpResponse response = new HttpResponse(); — a fabricated response, no real network call involved.
5. response.setStatusCode(200); — a successful status.
6. response.setBody('{"rate": 45.50}'); — a fabricated JSON body.
7. return response; — hands it back to whatever code called Http.send().
8. } — closes the method.
9. } — closes the mock class.
10. (blank line)
11. @isTest — marks the test class.
12. private class ShippingRateServiceTest { — the test class.
13. @isTest — marks the test method.
14. static void getRateReturnsParsedValue() { — states what's verified.
15. Test.setMock(HttpCalloutMock.class, new ShippingRateMock()); — swaps in the fabricated response for any callout made during this test.
16. (blank line)
17. Test.startTest(); — the governor-limit boundary.
18. Decimal rate = new ShippingRateService().getRate('8001'); — calls the real service — its Http.send() returns the mock's fabricated response.
19. Test.stopTest(); — closes the boundary.
20. (blank line)
21. System.assertEquals(45.50, rate); — Module 31's specific-value assertion habit, not just "not null."
22. } — closes the test method.
23. } — closes the test class.

This is exactly Module 31's "Mocking HTTP Callouts" lesson, now testing genuinely real integration logic instead of an isolated example — the mock, the assertion, and the specific-value habit from Module 31 all directly applied.

@isTest
public class ShippingRateFailureMock implements HttpCalloutMock {
    public HttpResponse respond(HttpRequest request) {
        HttpResponse response = new HttpResponse();
        response.setStatusCode(500);
        response.setBody('Internal Server Error');
        return response;
    }
}

@isTest
static void getRateThrowsOnServerError() {
    Test.setMock(HttpCalloutMock.class, new ShippingRateFailureMock());

    try {
        new ShippingRateService().getRate('8001');
        System.assert(false, 'Expected a CalloutException');
    } catch (CalloutException e) {
        System.assert(e.getMessage().contains('500'));
    }
}

1. @isTest — marks the failure mock.
2. public class ShippingRateFailureMock implements HttpCalloutMock { — a second, separate mock for the failure scenario.
3. public HttpResponse respond(HttpRequest request) { — the required method.
4. HttpResponse response = new HttpResponse(); — a fabricated response.
5. response.setStatusCode(500); — this time, a failure status.
6. response.setBody('Internal Server Error'); — a plausible error body.
7. return response; — hands it back.
8. } — closes the method.
9. } — closes the mock class.
10. (blank line)
11. @isTest — marks the test method.
12. static void getRateThrowsOnServerError() { — states the exact scenario under test.
13. Test.setMock(HttpCalloutMock.class, new ShippingRateFailureMock()); — swaps in the failure mock this time.
14. (blank line)
15. try { — Module 31's exception-testing shape.
16. new ShippingRateService().getRate('8001'); — expected to throw, given the mocked 500.
17. System.assert(false, 'Expected a CalloutException'); — fails the test if no exception was actually thrown.
18. } catch (CalloutException e) { — catches the expected exception type.
19. System.assert(e.getMessage().contains('500')); — confirms the message reflects the actual failing status code.
20. } — closes the try/catch.
21. } — closes the test method.

This is Module 31's exception-testing pattern (the try/System.assert(false)/catch shape) combined with Module 31's failure-mock pattern — confirming the throw new CalloutException(...) guard in getRate actually fires correctly on a real 500 response.