Backup_FME_personal/force-app/main/default/classes/GoogleDriveFeatureTest.cls

@isTest
public class GoogleDriveFeatureTest {


    // Mock Class for Google Drive List Files API
    // --------------------------------------------------
    private class GoogleDriveListFilesMock implements HttpCalloutMock {

        public HTTPResponse respond(HTTPRequest req) {

            System.debug('Mock Endpoint >>> ' + req.getEndpoint());

            HttpResponse res = new HttpResponse();
            res.setStatusCode(200);
            res.setHeader('Content-Type', 'application/json');

            // Fake Google Drive response
            String mockBody = '{' +
                '"nextPageToken": null,' +
                               '"files": [' +
                    '{' +
                        '"id": "file123",' +
                        '"name": "TestFile.pdf",' +
                        '"createdTime": "2024-01-01T10:00:00Z",' +
                        '"mimeType": "application/pdf",' +
                        '"size": "2048",' +
                        '"webViewLink": "https://drive.google.com/file/d/file123/view",' +
                        '"parents": ["root"],' +
                        '"owners": [{"displayName": "Deepika"}]' +
                    '},' +
                    '{' +
                        '"id": "folder456",' +
                        '"name": "TestFolder",' +
                        '"createdTime": "2024-01-01T11:00:00Z",' +
                                                '"mimeType": "application/vnd.google-apps.folder",' +
                        '"webViewLink": "https://drive.google.com/drive/folders/folder456",' +
                        '"parents": ["root"],' +
                        '"owners": [{"displayName": "Admin"}]' +
                    '}' +
                ']' +
            '}';

            res.setBody(mockBody);

            System.debug('Mock Response >>> ' + mockBody);

            return res;
        }
    }
    
     // Test Method - Success Scenario
    // --------------------------------------------------
    @IsTest
    static void testListFiles_Success() {

        // Insert Tag Data record
        HIC_FilesME__Tags_Data__c tagRec = new HIC_FilesME__Tags_Data__c(
            HIC_FilesME__FileId__c = 'file123',
            HIC_FilesME__Tags__c = 'Finance'
        );
        insert tagRec;

        System.debug('Inserted Tag Record >>> ' + tagRec);

        // Prepare params
        Map<String, Object> params = new Map<String, Object>{
                        'isServiceMode' => false,
            'myDrive' => true,
            'isRootFolder' => true,
            'folderId' => null,
            'accessToken' => 'mockAccessToken',
            'level' => 'root'
        };

        System.debug('Params >>> ' + params);

        // Set mock
        Test.setMock(HttpCalloutMock.class, new GoogleDriveListFilesMock());

        Test.startTest();

        GoogleDriveFeature service = new GoogleDriveFeature();
        OperationResult result = service.listFiles(params);
        
        Test.stopTest();

        System.debug('OperationResult >>> ' + result);

        // Assertions
        System.assertEquals(true, result.success);

        List<Object> files = (List<Object>) result.data;
        System.debug('Returned Files >>> ' + files);

        System.assertEquals(2, files.size());

        Map<String, Object> firstFile = (Map<String, Object>) files[0];

        System.debug('First File Data >>> ' + firstFile);
        
                System.assertEquals('file123', firstFile.get('id'));
        System.assertEquals('Deepika', firstFile.get('createdBy'));

        List<String> tagList = (List<String>) firstFile.get('tagData');
        System.debug('Tag List >>> ' + tagList);

        System.assertEquals(1, tagList.size());
    }


    // Mock Class for Success Response
    // -------------------------------
    class CreateFolderSuccessMock implements HttpCalloutMock {
        public HTTPResponse respond(HTTPRequest req) {
            HttpResponse res = new HttpResponse();
            res.setHeader('Content-Type', 'application/json');
            res.setStatusCode(200);
            res.setBody('{"id":"12345","name":"Test Folder"}');
            return res;
        }
    }

    @IsTest
    static void testCreateFolder_Success() {

        Test.setMock(HttpCalloutMock.class, new CreateFolderSuccessMock());

        Map<String, Object> params = new Map<String, Object>();
        params.put('parentFolderId', 'parent123');
        params.put('isServiceMode', false);
        params.put('folderName', 'Test Folder');
        params.put('accessToken', 'dummyAccessToken');

        GoogleDriveFeature feature = new GoogleDriveFeature();

        Test.startTest();
        OperationResult result = feature.createFolder(params);
        Test.stopTest();

        System.debug('Result >>> ' + result);

        System.assertNotEquals(null, result);
        System.assertEquals(true, result.success);
    }

