Salesforce Platform Developer II (PDII) - Fact Sheet¶

public with sharing class OpportunityService {
    @TestVisible private static Boolean bypassRecursion = false;

    public interface IOpportunityRepo {
        List<Opportunity> findByStage(String stage);
    }

    public class StageChangeException extends Exception {}

    private final IOpportunityRepo repo;

    public OpportunityService(IOpportunityRepo repo) {
        this.repo = repo;
    }

    public void closeWon(Set<Id> oppIds) {
        List<Opportunity> opps = repo.findByStage('Negotiation');
        // ... business logic
    }
}

List<Account> accs = [SELECT Id, Name, AnnualRevenue FROM Account WITH SECURITY_ENFORCED];

SObjectAccessDecision decision = Security.stripInaccessible(
    AccessType.READABLE, [SELECT Id, Name, AnnualRevenue FROM Account]);
List<Account> safeList = (List<Account>) decision.getRecords();

String name = 'Acme%';
List<Account> accs = [SELECT Id FROM Account WHERE Name LIKE :name];

// Dynamic
String soql = 'SELECT Id FROM Account WHERE Name LIKE :name';
List<Account> dyn = Database.query(soql);

// Sanitize when concatenating
String safe = String.escapeSingleQuotes(userInput);

List<List<sObject>> results = [
    FIND :searchTerm IN ALL FIELDS
    RETURNING Account(Id, Name WHERE Industry='Technology'),
              Contact(Id, LastName)
    LIMIT 100
];

public class CalloutHelper {
    @future(callout=true)
    public static void postToService(Set<Id> ids, String url) {
        Http h = new Http();
        HttpRequest req = new HttpRequest();
        req.setEndpoint(url);
        req.setMethod('POST');
        HttpResponse res = h.send(req);
        if (res.getStatusCode() != 200) {
            System.debug(LoggingLevel.ERROR, 'Callout failed: ' + res.getStatusCode());
        }
    }
}

public class SyncOpportunitiesQueueable implements Queueable, Database.AllowsCallouts {
    private List<Id> oppIds;
    private Integer offset;

    public SyncOpportunitiesQueueable(List<Id> oppIds, Integer offset) {
        this.oppIds = oppIds;
        this.offset = offset;
    }

    public void execute(QueueableContext ctx) {
        List<Id> chunk = new List<Id>();
        Integer end = Math.min(offset + 50, oppIds.size());
        for (Integer i = offset; i < end; i++) chunk.add(oppIds[i]);

        // ... do callout for chunk
        if (end < oppIds.size() && !Test.isRunningTest()) {
            System.enqueueJob(new SyncOpportunitiesQueueable(oppIds, end));
        }
    }
}

public class RevenueRecalcBatch implements Database.Batchable<sObject>, Database.Stateful {
    public Integer processed = 0;
    public List<Id> failedIds = new List<Id>();

    public Database.QueryLocator start(Database.BatchableContext bc) {
        return Database.getQueryLocator('SELECT Id, AnnualRevenue FROM Account WHERE Active__c = true');
    }

    public void execute(Database.BatchableContext bc, List<Account> scope) {
        for (Account a : scope) {
            try {
                a.AnnualRevenue = (a.AnnualRevenue == null ? 0 : a.AnnualRevenue) * 1.05;
            } catch (Exception e) {
                failedIds.add(a.Id);
            }
        }
        Database.SaveResult[] results = Database.update(scope, false);
        for (Database.SaveResult r : results) {
            if (r.isSuccess()) processed++;
            else failedIds.add(r.getId());
        }
    }

    public void finish(Database.BatchableContext bc) {
        // Optional: chain another batch, send email, log
    }
}

// Run:
Id jobId = Database.executeBatch(new RevenueRecalcBatch(), 200);

public class NightlyRecalcScheduler implements Schedulable {
    public void execute(SchedulableContext ctx) {
        Database.executeBatch(new RevenueRecalcBatch(), 200);
    }
}
// CRON: 'seconds minutes hours dayOfMonth month dayOfWeek [year]'
String cron = '0 0 2 * * ?'; // every day 02:00
System.schedule('Nightly Recalc', cron, new NightlyRecalcScheduler());

@RestResource(urlMapping='/orders/*')
global with sharing class OrderResource {
    @HttpGet
    global static Order__c doGet() {
        RestRequest req = RestContext.request;
        Id orderId = req.requestURI.substringAfterLast('/');
        return [SELECT Id, Status__c FROM Order__c WHERE Id = :orderId];
    }

    @HttpPost
    global static Id doPost(String name, Decimal total) {
        Order__c o = new Order__c(Name=name, Total__c=total);
        insert o;
        return o.Id;
    }
}

HttpRequest req = new HttpRequest();
req.setEndpoint('callout:My_Named_Cred/path');
req.setMethod('GET');
HttpResponse res = new Http().send(req);

// Define: Order_Placed__e (custom event with fields)
Order_Placed__e evt = new Order_Placed__e(Order_Id__c = ord.Id, Total__c = ord.Total__c);
Database.SaveResult sr = EventBus.publish(evt);
if (!sr.isSuccess()) {
    for (Database.Error err : sr.getErrors()) System.debug(err.getMessage());
}

@isTest
private class OpportunityServiceTest {

    private class MockRepo implements OpportunityService.IOpportunityRepo {
        public List<Opportunity> findByStage(String stage) {
            return new List<Opportunity>{
                new Opportunity(Id='006000000000001AAA', StageName=stage)
            };
        }
    }

    @TestSetup
    static void setup() {
        Account a = new Account(Name='Acme');
        insert a;
    }

    @isTest
    static void closeWon_marksOpps() {
        OpportunityService svc = new OpportunityService(new MockRepo());

        Test.startTest();
        svc.closeWon(new Set<Id>{ '006000000000001AAA' });
        Test.stopTest();

        // assertions...
    }
}

public class StubExample implements System.StubProvider {
    public Object handleMethodCall(Object stubbed, String method, Type returnType,
                                   List<Type> paramTypes, List<String> paramNames,
                                   List<Object> args) {
        if (method == 'getName') return 'mocked';
        return null;
    }
}

@isTest
static void testWithStub() {
    AccountService svc = (AccountService) Test.createStub(AccountService.class, new StubExample());
    System.assertEquals('mocked', svc.getName());
}

public class MockResponse implements HttpCalloutMock {
    public HttpResponse respond(HttpRequest req) {
        HttpResponse r = new HttpResponse();
        r.setStatusCode(200);
        r.setBody('{"status":"ok"}');
        return r;
    }
}

@isTest
static void testCallout() {
    Test.setMock(HttpCalloutMock.class, new MockResponse());
    Test.startTest();
    String result = MyService.callExternal();
    Test.stopTest();
    System.assertEquals('ok', result);
}

@isTest
public class TestDataFactory {
    public static List<Account> createAccounts(Integer n) {
        List<Account> accs = new List<Account>();
        for (Integer i = 0; i < n; i++) accs.add(new Account(Name='Test ' + i));
        insert accs;
        return accs;
    }
}