Queue-Creation/force-app/main/default/classes/QueueMetadataActionsTest.cls

@IsTest
private class QueueMetadataActionsTest {
  @TestSetup
  static void setupQueue() {
    insert new Group(
      Name = 'Support Queue',
      DeveloperName = 'Support_Queue',
      Type = 'Queue',
      Email = 'support@example.com'
    );
  }

  @IsTest
  static void createsOriginWhenMissing() {
    MetadataMock mock = new MetadataMock('origin');
    Test.setMock(HttpCalloutMock.class, mock);
    CreateOriginPicklistItem.Request request = new CreateOriginPicklistItem.Request();
    request.picklistItemName = 'Phone Support';

    Test.startTest();
    CreateOriginPicklistItem.Result result = CreateOriginPicklistItem.createOrigin(
      new List<CreateOriginPicklistItem.Request>{ request }
    )[0];
    Test.stopTest();

    Assert.areEqual('Phone_Support', result.caseOrigin);
    Assert.isTrue(result.created);
    Assert.areEqual(2, mock.requests.size());
    Assert.isTrue(
      mock.requests[1].contains('<fullName>Phone_Support</fullName>')
    );
    Assert.isTrue(mock.requests[1].contains('<label>Phone Support</label>'));
  }

  @IsTest
  static void createsEmailToCaseRoute() {
    Group queue = [
      SELECT Id
      FROM Group
      WHERE DeveloperName = 'Support_Queue'
      LIMIT 1
    ];
    MetadataMock mock = new MetadataMock('emailToCase');
    Test.setMock(HttpCalloutMock.class, mock);
    CreateEmailToCase.Request request = new CreateEmailToCase.Request();
    request.routingName = 'Support Route';
    request.emailAddress = 'support@example.com';
    request.caseOwnerId = queue.Id;
    request.caseOrigin = 'Phone_Support';

    Test.startTest();
    CreateEmailToCase.Result result = CreateEmailToCase.createRoutingAddress(
      new List<CreateEmailToCase.Request>{ request }
    )[0];
    Test.stopTest();

    Assert.isTrue(result.created);
    Assert.areEqual('Case', result.metadataFullName);
    Assert.areEqual(2, mock.requests.size());
    Assert.isTrue(
      mock.requests[1].contains('<caseOwner>Support_Queue</caseOwner>')
    );
    Assert.isTrue(
      mock.requests[1].contains('<casePriority>Medium</casePriority>')
    );
    Assert.isTrue(
      mock.requests[1].contains('<addressType>EmailToCase</addressType>')
    );
    Assert.isTrue(
      mock.requests[1]
        .contains('<emailAddress>support@example.com</emailAddress>')
    );
    Assert.isTrue(
      mock.requests[1].contains('<caseOrigin>Phone_Support</caseOrigin>')
    );
  }

  @IsTest
  static void createsQueueListView() {
    Group queue = [
      SELECT Id
      FROM Group
      WHERE DeveloperName = 'Support_Queue'
      LIMIT 1
    ];
    MetadataMock mock = new MetadataMock('listView');
    Test.setMock(HttpCalloutMock.class, mock);
    CreateListView.Request request = new CreateListView.Request();
    request.listViewLabel = 'Support Open Cases';
    request.objectApiName = 'Case';
    request.groupId = queue.Id;
    request.displayColumns = 'CASE.CASE_NUMBER, CASE.SUBJECT, CASE.STATUS';

    Test.startTest();
    CreateListView.Result result = CreateListView.createView(
      new List<CreateListView.Request>{ request }
    )[0];
    Test.stopTest();

    Assert.areEqual('Support_Open_Cases', result.listViewApiName);
    Assert.areEqual('Case.Support_Open_Cases', result.metadataFullName);
    Assert.isTrue(result.created);
    Assert.isTrue(
      mock.requests[1].contains('<filterScope>Queue</filterScope>')
    );
    Assert.isTrue(mock.requests[1].contains('<queue>Support_Queue</queue>'));
    Assert.isTrue(
      mock.requests[1].contains('<value>Resolved,Cancelled,Closed</value>')
    );
  }

