Salesforce Developer Integration Callout

salesforce-developer

// Salesforce - Developer - Integration & Callouts:

Before you start working with callouts, update the list of approved sites for 
your org on the Remote Site Settings page.

1. From Setup, enter Remote Site Settings in the Quick Find box, then click 
   Remote Site Settings.
2. Click New Remote Site.
3. For the remote site name, enter animals_http.
4. For the remote site URL, enter 
   https://th-apex-http-callout.herokuapp.com. This URL authorizes all 
   subfolders for the endpoint, like 
   https://th-apex-http-callout.herokuapp.com/path1 and 
   https://th-apex-http-callout.herokuapp.com/path2.
5. For the description, enter Trailhead animal service: HTTP.
6. Click Save & New.
7. For the second remote site name, enter animals_soap.
8. For the remote site URL, enter https://th-apex-soap-service.herokuapp.com.
9. For the description, enter Trailhead animal service: SOAP.
10. Click Save.

Http http = new Http();
HttpRequest request = new HttpRequest();
request.setEndpoint('https://th-apex-http-callout.herokuapp.com/animals');
request.setMethod('GET');
HttpResponse response = http.send(request);
// If the request is successful, parse the JSON response.
if (response.getStatusCode() == 200) {
    // Deserialize the JSON string into collections of primitive data types.
    Map<String, Object> results = (Map<String, Object>) 
      JSON.deserializeUntyped(response.getBody());
    // Cast the values in the 'animals' key as a list
    List<Object> animals = (List<Object>) results.get('animals');
    System.debug('Received the following animals:');
    for (Object animal: animals) {
        System.debug(animal);
    }
}

The JSON2Apex tool generates strongly typed Apex code for parsing a JSON 
structure. You simply paste in the JSON, and the tool generates the necessary 
Apex code for you.

JSON2Apex: https://json2apex.herokuapp.com/

Http http = new Http();
HttpRequest request = new HttpRequest();
request.setEndpoint('https://th-apex-http-callout.herokuapp.com/animals');
request.setMethod('POST');
request.setHeader('Content-Type', 'application/json;charset=UTF-8');
// Set the body as a JSON object
request.setBody('{"name":"mighty moose"}');
HttpResponse response = http.send(request);
// Parse the JSON response
if (response.getStatusCode() != 201) {
    System.debug('The status code returned was not expected: ' +
        response.getStatusCode() + ' ' + response.getStatus());
} else {
    System.debug(response.getBody());
}

public class AnimalsCallouts {
    public static HttpResponse makeGetCallout() {
        Http http = new Http();
        HttpRequest request = new HttpRequest();
        request.setEndpoint('https://th-apex-http-callout.herokuapp.com/animals');
        request.setMethod('GET');
        HttpResponse response = http.send(request);
        // If the request is successful, parse the JSON response.
        if (response.getStatusCode() == 200) {
            // Deserializes the JSON string into collections of primitive data types.
            Map<String, Object> results = (Map<String, Object>) JSON.deserializeUntyped(response.getBody());
            // Cast the values in the 'animals' key as a list
            List<Object> animals = (List<Object>) results.get('animals');
            System.debug('Received the following animals:');
            for (Object animal: animals) {
                System.debug(animal);
            }
        }
        return response;
    }
    public static HttpResponse makePostCallout() {
        Http http = new Http();
        HttpRequest request = new HttpRequest();
        request.setEndpoint('https://th-apex-http-callout.herokuapp.com/animals');
        request.setMethod('POST');
        request.setHeader('Content-Type', 'application/json;charset=UTF-8');
        request.setBody('{"name":"mighty moose"}');
        HttpResponse response = http.send(request);
        // Parse the JSON response
        if (response.getStatusCode() != 201) {
            System.debug('The status code returned was not expected: ' +
                response.getStatusCode() + ' ' + response.getStatus());
        } else {
            System.debug(response.getBody());
        }
        return response;
    }        
}
// Salesforce - Developer - Integration - Test a Callout with StaticResourceCalloutMock:

To test your callouts, use mock callouts by either implementing an interface or 
using static resources. In this example, we use static resources and a mock 
interface later on. The static resource contains the response body to return. 
Again, when using a mock callout, the request isn’t sent to the endpoint. 
Instead, the Apex runtime knows to look up the response specified in the static 
resource and return it instead. The Test.setMock method informs the runtime that 
mock callouts are used in the test method. Let’s see mock callouts in action. 
First, we create a static resource containing a JSON-formatted string to use for 
the GET request.

1. In the Developer Console, select File | New | Static Resource.
2. For the name, enter GetAnimalResource.
3. For the MIME type, select text/plain, even though we are using JSON.
4. Click Submit.
5. In the tab that opens for the resource, insert the following content. Make 
   sure that it is all on one line and doesn’t break to the next line. This 
   content is what the mock callout returns. It’s an array of three woodland 
   creatures.
