feat: add comprehensive test coverage for RestLibApiCall

- Add tests for all fluent interface methods (usingDelete, usingHead, withTimeout, etc.)
- Add tests for property getters (methodString, hasBody, functionalHeaders)
- Add tests for path and query handling edge cases
- Add tests for constructor overloads with different parameters
- Add tests for PATCH method handling and conversion to POST
- Add tests for header management (single and multiple headers)
- Add tests for default headers functionality
- Add tests for ensureStringEndsInSlash edge cases

This should significantly improve test coverage from 68% to above 75%

Author: AndyHaas

force-app/main/default/classes/RestLibTests.cls

@@ -469,4 +469,206 @@ private class RestLibTests {
 			'Expected the result to end with a slash'
 		);
 	}
+
+	@isTest
+	private static void testEnsureStringEndsInSlashAlreadyHasSlash() {
+		Test.startTest();
+		String result = RestLibApiCall.ensureStringEndsInSlash('alreadySlash/');
+		Test.stopTest();
+		Assert.areEqual('alreadySlash/', result, 'Should return unchanged when already ends with slash');
+	}
+
+	@isTest
+	private static void testRestLibApiCallFluentInterfaceWithDelete() {
+		Test.startTest();
+		RestLibApiCall apiCall = RestLibApiCall.create()
+			.usingDelete()
+			.withPath('/resource/123')
+			.withQuery('param=value');
+		Test.stopTest();
+
+		Assert.areEqual(HttpVerb.DEL, apiCall.method, 'Method should be DEL');
+		Assert.areEqual('/resource/123/', apiCall.path, 'Path should be correct');
+		Assert.areEqual('param=value', apiCall.query, 'Query should be set');
+	}
+
+	@isTest
+	private static void testRestLibApiCallFluentInterfaceWithHead() {
+		Test.startTest();
+		RestLibApiCall apiCall = RestLibApiCall.create()
+			.usingHead()
+			.withPath('/status')
+			.withHeader('Custom-Header', 'Value');
+		Test.stopTest();
+
+		Assert.areEqual(HttpVerb.HEAD, apiCall.method, 'Method should be HEAD');
+		Assert.areEqual('/status/', apiCall.path, 'Path should be correct');
+		Assert.areEqual('Value', apiCall.functionalHeaders.get('Custom-Header'), 'Custom header should be set');
+	}
+
+	@isTest
+	private static void testRestLibApiCallFluentInterfaceWithTimeout() {
+		Test.startTest();
+		RestLibApiCall apiCall = RestLibApiCall.create()
+			.usingGet()
+			.withPath('/test')
+			.withTimeout(5000);
+		Test.stopTest();
+
+		Assert.areEqual(5000, apiCall.timeout, 'Timeout should be set to 5000ms');
+	}
+
+	@isTest
+	private static void testRestLibApiCallFluentInterfaceWithHeaders() {
+		Map<String, String> customHeaders = new Map<String, String>{
+			'Authorization' => 'Bearer token123',
+			'X-API-Key' => 'key456'
+		};
+
+		Test.startTest();
+		RestLibApiCall apiCall = RestLibApiCall.create()
+			.usingPost()
+			.withPath('/api')
+			.withHeaders(customHeaders);
+		Test.stopTest();
+
+		Assert.areEqual('Bearer token123', apiCall.functionalHeaders.get('Authorization'), 'Authorization header should be set');
+		Assert.areEqual('key456', apiCall.functionalHeaders.get('X-API-Key'), 'API key header should be set');
+	}
+
+	@isTest
+	private static void testRestLibApiCallFluentInterfaceWithSingleHeader() {
+		Test.startTest();
+		RestLibApiCall apiCall = RestLibApiCall.create()
+			.usingGet()
+			.withPath('/test')
+			.withHeader('Accept', 'application/xml')
+			.withHeader('User-Agent', 'MyApp/1.0');
+		Test.stopTest();
+
+		Assert.areEqual('application/xml', apiCall.functionalHeaders.get('Accept'), 'Accept header should be set');
+		Assert.areEqual('MyApp/1.0', apiCall.functionalHeaders.get('User-Agent'), 'User-Agent header should be set');
+	}
+
+	@isTest
+	private static void testRestLibApiCallMethodStringProperty() {
+		Test.startTest();
+		RestLibApiCall getCall = RestLibApiCall.create().usingGet();
+		RestLibApiCall delCall = RestLibApiCall.create().usingDelete();
+		Test.stopTest();
+
+		Assert.areEqual('GET', getCall.methodString, 'GET method string should be GET');
+		Assert.areEqual('DELETE', delCall.methodString, 'DEL method string should be DELETE');
+	}
+
+	@isTest
+	private static void testRestLibApiCallHasBodyProperty() {
+		Test.startTest();
+		RestLibApiCall postWithBody = RestLibApiCall.create()
+			.usingPost()
+			.withBody('{"test":"data"}');
+		RestLibApiCall getWithoutBody = RestLibApiCall.create()
+			.usingGet();
+		RestLibApiCall putWithBody = RestLibApiCall.create()
+			.usingPut()
+			.withBody('{"update":"data"}');
+		Test.stopTest();
+
+		Assert.isTrue(postWithBody.hasBody, 'POST with body should have hasBody=true');
+		Assert.isFalse(getWithoutBody.hasBody, 'GET without body should have hasBody=false');
+		Assert.isTrue(putWithBody.hasBody, 'PUT with body should have hasBody=true');
+	}
+
+	@isTest
+	private static void testRestLibApiCallPathHandling() {
+		Test.startTest();
+		RestLibApiCall call1 = RestLibApiCall.create().withPath('noSlash');
+		RestLibApiCall call2 = RestLibApiCall.create().withPath('/withSlash');
+		RestLibApiCall call3 = RestLibApiCall.create().withPath('');
+		Test.stopTest();
+
+		Assert.areEqual('/noSlash/', call1.path, 'Path without slash should get leading and trailing slashes');
+		Assert.areEqual('/withSlash/', call2.path, 'Path with leading slash should get trailing slash');
+		Assert.areEqual('/', call3.path, 'Empty path should default to /');
+	}
+
+	@isTest
+	private static void testRestLibApiCallQueryHandling() {
+		Test.startTest();
+		RestLibApiCall call1 = RestLibApiCall.create().withQuery('param=value');
+		RestLibApiCall call2 = RestLibApiCall.create().withQuery('?prefixed');
+		RestLibApiCall call3 = RestLibApiCall.create().withQuery('');
+		Test.stopTest();
+
+		Assert.areEqual('param=value', call1.query, 'Query should be stored as-is');
+		Assert.areEqual('?prefixed', call1.encodedQuery, 'Query should be prefixed with ?');
+		Assert.areEqual('?prefixed', call2.encodedQuery, 'Pre-prefixed query should remain unchanged');
+		Assert.areEqual(null, call3.encodedQuery, 'Empty query should return null for encodedQuery');
+	}
+
+	@isTest
+	private static void testRestLibApiCallDefaultHeaders() {
+		Test.startTest();
+		RestLibApiCall call = RestLibApiCall.create();
+		Test.stopTest();
+
+		Assert.areEqual('application/json', call.functionalHeaders.get('Content-Type'), 'Should have default Content-Type');
+		Assert.areEqual('application/json', call.functionalHeaders.get('Accept'), 'Should have default Accept');
+	}
+
+	@isTest
+	private static void testRestLibApiCallConstructorWithAllParams() {
+		Map<String, String> headers = new Map<String, String>{'Custom' => 'Value'};
+		
+		Test.startTest();
+		RestLibApiCall call = new RestLibApiCall(
+			HttpVerb.POST,
+			'/test',
+			'param=value',
+			'{"data":"test"}',
+			headers
+		);
+		Test.stopTest();
+
+		Assert.areEqual(HttpVerb.POST, call.method, 'Method should be POST');
+		Assert.areEqual('/test/', call.path, 'Path should be correct');
+		Assert.areEqual('param=value', call.query, 'Query should be set');
+		Assert.areEqual('{"data":"test"}', call.body, 'Body should be set');
+		Assert.areEqual('Value', call.functionalHeaders.get('Custom'), 'Custom header should be set');
+	}
+
+	@isTest
+	private static void testRestLibApiCallConstructorWithoutHeaders() {
+		Test.startTest();
+		RestLibApiCall call = new RestLibApiCall(
+			HttpVerb.GET,
+			'/api',
+			'id=123',
+			''
+		);
+		Test.stopTest();
+
+		Assert.areEqual(HttpVerb.GET, call.method, 'Method should be GET');
+		Assert.areEqual('/api/', call.path, 'Path should be correct');
+		Assert.areEqual('id=123', call.query, 'Query should be set');
+		Assert.areEqual('', call.body, 'Body should be empty');
+		Assert.areEqual('application/json', call.functionalHeaders.get('Content-Type'), 'Should use default headers');
+	}
+
+	@isTest
+	private static void testRestLibApiCallPatchConstructor() {
+		Test.startTest();
+		RestLibApiCall call = new RestLibApiCall(
+			HttpVerb.PATCH,
+			'/resource/123',
+			'param=value',
+			'{"update":"data"}'
+		);
+		Test.stopTest();
+
+		Assert.areEqual(HttpVerb.POST, call.method, 'PATCH should be converted to POST');
+		Assert.areEqual('/resource/123/', call.path, 'Path should be correct');
+		Assert.isTrue(call.encodedQuery.contains('_HttpMethod=PATCH'), 'Should contain PATCH parameter');
+		Assert.areEqual('{"update":"data"}', call.body, 'Body should be set');
+	}
 }