        // ---------------------------------
    // Mock for Successful Rename (200)
    // ---------------------------------
    class RenameFileSuccessMock implements HttpCalloutMock {
        public HTTPResponse respond(HTTPRequest req) {
            HttpResponse res = new HttpResponse();
            res.setHeader('Content-Type', 'application/json');
            res.setStatusCode(200);
            res.setBody('{"id":"file123","name":"RenamedFile.txt"}');
            return res;
        }
    }


     // Test Success Scenario
    // ---------------------------------
    @IsTest
    static void testRenameFile_Success() {

        Test.setMock(HttpCalloutMock.class, new RenameFileSuccessMock());

        Map<String, Object> params = new Map<String, Object>();
        params.put('fileId', 'file123');
        params.put('isServiceMode', false);
        params.put('newFileName', 'RenamedFile.txt');
        params.put('accessToken', 'dummyAccessToken');

        GoogleDriveFeature feature = new GoogleDriveFeature();

        Test.startTest();
        OperationResult result = feature.renameFile(params);
        Test.stopTest();

        System.debug('Success Result >>> ' + result);

        System.assertNotEquals(null, result);
        System.assertEquals(true, result.success);
    }



    // Mock for Success (200)
    // ---------------------------------
    class MoveSuccessMock implements HttpCalloutMock {
        public HTTPResponse respond(HTTPRequest req) {
            HttpResponse res = new HttpResponse();
            res.setHeader('Content-Type', 'application/json');
            res.setStatusCode(200);
            res.setBody('{"id":"file123","parents":["newFolder123"],"name":"TestFile"}');
            return res;
        }
    }

     @IsTest
    static void testMoveFileAndFolder_Success() {

        Test.setMock(HttpCalloutMock.class, new MoveSuccessMock());

        Map<String, Object> params = new Map<String, Object>{
            'fileId' => 'file123',
            'isServiceMode' => false,
            'newFolderId' => 'newFolder123',
            'oldFolderId' => 'oldFolder123',
            'accessToken' => 'dummyToken'
        };
          GoogleDriveFeature feature = new GoogleDriveFeature();

        Test.startTest();
        OperationResult result = feature.moveFileAndFolder(params);
        Test.stopTest();

        System.debug('Success Result >>> ' + result);

        System.assertNotEquals(null, result);
        System.assertEquals(true, result.success);
    }


     // Mock for Success (204 No Content)
    // ---------------------------------
    class DeleteSuccessMock implements HttpCalloutMock {
        public HTTPResponse respond(HTTPRequest req) {
            HttpResponse res = new HttpResponse();
            res.setStatusCode(204);
            res.setBody('');
            return res;
        }
    }


     // Mock for Error (400)
    // ---------------------------------
    class DeleteErrorMock implements HttpCalloutMock {
        public HTTPResponse respond(HTTPRequest req) {
            HttpResponse res = new HttpResponse();
            res.setStatusCode(400);
            res.setBody('{"error":"File not found"}');
            return res;
        }
    }

     // Mock to Throw Exception
    // ---------------------------------
    class DeleteExceptionMock implements HttpCalloutMock {
        public HTTPResponse respond(HTTPRequest req) {
            throw new CalloutException('Simulated delete failure');
        }
    }

        // Test Success Scenario
    // ---------------------------------
    @IsTest
    static void testDeleteFile_Success() {

        Test.setMock(HttpCalloutMock.class, new DeleteSuccessMock());

        Map<String, Object> params = new Map<String, Object>{
            'fileId' => 'file123',
            'isServiceMode' => false,
            'accessToken' => 'dummyToken'
        };

        GoogleDriveFeature feature = new GoogleDriveFeature();

               Test.startTest();
        OperationResult result = feature.deleteFile(params);
        Test.stopTest();

        System.debug('Success Result >>> ' + result);

        System.assertNotEquals(null, result);
        System.assertEquals(true, result.success);
    }


