Test Framework #53

agent/src/test/java/org/apache/airavata/mft/agent/MFTAgentTest.java

@@ -0,0 +1,116 @@
+package org.apache.airavata.mft.agent;
+
+import com.orbitz.consul.KeyValueClient;
+import com.orbitz.consul.cache.ConsulCache;
+import com.orbitz.consul.cache.KVCache;
+import com.orbitz.consul.model.kv.Value;
+import org.apache.airavata.mft.admin.MFTConsulClient;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.*;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class MFTAgentTest {
+
+    @Autowired
+    @InjectMocks
+    private MFTAgent mftAgent;
+
+    @Mock
+    private MFTConsulClient mftConsulClient;
+
+    @Mock
+    private ExecutorService transferRequestExecutor;
+
+    @Mock
+    private ConsulCache.Listener<String, Value> transferCacheListener;
+
+    @Mock
+    private ConsulCache.Listener<String, Value> rpcCacheListener;
+
+    @Mock
+    private KVCache rpcMessageCache;
+
+    @Mock
+    private KVCache transferMessageCache;
+
+    // Mocking a static method using Mockito.mockStatic
+    @Test
+    void testInit() {
+        try (MockedStatic<KVCache> kvCache = Mockito.mockStatic(KVCache.class);
+             MockedStatic<Executors> transferRequestExecutor = Mockito.mockStatic(Executors.class)) {
+            // given
+            kvCache.when(() -> KVCache.newCache(
+                    any(KeyValueClient.class),
+                    any(String.class))).thenReturn(null);
+            transferRequestExecutor.when(() -> Executors.newFixedThreadPool(any(Integer.class)))
+                    .thenReturn(null);
+
+            // when
+            mftAgent.init();
+
+            //then
+            verify(mftConsulClient, times(2)).getKvClient();
+        }
+    }
+
+    @Test
+    void testDisconnectAgent() {
+        mftAgent.disconnectAgent();
+        verify(rpcMessageCache, times(1)).removeListener(any());
+    }
+
+    // Mocking a method in the same class using Mockito.spy
+    @Test
+    void testStop(){
+        // given
+        MFTAgent mftAgent1 = spy(mftAgent);
+        doNothing().when(mftAgent1).disconnectAgent();
+        doNothing().when(transferRequestExecutor).shutdown();
+
+        // when
+        mftAgent1.stop();
+
+        // then
+        verify(mftAgent1, times(1)).disconnectAgent();
+        verify(transferRequestExecutor, times(1)).shutdown();
+    }
+
+    // Mock nested methods
+    @Test
+    void testEstablishConnectionWithConsul() throws Exception{
+//        ImmutableSession sessionObj = ImmutableSession.builder().name("testagent").behavior("delete").ttl("10s").build();
+//        try (MockedStatic<ImmutableSession> session = Mockito.mockStatic(ImmutableSession.class)) {
+//            // given
+//            SessionCreatedResponse sessResp = new SessionCreatedResponse() {
+//                @Override
+//                public String getId() {
+//                    return "test-id";
+//                }
+//            };
+//            MFTAgent mftAgent1 = spy(mftAgent);
+//            MFTConsulClient mftConsulClient1 = mock(MFTConsulClient.class, RETURNS_DEEP_STUBS);
+//            session.when(() -> ImmutableSession.builder().name(anyString()).behavior(anyString()).ttl(anyString()).build()).thenReturn(sessionObj);
+//            when(mftConsulClient1.getSessionClient().createSession(any(ImmutableSession.class))).thenReturn(sessResp);
+//            when(mftConsulClient1.getKvClient().acquireLock(anyString(), anyString())).thenReturn(true);
+//            doNothing().when(mftAgent1).init();
+//
+//            // when
+//            mftAgent1.start();
+//
+//            // then
+//            verify(mftConsulClient).submitTransferStateToProcess(anyString(), anyString(), any(TransferState.class));
+//        }
+    }
+
+    @Test
+    void testRunMFTAgent() throws Exception{
+    }
+}

api/service/pom.xml

@@ -86,6 +86,12 @@
             <version>0.01-SNAPSHOT</version>
             <scope>runtime</scope>
         </dependency>
+        <dependency>
+            <groupId>org.apache.airavata</groupId>
+            <artifactId>mft-api-client</artifactId>
+            <version>0.01-SNAPSHOT</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>

api/service/src/test/java/org/apache/airavata/mft/api/handler/MFTApiHandlerTest.java