6. Press CTRL+S to save.

You’ve successfully created your static resource! Now, let’s add a test for our 
callout that uses this resource.

@isTest
private class AnimalsCalloutsTest {
    @isTest static  void testGetCallout() {
        // Create the mock response based on a static resource
        StaticResourceCalloutMock mock = new StaticResourceCalloutMock();
        mock.setStaticResource('GetAnimalResource');
        mock.setStatusCode(200);
        mock.setHeader('Content-Type', 'application/json;charset=UTF-8');
        // Associate the callout with a mock response
        Test.setMock(HttpCalloutMock.class, mock);
        // Call method to test
        HttpResponse result = AnimalsCallouts.makeGetCallout();
        // Verify mock response is not null
        System.assertNotEquals(null,result,
            'The callout returned a null response.');
        // Verify status code
        System.assertEquals(200,result.getStatusCode(),
          'The status code is not 200.');
        // Verify content type   
        System.assertEquals('application/json;charset=UTF-8',
          result.getHeader('Content-Type'),
          'The content type value is not expected.');  
        // Verify the array contains 3 items     
        Map<String, Object> results = (Map<String, Object>) 
            JSON.deserializeUntyped(result.getBody());
        List<Object> animals = (List<Object>) results.get('animals');
        System.assertEquals(3, animals.size(),
          'The array should only contain 3 items.');          
    }   
}

If you don’t select Always Run Asynchronously, test runs that include only one 
class run synchronously. You can open logs from the Tests tab only for 
synchronous test runs.

Double-click AnimalCallouts in the Overall Code Coverage pane to see which lines 
are covered by your tests.
// Salesforce - Developer - Integration - Test a Callout with HttpCalloutMock:

To test your POST callout, we provide an implementation of the HttpCalloutMock 
interface. This interface enables you to specify the response that’s sent in the 
respond method. Your test class instructs the Apex runtime to send this fake 
response by calling Test.setMock again. For the first argument, pass 
HttpCalloutMock.class. For the second argument, pass a new instance of 
AnimalsHttpCalloutMock, which is your interface implementation of 
HttpCalloutMock.

Test.setMock(HttpCalloutMock.class, new AnimalsHttpCalloutMock());

Now add the class that implements the HttpCalloutMock interface to intercept the 
callout. If an HTTP callout is invoked in test context, the callout is not made. 
Instead, you receive the mock response that you specify in the respond method 
implementation in AnimalsHttpCalloutMock.

@isTest
global class AnimalsHttpCalloutMock implements HttpCalloutMock {
    // Implement this interface method
    global HTTPResponse respond(HTTPRequest request) {
        // Create a fake response
        HttpResponse response = new HttpResponse();
        response.setHeader('Content-Type', 'application/json');
        response.setBody('{"animals": ["majestic badger", "fluffy bunny", "scary bear", "chicken", "mighty moose"]}');
        response.setStatusCode(200);
        return response; 
    }
}

In your test class, create the testPostCallout method to set the mock callout, 
as shown in the next example. The testPostCallout method calls Test.setMock, 
and then calls the makePostCallout method in the AnimalsCallouts class. It 
then verifies that the response that’s returned is what you specified in the 
respond method of the mock implementation.

// AnimalsCalloutsTest:
@isTest static void testPostCallout() {
    // Set mock callout class 
    Test.setMock(HttpCalloutMock.class, new AnimalsHttpCalloutMock()); 
    // This causes a fake response to be sent
    // from the class that implements HttpCalloutMock. 
    HttpResponse response = AnimalsCallouts.makePostCallout();
    // Verify that the response received contains fake values
    String contentType = response.getHeader('Content-Type');
    System.assert(contentType == 'application/json');
    String actualValue = response.getBody();
    System.debug(response.getBody());
    String expectedValue = '{"animals": ["majestic badger", "fluffy bunny", "scary bear", "chicken", "mighty moose"]}';
    System.assertEquals(actualValue, expectedValue);
    System.assertEquals(200, response.getStatusCode());
}

When making a callout from a method, the method waits for the external service 
to send back the callout response before executing subsequent lines of code. 
Alternatively, you can place the callout code in an asynchronous method that’s 
annotated with @future(callout=true) or use Queueable Apex. This way, the 
callout runs on a separate thread, and the execution of the calling method isn’t 
blocked.

When making a callout from a trigger, the callout must not block the trigger 
process while waiting for the response. For the trigger to be able to make a 
callout, the method containing the callout code must be annotated with 
@future(callout=true) to run in a separate thread.
Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License