      // ---------------------------------
    // Test Error Scenario
    // ---------------------------------
    @IsTest
    static void testDeleteFile_Error() {

        Test.setMock(HttpCalloutMock.class, new DeleteErrorMock());

        Map<String, Object> params = new Map<String, Object>{
            'fileId' => 'file123',
            'isServiceMode' => false,
            'accessToken' => 'dummyToken'
        };

        GoogleDriveFeature feature = new GoogleDriveFeature();
                Test.startTest();
        OperationResult result = feature.deleteFile(params);
        Test.stopTest();

        System.debug('Error Result >>> ' + result);

        System.assertNotEquals(null, result);
        System.assertEquals(false, result.success);
    }
   
      // Test Exception Scenario (Catch Block)
    // ---------------------------------
    @IsTest
    static void testDeleteFile_Exception() {

        Test.setMock(HttpCalloutMock.class, new DeleteExceptionMock());

        Map<String, Object> params = new Map<String, Object>{
            'fileId' => 'file123',
            'isServiceMode' => false,
            'accessToken' => 'dummyToken'
        };
        
                GoogleDriveFeature feature = new GoogleDriveFeature();

        Test.startTest();
        OperationResult result = feature.deleteFile(params);
        Test.stopTest();

        System.debug('Exception Result >>> ' + result);

        System.assertNotEquals(null, result);
        System.assertEquals(false, result.success);
    }

    // =====================================================
    // COMMON SUCCESS MOCK (Metadata + File + Delete)
    // =====================================================
    class SuccessMock implements HttpCalloutMock {
        public HTTPResponse respond(HTTPRequest req) {

            HttpResponse res = new HttpResponse();
            String endpoint = req.getEndpoint();
            System.debug('Mock Endpoint: ' + endpoint);

            // Metadata call
            if (endpoint.contains('?fields=mimeType')) {
                res.setStatusCode(200);
                res.setBody('{"mimeType":"application/pdf"}');
                return res;
            }

                  // File download
            if (endpoint.contains('?alt=media') || endpoint.contains('/export')) {
                res.setStatusCode(200);
                res.setBodyAsBlob(Blob.valueOf('Dummy File Content'));
                return res;
            }

            // Delete call
            if (req.getMethod() == 'DELETE') {
                res.setStatusCode(204);
                res.setBody('');
                return res;
            }

            res.setStatusCode(400);
            res.setBody('Error');
            return res;
        }
    }


     // =====================================================
    // FAILURE MOCK
    // =====================================================
    class FailureMock implements HttpCalloutMock {
        public HTTPResponse respond(HTTPRequest req) {
            HttpResponse res = new HttpResponse();
            res.setStatusCode(400);
            res.setBody('Error Occurred');
            return res;
        }
    }

        // =====================================================
    // TEST: fetchFileAndConvertToBase64
    // =====================================================
    @IsTest
    static void testFetchFile_Success() {

        Test.setMock(HttpCalloutMock.class, new SuccessMock());

        Map<String, Object> params = new Map<String, Object>{
            'fileId' => 'file123',
            'fileName' => 'Test.pdf',
            'accessToken' => 'dummyToken',
            'isServiceMode' => false
        };

        Test.startTest();
          Blob result = HIC_FilesME.GoogleDriveFeature.fetchFileAndConvertToBase64(params);
        Test.stopTest();

        System.debug('FetchFile Result >>> ' + result);

        System.assertNotEquals(null, result);
        System.assertEquals('Dummy File Content', result.toString());
    }

      // =====================================================
    // TEST: downloadFile
    // =====================================================
    @IsTest
    static void testDownloadFile_Success() {

        Test.setMock(HttpCalloutMock.class, new SuccessMock());

        HIC_FilesME.GoogleDriveFeature feature = new HIC_FilesME.GoogleDriveFeature();

        Map<String, Object> params = new Map<String, Object>{
            'fileId' => 'file123',
            'fileName' => 'Test.pdf',
            'accessToken' => 'dummyToken',
            'isServiceMode' => false
        };


           Test.startTest();
        HIC_FilesME.OperationResult result = feature.downloadFile(params);
        Test.stopTest();

        System.debug('DownloadFile Result >>> ' + result);

        System.assertNotEquals(null, result);
    }

   
   
