@capillarytech/creatives-library 8.0.129 → 8.0.131

package/v2Containers/MobilePushNew/hooks/tests/useUpload.test.js

@@ -1,1223 +1,1459 @@
 import { renderHook, act } from '@testing-library/react';
-import { getCdnUrl } from '../../../../utils/cdnTransformation';
 import useUpload from '../useUpload';
 import {
+  ANDROID,
+  IOS,
   MOBILE_PUSH_CHANNEL,
   MPUSH_IMG_SIZE,
   MPUSH_VIDEO_SIZE,
   MPUSH_GIF_SIZE,
-  ANDROID,
   IMAGE,
   VIDEO,
   GIF,
   CAROUSEL,
 } from '../../constants';
 
-// Mock the CDN transformation utility
+// Mock cdnTransformation module
 jest.mock('../../../../utils/cdnTransformation', () => ({
-  getCdnUrl: jest.fn(),
+  getCdnUrl: ({ url, channelName }) => {
+    if (!url) return '';
+    return `cdn/${channelName}/${url}`;
+  },
+  getLocalStorageItem: (key, parse = false) => {
+    const mockData = {
+      CREATIVES_CDN_BASE_URL: 'https://cdn.example.com',
+      CREATIVES_CDN_QUALITY_CONFIG: '{"MOBILEPUSH":75,"DEFAULT":80}',
+      CREATIVES_CDN_TRANSFORMATION_URL_SUFFIX: 'cdn-cgi/image',
+      CREATIVES_S3_BUCKET_PATH: 'intouch_creative_assets',
+    };
+    const val = mockData[key];
+    if (parse && val) {
+      return JSON.parse(val);
+    }
+    return val;
+  },
 }));
 
 describe('useUpload Hook', () => {
   // Mock data and functions
-  const mockMobilePushActions = {
+  let mockMobilePushActions;
+  let androidContent;
+  let iosContent;
+  let mockSetAndroidContent;
+  let mockSetIosContent;
+
+// Mock formatMessage function
+  const mockFormatMessage = (message, values = {}) => {
+  if (message.id === 'app.containers.MobilePushNew.fileSizeError') {
+      return `File size should be less than ${values.size}MB`;
+  }
+  if (message.id === 'app.containers.MobilePushNew.imageFileTypeError') {
+      return 'Only JPEG and PNG files are allowed';
+  }
+  if (message.id === 'app.containers.MobilePushNew.videoFileTypeError') {
+      return 'Only 3GP, MP4, MOV, M4V files are allowed';
+  }
+  if (message.id === 'app.containers.MobilePushNew.gifFileTypeError') {
+      return 'Only GIF files are allowed';
+  }
+  return message.defaultMessage;
+};
+
+  // Helper function to create hook instance
+  const createHook = (props = {}) => renderHook(() => useUpload(
+    mockMobilePushActions,
+    props.editData || {},
+    props.uploadedAssetData0 || {},
+    props.uploadedAssetData1 || {},
+    props.uploadAssetSuccess || false,
+    props.sameContent || false,
+    mockSetAndroidContent,
+    mockSetIosContent,
+    props.activeTab || ANDROID,
+    androidContent,
+    iosContent,
+    mockFormatMessage,
+  ));
+
+  beforeEach(() => {
+    mockMobilePushActions = {
     uploadAsset: jest.fn(),
     clearAsset: jest.fn(),
   };
 
-  const mockSetAndroidContent = jest.fn();
-  const mockSetIosContent = jest.fn();
-
-  const defaultProps = {
-    mobilePushActions: mockMobilePushActions,
-    editData: {},
-    uploadedAssetData0: {},
-    uploadedAssetData1: {},
-    uploadAssetSuccess: false,
-    sameContent: false,
-    setAndroidContent: mockSetAndroidContent,
-    setIosContent: mockSetIosContent,
-    activeTab: ANDROID,
-    androidContent: { title: 'Test Android', message: 'Test message' },
-    iosContent: { title: 'Test iOS', message: 'Test message' },
-  };
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    getCdnUrl.mockImplementation(({ url }) => `cdn_${url}`);
-  });
-
-  describe('Hook Initialization', () => {
-    it('should initialize with default states', () => {
-      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-      expect(result.current.androidAssetList).toEqual([]);
-      expect(result.current.iosAssetList).toEqual([]);
-      expect(result.current.mpushVideoSrcAndPreview).toEqual({
-        mpushVideoSrc: "",
-        mpushVideoPreviewImg: "",
-        duration: 0,
-      });
-      expect(result.current.imageSrc).toEqual({
-        androidImageSrc: "",
-        iosImageSrc: "",
-      });
-      expect(result.current.uploadErrors).toEqual({});
-    });
-
-    it('should initialize from edit data when provided', () => {
-      const editData = {
-        templateDetails: {
-          versions: {
-            base: {
-              content: {
-                ANDROID: {
-                  expandableDetails: {
-                    image: 'test-android-image.jpg',
-                    video: 'test-video.mp4',
-                    videoPreview: 'test-preview.jpg',
-                  },
-                },
-                IOS: {
-                  expandableDetails: {
-                    image: 'test-ios-image.jpg',
-                  },
-                },
-              },
-            },
-          },
-        },
-      };
-
-      const { result } = renderHook(() => useUpload(
-        mockMobilePushActions,
-        editData,
-        {},
-        {},
-        false,
-        false,
-        mockSetAndroidContent,
-        mockSetIosContent,
-        ANDROID,
-        defaultProps.androidContent,
-        defaultProps.iosContent
-      ));
-
-      expect(result.current.imageSrc.androidImageSrc).toBe('test-android-image.jpg');
-      expect(result.current.imageSrc.iosImageSrc).toBe('test-ios-image.jpg');
-      expect(result.current.mpushVideoSrcAndPreview.mpushVideoSrc).toBe('test-video.mp4');
-      expect(result.current.mpushVideoSrcAndPreview.mpushVideoPreviewImg).toBe('test-preview.jpg');
-    });
-  });
-
-  describe('File Validation Functions', () => {
-    describe('validateImageFile', () => {
-      it('should pass validation for valid image file', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-        const validFile = new File(['test'], 'test.jpg', {
-          type: 'image/jpeg',
-          size: MPUSH_IMG_SIZE - 1000, // Under the limit
-        });
-
-        const errors = result.current.validateImageFile(validFile);
-        expect(errors).toEqual([]);
-      });
-
-      it('should fail validation for oversized image file', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-        // Create a file with data that exceeds the limit
-        const oversizedData = new Array(MPUSH_IMG_SIZE + 1000).fill('a').join('');
-        const oversizedFile = new File([oversizedData], 'test.jpg', {
-          type: 'image/jpeg',
-        });
-
-        const errors = result.current.validateImageFile(oversizedFile);
-        expect(errors).toContain('File size should be less than 2MB');
-      });
+    androidContent = { title: 'Test Android', message: 'Test message' };
+    iosContent = { title: 'Test iOS', message: 'Test message' };
 
-      it('should fail validation for invalid file type', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-        const invalidFile = new File(['test'], 'test.pdf', {
-          type: 'application/pdf',
-          size: 1000,
-        });
-
-        const errors = result.current.validateImageFile(invalidFile);
-        expect(errors).toContain('Only JPEG and PNG files are allowed');
-      });
-
-      it('should fail validation for both size and type errors', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-        // Create a file with data that exceeds the limit
-        const oversizedData = new Array(MPUSH_IMG_SIZE + 1000).fill('a').join('');
-        const invalidFile = new File([oversizedData], 'test.pdf', {
-          type: 'application/pdf',
-        });
-
-        const errors = result.current.validateImageFile(invalidFile);
-        expect(errors).toHaveLength(2);
-        expect(errors).toContain('File size should be less than 2MB');
-        expect(errors).toContain('Only JPEG and PNG files are allowed');
-      });
+    mockSetAndroidContent = jest.fn((updater) => {
+      if (typeof updater === 'function') {
+        androidContent = updater(androidContent);
+      } else {
+        androidContent = { ...androidContent, ...updater };
+      }
     });
 
-    describe('validateVideoFile', () => {
-      it('should pass validation for valid video file', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-        const validFile = new File(['test'], 'test.mp4', {
-          type: 'video/mp4',
-          size: MPUSH_VIDEO_SIZE - 1000,
-        });
-
-        const errors = result.current.validateVideoFile(validFile);
-        expect(errors).toEqual([]);
-      });
-
-      it('should fail validation for oversized video file', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-        // Mock a file with oversized property
-        const oversizedFile = new File(['test'], 'test.mp4', {
-          type: 'video/mp4',
-        });
-        // Override the size property to simulate an oversized file
-        Object.defineProperty(oversizedFile, 'size', {
-          value: MPUSH_VIDEO_SIZE + 1000,
-          writable: false,
-        });
-
-        const errors = result.current.validateVideoFile(oversizedFile);
-        expect(errors).toContain('File size should be less than 209.7152MB');
-      });
-
-      it('should fail validation for invalid video file type', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-        const invalidFile = new File(['test'], 'test.avi', {
-          type: 'video/avi',
-          size: 1000,
-        });
-
-        const errors = result.current.validateVideoFile(invalidFile);
-        expect(errors).toContain('Only 3GP, MP4, MOV, M4V files are allowed');
-      });
+    mockSetIosContent = jest.fn((updater) => {
+      if (typeof updater === 'function') {
+        iosContent = updater(iosContent);
+      } else {
+        iosContent = { ...iosContent, ...updater };
+      }
     });
 
-    describe('validateGifFile', () => {
-      it('should pass validation for valid GIF file', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-        const validFile = new File(['test'], 'test.gif', {
-          type: 'image/gif',
-          size: MPUSH_GIF_SIZE - 1000,
-        });
-
-        const errors = result.current.validateGifFile(validFile);
-        expect(errors).toEqual([]);
-      });
-
-      it('should fail validation for oversized GIF file', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-        // Mock a file with oversized property
-        const oversizedFile = new File(['test'], 'test.gif', {
-          type: 'image/gif',
-        });
-        // Override the size property to simulate an oversized file
-        Object.defineProperty(oversizedFile, 'size', {
-          value: MPUSH_GIF_SIZE + 1000,
-          writable: false,
-        });
-
-        const errors = result.current.validateGifFile(oversizedFile);
-        expect(errors).toContain('File size should be less than 209.7152MB');
-      });
-
-      it('should fail validation for non-GIF file', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-        const invalidFile = new File(['test'], 'test.jpg', {
-          type: 'image/jpeg',
-          size: 1000,
-        });
-
-        const errors = result.current.validateGifFile(invalidFile);
-        expect(errors).toContain('Only GIF files are allowed');
-      });
-    });
+    // Reset all mocks
+    jest.clearAllMocks();
   });
 
