Salesforce Developer Apex Rest Callout

salesforce-developer-apex-rest

// Salesforce - Developer - REST - Callout - Authorize Remote REST endpoints:

To authorize remote REST endpoints:

1. From Setup, enter Remote Site Settings in the Quick Find box, 

2. Click Remote Site Settings.

3. Click New Remote Site.

4. Provide a name for the remote site

5. Provide the URL for the remote site.   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.

6. Provide a description for the remote site / service.

7. Click Save
https://json2apex.herokuapp.com/ - 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.
// Salesforce - Developer - Apex REST - Callout:

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 - Apex REST - Callout - Testing using 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 appropriate JSON 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!  To add a test for our callout 
that uses this resource:

1. In the Developer Console, select File | New | Apex Class.

2. For the class name, enter AnimalsCalloutsTest and then click OK.

@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.');          
    }   

}

4. Press CTRL+S to save.

5. Select Test | Always Run Asynchronously. 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.

6. To run the test, select Test | New Run.

7. From the Test Classes list, select AnimalsCalloutsTest.

8. Click Add Selected | Run.

The test result is displayed in the Tests tab under a test run ID. When the test 
execution finishes, expand the test run to view details. Now double-click 
AnimalCallouts in the Overall Code Coverage pane to see which lines are covered 
by your tests.
// Salesforce - Developer - Apex REST - Callout - Test using 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. (We’ll write AnimalsHttpCalloutMock in the example after this 
one.)

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.

1. In the Developer Console, select File | New | Apex Class.

2. For the class name, enter AnimalsHttpCalloutMock and then click OK.

3. Replace the autogenerated code with the following class definition.

@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; 
    }
}

4. Press CTRL+S to save.

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.

1. Modify the test class AnimalsCalloutsTest to add a second test method. Click 
   the class tab, and then add the following method before the closing bracket.

@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());
}

2. Press CTRL+S to save.

3. Select Test | New Run.

4. From the Test Classes list, select AnimalsCalloutsTest.

5. Click Add Selected | Run.
// Salesforce - Developer - Apex REST - Callout - Cautions:

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.
public class AnimalLocator {
    public static String getAnimalNameById(Integer id) {
        String name = 'Not found';
        Http http = new Http();
        HttpRequest request = new HttpRequest();
        request.setEndpoint('https://th-apex-http-callout.herokuapp.com/animals/' + id);
        request.setMethod('GET');
        HttpResponse response = http.send(request);

        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());
            System.debug(results);
            // 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) {
                Map<String,Object> m = (Map<String,Object>) animal;
                System.debug(animal);
                //System.debug(animal.get('id'));
                String mid = m.get('id') + '';
                String mname = m.get('name') + '';
                System.debug('ID:' + mid + ',mname:' + mname);
                if (mid == id + '') {
                    name = mname;
                    break;
                }
            }
        }
        return name; 
    }
}

@IsTest
global class AnimalLocatorMock implements HttpCalloutMock  {
    global HTTPResponse respond(HTTPRequest request) {
        HttpResponse response = new HttpResponse();
        response.setHeader('Content-Type', 'application/json');
        response.setBody('
          {"animals": [{"id": 1, "name":"majestic badger"}, 
                             {"id":2, "name":"fluffy bunny"}, 
                             {"id":3, "name": "scary bear"}, 
                             {"id":4, "name": "chicken"}, 
                             {"id":5, "name":"mighty moose"}]}');
        response.setStatusCode(200);
        return response; 
    }
}

@IsTest
public class AnimalLocatorTest {
    static testmethod void testGetAnimalNameById() {
        Test.setMock(HttpCalloutMock.class, new AnimalLocatorMock()); 
        String name = AnimalLocator.getAnimalNameById(1);
        System.assertEquals('majestic badger', name, 'Name not matching.');

        String overflow = AnimalLocator.getAnimalNameById(20);
        System.assertEquals('Not found', overflow);
    }
}
Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License