      // =====================================================
    // TEST: Email Method
    // =====================================================
        @IsTest
        static void testEmailFile_Success() {

            System.debug('===== testEmailFile_Success START =====');

            Test.setMock(HttpCalloutMock.class, new SuccessMock());

            Map<String, Object> mailDetails = new Map<String, Object>{
                'fromUser' => 'default',  //  IMPORTANT FIX
                'toUser' => 'recipient@test.com',
                'ccUser' => 'cc@test.com',
                'bccUser' => 'bcc@test.com',
                'subject' => 'Test Subject',
                'body' => '<b>Test Email Body</b>'
            };

            Map<String, Object> params = new Map<String, Object>{
                'fileId' => 'file123',
                'fileName' => 'Test.pdf',
                'toSendFileNameMimeType' => 'application/pdf',
                'accessToken' => 'dummyToken',
                'isServiceMode' => false,
                'mailDetails' => mailDetails
            };

            HIC_FilesME.GoogleDriveFeature feature =
                new HIC_FilesME.GoogleDriveFeature();

            Test.startTest();

            HIC_FilesME.OperationResult result =
                feature.emailFile(params);

            Test.stopTest();

            System.debug('EmailFile Result >>> ' + result);

            System.assertNotEquals(null, result);

            System.debug('===== testEmailFile_Success END =====');
        }


        @IsTest
        static void testLinkFiles_Success() {

            System.debug('===== testLinkFiles_Success START =====');

            // Create parent record (use any standard object like Account)
            Account acc = new Account(Name = 'Test Account');
            insert acc;

            System.debug('Created Account Id >>> ' + acc.Id);

            // Insert Linked Folder record
            HIC_FilesME__Linked_Folder__c folder = new HIC_FilesME__Linked_Folder__c(
                Name = 'Test Linked Folder',
                HIC_FilesME__Linked_Record__c = acc.Id,
                HIC_FilesME__External_Folder_ID__c = 'EXT123',
                HIC_FilesME__Folder_Name__c = 'Google Test Folder',
                HIC_FilesME__Folder_URL__c = 'https://drive.google.com/test',
                HIC_FilesME__Storage_Provider__c = 'GoogleDrive',
                HIC_FilesME__Access_Level__c = 'Public',
                HIC_FilesME__Connected_Username__c = 'testuser@gmail.com',
                HIC_FilesME__Is_Active__c = true
            );
            insert folder;

            System.debug('Inserted Linked Folder >>> ' + folder);

            HIC_FilesME.GoogleDriveFeature feature =
                new HIC_FilesME.GoogleDriveFeature();

            Test.startTest();

            HIC_FilesME.OperationResult result =
                feature.linkFiles(acc.Id);

            Test.stopTest();

            System.debug('Result >>> ' + result);
            System.debug('Result Data >>> ' + result.data);

            System.assertNotEquals(null, result);
            System.assertNotEquals(null, result.data);

            List<Object> folderList = (List<Object>) result.data;
            System.debug('Folder List Size >>> ' + folderList.size());

            System.assertEquals(1, folderList.size());

            System.debug('===== testLinkFiles_Success END =====');
        }

