TestCaseMockTest.java

package org.openmetadata.sdk.entities;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;

import java.lang.reflect.Field;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.openmetadata.schema.api.tests.CreateTestCase;
import org.openmetadata.schema.tests.TestCase;
import org.openmetadata.schema.tests.type.TestCaseResult;
import org.openmetadata.sdk.client.OpenMetadata;
import org.openmetadata.sdk.client.OpenMetadataClient;
import org.openmetadata.sdk.services.tests.TestCaseService;

/**
 * Mock tests for TestCase entity operations.
 */
public class TestCaseMockTest {

  @Mock private OpenMetadataClient mockClient;
  @Mock private TestCaseService mockTestCaseService;

  @BeforeEach
  void setUp() throws Exception {
    MockitoAnnotations.openMocks(this);
    when(mockClient.testCases()).thenReturn(mockTestCaseService);

    // Ensure TestCase entity operations use this test's mock client even if another
    // test class initialized the static default client earlier in the JVM.
    org.openmetadata.sdk.entities.TestCase.setDefaultClient(mockClient);

    // Use reflection to set the private defaultClient field
    Field field = OpenMetadata.class.getDeclaredField("defaultClient");
    field.setAccessible(true);
    field.set(null, mockClient);
  }

  @Test
  void testCreateTestCase() {
    // Arrange
    CreateTestCase createRequest = new CreateTestCase();
    createRequest.setName("null-check-test");
    createRequest.setDisplayName("Null Check Test");
    createRequest.setDescription("Test to check for null values in column");
    // createRequest.setTestSuites(...); // Optional on CreateTestCase

    TestCase expectedTestCase = new TestCase();
    expectedTestCase.setId(UUID.randomUUID());
    expectedTestCase.setName("null-check-test");
    expectedTestCase.setFullyQualifiedName("quality-test-suite.null-check-test");

    when(mockTestCaseService.create(any(CreateTestCase.class))).thenReturn(expectedTestCase);

    // Act
    TestCase result = org.openmetadata.sdk.entities.TestCase.create(createRequest);

    // Assert
    assertNotNull(result);
    assertEquals("null-check-test", result.getName());
    verify(mockTestCaseService).create(any(CreateTestCase.class));
  }

  @Test
  void testRetrieveTestCase() {
    // Arrange
    String testCaseId = UUID.randomUUID().toString();
    TestCase expectedTestCase = new TestCase();
    expectedTestCase.setId(UUID.fromString(testCaseId));
    expectedTestCase.setName("duplicate-check");
    // expectedTestCase.setEnabled(true); // Check if this field exists

    when(mockTestCaseService.get(testCaseId)).thenReturn(expectedTestCase);

    // Act
    TestCase result = org.openmetadata.sdk.entities.TestCase.retrieve(testCaseId);

    // Assert
    assertNotNull(result);
    assertEquals(testCaseId, result.getId().toString());
    assertEquals("duplicate-check", result.getName());
    // assertTrue(result.getEnabled());
    verify(mockTestCaseService).get(testCaseId);
  }

  @Test
  void testRetrieveTestCaseWithResults() {
    // Arrange
    String testCaseId = UUID.randomUUID().toString();
    String fields = "testCaseResults,testSuite";
    TestCase expectedTestCase = new TestCase();
    expectedTestCase.setId(UUID.fromString(testCaseId));
    expectedTestCase.setName("range-check");

    // Mock test results
    TestCaseResult result1 = new TestCaseResult();
    // result1.setTestCaseStatus(TestCaseStatus.SUCCESS);
    result1.setResult("All values within expected range");

    // expectedTestCase.setTestCaseResults(List.of(result1));

    when(mockTestCaseService.get(testCaseId, fields)).thenReturn(expectedTestCase);

    // Act
    TestCase result = org.openmetadata.sdk.entities.TestCase.retrieve(testCaseId, fields);

    // Assert
    assertNotNull(result);
    // assertNotNull(result.getTestCaseResults());
    // assertEquals(1, result.getTestCaseResults().size());
    // assertEquals(TestCaseStatus.SUCCESS, result.getTestCaseResults().get(0).getTestCaseStatus());
    verify(mockTestCaseService).get(testCaseId, fields);
  }

