From 2d4886eb025e478c67b8f19bfba369f4dd2036f3 Mon Sep 17 00:00:00 2001 From: Holash Chand Date: Tue, 23 Apr 2024 13:17:22 +0530 Subject: [PATCH] credential and credential schema registry unit tests added --- .../service/impl/SignatureV2ServiceImpl.java | 2 +- .../service/CredentialSchemaServiceTest.java | 251 +++++++++++++ .../registry/service/DIDServiceTest.java | 1 - .../impl/SignatureV2ServiceImplTest.java | 332 ++++++++++++++++++ 4 files changed, 584 insertions(+), 2 deletions(-) create mode 100644 java/registry/src/test/java/dev/sunbirdrc/registry/service/CredentialSchemaServiceTest.java create mode 100644 java/registry/src/test/java/dev/sunbirdrc/registry/service/impl/SignatureV2ServiceImplTest.java diff --git a/java/registry/src/main/java/dev/sunbirdrc/registry/service/impl/SignatureV2ServiceImpl.java b/java/registry/src/main/java/dev/sunbirdrc/registry/service/impl/SignatureV2ServiceImpl.java index 4f3bc6c86..be7100753 100644 --- a/java/registry/src/main/java/dev/sunbirdrc/registry/service/impl/SignatureV2ServiceImpl.java +++ b/java/registry/src/main/java/dev/sunbirdrc/registry/service/impl/SignatureV2ServiceImpl.java @@ -213,7 +213,7 @@ public ArrayNode revocationList(String issuerDid, Integer page, Integer limit) t return JsonNodeFactory.instance.arrayNode(); } - private JsonNode verifyCredential(String credentialId) throws IOException { + public JsonNode verifyCredential(String credentialId) throws IOException { ResponseEntity response = retryRestTemplate.getForEntity(verifyCredentialURL, credentialId); if (response.getStatusCode().is2xxSuccessful()) { return JSONUtil.convertStringJsonNode(response.getBody()); diff --git a/java/registry/src/test/java/dev/sunbirdrc/registry/service/CredentialSchemaServiceTest.java b/java/registry/src/test/java/dev/sunbirdrc/registry/service/CredentialSchemaServiceTest.java new file mode 100644 index 000000000..de475565b --- /dev/null +++ b/java/registry/src/test/java/dev/sunbirdrc/registry/service/CredentialSchemaServiceTest.java @@ -0,0 +1,251 @@ +package dev.sunbirdrc.registry.service; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.node.ArrayNode; +import com.fasterxml.jackson.databind.node.JsonNodeFactory; +import com.fasterxml.jackson.databind.node.ObjectNode; +import dev.sunbirdrc.pojos.ComponentHealthInfo; +import dev.sunbirdrc.registry.entities.AttestationPolicy; +import dev.sunbirdrc.registry.middleware.util.Constants; +import dev.sunbirdrc.registry.service.impl.RetryRestTemplate; +import dev.sunbirdrc.registry.util.Definition; +import dev.sunbirdrc.registry.util.IDefinitionsManager; +import org.junit.Test; +import org.junit.Before; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.springframework.http.HttpEntity; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.test.context.ActiveProfiles; +import org.springframework.test.context.junit4.SpringRunner; + +import java.io.IOException; +import java.lang.reflect.Field; +import java.util.*; + +import static org.junit.Assert.*; +import static org.mockito.Mockito.*; + +@RunWith(SpringRunner.class) +@ActiveProfiles(Constants.TEST_ENVIRONMENT) +public class CredentialSchemaServiceTest { + + @Mock + private DIDService didService; + @Mock + private ObjectMapper objectMapper; + @Mock + private RetryRestTemplate retryRestTemplate; + @Mock + private IDefinitionsManager definitionsManager; + @InjectMocks + private CredentialSchemaService credentialSchemaService; + @Mock + private CredentialSchemaService credentialSchemaServiceMock; + + @Before + public void setup() { + MockitoAnnotations.initMocks(this); + credentialSchemaServiceMock = spy(credentialSchemaService); + } + + @Test + public void test_valid_title_and_credential_template() throws IOException { + // Given + String title = "Test100"; + String credTemplate = "{ \"context\": [], \"credentialSubject\": { \"property1\": \"value1\", \"property2\": \"value2\" } }"; + + // When + JsonNode result = credentialSchemaService.convertCredentialTemplateToSchema(title, credTemplate); + + // Then + assertEquals("https://w3c-ccg.github.io/vc-json-schemas/", result.get("type").asText()); + assertEquals("1.0.0", result.get("version").asText()); + assertEquals("Proof of Test100 Credential", result.get("name").asText()); + assertEquals("Proof-of-Test100-Credential", result.get("schema").get("$id").asText()); + assertEquals("object", result.get("schema").get("type").asText()); + assertEquals("string", result.get("schema").get("properties").get("property1").get("type").asText()); + assertEquals("string", result.get("schema").get("properties").get("property2").get("type").asText()); + assertEquals(2, result.get("schema").get("required").size()); + assertEquals("property1", result.get("schema").get("required").get(0).asText()); + assertEquals("property2", result.get("schema").get("required").get(1).asText()); + } + + @Test + public void test_empty_title_and_valid_credential_template() throws IOException { + String title = "Test"; + Object credTemplate = new LinkedHashMap<>(); + ((LinkedHashMap) credTemplate).put("credentialSubject", new LinkedHashMap<>()); + + when(credentialSchemaServiceMock.convertCredentialTemplateToSchema(title, credTemplate)) + .thenCallRealMethod(); + + JsonNode result = credentialSchemaService.convertCredentialTemplateToSchema(title, credTemplate); + assertEquals("Proof of Test Credential", result.get("name").asText()); + assertFalse(result.get("schema").isEmpty()); + assertTrue(result.get("schema").get("properties").isObject()); + } + + @Test + public void test_ensure_credential_schemas() throws Exception { + Map credTemplates = new HashMap<>(); + JsonNode schema1 = new ObjectMapper().readTree("{\"title\": \"Title1\", \"definitions\": { \"title\": \"Title1\", \"properties\": {} }, \"_osConfig\": {}}"); + JsonNode schema2 = new ObjectMapper().readTree("{\"title\": \"Title2\", \"definitions\": { \"title\": \"Title2\", \"properties\": {} }, \"_osConfig\": {}}"); + JsonNode schema3 = new ObjectMapper().readTree("{\"title\": \"Title3\", \"definitions\": { \"title\": \"Title3\", \"properties\": {} }, \"_osConfig\": {}}"); + Definition definition1 = new Definition(schema1); + definition1.getOsSchemaConfiguration().setCredentialTemplate("CredTemplate1"); + credTemplates.put("Title1", "CredTemplate1"); + + Definition definition2 = new Definition(schema2); + definition2.getOsSchemaConfiguration().setCredentialTemplate("CredTemplate2"); + credTemplates.put("Title2", "CredTemplate2"); + + List attestationPolicies = new ArrayList<>(); + AttestationPolicy attestationPolicy1 = new AttestationPolicy(); + attestationPolicy1.setName("Policy1"); + attestationPolicy1.setCredentialTemplate("CredTemplate3"); + attestationPolicies.add(attestationPolicy1); + credTemplates.put("Title3_Policy1", "CredTemplate3"); + + Definition definition3 = new Definition(schema3); + definition3.getOsSchemaConfiguration().setAttestationPolicies(attestationPolicies); + + when(definitionsManager.getAllDefinitions()).thenReturn(Arrays.asList(definition1, definition2, definition3)); + doNothing().when(credentialSchemaServiceMock).ensureCredentialSchema(any(), any(), any()); + Field field = credentialSchemaServiceMock.getClass().getDeclaredField("definitionsManager"); + field.setAccessible(true); + field.set(credentialSchemaServiceMock, definitionsManager); + + doCallRealMethod().when(credentialSchemaServiceMock).ensureCredentialSchemas(); + + // Call the method under test + credentialSchemaServiceMock.ensureCredentialSchemas(); + + // Verify that the credential templates are retrieved correctly + verify(definitionsManager).getAllDefinitions(); + verify(credentialSchemaServiceMock).ensureCredentialSchema(eq("Title1"), eq("CredTemplate1"), any()); + verify(credentialSchemaServiceMock).ensureCredentialSchema(eq("Title2"), eq("CredTemplate2"), any()); + verify(credentialSchemaServiceMock).ensureCredentialSchema(eq("Title3_Policy1"), eq("CredTemplate3"), any()); + } + + @Test + public void test_getLatestSchemaByTags_success() throws Exception { + List tags = Collections.singletonList("Test Tag"); + ArrayNode schemas = JsonNodeFactory.instance.arrayNode(); + JsonNode schema1 = new ObjectMapper().readTree( + "{\"status\": \"DRAFT\", \"schema\": { \"version\": \"1.0.0\" }}" + ); + JsonNode schema2 = new ObjectMapper().readTree( + "{\"status\": \"DRAFT\", \"schema\": { \"version\": \"1.1.0\" }}" + ); + schemas.add(schema1); + schemas.add(schema2); + + doReturn(schemas).when(credentialSchemaServiceMock).getSchemaByTags(any()); + when(credentialSchemaServiceMock.getLatestSchemaByTags(any())).thenCallRealMethod(); + + JsonNode result = credentialSchemaServiceMock.getLatestSchemaByTags(tags); + + assertEquals(schema2, result); + } + + @Test + public void testGetSchemaByTags() throws IOException { + // Arrange + List tags = Arrays.asList("tag1", "tag2"); + String responseBody = "[{\"schema\": {\"version\": \"1.0\", \"id\": \"123\"}, \"status\": \"ACTIVE\"}, {\"schema\": {\"version\": \"2.0\", \"id\": \"456\"}, \"status\": \"ACTIVE\"}]"; + ResponseEntity responseEntity = new ResponseEntity<>(responseBody, HttpStatus.OK); + + when(retryRestTemplate.getForEntity(any(), any())).thenReturn(responseEntity); + ArrayNode result = credentialSchemaService.getSchemaByTags(tags); + assertNotNull(result); + assertEquals(2, result.size()); + + when(retryRestTemplate.getForEntity(any(), any())).thenReturn(ResponseEntity.badRequest().body("")); + result = credentialSchemaService.getSchemaByTags(tags); + assertNotNull(result); + assertEquals(0, result.size()); + } + + @Test + public void testCreateSchema() throws IOException { + String title = "Test Title"; + JsonNode credentialSchema = JsonNodeFactory.instance.objectNode(); + String status = "DRAFT"; + ObjectNode node = JsonNodeFactory.instance.objectNode(); + node.set("schema", credentialSchema); + ArrayNode tags = JsonNodeFactory.instance.arrayNode(); + tags.add(title); + node.set("tags", tags); + node.set("status", JsonNodeFactory.instance.textNode(status)); + ResponseEntity response = new ResponseEntity<>("{\"schema\": {\"title\": \"Test Title\"}}", HttpStatus.OK); + JsonNode expectedResult = JsonNodeFactory.instance.objectNode().set("title", JsonNodeFactory.instance.textNode("Test Title")); + + when(retryRestTemplate.postForEntity(any(), any(HttpEntity.class))).thenReturn(response); + when(objectMapper.readTree(anyString())).thenReturn(expectedResult); + JsonNode result = credentialSchemaService.createSchema(title, credentialSchema, status); + assertEquals(expectedResult, result); + + when(retryRestTemplate.postForEntity(any(), any(HttpEntity.class))).thenReturn(ResponseEntity.badRequest().body("")); + try { + credentialSchemaService.createSchema(title, credentialSchema, status); + fail("Exception should be thrown"); + } catch (RuntimeException e) { + assertTrue(true); + } + } + + @Test + public void testUpdateSchema() throws IOException { + String did = "did:example:123"; + String version = "1.0"; + String status = "ACTIVE"; + JsonNode credentialSchema = JsonNodeFactory.instance.objectNode(); + ((ObjectNode) credentialSchema).put("type", "Credential"); + ((ObjectNode) credentialSchema).put("title", "Test Credential"); + ((ObjectNode) credentialSchema).put("version", version); + + // Create expected result + JsonNode expectedResult = JsonNodeFactory.instance.objectNode(); + JsonNode expectedResultSchema = JsonNodeFactory.instance.objectNode(); + ((ObjectNode) expectedResult).set("schema", expectedResultSchema); + ((ObjectNode) expectedResultSchema).put("type", "Credential"); + ((ObjectNode) expectedResultSchema).put("title", "Test Credential"); + ((ObjectNode) expectedResultSchema).put("version", version); + + // Mock method calls + when(retryRestTemplate.putForEntity(any(), any(), eq(did), eq(version))).thenReturn(ResponseEntity.ok(expectedResult.toString())); + + // Call method under test + JsonNode result = credentialSchemaService.updateSchema(did, version, credentialSchema, status); + + // Verify the result + assertEquals(expectedResult.get("schema"), result); + } + + @Test + public void testGetHealthInfo() throws Exception { + // Mocking the RetryRestTemplate to return a ResponseEntity with a successful response + ResponseEntity successResponse = ResponseEntity.ok("{\"status\": \"UP\"}"); + when(retryRestTemplate.getForEntity(any())).thenReturn(successResponse); + + // Positive test case + ComponentHealthInfo healthInfo = credentialSchemaService.getHealthInfo(); + assertNotNull(healthInfo); + assertTrue(healthInfo.isHealthy()); + // Add assertions based on the expected behavior of getHealthInfo method for a successful response + + // Mocking the RetryRestTemplate to return a ResponseEntity with an unsuccessful response + ResponseEntity failureResponse = ResponseEntity.badRequest().body("Error"); + when(retryRestTemplate.getForEntity(any())).thenReturn(failureResponse); + + // Negative test case + ComponentHealthInfo failedHealthInfo = credentialSchemaService.getHealthInfo(); + assertNotNull(failedHealthInfo); + assertFalse(failedHealthInfo.isHealthy()); + } +} \ No newline at end of file diff --git a/java/registry/src/test/java/dev/sunbirdrc/registry/service/DIDServiceTest.java b/java/registry/src/test/java/dev/sunbirdrc/registry/service/DIDServiceTest.java index f11c6f90d..14f937afb 100644 --- a/java/registry/src/test/java/dev/sunbirdrc/registry/service/DIDServiceTest.java +++ b/java/registry/src/test/java/dev/sunbirdrc/registry/service/DIDServiceTest.java @@ -19,7 +19,6 @@ import org.junit.runner.RunWith; import org.mockito.InjectMocks; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; import org.springframework.http.ResponseEntity; import org.springframework.test.context.ActiveProfiles; import org.springframework.test.context.junit4.SpringRunner; diff --git a/java/registry/src/test/java/dev/sunbirdrc/registry/service/impl/SignatureV2ServiceImplTest.java b/java/registry/src/test/java/dev/sunbirdrc/registry/service/impl/SignatureV2ServiceImplTest.java new file mode 100644 index 000000000..8273a6790 --- /dev/null +++ b/java/registry/src/test/java/dev/sunbirdrc/registry/service/impl/SignatureV2ServiceImplTest.java @@ -0,0 +1,332 @@ +package dev.sunbirdrc.registry.service.impl; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.node.ArrayNode; +import com.fasterxml.jackson.databind.node.JsonNodeFactory; +import com.fasterxml.jackson.databind.node.ObjectNode; +import com.fasterxml.jackson.databind.node.TextNode; +import dev.sunbirdrc.pojos.ComponentHealthInfo; +import dev.sunbirdrc.registry.dao.NotFoundException; +import dev.sunbirdrc.registry.exception.SignatureException; +import dev.sunbirdrc.registry.middleware.util.Constants; +import dev.sunbirdrc.registry.service.CredentialSchemaService; +import dev.sunbirdrc.registry.service.DIDService; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpStatus; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.test.context.ActiveProfiles; +import org.springframework.test.context.junit4.SpringRunner; + +import java.io.IOException; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; + +import static org.junit.Assert.*; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.*; + +@RunWith(SpringRunner.class) +@ActiveProfiles(Constants.TEST_ENVIRONMENT) +public class SignatureV2ServiceImplTest { + + @Mock + private RetryRestTemplate retryRestTemplate; + + @Mock + private ObjectMapper objectMapper; + + @Mock + private CredentialSchemaService credentialSchemaService; + + @Mock + private DIDService didService; + + @InjectMocks + private SignatureV2ServiceImpl signatureService; + + private SignatureV2ServiceImpl signatureServiceMock; + + @Before + public void setup() { + MockitoAnnotations.initMocks(this); + signatureServiceMock = spy(signatureService); + } + + @Test + public void testSign_Success() throws Exception { + // Prepare test data + String title = "Test Title"; + ObjectNode data = JsonNodeFactory.instance.objectNode(); + data.put("key", "value"); + Object credentialTemplate = "{ \"context\": [], \"credentialSubject\": { \"property1\": \"value1\", \"property2\": \"value2\" } }"; + + doReturn(null).when(signatureServiceMock).issueCredential(any(), any(), any()); + doReturn(new ObjectMapper().readTree("{ \"schema\": { \"id\": \"schemaid\", \"version\": \"1.0.0\" }}")).when(credentialSchemaService).getLatestSchemaByTags(any()); + + Map map = new HashMap<>(); + map.put("title", title); + map.put("data", data); + map.put("credentialTemplate", credentialTemplate); + + try { + signatureServiceMock.sign(map); + } catch (Exception e) { + fail("Exception should not be thrown"); + } + } + + @Test + public void testSign_Exception() throws Exception { + // Prepare test data + String title = "Test Title"; + ObjectNode data = JsonNodeFactory.instance.objectNode(); + data.put("key", "value"); + Object credentialTemplate = "{ \"context\": [], \"credentialSubject\": { \"property1\": \"value1\", \"property2\": \"value2\" } }"; + + doThrow(new RuntimeException()).when(signatureServiceMock).issueCredential(any(), any(), any()); + doReturn(new ObjectMapper().readTree("{ \"schema\": { \"id\": \"schemaid\", \"version\": \"1.0.0\" }}")).when(credentialSchemaService).getLatestSchemaByTags(any()); + + Map map = new HashMap<>(); + map.put("title", title); + map.put("data", data); + map.put("credentialTemplate", credentialTemplate); + + try { + signatureServiceMock.sign(map); + fail("Exception should be thrown"); + } catch (Exception e) { + assertTrue(true); + } + } + + @Test + public void testVerify_Success() throws SignatureException.VerificationException, SignatureException.UnreachableException, IOException { + // Prepare test data + ObjectNode credential = JsonNodeFactory.instance.objectNode(); + credential.put("credentialId", "12345"); + + ObjectNode result = JsonNodeFactory.instance.objectNode(); + result.put("verified", "true"); + + doReturn(result).when(signatureServiceMock).verifyCredential(any()); + assertTrue(signatureServiceMock.verify(Collections.singletonMap("credentialId", "12345"))); + + result.put("verified", "false"); + assertFalse(signatureServiceMock.verify(Collections.singletonMap("credentialId", "12345"))); + } + + @Test + public void testVerify_Exception() throws Exception { + // Prepare test data + ObjectNode credential = JsonNodeFactory.instance.objectNode(); + credential.put("credentialId", "12345"); + + doThrow(new IOException()).when(signatureServiceMock).verifyCredential(any()); + try { + signatureServiceMock.verify(Collections.singletonMap("credentialId", "12345")); + fail("Exception should be thrown"); + } catch (Exception e) { + assertTrue(true); + } + } + + @Test + public void testGetKey_success() throws Exception { + String keyId = "did:1234"; + JsonNode didDocument = new ObjectMapper().readTree("{\"verificationMethod\": [{\"id\": \"did:1234\"}]}"); + when(didService.resolveDid(keyId)).thenReturn(didDocument); + assertEquals(new ObjectMapper().readTree(signatureService.getKey(keyId)).get("id").asText(), keyId); + } + + @Test + public void testGetKey_not_exists() throws Exception { + String keyId = "did:1234"; + JsonNode didDocument = new ObjectMapper().readTree("{\"verificationMethod\": [{\"id\": \"did:12345\"}]}"); + when(didService.resolveDid(keyId)).thenReturn(didDocument); + assertNull(signatureService.getKey(keyId)); + } + + @Test + public void restRevoke_success() throws Exception { + String credentialId = "did:1234"; + doNothing().when(retryRestTemplate).deleteForEntity(any(), eq(credentialId)); + try { + signatureService.revoke("", "", credentialId); + } catch (Exception e) { + fail("Exception should not be thrown"); + } + } + + @Test + public void testRevoke_Exception() throws Exception { + String credentialId = "did:1234"; + doThrow(new RuntimeException("Not Valid")).when(retryRestTemplate).deleteForEntity(any(), eq(credentialId)); + try { + signatureService.revoke("", "", credentialId); + fail("Exception should be thrown"); + } catch (Exception e) { + assertTrue(true); + } + } + + @Test + public void testGetCertificate_application_json() throws Exception { + // Set up test data + String credentialId = "123"; + byte[] bytesResult = new byte[]{1,2,3,4,5}; + + // Mock getCredentialById method + String template = "abcd"; + when(retryRestTemplate.getForEntity(any(), any())).thenReturn(ResponseEntity.ok(template)); + doReturn(JsonNodeFactory.instance.objectNode()).when(signatureServiceMock).getCredentialById(any()); + doReturn(bytesResult).when(signatureServiceMock).getCredentialById(any(), any(), any(), any()); + + Object result = signatureServiceMock.getCertificate(new TextNode(credentialId), null, null, "application/json", null, null, null); + assertEquals(JsonNodeFactory.instance.objectNode(), result); + + result = signatureServiceMock.getCertificate(new TextNode(credentialId), null, null, "application/pdf", null, null, null); + assertEquals(bytesResult, result); + } + + @Test + public void testGetCredentialById() throws IOException, NotFoundException { + String credentialId = "validCredentialId"; + String responseBody = "{\"id\": \"validCredentialId\", \"name\": \"John Doe\"}"; + ResponseEntity responseEntity = new ResponseEntity<>(responseBody, HttpStatus.OK); + ResponseEntity badResponse = new ResponseEntity<>(responseBody, HttpStatus.BAD_REQUEST); + + // Positive test case + when(retryRestTemplate.getForEntity(any(), any())).thenReturn(responseEntity); + JsonNode expectedJsonNode = new ObjectMapper().readTree(responseBody); + JsonNode actualJsonNode = signatureService.getCredentialById(credentialId); + assertEquals(expectedJsonNode, actualJsonNode); + + // negative test case + when(retryRestTemplate.getForEntity(any(), any())).thenReturn(badResponse); + try { + signatureService.getCredentialById(credentialId); + fail("Exception should be thrown"); + } catch (NotFoundException e) { + assertTrue(true); + } + } + + @Test + public void testGetCredentialByIdWithFormatRender() { + // Set up test data + String credentialId = "123"; + String format = "application/pdf"; + String templateId = "456"; + String template = "template"; + + // Set up mock response + HttpHeaders headers = new HttpHeaders(); + headers.set("templateId", templateId); + headers.set("template", template.trim()); + headers.setAccept(Collections.singletonList(MediaType.valueOf(format))); + byte[] responseBody = "credential".getBytes(); + ResponseEntity responseEntity = new ResponseEntity<>(responseBody, HttpStatus.OK); + when(retryRestTemplate.getForObject(any(), eq(headers), eq(byte[].class), eq(credentialId))).thenReturn(responseEntity); + + // Invoke the method + byte[] result = null; + try { + result = signatureService.getCredentialById(credentialId, format, templateId, template); + } catch (IOException | NotFoundException e) { + fail("Exception should not be thrown"); + } + + // Verify the result + assertNotNull(result); + assertEquals(responseBody, result); + } + + @Test + public void testRevocationList_success() throws IOException { + // Set up test data + String issuerDid = "validIssuerDid"; + Integer page = 1; + Integer limit = 10; + String responseBody = "[{\"id\": \"1\", \"name\": \"John Doe\"}, {\"id\": \"2\", \"name\": \"Jane Smith\"}]"; + ResponseEntity responseEntity = new ResponseEntity<>(responseBody, HttpStatus.OK); + + // Mock the behavior of retryRestTemplate.getForEntity() + when(retryRestTemplate.getForEntity(any(), any(), any(), any())).thenReturn(responseEntity); + + // Invoke the method under test + ArrayNode result = signatureService.revocationList(issuerDid, page, limit); + + // Verify the result + assertNotNull(result); + assertEquals(2, result.size()); + assertEquals("1", result.get(0).get("id").asText()); + assertEquals("John Doe", result.get(0).get("name").asText()); + assertEquals("2", result.get(1).get("id").asText()); + assertEquals("Jane Smith", result.get(1).get("name").asText()); + + // Verify the interaction with dependencies + verify(retryRestTemplate).getForEntity(any(), eq(issuerDid), eq(page), eq(limit)); + verifyNoMoreInteractions(retryRestTemplate); + verifyNoInteractions(objectMapper, credentialSchemaService, didService); + } + + @Test + public void testRevocationList_Exception() throws IOException { + // Set up test data + String issuerDid = "validIssuerDid"; + Integer page = 1; + Integer limit = 10; + String responseBody = "{\"error\": \"Invalid request\"}"; + ResponseEntity responseEntity = new ResponseEntity<>(responseBody, HttpStatus.BAD_REQUEST); + + // Mock the behavior of retryRestTemplate.getForEntity() + when(retryRestTemplate.getForEntity(any(), any(), any(), any())).thenReturn(responseEntity); + + // Invoke the method under test + ArrayNode result = signatureService.revocationList(issuerDid, page, limit); + + // Verify the result + assertNotNull(result); + assertTrue(result.isEmpty()); + + // Verify the interaction with dependencies + verify(retryRestTemplate).getForEntity(any(), eq(issuerDid), eq(page), eq(limit)); + verifyNoMoreInteractions(retryRestTemplate); + verifyNoInteractions(objectMapper, credentialSchemaService, didService); + } + + @Test + public void testGetHealthInfo() throws Exception { + // Mocking the RetryRestTemplate to return a ResponseEntity with a successful response + ResponseEntity successResponse = ResponseEntity.ok("{\"status\": \"UP\"}"); + when(retryRestTemplate.getForEntity(any())).thenReturn(successResponse); + + // Positive test case + ComponentHealthInfo healthInfo = signatureService.getHealthInfo(); + assertNotNull(healthInfo); + assertTrue(healthInfo.isHealthy()); + // Add assertions based on the expected behavior of getHealthInfo method for a successful response + + // Mocking the RetryRestTemplate to return a ResponseEntity with an unsuccessful response + ResponseEntity failureResponse = ResponseEntity.badRequest().body("Error"); + when(retryRestTemplate.getForEntity(any())).thenReturn(failureResponse); + + // Negative test case + ComponentHealthInfo failedHealthInfo = signatureService.getHealthInfo(); + assertNotNull(failedHealthInfo); + assertFalse(failedHealthInfo.isHealthy()); + // Add assertions based on the expected behavior of getHealthInfo method with a failed response + } + + // Add similar tests for other methods like getKey, revoke, getCertificate, etc. +} \ No newline at end of file