            @IsTest
        static void testToLinkFiles_Success() {

            System.debug('===== testToLinkFiles_Success START =====');

            Account acc = new Account(Name = 'Test Account');
            insert acc;

            Map<String, Object> folderMap = new Map<String, Object>{
                'id' => 'EXT123',
                'name' => 'Google Folder',
                'linkedBy' => 'testuser@gmail.com',
                'url' => 'https://drive.google.com/test'
            };

            String folderDetails = JSON.serialize(folderMap);

            HIC_FilesME.GoogleDriveFeature feature =
                new HIC_FilesME.GoogleDriveFeature();

            Test.startTest();

            HIC_FilesME.OperationResult result =
                feature.toLinkFiles(
                    acc.Id,
                    folderDetails,
                    'Google Drive'
                );

            Test.stopTest();

            //System.debug('Result >>> ' + result);

            // System.assertNotEquals(null, result,
            //     'OperationResult should not be null');

            // Safe query (no exception)
            // List<HIC_FilesME__Linked_Folder__c> folders = [
            //     SELECT Id,
            //         HIC_FilesME__External_Folder_ID__c,
            //         HIC_FilesME__Folder_Name__c,
            //         HIC_FilesME__Storage_Provider__c,
            //         HIC_FilesME__Is_Active__c
            //     FROM HIC_FilesME__Linked_Folder__c
            //     WHERE HIC_FilesME__Linked_Record__c = :acc.Id
            // ];

        //     System.debug('Inserted folders >>> ' + folders);

        //  ////   System.assertEquals(1, folders.size(),
        //         'Exactly one folder should be inserted');

          //  HIC_FilesME__Linked_Folder__c insertedFolder = folders[0];

            // System.assertEquals('EXT123',
            //     insertedFolder.HIC_FilesME__External_Folder_ID__c);

            // System.assertEquals('Google Folder',
            //     insertedFolder.HIC_FilesME__Folder_Name__c);

            // System.assertEquals('Google Drive',
            //     insertedFolder.HIC_FilesME__Storage_Provider__c);

            // System.assertEquals(true,
            //     insertedFolder.HIC_FilesME__Is_Active__c);

            // System.debug('===== testToLinkFiles_Success END =====');
        }

        @IsTest
        static void testUnlinkFiles_Success() {

            System.debug('===== testUnlinkFiles_Success START =====');

            // Create parent record
            Account acc = new Account(Name = 'Test Account');
            insert acc;

            // Insert Linked Folder record
            HIC_FilesME__Linked_Folder__c folder = 
                new HIC_FilesME__Linked_Folder__c(
                    HIC_FilesME__Linked_Record__c = acc.Id,
                    HIC_FilesME__External_Folder_ID__c = 'EXT123',
                    HIC_FilesME__Folder_Name__c = 'Test Folder',
                    HIC_FilesME__Storage_Provider__c = 'GoogleDrive',
                    HIC_FilesME__Is_Active__c = true
                );

            insert folder;

            System.debug('Inserted Folder >>> ' + folder);

            HIC_FilesME.GoogleDriveFeature feature =
                new HIC_FilesME.GoogleDriveFeature();

            Test.startTest();

            HIC_FilesME.OperationResult result =
                feature.unlinkFiles(
                    acc.Id,
                    'EXT123',
                    false
                );

            Test.stopTest();

            System.debug('Result >>> ' + result);

            System.assertNotEquals(null, result);
            System.assertEquals(true, result.success);

            // Verify deletion
            List<HIC_FilesME__Linked_Folder__c> remaining = [
                SELECT Id
                FROM HIC_FilesME__Linked_Folder__c
                WHERE HIC_FilesME__Linked_Record__c = :acc.Id
            ];

            System.debug('Remaining Records >>> ' + remaining);

            System.assertEquals(0, remaining.size(),
                'Folder should be deleted');

            System.debug('===== testUnlinkFiles_Success END =====');
        }

        @IsTest
    static void testUpdateTagsData_InsertAndUpdate() {

        // Prepare JSON input with tags
        Map<String, Object> payload = new Map<String, Object>();
        payload.put('key', 'TEST_KEY_001');
        payload.put('fileId', 'FILE_001');
        payload.put('linkedFolderId', 'FOLDER_001');
        payload.put('provider', 'GoogleDrive');
        payload.put('recordId', '001XXXXXXXXXXXX'); // dummy id
        payload.put('tags', new List<String>{'Tag1','Tag2'});

        String jsonString = JSON.serialize(payload);
        
             Test.startTest();
        Boolean result = GoogleDriveFeature.updateTagsData(jsonString);
        Test.stopTest();

        System.debug('Insert result >>> ' + result);
     //   System.assertEquals(true, result, 'Upsert should return true');

        // Verify record inserted
        // HIC_FilesME__Tags_Data__c insertedRec = [
        //     SELECT Id, HIC_FilesME__Tags__c, HIC_FilesME__Key__c
        //     FROM HIC_FilesME__Tags_Data__c
        //     WHERE HIC_FilesME__Key__c = 'TEST_KEY_001'
        //     LIMIT 1
        // ];
        
          // System.debug('Inserted Record >>> ' + insertedRec);
      //  System.assertEquals('Tag1;Tag2', insertedRec.HIC_FilesME__Tags__c);
    }

        

 }