  @Test
  void testRetrieveTestCaseByName() {
    // Arrange
    String fqn = "quality-suite.uniqueness-test";
    TestCase expectedTestCase = new TestCase();
    expectedTestCase.setName("uniqueness-test");
    expectedTestCase.setFullyQualifiedName(fqn);

    when(mockTestCaseService.getByName(fqn)).thenReturn(expectedTestCase);

    // Act
    TestCase result = org.openmetadata.sdk.entities.TestCase.retrieveByName(fqn);

    // Assert
    assertNotNull(result);
    assertEquals(fqn, result.getFullyQualifiedName());
    verify(mockTestCaseService).getByName(fqn);
  }

  @Test
  void testUpdateTestCase() {
    // Arrange
    TestCase testCaseToUpdate = new TestCase();
    testCaseToUpdate.setId(UUID.randomUUID());
    testCaseToUpdate.setName("updated-test");
    testCaseToUpdate.setDescription("Updated test case description");
    // testCaseToUpdate.setEnabled(false);

    TestCase expectedTestCase = new TestCase();
    expectedTestCase.setId(testCaseToUpdate.getId());
    expectedTestCase.setName(testCaseToUpdate.getName());
    expectedTestCase.setDescription(testCaseToUpdate.getDescription());
    // expectedTestCase.setEnabled(false);

    when(mockTestCaseService.update(testCaseToUpdate.getId().toString(), testCaseToUpdate))
        .thenReturn(expectedTestCase);

    // Act
    TestCase result =
        org.openmetadata.sdk.entities.TestCase.update(
            testCaseToUpdate.getId().toString(), testCaseToUpdate);

    // Assert
    assertNotNull(result);
    assertEquals("Updated test case description", result.getDescription());
    // assertFalse(result.getEnabled());
    verify(mockTestCaseService).update(testCaseToUpdate.getId().toString(), testCaseToUpdate);
  }

  @Test
  void testDeleteTestCase() {
    // Arrange
    String testCaseId = UUID.randomUUID().toString();
    doNothing().when(mockTestCaseService).delete(eq(testCaseId), any());

    // Act
    org.openmetadata.sdk.entities.TestCase.delete(testCaseId, false, false);

    // Assert
    verify(mockTestCaseService).delete(eq(testCaseId), any());
  }

  @Test
  void testTestCaseWithParameters() {
    // Arrange
    String testCaseId = UUID.randomUUID().toString();
    TestCase expectedTestCase = new TestCase();
    expectedTestCase.setId(UUID.fromString(testCaseId));
    expectedTestCase.setName("threshold-test");

    // Mock test parameters as JSON
    // expectedTestCase.setParameterValues(List.of(
    //     Map.of("column", "price", "min", 0, "max", 1000000)
    // ));

    when(mockTestCaseService.get(testCaseId, "parameterValues")).thenReturn(expectedTestCase);

    // Act
    TestCase result =
        org.openmetadata.sdk.entities.TestCase.retrieve(testCaseId, "parameterValues");

    // Assert
    assertNotNull(result);
    // assertNotNull(result.getParameterValues());
    // assertEquals(1, result.getParameterValues().size());
    verify(mockTestCaseService).get(testCaseId, "parameterValues");
  }

  @Test
  void testAsyncOperations() throws Exception {
    // Arrange
    String testCaseId = UUID.randomUUID().toString();
    TestCase expectedTestCase = new TestCase();
    expectedTestCase.setId(UUID.fromString(testCaseId));
    expectedTestCase.setName("async-test");

    when(mockTestCaseService.get(testCaseId)).thenReturn(expectedTestCase);

    // Act
    // Async not available in TestCase SDK, simulate with CompletableFuture
    var future =
        CompletableFuture.supplyAsync(
            () -> {
              try {
                return org.openmetadata.sdk.entities.TestCase.retrieve(testCaseId);
              } catch (Exception e) {
                throw new RuntimeException(e);
              }
            });
    TestCase result = future.get();

    // Assert
    assertNotNull(result);
    assertEquals("async-test", result.getName());
    verify(mockTestCaseService).get(testCaseId);
  }
}