  @IsTest
  static void appendsAutoResponseEntryAtEnd() {
    String sourceXml =
      '<?xml version="1.0" encoding="UTF-8"?>' +
      '<AutoResponseRules xmlns="http://soap.sforce.com/2006/04/metadata">' +
      '<autoResponseRule><fullName>Case Auto-Response</fullName><active>true</active>' +
      '<ruleEntry><senderEmail>old@example.com</senderEmail>' +
      '<template>unfiled$public/Old</template></ruleEntry>' +
      '</autoResponseRule></AutoResponseRules>';
    CreateCaseAutoResponseRule.Configuration configuration = new CreateCaseAutoResponseRule.Configuration();
    configuration.autoResponseRuleName = 'Case Auto-Response';
    configuration.caseOrigin = 'Phone_Support';
    configuration.templateFullName = 'unfiled$public/Support_Template';

    String result = CreateCaseAutoResponseRule.appendRuleEntry(
      sourceXml,
      configuration
    );

    Assert.areNotEqual(
      result.indexOf('<ruleEntry>'),
      result.lastIndexOf('<ruleEntry>')
    );
    Assert.isFalse(result.contains('<sortOrder>'));
    Assert.isTrue(result.contains('<field>Case.Origin</field>'));
    Assert.isTrue(result.contains('<value>Phone_Support</value>'));
    Assert.isTrue(result.contains('<field>Case.ContactEmail</field>'));
    Assert.isTrue(result.contains('<field>Case.Status</field>'));
    Assert.isTrue(result.contains('<value>Active</value>'));
    Assert.isTrue(result.contains('<field>Case.RecordTypeId</field>'));
    Assert.isTrue(result.contains('<value>Customer Service</value>'));
    Assert.isTrue(
      result.contains('<template>unfiled$public/Support_Template</template>')
    );
  }

  @IsTest
  static void rejectsMultipleInvocableRequests() {
    CreateOriginPicklistItem.Request first = new CreateOriginPicklistItem.Request();
    first.picklistItemName = 'One';
    CreateOriginPicklistItem.Request second = new CreateOriginPicklistItem.Request();
    second.picklistItemName = 'Two';

    try {
      CreateOriginPicklistItem.createOrigin(
        new List<CreateOriginPicklistItem.Request>{ first, second }
      );
      Assert.fail('Expected a validation exception.');
    } catch (IllegalArgumentException expected) {
      Assert.isTrue(expected.getMessage().contains('exactly one request'));
    }
  }

  @IsTest
  static void insertsAutoResponseEntryAtRequestedPosition() {
    String sourceXml =
      '<AutoResponseRules xmlns="http://soap.sforce.com/2006/04/metadata">' +
      '<autoResponseRule><fullName>Case Auto-Response</fullName><active>true</active>' +
      '<ruleEntry><template>unfiled$public/First</template></ruleEntry>' +
      '</autoResponseRule></AutoResponseRules>';
    CreateCaseAutoResponseRule.Configuration configuration = new CreateCaseAutoResponseRule.Configuration();
    configuration.autoResponseRuleName = 'Case Auto-Response';
    configuration.caseOrigin = 'Phone_Support';
    configuration.templateFullName = 'unfiled$public/Inserted';
    configuration.sortOrder = 1;

    String result = CreateCaseAutoResponseRule.appendRuleEntry(
      sourceXml,
      configuration
    );

    Assert.isTrue(
      result.indexOf('unfiled$public/Inserted') <
      result.indexOf('unfiled$public/First')
    );
  }

  private class MetadataMock implements HttpCalloutMock {
    private String scenario;
    public List<String> requests = new List<String>();

    private MetadataMock(String scenario) {
      this.scenario = scenario;
    }

    public HttpResponse respond(HttpRequest request) {
      requests.add(request.getBody());
      HttpResponse response = new HttpResponse();
      response.setStatusCode(200);
      response.setHeader('Content-Type', 'text/xml');
      if (request.getBody().contains('<met:readMetadata>')) {
        response.setBody(readResponse());
      } else {
        response.setBody(saveResponse());
      }
      return response;
    }

    private String readResponse() {
      String recordXml;
      if (scenario == 'origin') {
        recordXml =
          '<records xsi:type="StandardValueSet"><fullName>CaseOrigin</fullName>' +
          '<standardValue><fullName>Email</fullName><default>false</default>' +
          '<label>Email</label></standardValue></records>';
      } else if (scenario == 'emailToCase') {
        recordXml =
          '<records xsi:type="CaseSettings"><fullName>Case</fullName>' +
          '<emailToCase><enableEmailToCase>true</enableEmailToCase>' +
          '<unauthorizedSenderAction>Discard</unauthorizedSenderAction>' +
          '</emailToCase></records>';
      } else {
        recordXml = '<records xsi:nil="true"/>';
      }
      return envelope(
        '<readMetadataResponse><result>' +
          recordXml +
          '</result></readMetadataResponse>'
      );
    }

    private String saveResponse() {
      Boolean created = scenario == 'listView';
      return envelope(
        '<saveResponse><result><created>' +
          String.valueOf(created).toLowerCase() +
          '</created><fullName>Test</fullName><success>true</success>' +
          '</result></saveResponse>'
      );
    }

    private String envelope(String body) {
      return '<?xml version="1.0" encoding="UTF-8"?>' +
        '<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" ' +
        'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">' +
        '<soapenv:Body>' +
        body +
        '</soapenv:Body></soapenv:Envelope>';
    }
  }
}