@@ -0,0 +1,118 @@
+package org.apache.airavata.mft.api.handler;
+
+import io.grpc.stub.StreamObserver;
+import org.apache.airavata.mft.admin.MFTConsulClient;
+import org.apache.airavata.mft.admin.MFTConsulClientException;
+import org.apache.airavata.mft.admin.models.TransferState;
+import org.apache.airavata.mft.api.service.TransferApiRequest;
+import org.apache.airavata.mft.api.service.TransferApiResponse;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+public class MFTApiHandlerTest {
+
+    @Autowired
+    @InjectMocks
+    private MFTApiHandler mftApiHandler;
+
+    @Mock
+    private MFTConsulClient mftConsulClient;
+
+    @BeforeEach
+    public void setUp() throws Exception {
+    }
+
+    @AfterEach
+    public void tearDown() throws Exception {
+        mftApiHandler = null;
+        mftConsulClient = null;
+    }
+
+    @Test
+    public void testValidSubmitTransfer() throws MFTConsulClientException {
+        // given
+        TransferApiRequest transferApiRequest = TransferApiRequest.newBuilder()
+                .setSourceToken("mock-source-token-1234")
+                .setDestinationToken("mock-destination-token-1234")
+                .setDestinationStorageId("mock-destination-storage-id-1234")
+                .setDestinationPath("test/test-file2.txt")
+                .setSourceStorageId("mock-source-storage-id-1234")
+                .setSourcePath("test-file.txt").build();
+        // mftConsulClient mock behavior
+        when(mftConsulClient.submitTransfer(transferApiRequest)).thenReturn("mock-transfer-id-test-1234");
+        doNothing().when(mftConsulClient).saveTransferState(any(String.class), any(TransferState.class));
+        // mock stream observer
+        StreamObserver<TransferApiResponse> observer = mock(StreamObserver.class);
+
+        // when
+        mftApiHandler.submitTransfer(transferApiRequest, observer);
+
+        // then
+        verify(observer).onNext(any(TransferApiResponse.class));
+        verify(observer, times(1)).onCompleted();
+        verify(observer, times(0)).onError(any(MFTConsulClientException.class));
+    }
+
+    @Test
+    public void testInvalidSubmitTransfer() throws MFTConsulClientException {
+        // given
+        TransferApiRequest transferApiRequest = TransferApiRequest.newBuilder()
+                .setSourceToken("mock-source-token-1234")
+                .setDestinationToken("mock-destination-token-1234")
+                .setDestinationStorageId("mock-destination-storage-id-1234")
+                .setDestinationPath("test/test-file2.txt")
+                .setSourceStorageId("mock-source-storage-id-1234")
+                .setSourcePath("test-file.txt").build();
+        // mftConsulClient mock behavior
+        when(mftConsulClient.submitTransfer(transferApiRequest)).thenThrow(new MFTConsulClientException("Test Exception"));
+        // mock stream observer
+        StreamObserver<TransferApiResponse> observer = mock(StreamObserver.class);
+
+        // when
+        mftApiHandler.submitTransfer(transferApiRequest, observer);
+
+        // then
+        verify(observer, times(0)).onNext(any(TransferApiResponse.class));
+        verify(observer, times(0)).onCompleted();
+        verify(observer, times(0)).onError(any(MFTConsulClientException.class));
+    }
+
+    @Disabled
+    public void testSubmitBatchTransfer() {
+    }
+
+    @Disabled
+    public void testSubmitHttpUpload() {
+    }
+
+    @Disabled
+    public void testSubmitHttpDownload() {
+    }
+
+    @Disabled
+    public void testGetTransferStates() {
+    }
+
+    @Disabled
+    public void testGetTransferState() {
+    }
+
+    @Disabled
+    public void testGetFileResourceMetadata() {
+    }
+
+    @Disabled
+    public void testGetDirectoryResourceMetadata() {
+    }
+}

pom.xml

@@ -130,6 +130,36 @@
             <artifactId>log4j-1.2-api</artifactId>
             <version>${log4j2.version}</version>
         </dependency>
+<!--        <dependency>-->
+<!--            <groupId>org.junit.jupiter</groupId>-->
+<!--            <artifactId>junit-jupiter</artifactId>-->
+<!--            <version>5.9.0</version>-->
+<!--            <scope>test</scope>-->
+<!--        </dependency>-->
+<!--        <dependency>-->
+<!--            <groupId>org.mockito</groupId>-->
+<!--            <artifactId>mockito-inline</artifactId>-->
+<!--            <version>4.8.0</version>-->
+<!--            <scope>test</scope>-->
+<!--        </dependency>-->
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-junit-jupiter</artifactId>
+            <version>4.8.0</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
+            <version>5.7.0</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>4.8.0</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <properties>