-  describe('Upload Asset Function', () => {
-    it('should upload valid image file', () => {
-      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-      const validFile = new File(['test'], 'test.jpg', {
-        type: 'image/jpeg',
-        size: 1000,
-      });
+  describe('Asset Upload', () => {
+    it('should handle image upload with validation', () => {
+      const { result } = createHook();
 
+      // Test valid image upload
+      const validFile = new File([''], 'test.jpg', { type: 'image/jpeg' });
+      Object.defineProperty(validFile, 'size', { value: MPUSH_IMG_SIZE - 1000 }); // Just under limit
       act(() => {
         result.current.uploadMpushAsset(validFile, IMAGE.toLowerCase(), {});
       });
-
       expect(mockMobilePushActions.uploadAsset).toHaveBeenCalledWith(
         validFile,
         IMAGE.toLowerCase(),
         {},
-        0, // Android tab
-        {
-          source: MOBILE_PUSH_CHANNEL.toLowerCase(),
-          channel: MOBILE_PUSH_CHANNEL,
-        }
+        0,
+        { source: MOBILE_PUSH_CHANNEL.toLowerCase(), channel: MOBILE_PUSH_CHANNEL }
       );
-    });
 
-    it('should upload valid video file', () => {
-      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-      const validFile = new File(['test'], 'test.mp4', {
-        type: 'video/mp4',
-        size: 1000,
+      // Test invalid image upload
+      const invalidFile = new File([''], 'test.txt', { type: 'text/plain' });
+      act(() => {
+        result.current.uploadMpushAsset(invalidFile, IMAGE.toLowerCase(), {});
       });
+      expect(result.current.uploadErrors[0]).toEqual(['Only JPEG and PNG files are allowed']);
+    });
 
+    it('should handle video upload with validation', () => {
+      const { result } = createHook();
+
+      // Test valid video upload
+      const validFile = new File([''], 'test.mp4', { type: 'video/mp4' });
+      Object.defineProperty(validFile, 'size', { value: MPUSH_VIDEO_SIZE - 1000 }); // Just under limit
       act(() => {
         result.current.uploadMpushAsset(validFile, VIDEO.toLowerCase(), {});
       });
-
       expect(mockMobilePushActions.uploadAsset).toHaveBeenCalledWith(
         validFile,
         VIDEO.toLowerCase(),
         {},
         0,
-        {
-          source: MOBILE_PUSH_CHANNEL.toLowerCase(),
-          channel: MOBILE_PUSH_CHANNEL,
-        }
+        { source: MOBILE_PUSH_CHANNEL.toLowerCase(), channel: MOBILE_PUSH_CHANNEL }
       );
-    });
-
-    it('should upload GIF file as video type', () => {
-      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
 
-      const validFile = new File(['test'], 'test.gif', {
-        type: 'image/gif',
-        size: 1000,
+      // Test invalid video upload
+      const invalidFile = new File([''], 'test.txt', { type: 'text/plain' });
+      act(() => {
+        result.current.uploadMpushAsset(invalidFile, VIDEO.toLowerCase(), {});
       });
+      expect(result.current.uploadErrors[0]).toEqual(['Only 3GP, MP4, MOV, M4V files are allowed']);
+    });
+
+    it('should handle GIF upload with validation', () => {
+      const { result } = createHook();
 
+      // Test valid GIF upload
+      const validFile = new File([''], 'test.gif', { type: 'image/gif' });
+      Object.defineProperty(validFile, 'size', { value: MPUSH_GIF_SIZE - 1000 }); // Just under limit
       act(() => {
         result.current.uploadMpushAsset(validFile, GIF.toLowerCase(), {});
       });
-
       expect(mockMobilePushActions.uploadAsset).toHaveBeenCalledWith(
         validFile,
-        VIDEO.toLowerCase(), // GIF uploads use video type
+        VIDEO.toLowerCase(), // GIF uses video type internally
         {},
         0,
-        {
-          source: MOBILE_PUSH_CHANNEL.toLowerCase(),
-          channel: MOBILE_PUSH_CHANNEL,
-        }
+        { source: MOBILE_PUSH_CHANNEL.toLowerCase(), channel: MOBILE_PUSH_CHANNEL }
       );
-    });
 
-    it('should not upload invalid file and set upload errors', () => {
-      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-      // Create a file with data that exceeds the limit
-      const oversizedData = new Array(MPUSH_IMG_SIZE + 1000).fill('a').join('');
-      const invalidFile = new File([oversizedData], 'test.pdf', {
-        type: 'application/pdf',
+      // Test invalid GIF upload
+      const invalidFile = new File([''], 'test.jpg', { type: 'image/jpeg' });
+      act(() => {
+        result.current.uploadMpushAsset(invalidFile, GIF.toLowerCase(), {});
       });
+      expect(result.current.uploadErrors[0]).toEqual(['Only GIF files are allowed']);
+    });
+  });
+
+  describe('Media Payload Generation', () => {
+    it('should generate correct payload for IMAGE type', () => {
+      const { result } = createHook();
 
       act(() => {
-        result.current.uploadMpushAsset(invalidFile, IMAGE.toLowerCase(), {});
+        result.current.setImageSrc({
+          androidImageSrc: 'test-image.jpg',
+          iosImageSrc: 'test-image-ios.jpg',
+        });
       });
 
-      expect(mockMobilePushActions.uploadAsset).not.toHaveBeenCalled();
-      expect(result.current.uploadErrors[0]).toHaveLength(2);
-      expect(result.current.uploadErrors[0]).toContain('File size should be less than 2MB');
-      expect(result.current.uploadErrors[0]).toContain('Only JPEG and PNG files are allowed');
+      const androidPayload = result.current.getMediaPayload(IMAGE, ANDROID);
+      expect(androidPayload).toHaveProperty('imageUrl');
+      expect(androidPayload.imageUrl).toBe('cdn/MOBILEPUSH/test-image.jpg');
+
+      const iosPayload = result.current.getMediaPayload(IMAGE, IOS);
+      expect(iosPayload).toHaveProperty('imageUrl');
+      expect(iosPayload.imageUrl).toBe('cdn/MOBILEPUSH/test-image-ios.jpg');
     });
 
-    it('should handle iOS tab correctly', () => {
-      const iosProps = { ...defaultProps, activeTab: 'IOS' };
-      const { result } = renderHook(() => useUpload(...Object.values(iosProps)));
+    it('should generate correct payload for VIDEO type', () => {
+      const { result } = createHook();
 
-      const validFile = new File(['test'], 'test.jpg', {
-        type: 'image/jpeg',
-        size: 1000,
-      });
+      act(() => {
+        result.current.setVideoState({
+          androidVideoSrc: 'test-video.mp4',
+          androidVideoPreview: 'test-preview.jpg',
+          androidVideoDuration: 30,
+          iosVideoSrc: 'test-video-ios.mp4',
+          iosVideoPreview: 'test-preview-ios.jpg',
+          iosVideoDuration: 30,
+        });
+      });
+
+      const androidPayload = result.current.getMediaPayload(VIDEO, ANDROID);
+      expect(androidPayload).toHaveProperty('videoUrl');
+      expect(androidPayload).toHaveProperty('videoPreviewImg');
+      expect(androidPayload).toHaveProperty('duration');
+      expect(androidPayload.videoUrl).toBe('cdn/MOBILEPUSH/test-video.mp4');
+      expect(androidPayload.videoPreviewImg).toBe('cdn/MOBILEPUSH/test-preview.jpg');
+      expect(androidPayload.duration).toBe(30);
+
+      const iosPayload = result.current.getMediaPayload(VIDEO, IOS);
+      expect(iosPayload).toHaveProperty('videoUrl');
+      expect(iosPayload).toHaveProperty('videoPreviewImg');
+      expect(iosPayload).toHaveProperty('duration');
+      expect(iosPayload.videoUrl).toBe('cdn/MOBILEPUSH/test-video-ios.mp4');
+      expect(iosPayload.videoPreviewImg).toBe('cdn/MOBILEPUSH/test-preview-ios.jpg');
+      expect(iosPayload.duration).toBe(30);
+    });
+
+    it('should generate correct payload for GIF type', () => {
+      const { result } = createHook();
 
       act(() => {
-        result.current.uploadMpushAsset(validFile, IMAGE.toLowerCase(), {});
+        result.current.setVideoState({
+          androidVideoSrc: 'test.gif',
+          androidVideoPreview: 'test-preview.jpg',
+          iosVideoSrc: 'test-ios.gif',
+          iosVideoPreview: 'test-preview-ios.jpg',
+        });
       });
 
-      expect(mockMobilePushActions.uploadAsset).toHaveBeenCalledWith(
-        validFile,
-        IMAGE.toLowerCase(),
-        {},
-        1, // iOS tab
-        expect.any(Object)
-      );
+      const androidPayload = result.current.getMediaPayload(GIF, ANDROID);
+      expect(androidPayload).toHaveProperty('gifUrl');
+      expect(androidPayload).toHaveProperty('gifPreviewImg');
+      expect(androidPayload.gifUrl).toBe('cdn/MOBILEPUSH/test.gif');
+      expect(androidPayload.gifPreviewImg).toBe('cdn/MOBILEPUSH/test-preview.jpg');
+
+      const iosPayload = result.current.getMediaPayload(GIF, IOS);
+      expect(iosPayload).toHaveProperty('gifUrl');
+      expect(iosPayload).toHaveProperty('gifPreviewImg');
+      expect(iosPayload.gifUrl).toBe('cdn/MOBILEPUSH/test-ios.gif');
+      expect(iosPayload.gifPreviewImg).toBe('cdn/MOBILEPUSH/test-preview-ios.jpg');
+    });
+
+    it('should return empty object for unknown media type', () => {
+      const { result } = createHook();
+      const payload = result.current.getMediaPayload('UNKNOWN', ANDROID);
+      expect(payload).toEqual({});
     });
   });
 
-  describe('Image Source Management', () => {
-    describe('setUpdateMpushImageSrc', () => {
-      it('should update Android image source when sync is disabled', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+  describe('Preview Data Generation', () => {
+    it('should generate correct preview data for IMAGE type', () => {
+      const { result } = createHook();
 
-        act(() => {
-          result.current.setUpdateMpushImageSrc('test-image.jpg', 0, IMAGE);
+      act(() => {
+        result.current.setImageSrc({
+          androidImageSrc: 'test-image.jpg',
+          iosImageSrc: 'test-image-ios.jpg',
         });
-
-        expect(result.current.imageSrc.androidImageSrc).toBe('test-image.jpg');
-        expect(result.current.imageSrc.iosImageSrc).toBe('');
-        expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(0);
       });
 
-      it('should update both platforms when sync is enabled', () => {
-        const syncProps = { ...defaultProps, sameContent: true };
-        const { result } = renderHook(() => useUpload(...Object.values(syncProps)));
+      const androidPreview = result.current.getPreviewData(IMAGE, ANDROID);
+      expect(androidPreview).toHaveProperty('imageSrc', 'test-image.jpg');
 
-        act(() => {
-          result.current.setUpdateMpushImageSrc('test-image.jpg', 0, IMAGE);
-        });
-
-        expect(result.current.imageSrc.androidImageSrc).toBe('test-image.jpg');
-        expect(result.current.imageSrc.iosImageSrc).toBe('test-image.jpg');
-      });
+      const iosPreview = result.current.getPreviewData(IMAGE, IOS);
+      expect(iosPreview).toHaveProperty('imageSrc', 'test-image-ios.jpg');
+    });
 
-      it('should update iOS image source when iOS tab is active', () => {
-        const iosProps = { ...defaultProps, activeTab: 'IOS' };
-        const { result } = renderHook(() => useUpload(...Object.values(iosProps)));
+    it('should generate correct preview data for VIDEO type', () => {
+      const { result } = createHook();
 
-        act(() => {
-          result.current.setUpdateMpushImageSrc('test-ios-image.jpg', 1, IMAGE);
+      act(() => {
+        result.current.setVideoState({
+          androidVideoSrc: 'test-video.mp4',
+          androidVideoPreview: 'test-preview.jpg',
+          androidVideoDuration: 30,
+          iosVideoSrc: 'test-video-ios.mp4',
+          iosVideoPreview: 'test-preview-ios.jpg',
+          iosVideoDuration: 30,
         });
-
-        expect(result.current.imageSrc.androidImageSrc).toBe('');
-        expect(result.current.imageSrc.iosImageSrc).toBe('test-ios-image.jpg');
-        expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(1);
       });
 
-      it('should not handle carousel media type', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-        act(() => {
-          result.current.setUpdateMpushImageSrc('test-image.jpg', 0, CAROUSEL);
-        });
+      const androidPreview = result.current.getPreviewData(VIDEO, ANDROID);
+      expect(androidPreview).toEqual({
+        videoSrc: 'test-video.mp4',
+        videoPreviewImg: 'test-preview.jpg',
+        duration: 30,
+      });
 
-        expect(result.current.imageSrc.androidImageSrc).toBe('test-image.jpg');
-        expect(result.current.imageSrc.iosImageSrc).toBe('');
-        expect(mockMobilePushActions.clearAsset).not.toHaveBeenCalled();
+      const iosPreview = result.current.getPreviewData(VIDEO, IOS);
+      expect(iosPreview).toEqual({
+        videoSrc: 'test-video-ios.mp4',
+        videoPreviewImg: 'test-preview-ios.jpg',
+        duration: 30,
       });
+    });
 
-      it('should default to IMAGE media type when mediaType parameter is not provided', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+    it('should generate correct preview data for GIF type', () => {
+      const { result } = createHook();
 
-        act(() => {
-          result.current.setUpdateMpushImageSrc('test-image.jpg', 0); // No mediaType parameter
+      act(() => {
+        result.current.setVideoState({
+          androidVideoSrc: 'test.gif',
+          androidVideoPreview: 'test-preview.jpg',
+          iosVideoSrc: 'test-ios.gif',
+          iosVideoPreview: 'test-preview-ios.jpg',
         });
+      });
 
-        expect(result.current.imageSrc.androidImageSrc).toBe('test-image.jpg');
-        expect(result.current.imageSrc.iosImageSrc).toBe('');
-        expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(0);
+      const androidPreview = result.current.getPreviewData(GIF, ANDROID);
+      expect(androidPreview).toEqual({
+        gifSrc: 'test.gif',
+        gifPreviewImg: 'test-preview.jpg',
       });
 
-      it('should default to IMAGE media type for iOS platform when mediaType parameter is not provided', () => {
-        const iosProps = { ...defaultProps, activeTab: 'IOS' };
-        const { result } = renderHook(() => useUpload(...Object.values(iosProps)));
+      const iosPreview = result.current.getPreviewData(GIF, IOS);
+      expect(iosPreview).toEqual({
+        gifSrc: 'test-ios.gif',
+        gifPreviewImg: 'test-preview-ios.jpg',
+      });
+    });
 
-        act(() => {
-          result.current.setUpdateMpushImageSrc('test-ios-image.jpg', 1); // No mediaType parameter
-        });
+    it('should return empty object for unknown media type', () => {
+      const { result } = createHook();
+      const preview = result.current.getPreviewData('UNKNOWN', ANDROID);
+      expect(preview).toEqual({});
+    });
+  });
+
+  describe('Media Upload Status', () => {
+    it('should correctly check if IMAGE is uploaded', () => {
+      const { result } = createHook();
 
-        expect(result.current.imageSrc.androidImageSrc).toBe('');
-        expect(result.current.imageSrc.iosImageSrc).toBe('test-ios-image.jpg');
-        expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(1);
+      act(() => {
+        result.current.setImageSrc({
+          androidImageSrc: 'test-image.jpg',
+          iosImageSrc: 'test-image-ios.jpg',
+        });
       });
 
-      it('should default to IMAGE media type when sync is enabled and mediaType parameter is not provided', () => {
-        const syncProps = { ...defaultProps, sameContent: true };
-        const { result } = renderHook(() => useUpload(...Object.values(syncProps)));
+      expect(result.current.isMediaUploaded(IMAGE, ANDROID)).toBe(true);
+      expect(result.current.isMediaUploaded(IMAGE, IOS)).toBe(true);
+    });
 
-        act(() => {
-          result.current.setUpdateMpushImageSrc('test-image.jpg', 0); // No mediaType parameter
-        });
+    it('should correctly check if VIDEO is uploaded', () => {
+      const { result } = createHook();
 
-        expect(result.current.imageSrc.androidImageSrc).toBe('test-image.jpg');
-        expect(result.current.imageSrc.iosImageSrc).toBe('test-image.jpg');
-        expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(0);
+      act(() => {
+        result.current.setVideoState({
+          androidVideoSrc: 'test-video.mp4',
+          iosVideoSrc: 'test-video-ios.mp4',
+        });
       });
+
+      expect(result.current.isMediaUploaded(VIDEO, ANDROID)).toBe(true);
+      expect(result.current.isMediaUploaded(VIDEO, IOS)).toBe(true);
     });
 
-    describe('updateOnMpushImageReUpload', () => {
-      it('should clear Android platform image when sync is disabled and Android tab is active', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+    it('should correctly check if GIF is uploaded', () => {
+      const { result } = createHook();
 
-        // Set initial images for both platforms
-        act(() => {
-          result.current.setImageSrc({
-            androidImageSrc: 'test-android-image.jpg',
-            iosImageSrc: 'test-ios-image.jpg',
-          });
+      act(() => {
+        result.current.setVideoState({
+          androidVideoSrc: 'test.gif',
+          iosVideoSrc: 'test-ios.gif',
         });
+      });
 
-        // Clear image (should only clear Android since activeTab is ANDROID)
-        act(() => {
-          result.current.updateOnMpushImageReUpload();
-        });
+      expect(result.current.isMediaUploaded(GIF, ANDROID)).toBe(true);
+      expect(result.current.isMediaUploaded(GIF, IOS)).toBe(true);
+    });
 
-        expect(result.current.imageSrc.androidImageSrc).toBe('');
-        expect(result.current.imageSrc.iosImageSrc).toBe('test-ios-image.jpg'); // iOS should remain
-      });
+    it('should return true for unknown media type', () => {
+      const { result } = createHook();
+      expect(result.current.isMediaUploaded('UNKNOWN', ANDROID)).toBe(true);
+    });
+  });
 
-      it('should clear iOS platform image when sync is disabled and iOS tab is active', () => {
-        const iosProps = { ...defaultProps, activeTab: 'IOS' };
-        const { result } = renderHook(() => useUpload(...Object.values(iosProps)));
+  describe('Edit Mode Initialization', () => {
+    it('should initialize from edit data with Android content', () => {
+      const editData = {
+        templateDetails: {
+          versions: {
+            base: {
+              content: {
+                ANDROID: {
+                  expandableDetails: {
+                    image: 'android-image.jpg',
+                    video: 'android-video.mp4',
+                    videoPreview: 'android-preview.jpg',
+                    videoDuration: 30,
+                  },
+                },
+              },
+            },
+          },
+        },
+      };
 
-        // Set initial images for both platforms
-        act(() => {
-          result.current.setImageSrc({
-            androidImageSrc: 'test-android-image.jpg',
-            iosImageSrc: 'test-ios-image.jpg',
-          });
-        });
+      const { result } = createHook({ editData });
 
-        // Clear image (should only clear iOS since activeTab is IOS)
-        act(() => {
-          result.current.updateOnMpushImageReUpload();
-        });
+      expect(result.current.imageSrc.androidImageSrc).toBe('android-image.jpg');
+      expect(result.current.videoState.androidVideoSrc).toBe('android-video.mp4');
+      expect(result.current.videoState.androidVideoPreview).toBe('android-preview.jpg');
+      expect(result.current.videoState.androidVideoDuration).toBe(30);
+    });
 
-        expect(result.current.imageSrc.androidImageSrc).toBe('test-android-image.jpg'); // Android should remain
-        expect(result.current.imageSrc.iosImageSrc).toBe(''); // iOS should be cleared
-      });
+    it('should initialize from edit data with iOS content', () => {
+      const editData = {
+        templateDetails: {
+          versions: {
+            base: {
+              content: {
+                IOS: {
+                  expandableDetails: {
+                    image: 'ios-image.jpg',
+                    video: 'ios-video.mp4',
+                    videoPreview: 'ios-preview.jpg',
+                    videoDuration: 30,
+                  },
+                },
+              },
+            },
+          },
+        },
+      };
 
-      it('should clear both platforms when sync is enabled', () => {
-        const syncProps = { ...defaultProps, sameContent: true };
-        const { result } = renderHook(() => useUpload(...Object.values(syncProps)));
+      const { result } = createHook({ editData });
 
-        // Set initial images
-        act(() => {
-          result.current.setUpdateMpushImageSrc('test-image.jpg', IMAGE);
-        });
+      expect(result.current.imageSrc.iosImageSrc).toBe('ios-image.jpg');
+      expect(result.current.videoState.iosVideoSrc).toBe('ios-video.mp4');
+      expect(result.current.videoState.iosVideoPreview).toBe('ios-preview.jpg');
+      expect(result.current.videoState.iosVideoDuration).toBe(30);
+    });
 
-        // Clear images
-        act(() => {
-          result.current.updateOnMpushImageReUpload();
-        });
+    it('should handle missing video preview and duration in edit data', () => {
+      const editData = {
+        templateDetails: {
+          versions: {
+            base: {
+              content: {
+                ANDROID: {
+                  expandableDetails: {
+                    video: 'android-video.mp4',
+                  },
+                },
+                IOS: {
+                  expandableDetails: {
+                    video: 'ios-video.mp4',
+                  },
+                },
+              },
+            },
+          },
+        },
+      };
 
-        expect(result.current.imageSrc.androidImageSrc).toBe('');
-        expect(result.current.imageSrc.iosImageSrc).toBe('');
-      });
+      const { result } = createHook({ editData });
+
+      expect(result.current.videoState.androidVideoSrc).toBe('android-video.mp4');
+      expect(result.current.videoState.androidVideoPreview).toBe('');
+      expect(result.current.videoState.androidVideoDuration).toBe(0);
+      expect(result.current.videoState.iosVideoSrc).toBe('ios-video.mp4');
+      expect(result.current.videoState.iosVideoPreview).toBe('');
+      expect(result.current.videoState.iosVideoDuration).toBe(0);
     });
   });
 
-  describe('Video Source Management', () => {
-    describe('setUpdateMpushVideoSrc', () => {
-      it('should update video source and asset list', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+  describe('CDN URL Generation', () => {
+    it('should generate CDN URLs for images and videos', () => {
+      const { result } = createHook();
 
-        const videoData = {
-          videoSrc: 'test-video.mp4',
-          previewUrl: 'test-preview.jpg',
-          videoDuration: 120,
-          videoName: 'test-video.mp4',
-          fileHandle: 'file-handle-123',
-        };
+      // Test image URL generation
+      const imageUrl = result.current.getCdnImageUrl('test-image.jpg');
+      expect(imageUrl).toBeDefined();
+      expect(imageUrl).toBe('cdn/MOBILEPUSH/test-image.jpg');
 
-        act(() => {
-          result.current.setUpdateMpushVideoSrc(0, videoData);
-        });
+      // Test video URL generation
+      const videoUrl = result.current.getCdnVideoUrl('test-video.mp4');
+      expect(videoUrl).toBeDefined();
+      expect(videoUrl).toBe('cdn/MOBILEPUSH/test-video.mp4');
 
-        expect(result.current.mpushVideoSrcAndPreview).toEqual({
+      // Test empty URL handling
+      expect(result.current.getCdnImageUrl('')).toBe('');
+      expect(result.current.getCdnVideoUrl('')).toBe('');
+    });
+  });
+
+  describe('Reset Upload States', () => {
+    it('should reset all upload states', () => {
+      const { result } = createHook();
+
+      // Set some initial state
+      act(() => {
+        result.current.setImageSrc({
+          androidImageSrc: 'test-image.jpg',
+          iosImageSrc: 'test-image-ios.jpg',
+        });
+        result.current.setVideoState({
+          androidVideoSrc: 'test-video.mp4',
+          androidVideoPreview: 'test-preview.jpg',
+          androidVideoDuration: 30,
+          iosVideoSrc: 'test-video-ios.mp4',
+          iosVideoPreview: 'test-preview-ios.jpg',
+          iosVideoDuration: 30,
+        });
+        result.current.setMpushVideoSrcAndPreview({
           mpushVideoSrc: 'test-video.mp4',
           mpushVideoPreviewImg: 'test-preview.jpg',
-          duration: 120,
+          duration: 30,
         });
+      });
 
-        expect(result.current.assetList).toEqual(videoData);
-        expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(0);
+      // Reset all states
+      act(() => {
+        result.current.resetUploadStates();
       });
 
-      it('should handle partial video data', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+      // Verify all states are reset
+      expect(result.current.imageSrc).toEqual({
+        androidImageSrc: '',
+        iosImageSrc: '',
+      });
+      expect(result.current.videoState).toEqual({
+        androidVideoSrc: '',
+        iosVideoSrc: '',
+        androidVideoPreview: '',
+        iosVideoPreview: '',
+        androidVideoDuration: 0,
+        iosVideoDuration: 0,
+      });
+      expect(result.current.mpushVideoSrcAndPreview).toEqual({
+        mpushVideoSrc: '',
+        mpushVideoPreviewImg: '',
+        duration: 0,
+      });
+      expect(result.current.androidAssetList).toEqual([]);
+      expect(result.current.iosAssetList).toEqual([]);
+    });
+  });
 
-        const partialVideoData = {
-          videoSrc: 'test-video.mp4',
-        };
+  describe('Image Re-upload Handlers', () => {
+    it('should handle image re-upload with sync enabled', () => {
+      const { result } = createHook({ sameContent: true });
 
-        act(() => {
-          result.current.setUpdateMpushVideoSrc(0, partialVideoData);
+      // Set initial state
+      act(() => {
+        result.current.setImageSrc({
+          androidImageSrc: 'test-image.jpg',
+          iosImageSrc: 'test-image.jpg',
         });
+      });
 
-        expect(result.current.mpushVideoSrcAndPreview).toEqual({
-          mpushVideoSrc: 'test-video.mp4',
-          mpushVideoPreviewImg: '',
-          duration: 0,
-        });
+      // Re-upload image
+      act(() => {
+        result.current.updateOnMpushImageReUpload();
+      });
+
+      // Verify both platforms are cleared
+      expect(result.current.imageSrc).toEqual({
+        androidImageSrc: '',
+        iosImageSrc: '',
       });
     });
 
-    describe('updateOnMpushVideoReUpload', () => {
-      it('should clear all video-related state', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-        // Set initial video data
-        act(() => {
-          result.current.setUpdateMpushVideoSrc(0, {
-            videoSrc: 'test-video.mp4',
-            previewUrl: 'test-preview.jpg',
-            videoDuration: 120,
-          });
+    it('should handle image re-upload with sync disabled', () => {
+      const { result } = createHook({ sameContent: false, activeTab: ANDROID });
+
+      // Set initial state
+      act(() => {
+        result.current.setImageSrc({
+          androidImageSrc: 'test-image.jpg',
+          iosImageSrc: 'test-image-ios.jpg',
         });
+      });
+
+      // Re-upload image
+      act(() => {
+        result.current.updateOnMpushImageReUpload();
+      });
+
+      // Verify only Android is cleared
+      expect(result.current.imageSrc).toEqual({
+        androidImageSrc: '',
+        iosImageSrc: 'test-image-ios.jpg',
+      });
+    });
 
-        // Clear video data
-        act(() => {
-          result.current.updateOnMpushVideoReUpload();
-        });
+    it('should handle image source update with sync enabled', () => {
+      const { result } = createHook({ sameContent: true });
 
-        expect(result.current.mpushVideoSrcAndPreview).toEqual({
-          mpushVideoSrc: '',
-          mpushVideoPreviewImg: '',
-          duration: 0,
-        });
+      // Update image source
+      act(() => {
+        result.current.setUpdateMpushImageSrc('test-image.jpg', 0);
+      });
 
-        expect(result.current.assetList).toEqual([]);
-        expect(mockSetAndroidContent).toHaveBeenCalledWith(expect.any(Function));
-        expect(mockSetIosContent).toHaveBeenCalledWith(expect.any(Function));
-        expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(0);
+      // Verify both platforms are updated
+      expect(result.current.imageSrc).toEqual({
+        androidImageSrc: 'test-image.jpg',
+        iosImageSrc: 'test-image.jpg',
       });
+      expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(0);
     });
-  });
 
-  describe('Media Payload Generation', () => {
-    it('should generate correct payload for IMAGE media type', () => {
-      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+    it('should handle image source update with sync disabled', () => {
+      const { result } = createHook({ sameContent: false });
 
-      // Set image source
+      // Update Android image source
       act(() => {
-        result.current.setUpdateMpushImageSrc('test-image.jpg', 0, IMAGE);
+        result.current.setUpdateMpushImageSrc('test-image.jpg', 0);
       });
 
-      const payload = result.current.getMediaPayload(IMAGE, ANDROID);
+      // Verify only Android is updated
+      expect(result.current.imageSrc).toEqual({
+        androidImageSrc: 'test-image.jpg',
+        iosImageSrc: '',
+      });
+      expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(0);
+
+      // Update iOS image source
+      act(() => {
+        result.current.setUpdateMpushImageSrc('test-image-ios.jpg', 1);
+      });
 
-      expect(payload).toEqual({
-        imageUrl: 'cdn_test-image.jpg',
+      // Verify iOS is updated
+      expect(result.current.imageSrc).toEqual({
+        androidImageSrc: 'test-image.jpg',
+        iosImageSrc: 'test-image-ios.jpg',
       });
+      expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(1);
     });
 
-    it('should generate correct payload for VIDEO media type', () => {
-      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+    it('should handle carousel image source update', () => {
+      const { result } = createHook({ sameContent: true });
 
-      // Set video source with preview
+      // Update carousel image source
       act(() => {
-        result.current.setUpdateMpushVideoSrc(0, {
-          videoSrc: 'test-video.mp4',
-          previewUrl: 'test-preview.jpg',
-          videoDuration: 30,
-        });
+        result.current.setUpdateMpushImageSrc('test-image.jpg', 0, CAROUSEL);
       });
 
-      const payload = result.current.getMediaPayload(VIDEO, ANDROID);
-
-      expect(payload).toEqual({
-        videoUrl: 'cdn_test-video.mp4',
-        videoPreviewImg: 'cdn_test-preview.jpg',
-        duration: 30,
+      // Verify both platforms are updated but clearAsset is not called
+      expect(result.current.imageSrc).toEqual({
+        androidImageSrc: 'test-image.jpg',
+        iosImageSrc: 'test-image.jpg',
       });
+      expect(mockMobilePushActions.clearAsset).not.toHaveBeenCalled();
     });
+  });
 
-    it('should generate correct payload for GIF media type with preview image', () => {
-      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+  describe('Video Re-upload Handlers', () => {
+    it('should handle video re-upload with sync enabled', () => {
+      const { result } = createHook({ sameContent: true });
 
-      // Set GIF source with preview
+      // Set initial state
       act(() => {
-        result.current.setUpdateMpushVideoSrc(0, {
-          videoSrc: 'test-gif.gif',
-          previewUrl: 'test-preview.jpg',
-          videoDuration: 5,
+        result.current.setVideoState({
+          androidVideoSrc: 'test-video.mp4',
+          androidVideoPreview: 'test-preview.jpg',
+          androidVideoDuration: 30,
+          iosVideoSrc: 'test-video.mp4',
+          iosVideoPreview: 'test-preview.jpg',
+          iosVideoDuration: 30,
+        });
+        result.current.setMpushVideoSrcAndPreview({
+          mpushVideoSrc: 'test-video.mp4',
+          mpushVideoPreviewImg: 'test-preview.jpg',
+          duration: 30,
         });
       });
 
-      const payload = result.current.getMediaPayload(GIF, ANDROID);
+      // Re-upload video
+      act(() => {
+        result.current.updateOnMpushVideoReUpload();
+      });
 
-      expect(payload).toEqual({
-        gifUrl: 'cdn_test-gif.gif',
-        gifPreviewImg: 'cdn_test-preview.jpg',
+      // Verify all states are cleared
+      expect(result.current.videoState).toEqual({
+        androidVideoSrc: '',
+        iosVideoSrc: '',
+        androidVideoPreview: '',
+        iosVideoPreview: '',
+        androidVideoDuration: 0,
+        iosVideoDuration: 0,
+      });
+      expect(result.current.mpushVideoSrcAndPreview).toEqual({
+        mpushVideoSrc: '',
+        mpushVideoPreviewImg: '',
+        duration: 0,
       });
+      expect(result.current.androidAssetList).toEqual([]);
+      expect(result.current.iosAssetList).toEqual([]);
+      expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(0);
+      expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(1);
     });
 
-    it('should generate correct payload for GIF media type without preview image (covers line 328)', () => {
-      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+    it('should handle video re-upload with sync disabled', () => {
+      const { result } = createHook({ sameContent: false, activeTab: ANDROID });
 
-      // Set GIF source WITHOUT preview to cover the falsy condition on line 328
+      // Set initial state
       act(() => {
-        result.current.setUpdateMpushVideoSrc(0, {
-          videoSrc: 'test-gif.gif',
-          previewUrl: '', // Empty preview URL to trigger the falsy condition
-          videoDuration: 5,
+        result.current.setVideoState({
+          androidVideoSrc: 'test-video.mp4',
+          androidVideoPreview: 'test-preview.jpg',
+          androidVideoDuration: 30,
+          iosVideoSrc: 'test-video-ios.mp4',
+          iosVideoPreview: 'test-preview-ios.jpg',
+          iosVideoDuration: 30,
         });
       });
 
-      const payload = result.current.getMediaPayload(GIF, ANDROID);
+      // Re-upload video
+      act(() => {
+        result.current.updateOnMpushVideoReUpload();
+      });
 
-      expect(payload).toEqual({
-        gifUrl: 'cdn_test-gif.gif',
-        gifPreviewImg: '', // This should be empty string due to the falsy condition
+      // Verify only Android states are cleared
+      expect(result.current.videoState).toEqual({
+        androidVideoSrc: '',
+        androidVideoPreview: '',
+        androidVideoDuration: 0,
+        iosVideoSrc: 'test-video-ios.mp4',
+        iosVideoPreview: 'test-preview-ios.jpg',
+        iosVideoDuration: 30,
       });
+      expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(0);
+      expect(mockMobilePushActions.clearAsset).not.toHaveBeenCalledWith(1);
     });
 
-    it('should generate correct payload for GIF media type with null preview image (covers line 328)', () => {
-      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+    it('should handle video source update with sync enabled', () => {
+      const { result } = createHook({ sameContent: true });
 
-      // Set GIF source with null preview to cover the falsy condition on line 328
+      // Update video source
       act(() => {
         result.current.setUpdateMpushVideoSrc(0, {
-          videoSrc: 'test-gif.gif',
-          previewUrl: null, // Null preview URL to trigger the falsy condition
-          videoDuration: 5,
+          videoSrc: 'test-video.mp4',
+          previewUrl: 'test-preview.jpg',
+          videoDuration: 30,
+          videoName: 'test.mp4',
+          fileHandle: 'handle',
         });
       });
 
-      const payload = result.current.getMediaPayload(GIF, ANDROID);
-
-      expect(payload).toEqual({
-        gifUrl: 'cdn_test-gif.gif',
-        gifPreviewImg: '', // This should be empty string due to the falsy condition
+      // Verify both platforms are updated
+      expect(result.current.videoState).toEqual({
+        androidVideoSrc: 'test-video.mp4',
+        iosVideoSrc: 'test-video.mp4',
+        androidVideoPreview: 'test-preview.jpg',
+        iosVideoPreview: 'test-preview.jpg',
+        androidVideoDuration: 30,
+        iosVideoDuration: 30,
+      });
+      expect(result.current.mpushVideoSrcAndPreview).toEqual({
+        mpushVideoSrc: 'test-video.mp4',
+        mpushVideoPreviewImg: 'test-preview.jpg',
+        duration: 30,
+      });
+      expect(result.current.androidAssetList).toEqual({
+        videoSrc: 'test-video.mp4',
+        previewUrl: 'test-preview.jpg',
+        videoDuration: 30,
+        videoName: 'test.mp4',
+        fileHandle: 'handle',
+      });
+      expect(result.current.iosAssetList).toEqual({
+        videoSrc: 'test-video.mp4',
+        previewUrl: 'test-preview.jpg',
+        videoDuration: 30,
+        videoName: 'test.mp4',
+        fileHandle: 'handle',
       });
+      expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(0);
     });
 
-    it('should generate correct payload for GIF media type with undefined preview image (covers line 328)', () => {
-      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+    it('should handle video source update with sync disabled', () => {
+      const { result } = createHook({ sameContent: false });
 
-      // Set GIF source with undefined preview to cover the falsy condition on line 328
+      // Update Android video source
       act(() => {
         result.current.setUpdateMpushVideoSrc(0, {
-          videoSrc: 'test-gif.gif',
-          previewUrl: undefined, // Undefined preview URL to trigger the falsy condition
-          videoDuration: 5,
+          videoSrc: 'test-video.mp4',
+          previewUrl: 'test-preview.jpg',
+          videoDuration: 30,
+          videoName: 'test.mp4',
+          fileHandle: 'handle',
         });
       });
 
-      const payload = result.current.getMediaPayload(GIF, ANDROID);
-
-      expect(payload).toEqual({
-        gifUrl: 'cdn_test-gif.gif',
-        gifPreviewImg: '', // This should be empty string due to the falsy condition
+      // Verify only Android is updated
+      expect(result.current.videoState).toEqual({
+        androidVideoSrc: 'test-video.mp4',
+        androidVideoPreview: 'test-preview.jpg',
+        androidVideoDuration: 30,
+        iosVideoSrc: '',
+        iosVideoPreview: '',
+        iosVideoDuration: 0,
       });
-    });
-
-    it('should return empty object for unknown media type', () => {
-      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+      expect(result.current.androidAssetList).toEqual({
+        videoSrc: 'test-video.mp4',
+        previewUrl: 'test-preview.jpg',
+        videoDuration: 30,
+        videoName: 'test.mp4',
+        fileHandle: 'handle',
+      });
+      expect(result.current.iosAssetList).toEqual([]);
+      expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(0);
 
-      const payload = result.current.getMediaPayload('UNKNOWN_TYPE', ANDROID);
+      // Update iOS video source
+      act(() => {
+        result.current.setUpdateMpushVideoSrc(1, {
+          videoSrc: 'test-video-ios.mp4',
+          previewUrl: 'test-preview-ios.jpg',
+          videoDuration: 30,
+          videoName: 'test-ios.mp4',
+          fileHandle: 'handle-ios',
+        });
+      });
 
-      expect(payload).toEqual({});
+      // Verify iOS is updated
+      expect(result.current.videoState).toEqual({
+        androidVideoSrc: 'test-video.mp4',
+        androidVideoPreview: 'test-preview.jpg',
+        androidVideoDuration: 30,
+        iosVideoSrc: 'test-video-ios.mp4',
+        iosVideoPreview: 'test-preview-ios.jpg',
+        iosVideoDuration: 30,
+      });
+      expect(result.current.iosAssetList).toEqual({
+        videoSrc: 'test-video-ios.mp4',
+        previewUrl: 'test-preview-ios.jpg',
+        videoDuration: 30,
+        videoName: 'test-ios.mp4',
+        fileHandle: 'handle-ios',
+      });
+      expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(1);
     });
 
-    it('should return empty object when no media is set', () => {
-      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-      // Test with IMAGE but no image source set
-      const imagePayload = result.current.getMediaPayload(IMAGE, ANDROID);
-      expect(imagePayload).toEqual({});
+    it('should not clear asset during initialization', () => {
+      const { result } = createHook({ sameContent: true });
 
-      // Test with VIDEO but no video source set
-      const videoPayload = result.current.getMediaPayload(VIDEO, ANDROID);
-      expect(videoPayload).toEqual({});
+      // Update video source with isInitialization=true
+      act(() => {
+        result.current.setUpdateMpushVideoSrc(0, {
+          videoSrc: 'test-video.mp4',
+          previewUrl: 'test-preview.jpg',
+          videoDuration: 30,
+          videoName: 'test.mp4',
+          fileHandle: 'handle',
+        }, true);
+      });
 
-      // Test with GIF but no GIF source set
-      const gifPayload = result.current.getMediaPayload(GIF, ANDROID);
-      expect(gifPayload).toEqual({});
+      // Verify states are updated but clearAsset is not called
+      expect(result.current.videoState.androidVideoSrc).toBe('test-video.mp4');
+      expect(mockMobilePushActions.clearAsset).not.toHaveBeenCalled();
     });
   });
 
-  describe('Preview Data Generation', () => {
-    describe('getPreviewData', () => {
-      it('should generate image preview data', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-        act(() => {
-          result.current.setUpdateMpushImageSrc('test-image.jpg', 0, IMAGE);
-        });
-
-        const previewData = result.current.getPreviewData(IMAGE, ANDROID);
+  describe('Platform-specific Logic', () => {
+    it('should get correct video properties for Android', () => {
+      const { result } = createHook({ activeTab: ANDROID });
 
-        expect(previewData).toEqual({
-          imageSrc: 'test-image.jpg',
+      // Test Android video properties
+      act(() => {
+        result.current.setVideoState({
+          androidVideoSrc: 'test-video.mp4',
+          androidVideoPreview: 'test-preview.jpg',
+          androidVideoDuration: 30,
+          iosVideoSrc: 'test-video-ios.mp4',
+          iosVideoPreview: 'test-preview-ios.jpg',
+          iosVideoDuration: 25,
         });
       });
 
-      it('should generate video preview data', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-        act(() => {
-          result.current.setUpdateMpushVideoSrc(0, {
-            videoSrc: 'test-video.mp4',
-            previewUrl: 'test-preview.jpg',
-            videoDuration: 120,
-          });
-        });
+      const androidPayload = result.current.getMediaPayload(VIDEO, ANDROID);
+      expect(androidPayload.videoUrl).toBe('cdn/MOBILEPUSH/test-video.mp4');
+      expect(androidPayload.videoPreviewImg).toBe('cdn/MOBILEPUSH/test-preview.jpg');
+      expect(androidPayload.duration).toBe(30);
+    });
 
-        const previewData = result.current.getPreviewData(VIDEO, ANDROID);
+    it('should get correct video properties for iOS', () => {
+      const { result } = createHook({ activeTab: IOS });
 
-        expect(previewData).toEqual({
-          videoSrc: 'test-video.mp4',
-          videoPreviewImg: 'test-preview.jpg',
-          duration: 120,
+      // Test iOS video properties
+      act(() => {
+        result.current.setVideoState({
+          androidVideoSrc: 'test-video.mp4',
+          androidVideoPreview: 'test-preview.jpg',
+          androidVideoDuration: 30,
+          iosVideoSrc: 'test-video-ios.mp4',
+          iosVideoPreview: 'test-preview-ios.jpg',
+          iosVideoDuration: 25,
         });
       });
 
-      it('should generate GIF preview data', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-        act(() => {
-          result.current.setUpdateMpushVideoSrc(0, {
-            videoSrc: 'test-gif.gif',
-            previewUrl: 'test-preview.jpg',
-          });
-        });
+      const iosPayload = result.current.getMediaPayload(VIDEO, IOS);
+      expect(iosPayload.videoUrl).toBe('cdn/MOBILEPUSH/test-video-ios.mp4');
+      expect(iosPayload.videoPreviewImg).toBe('cdn/MOBILEPUSH/test-preview-ios.jpg');
+      expect(iosPayload.duration).toBe(25);
+    });
 
-        const previewData = result.current.getPreviewData(GIF, ANDROID);
+    it('should handle image re-upload for iOS', () => {
+      const { result } = createHook({ sameContent: false, activeTab: IOS });
 
-        expect(previewData).toEqual({
-          gifSrc: 'test-gif.gif',
-          gifPreviewImg: 'test-preview.jpg',
+      // Set initial state
+      act(() => {
+        result.current.setImageSrc({
+          androidImageSrc: 'test-image.jpg',
+          iosImageSrc: 'test-image-ios.jpg',
         });
       });
 
-      it('should generate image preview data for iOS platform', () => {
-        const iosProps = { ...defaultProps, activeTab: 'IOS' };
-        const { result } = renderHook(() => useUpload(...Object.values(iosProps)));
-
-        act(() => {
-          result.current.setUpdateMpushImageSrc('test-ios-image.jpg', 1, IMAGE);
-        });
-
-        const previewData = result.current.getPreviewData(IMAGE, 'IOS');
-
-        expect(previewData).toEqual({
-          imageSrc: 'test-ios-image.jpg',
-        });
+      // Re-upload image
+      act(() => {
+        result.current.updateOnMpushImageReUpload();
       });
 
-      it('should generate video preview data for iOS platform', () => {
-        const iosProps = { ...defaultProps, activeTab: 'IOS' };
-        const { result } = renderHook(() => useUpload(...Object.values(iosProps)));
-
-        act(() => {
-          result.current.setUpdateMpushVideoSrc(1, {
-            videoSrc: 'test-ios-video.mp4',
-            previewUrl: 'test-ios-preview.jpg',
-            videoDuration: 90,
-          });
-        });
-
-        const previewData = result.current.getPreviewData(VIDEO, 'IOS');
-
-        expect(previewData).toEqual({
-          videoSrc: 'test-ios-video.mp4',
-          videoPreviewImg: 'test-ios-preview.jpg',
-          duration: 90,
-        });
+      // Verify only iOS is cleared
+      expect(result.current.imageSrc).toEqual({
+        androidImageSrc: 'test-image.jpg',
+        iosImageSrc: '',
       });
+    });
 
-      it('should generate GIF preview data for iOS platform', () => {
-        const iosProps = { ...defaultProps, activeTab: 'IOS' };
-        const { result } = renderHook(() => useUpload(...Object.values(iosProps)));
+    it('should handle video re-upload for iOS', () => {
+      const { result } = createHook({ sameContent: false, activeTab: IOS });
 
-        act(() => {
-          result.current.setUpdateMpushVideoSrc(1, {
-            videoSrc: 'test-ios-gif.gif',
-            previewUrl: 'test-ios-preview.jpg',
-          });
+      // Set initial state
+      act(() => {
+        result.current.setVideoState({
+          androidVideoSrc: 'test-video.mp4',
+          androidVideoPreview: 'test-preview.jpg',
+          androidVideoDuration: 30,
+          iosVideoSrc: 'test-video-ios.mp4',
+          iosVideoPreview: 'test-preview-ios.jpg',
+          iosVideoDuration: 25,
         });
+      });
 
-        const previewData = result.current.getPreviewData(GIF, 'IOS');
+      // Re-upload video
+      act(() => {
+        result.current.updateOnMpushVideoReUpload();
+      });
 
-        expect(previewData).toEqual({
-          gifSrc: 'test-ios-gif.gif',
-          gifPreviewImg: 'test-ios-preview.jpg',
-        });
+      // Verify only iOS states are cleared
+      expect(result.current.videoState).toEqual({
+        androidVideoSrc: 'test-video.mp4',
+        androidVideoPreview: 'test-preview.jpg',
+        androidVideoDuration: 30,
+        iosVideoSrc: '',
+        iosVideoPreview: '',
+        iosVideoDuration: 0,
       });
+      expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(1);
+      expect(mockMobilePushActions.clearAsset).not.toHaveBeenCalledWith(0);
     });
-  });
-
-  describe('Media Upload Validation', () => {
-    describe('isMediaUploaded', () => {
-      it('should return true for uploaded image', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
 
-        act(() => {
-          result.current.setUpdateMpushImageSrc('test-image.jpg', 0, IMAGE);
-        });
+    it('should handle carousel image source update for iOS', () => {
+      const { result } = createHook({ sameContent: false, activeTab: IOS });
 
-        expect(result.current.isMediaUploaded(IMAGE, ANDROID)).toBe(true);
+      // Update carousel image source for iOS
+      act(() => {
+        result.current.setUpdateMpushImageSrc('test-image-ios.jpg', 1, CAROUSEL);
       });
 
-      it('should return false for non-uploaded image', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-        expect(result.current.isMediaUploaded(IMAGE, ANDROID)).toBe(false);
+      // Verify only iOS is updated and clearAsset is not called
+      expect(result.current.imageSrc).toEqual({
+        androidImageSrc: '',
+        iosImageSrc: 'test-image-ios.jpg',
       });
+      expect(mockMobilePushActions.clearAsset).not.toHaveBeenCalled();
+    });
 
-      it('should return true for uploaded video', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-        act(() => {
-          result.current.setUpdateMpushVideoSrc(0, {
-            videoSrc: 'test-video.mp4',
-          });
-        });
+    it('should handle empty file paths', () => {
+      const { result } = createHook();
 
-        expect(result.current.isMediaUploaded(VIDEO, ANDROID)).toBe(true);
-        expect(result.current.isMediaUploaded(GIF, ANDROID)).toBe(true);
-      });
+      // Test empty image URL
+      expect(result.current.getCdnImageUrl('')).toBe('');
 
-      it('should return true for text media types', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+      // Test empty video URL
+      expect(result.current.getCdnVideoUrl('')).toBe('');
 
-        expect(result.current.isMediaUploaded('TEXT', ANDROID)).toBe(true);
-        expect(result.current.isMediaUploaded('NONE', ANDROID)).toBe(true);
+      // Test empty image source update
+      act(() => {
+        result.current.setUpdateMpushImageSrc('', 0);
       });
+      expect(result.current.imageSrc).toEqual({
+        androidImageSrc: '',
+        iosImageSrc: '',
+      });
+
+      // Test empty video source update
+      act(() => {
+        result.current.setUpdateMpushVideoSrc(0, {
+          videoSrc: '',
+          previewUrl: '',
+          videoDuration: 0,
+        });
+      });
+      expect(result.current.videoState).toEqual({
+        androidVideoSrc: '',
+        androidVideoPreview: '',
+        androidVideoDuration: 0,
+        iosVideoSrc: '',
+        iosVideoPreview: '',
+        iosVideoDuration: 0,
+    });
+  });
 
-      it('should return true for uploaded image on iOS platform', () => {
-        const iosProps = { ...defaultProps, activeTab: 'IOS' };
-        const { result } = renderHook(() => useUpload(...Object.values(iosProps)));
+    it('should handle missing video preview and duration in source update', () => {
+      const { result } = createHook();
 
-        act(() => {
-          result.current.setUpdateMpushImageSrc('test-ios-image.jpg', IMAGE);
+      // Update video source without preview and duration
+      act(() => {
+        result.current.setUpdateMpushVideoSrc(0, {
+          videoSrc: 'test-video.mp4',
         });
-
-        expect(result.current.isMediaUploaded(IMAGE, 'IOS')).toBe(true);
       });
 
-      it('should return false for non-uploaded image on iOS platform', () => {
-        const iosProps = { ...defaultProps, activeTab: 'IOS' };
-        const { result } = renderHook(() => useUpload(...Object.values(iosProps)));
-
-        expect(result.current.isMediaUploaded(IMAGE, 'IOS')).toBe(false);
+      // Verify default values are used
+      expect(result.current.videoState).toEqual({
+        androidVideoSrc: 'test-video.mp4',
+        androidVideoPreview: '',
+        androidVideoDuration: 0,
+        iosVideoSrc: '',
+        iosVideoPreview: '',
+        iosVideoDuration: 0,
+      });
+      expect(result.current.mpushVideoSrcAndPreview).toEqual({
+        mpushVideoSrc: 'test-video.mp4',
+        mpushVideoPreviewImg: '',
+        duration: 0,
       });
+    });
 
-      it('should return true for uploaded video on iOS platform', () => {
-        const iosProps = { ...defaultProps, activeTab: 'IOS' };
-        const { result } = renderHook(() => useUpload(...Object.values(iosProps)));
+    it('should handle missing file name and handle in source update', () => {
+      const { result } = createHook();
 
-        act(() => {
-          result.current.setUpdateMpushVideoSrc(1, {
-            videoSrc: 'test-ios-video.mp4',
-          });
-        });
+      const videoData = {
+        videoSrc: 'test-video.mp4',
+        previewUrl: 'test-preview.jpg',
+        videoDuration: 30,
+        videoName: '',
+        fileHandle: '',
+      };
 
-        expect(result.current.isMediaUploaded(VIDEO, 'IOS')).toBe(true);
-        expect(result.current.isMediaUploaded(GIF, 'IOS')).toBe(true);
+      // Update video source without file name and handle
+      act(() => {
+        result.current.setUpdateMpushVideoSrc(0, videoData);
       });
 
-      it('should return true for text media types on iOS platform', () => {
-        const iosProps = { ...defaultProps, activeTab: 'IOS' };
-        const { result } = renderHook(() => useUpload(...Object.values(iosProps)));
-
-        expect(result.current.isMediaUploaded('TEXT', 'IOS')).toBe(true);
-        expect(result.current.isMediaUploaded('NONE', 'IOS')).toBe(true);
+      // Verify asset data is still updated
+      expect(result.current.androidAssetList).toEqual({
+        ...videoData,
       });
     });
   });
 
-  describe('Utility Functions', () => {
-    describe('clearImageDataByMediaType', () => {
-      it('should clear image data for IMAGE media type', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-        // Set initial image on both platforms
-        act(() => {
-          result.current.setImageSrc({
-            androidImageSrc: 'test-android.jpg',
-            iosImageSrc: 'test-ios.jpg',
-          });
-        });
+  describe('Clear Media Data', () => {
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
 
-        // Clear image data (should only clear Android since activeTab is ANDROID and sameContent is false)
-        act(() => {
-          result.current.clearImageDataByMediaType(IMAGE);
-        });
+    it('should clear image data with sync enabled', () => {
+      const { result } = createHook({ sameContent: true });
 
-        expect(result.current.imageSrc).toEqual({
-          androidImageSrc: '',
-          iosImageSrc: 'test-ios.jpg', // iOS should remain unchanged
+      // Set initial state
+      act(() => {
+        result.current.setImageSrc({
+          androidImageSrc: 'test-image.jpg',
+          iosImageSrc: 'test-image.jpg',
         });
       });
 
-      it('should not clear data for non-IMAGE media types', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-        // Set initial image
-        act(() => {
-          result.current.setUpdateMpushImageSrc('test-image.jpg', 0, IMAGE);
-        });
-
-        // Try to clear with different media type
-        act(() => {
-          result.current.clearImageDataByMediaType(VIDEO);
-        });
+      // Clear image data
+      act(() => {
+        result.current.clearImageDataByMediaType(IMAGE);
+      });
 
-        expect(result.current.imageSrc.androidImageSrc).toBe('test-image.jpg');
+      // Verify both platforms are cleared
+      expect(result.current.imageSrc).toEqual({
+        androidImageSrc: '',
+        iosImageSrc: '',
       });
     });
 
-    describe('resetUploadStates', () => {
-      it('should reset all upload states', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-        // Set some data
-        act(() => {
-          result.current.setUpdateMpushImageSrc('test-image.jpg', 0, IMAGE);
-          result.current.setUpdateMpushVideoSrc(0, {
-            videoSrc: 'test-video.mp4',
-            previewUrl: 'test-preview.jpg',
-          });
-        });
-
-        // Reset all states
-        act(() => {
-          result.current.resetUploadStates();
-        });
+    it('should clear image data with sync disabled', () => {
+      const { result } = createHook({ sameContent: false, activeTab: ANDROID });
 
-        expect(result.current.imageSrc).toEqual({
-          androidImageSrc: '',
-          iosImageSrc: '',
-        });
-        expect(result.current.mpushVideoSrcAndPreview).toEqual({
-          mpushVideoSrc: '',
-          mpushVideoPreviewImg: '',
-          duration: 0,
+      // Set initial state
+      act(() => {
+        result.current.setImageSrc({
+          androidImageSrc: 'test-image.jpg',
+          iosImageSrc: 'test-image-ios.jpg',
         });
-        expect(result.current.assetList).toEqual([]);
       });
-    });
 
-    describe('CDN URL functions', () => {
-      it('should generate CDN image URL', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-        const cdnUrl = result.current.getCdnImageUrl('test-image.jpg');
-
-        expect(cdnUrl).toBe('cdn_test-image.jpg');
-        expect(getCdnUrl).toHaveBeenCalledWith({
-          url: 'test-image.jpg',
-          channelName: MOBILE_PUSH_CHANNEL,
-        });
+      // Clear image data
+      act(() => {
+        result.current.clearImageDataByMediaType(IMAGE);
       });
 
-      it('should return empty string for empty image URL', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+      // Verify only Android is cleared
+      expect(result.current.imageSrc).toEqual({
+        androidImageSrc: '',
+        iosImageSrc: 'test-image-ios.jpg',
+      });
+    });
 
-        const cdnUrl = result.current.getCdnImageUrl('');
+    it('should clear video data with sync enabled', () => {
+      const { result } = createHook({ sameContent: true });
 
-        expect(cdnUrl).toBe('');
+      // Set initial state
+      act(() => {
+        result.current.setVideoState({
+          androidVideoSrc: 'test-video.mp4',
+          androidVideoPreview: 'test-preview.jpg',
+          androidVideoDuration: 30,
+          iosVideoSrc: 'test-video.mp4',
+          iosVideoPreview: 'test-preview.jpg',
+          iosVideoDuration: 30,
+        });
       });
 
-      it('should generate CDN video URL', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+      // Clear video data
+      act(() => {
+        result.current.clearImageDataByMediaType(VIDEO);
+      });
+
+      // Verify both platforms are cleared
+      expect(result.current.videoState).toEqual({
+        androidVideoSrc: '',
+        androidVideoPreview: '',
+        androidVideoDuration: 0,
+        iosVideoSrc: '',
+        iosVideoPreview: '',
+        iosVideoDuration: 0,
+      });
+
+      // Verify content is cleared
+      expect(androidContent).toMatchObject({
+        title: 'Test Android',
+        message: 'Test message',
+        videoSrc: '',
+        videoPreview: '',
+        videoDuration: 0,
+      });
+      expect(iosContent).toMatchObject({
+        title: 'Test iOS',
+        message: 'Test message',
+        videoSrc: '',
+        videoPreview: '',
+        videoDuration: 0,
+      });
+
+      // Verify Redux state is cleared
+      expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(0);
+      expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(1);
+    });
 
-        const cdnUrl = result.current.getCdnVideoUrl('test-video.mp4');
+    it('should clear video data with sync disabled', () => {
+      const { result } = createHook({ sameContent: false, activeTab: ANDROID });
 
-        expect(cdnUrl).toBe('cdn_test-video.mp4');
-        expect(getCdnUrl).toHaveBeenCalledWith({
-          url: 'test-video.mp4',
-          channelName: MOBILE_PUSH_CHANNEL,
+      // Set initial state
+      act(() => {
+        result.current.setVideoState({
+          androidVideoSrc: 'test-video.mp4',
+          androidVideoPreview: 'test-preview.jpg',
+          androidVideoDuration: 30,
+          iosVideoSrc: 'test-video-ios.mp4',
+          iosVideoPreview: 'test-preview-ios.jpg',
+          iosVideoDuration: 25,
         });
       });
 
-      it('should return empty string for empty video URL', () => {
-        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+      // Clear video data
+      act(() => {
+        result.current.clearImageDataByMediaType(VIDEO);
+      });
 
-        const cdnUrl = result.current.getCdnVideoUrl('');
+      // Verify only Android is cleared
+      expect(result.current.videoState).toEqual({
+        androidVideoSrc: '',
+        androidVideoPreview: '',
+        androidVideoDuration: 0,
+        iosVideoSrc: 'test-video-ios.mp4',
+        iosVideoPreview: 'test-preview-ios.jpg',
+        iosVideoDuration: 25,
+      });
 
-        expect(cdnUrl).toBe('');
+      // Verify only Android content is cleared
+      expect(androidContent).toMatchObject({
+        title: 'Test Android',
+        message: 'Test message',
+        videoSrc: '',
+        videoPreview: '',
+        videoDuration: 0,
+      });
+      expect(iosContent).toMatchObject({
+        title: 'Test iOS',
+        message: 'Test message',
       });
+
+      // Verify only Android Redux state is cleared
+      expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(0);
+      expect(mockMobilePushActions.clearAsset).not.toHaveBeenCalledWith(1);
     });
-  });
 
-  describe('useEffect behaviors', () => {
-    it('should call setAndroidContent and setIosContent when imageSrc changes', () => {
-      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+    it('should clear GIF data with sync enabled', () => {
+      const { result } = createHook({ sameContent: true });
 
+      // Set initial state
       act(() => {
-        result.current.setUpdateMpushImageSrc('test-image.jpg', 0, IMAGE);
+        result.current.setVideoState({
+          androidVideoSrc: 'test.gif',
+          androidVideoPreview: 'test-preview.jpg',
+          androidVideoDuration: 30,
+          iosVideoSrc: 'test.gif',
+          iosVideoPreview: 'test-preview.jpg',
+          iosVideoDuration: 30,
+        });
       });
 
-      expect(mockSetAndroidContent).toHaveBeenCalledWith(expect.any(Function));
-      expect(mockSetIosContent).toHaveBeenCalledWith(expect.any(Function));
+      // Clear GIF data
+      act(() => {
+        result.current.clearImageDataByMediaType(GIF);
+      });
+
+      // Verify both platforms are cleared
+      expect(result.current.videoState).toEqual({
+        androidVideoSrc: '',
+        androidVideoPreview: '',
+        androidVideoDuration: 0,
+        iosVideoSrc: '',
+        iosVideoPreview: '',
+        iosVideoDuration: 0,
+      });
+
+      // Verify content is cleared
+      expect(androidContent).toMatchObject({
+        title: 'Test Android',
+        message: 'Test message',
+        videoSrc: '',
+        videoPreview: '',
+        videoDuration: 0,
+      });
+      expect(iosContent).toMatchObject({
+        title: 'Test iOS',
+        message: 'Test message',
+        videoSrc: '',
+        videoPreview: '',
+        videoDuration: 0,
+      });
+
+      // Verify Redux state is cleared
+      expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(0);
+      expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(1);
     });
 
-    it('should call setAndroidContent and setIosContent when video src changes', () => {
-      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+    it('should clear GIF data with sync disabled', () => {
+      const { result } = createHook({ sameContent: false, activeTab: ANDROID });
 
+      // Set initial state
       act(() => {
-        result.current.setUpdateMpushVideoSrc(0, {
-          videoSrc: 'test-video.mp4',
-          previewUrl: 'test-preview.jpg',
+        result.current.setVideoState({
+          androidVideoSrc: 'test.gif',
+          androidVideoPreview: 'test-preview.jpg',
+          androidVideoDuration: 30,
+          iosVideoSrc: 'test-ios.gif',
+          iosVideoPreview: 'test-preview-ios.jpg',
+          iosVideoDuration: 25,
         });
       });
 
-      expect(mockSetAndroidContent).toHaveBeenCalledWith(expect.any(Function));
-      expect(mockSetIosContent).toHaveBeenCalledWith(expect.any(Function));
-    });
-  });
-
-  describe('Edge Cases', () => {
-    it('should handle undefined file in validation functions', () => {
-      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-      expect(() => {
-        result.current.validateImageFile(undefined);
-      }).toThrow();
-    });
+      // Clear GIF data
+      act(() => {
+        result.current.clearImageDataByMediaType(GIF);
+      });
 
-    it('should handle missing file properties gracefully', () => {
-      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+      // Verify only Android is cleared
+      expect(result.current.videoState).toEqual({
+        androidVideoSrc: '',
+        androidVideoPreview: '',
+        androidVideoDuration: 0,
+        iosVideoSrc: 'test-ios.gif',
+        iosVideoPreview: 'test-preview-ios.jpg',
+        iosVideoDuration: 25,
+      });
 
-      const fileWithoutSize = { name: 'test.jpg' };
+      // Verify only Android content is cleared
+      expect(androidContent).toMatchObject({
+        title: 'Test Android',
+        message: 'Test message',
+        videoSrc: '',
+        videoPreview: '',
+        videoDuration: 0,
+      });
+      expect(iosContent).toMatchObject({
+        title: 'Test iOS',
+        message: 'Test message',
+      });
 
-      expect(() => {
-        result.current.validateImageFile(fileWithoutSize);
-      }).not.toThrow();
+      // Verify only Android Redux state is cleared
+      expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(0);
+      expect(mockMobilePushActions.clearAsset).not.toHaveBeenCalledWith(1);
     });
 
-    it('should handle empty edit data gracefully', () => {
-      const { result } = renderHook(() => useUpload(
-        mockMobilePushActions,
-        { templateDetails: null },
-        {},
-        {},
-        false,
-        false,
-        mockSetAndroidContent,
-        mockSetIosContent,
-        ANDROID,
-        defaultProps.androidContent,
-        defaultProps.iosContent
-      ));
+    it('should do nothing for unknown media type', () => {
+      const { result } = createHook({ sameContent: true });
 
-      expect(result.current.imageSrc).toEqual({
-        androidImageSrc: '',
-        iosImageSrc: '',
+      // Set initial state
+      act(() => {
+        result.current.setImageSrc({
+          androidImageSrc: 'test-image.jpg',
+          iosImageSrc: 'test-image.jpg',
+        });
+        result.current.setVideoState({
+          androidVideoSrc: 'test-video.mp4',
+          androidVideoPreview: 'test-preview.jpg',
+          androidVideoDuration: 30,
+          iosVideoSrc: 'test-video.mp4',
+          iosVideoPreview: 'test-preview.jpg',
+          iosVideoDuration: 30,
+        });
       });
-    });
-
-    it('should handle malformed edit data structure', () => {
-      const malformedEditData = {
-        templateDetails: {
-          versions: {
-            base: {
-              content: null,
-            },
-          },
-        },
-      };
 
-      const { result } = renderHook(() => useUpload(
-        mockMobilePushActions,
-        malformedEditData,
-        {},
-        {},
-        false,
-        false,
-        mockSetAndroidContent,
-        mockSetIosContent,
-        ANDROID,
-        defaultProps.androidContent,
-        defaultProps.iosContent
-      ));
+      // Clear unknown media type
+      act(() => {
+        result.current.clearImageDataByMediaType('UNKNOWN');
+      });
 
+      // Verify nothing is cleared
       expect(result.current.imageSrc).toEqual({
-        androidImageSrc: '',
-        iosImageSrc: '',
-      });
+        androidImageSrc: 'test-image.jpg',
+        iosImageSrc: 'test-image.jpg',
+      });
+      expect(result.current.videoState).toEqual({
+        androidVideoSrc: 'test-video.mp4',
+        androidVideoPreview: 'test-preview.jpg',
+        androidVideoDuration: 30,
+        iosVideoSrc: 'test-video.mp4',
+        iosVideoPreview: 'test-preview.jpg',
+        iosVideoDuration: 30,
+      });
+      expect(androidContent).toMatchObject({
+        title: 'Test Android',
+        message: 'Test message',
+      });
+      expect(iosContent).toMatchObject({
+        title: 'Test iOS',
+        message: 'Test message',
+      });
+      expect(mockMobilePushActions.clearAsset).not.toHaveBeenCalled();
     });
   });
 
-  describe('Additional Edge Cases for Complete Coverage', () => {
-    it('should handle setUpdateMpushVideoSrc with minimal data', () => {
-      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+  describe('Image Source Updates', () => {
+    it('should update content when imageSrc changes with sync enabled', () => {
+      const { result } = createHook({ sameContent: true });
 
-      // Test with minimal data object
+      // Set image source
       act(() => {
-        result.current.setUpdateMpushVideoSrc(0, {
-          videoSrc: 'test.mp4',
+        result.current.setImageSrc({
+          androidImageSrc: 'test-image.jpg',
+          iosImageSrc: '',
         });
       });
 
-      expect(result.current.mpushVideoSrcAndPreview.mpushVideoSrc).toBe('test.mp4');
-      expect(result.current.mpushVideoSrcAndPreview.mpushVideoPreviewImg).toBe('');
-      expect(result.current.mpushVideoSrcAndPreview.duration).toBe(0);
-    });
-
-    it('should handle setUpdateMpushVideoSrc with extra data spread', () => {
-      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
-
-      const extraData = {
-        videoSrc: 'test.mp4',
-        previewUrl: 'preview.jpg',
-        videoDuration: 30,
-        extraField: 'extra-value',
-        anotherField: 123,
-      };
+      // Verify both platforms are updated with Android image
+      expect(androidContent).toMatchObject({
+        title: 'Test Android',
+        message: 'Test message',
+        imageSrc: 'test-image.jpg',
+      });
+      expect(iosContent).toMatchObject({
+        title: 'Test iOS',
+        message: 'Test message',
+        imageSrc: 'test-image.jpg',
+      });
 
+      // Set iOS image source
       act(() => {
-        result.current.setUpdateMpushVideoSrc(0, extraData);
+        result.current.setImageSrc({
+          androidImageSrc: '',
+          iosImageSrc: 'test-image-ios.jpg',
+        });
       });
 
-      expect(result.current.assetList).toEqual(expect.objectContaining({
-        videoSrc: 'test.mp4',
-        previewUrl: 'preview.jpg',
-        videoDuration: 30,
-        extraField: 'extra-value',
-        anotherField: 123,
-      }));
+      // Verify both platforms are updated with iOS image
+      expect(androidContent).toMatchObject({
+        title: 'Test Android',
+        message: 'Test message',
+        imageSrc: 'test-image-ios.jpg',
+      });
+      expect(iosContent).toMatchObject({
+        title: 'Test iOS',
+        message: 'Test message',
+        imageSrc: 'test-image-ios.jpg',
+      });
     });
 
-    it('should handle clearImageDataByMediaType for non-IMAGE types', () => {
-      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+    it('should update content when imageSrc changes with sync disabled', () => {
+      const { result } = createHook({ sameContent: false });
 
-      // Set some image data first
+      // Set Android image source
       act(() => {
-        result.current.setUpdateMpushImageSrc('test-image.jpg', 0, IMAGE);
+        result.current.setImageSrc({
+          androidImageSrc: 'test-image.jpg',
+          iosImageSrc: '',
+        });
       });
 
-      expect(result.current.imageSrc.androidImageSrc).toBe('test-image.jpg');
-
-      // Clear using CAROUSEL type (should not affect image data)
-      act(() => {
-        result.current.clearImageDataByMediaType(CAROUSEL);
+      // Verify only Android is updated
+      expect(androidContent).toMatchObject({
+        title: 'Test Android',
+        message: 'Test message',
+        imageSrc: 'test-image.jpg',
+      });
+      expect(iosContent).toMatchObject({
+        title: 'Test iOS',
+        message: 'Test message',
       });
 
-      // Image data should remain unchanged for CAROUSEL
-      expect(result.current.imageSrc.androidImageSrc).toBe('test-image.jpg');
-
-      // Set data for both platforms to test clearing behavior
+      // Set iOS image source
       act(() => {
         result.current.setImageSrc({
-          androidImageSrc: 'test-android.jpg',
-          iosImageSrc: 'test-ios.jpg',
+          androidImageSrc: 'test-image.jpg',
+          iosImageSrc: 'test-image-ios.jpg',
         });
       });
 
-      // Clear using IMAGE type (should clear only Android since activeTab is ANDROID and sameContent is false)
-      act(() => {
-        result.current.clearImageDataByMediaType(IMAGE);
+      // Verify both platforms have their respective images
+      expect(androidContent).toMatchObject({
+        title: 'Test Android',
+        message: 'Test message',
+        imageSrc: 'test-image.jpg',
+      });
+      expect(iosContent).toMatchObject({
+        title: 'Test iOS',
+        message: 'Test message',
+        imageSrc: 'test-image-ios.jpg',
       });
-
-      // Only Android should be cleared when sameContent=false
-      expect(result.current.imageSrc.androidImageSrc).toBe('');
-      expect(result.current.imageSrc.iosImageSrc).toBe('test-ios.jpg');
     });
   });
 });