services/resource-service/server/src/test/java/org/apache/airavata/mft/resource/server/backend/sql/SQLResourceBackendTest.java

@@ -0,0 +1,109 @@
+package org.apache.airavata.mft.resource.server.backend.sql;
+
+import org.apache.airavata.mft.resource.server.backend.sql.entity.ResolveStorageEntity;
+import org.apache.airavata.mft.resource.server.backend.sql.entity.S3StorageEntity;
+import org.apache.airavata.mft.resource.server.backend.sql.repository.ResolveStorageRepository;
+import org.apache.airavata.mft.resource.server.backend.sql.repository.S3StorageRepository;
+import org.apache.airavata.mft.resource.stubs.s3.storage.S3Storage;
+import org.apache.airavata.mft.resource.stubs.s3.storage.S3StorageCreateRequest;
+import org.apache.airavata.mft.resource.stubs.s3.storage.S3StorageListRequest;
+import org.apache.airavata.mft.resource.stubs.s3.storage.S3StorageListResponse;
+import org.dozer.DozerBeanMapper;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.PageRequest;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class SQLResourceBackendTest {
+
+    @InjectMocks
+    private SQLResourceBackend sqlResourceBackend;
+
+    @Mock
+    private S3StorageRepository s3StorageRepository;
+
+    @Mock
+    private ResolveStorageRepository resolveStorageRepository;
+
+    @Test
+    void successfullyListS3Storage() throws Exception{
+        // given
+        S3StorageListRequest testRequest = S3StorageListRequest.newBuilder().setOffset(0).setLimit(10).build();
+        // mock s3StorageRepository
+        List<S3StorageEntity> testResponse = new ArrayList<>();
+        S3StorageEntity s3StorageResp = new S3StorageEntity();
+        s3StorageResp.setStorageId("test-storage-id-1234");
+        s3StorageResp.setName("test-storage-1");
+        s3StorageResp.setBucketName("test-bucket-1");
+        s3StorageResp.setRegion("us-east-2");
+        s3StorageResp.setEndpoint("https://s3.us-east-2.amazonaws.com");
+        s3StorageResp.setUseTLS(false);
+        testResponse.add(s3StorageResp);
+        when(s3StorageRepository.findAll(
+                PageRequest.of(testRequest.getOffset(), testRequest.getLimit())))
+                .thenReturn(testResponse);
+
+        // when
+        S3StorageListResponse response = sqlResourceBackend.listS3Storage(testRequest);
+
+        // then
+        verify(s3StorageRepository, times(1)).findAll(
+                PageRequest.of(testRequest.getOffset(), testRequest.getLimit()));
+        assertEquals(response.getStoragesList().size(), testResponse.size());
+        assertFalse(response.getStoragesList().isEmpty());
+        assertEquals(response.getStoragesList().get(0).getStorageId(), testResponse.get(0).getStorageId());
+    }
+
+    @Test
+    void successfullyGetS3Storage() {
+
+    }
+
+    @Test
+    void successfullyCreateS3Storage() throws Exception{
+        // given
+        S3StorageCreateRequest testRequest = S3StorageCreateRequest.newBuilder()
+                .setBucketName("test-bucket-1")
+                .setRegion("us-east-2")
+                //.setStorageId("test-storage-id-1234")
+                .setEndpoint("https://s3.us-east-2.amazonaws.com")
+                .setUseTLS(false)
+                .setName("test-storage-1").build();
+        // mock s3StorageRepository save
+        S3StorageEntity testResponse = new S3StorageEntity();
+        testResponse.setStorageId("test-storage-id-1234");
+        testResponse.setName("test-storage-1");
+        testResponse.setBucketName("test-bucket-1");
+        testResponse.setRegion("us-east-2");
+        testResponse.setEndpoint("https://s3.us-east-2.amazonaws.com");
+        testResponse.setUseTLS(false);
+        DozerBeanMapper mapper = new DozerBeanMapper();
+        when(s3StorageRepository.save(any(S3StorageEntity.class))).thenReturn(testResponse);
+
+        // when
+        sqlResourceBackend.createS3Storage(testRequest);
+
+        // then
+        verify(s3StorageRepository, times(1)).save(any(S3StorageEntity.class));
+        verify(resolveStorageRepository, times(1)).save(any(ResolveStorageEntity.class));
+
+    }
+
+    @Test
+    void updateS3Storage() {
+    }
+
+    @Test
+    void deleteS3Storage() {
+    }
+}