@capillarytech/creatives-library 8.0.126 → 8.0.127-alpha.1

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

@@ -0,0 +1,1223 @@
+import { renderHook, act } from '@testing-library/react';
+import { getCdnUrl } from '../../../../utils/cdnTransformation';
+import useUpload from '../useUpload';
+import {
+  MOBILE_PUSH_CHANNEL,
+  MPUSH_IMG_SIZE,
+  MPUSH_VIDEO_SIZE,
+  MPUSH_GIF_SIZE,
+  ANDROID,
+  IMAGE,
+  VIDEO,
+  GIF,
+  CAROUSEL,
+} from '../../constants';
+
+// Mock the CDN transformation utility
+jest.mock('../../../../utils/cdnTransformation', () => ({
+  getCdnUrl: jest.fn(),
+}));
+
+describe('useUpload Hook', () => {
+  // Mock data and functions
+  const 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');
+      });
+
+      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');
+      });
+    });
+
+    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');
+      });
+    });
+
+    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');
+      });
+    });
+  });
+
+  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,
+      });
+
+      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,
+        }
+      );
+    });
+
+    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,
+      });
+
+      act(() => {
+        result.current.uploadMpushAsset(validFile, VIDEO.toLowerCase(), {});
+      });
+
+      expect(mockMobilePushActions.uploadAsset).toHaveBeenCalledWith(
+        validFile,
+        VIDEO.toLowerCase(),
+        {},
+        0,
+        {
+          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,
+      });
+
+      act(() => {
+        result.current.uploadMpushAsset(validFile, GIF.toLowerCase(), {});
+      });
+
+      expect(mockMobilePushActions.uploadAsset).toHaveBeenCalledWith(
+        validFile,
+        VIDEO.toLowerCase(), // GIF uploads use video type
+        {},
+        0,
+        {
+          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',
+      });
+
+      act(() => {
+        result.current.uploadMpushAsset(invalidFile, IMAGE.toLowerCase(), {});
+      });
+
+      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');
+    });
+
+    it('should handle iOS tab correctly', () => {
+      const iosProps = { ...defaultProps, activeTab: 'IOS' };
+      const { result } = renderHook(() => useUpload(...Object.values(iosProps)));
+
+      const validFile = new File(['test'], 'test.jpg', {
+        type: 'image/jpeg',
+        size: 1000,
+      });
+
+      act(() => {
+        result.current.uploadMpushAsset(validFile, IMAGE.toLowerCase(), {});
+      });
+
+      expect(mockMobilePushActions.uploadAsset).toHaveBeenCalledWith(
+        validFile,
+        IMAGE.toLowerCase(),
+        {},
+        1, // iOS tab
+        expect.any(Object)
+      );
+    });
+  });
+
+  describe('Image Source Management', () => {
+    describe('setUpdateMpushImageSrc', () => {
+      it('should update Android image source when sync is disabled', () => {
+        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+
+        act(() => {
+          result.current.setUpdateMpushImageSrc('test-image.jpg', 0, IMAGE);
+        });
+
+        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)));
+
+        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');
+      });
+
+      it('should update iOS image source when iOS tab is active', () => {
+        const iosProps = { ...defaultProps, activeTab: 'IOS' };
+        const { result } = renderHook(() => useUpload(...Object.values(iosProps)));
+
+        act(() => {
+          result.current.setUpdateMpushImageSrc('test-ios-image.jpg', 1, IMAGE);
+        });
+
+        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);
+        });
+
+        expect(result.current.imageSrc.androidImageSrc).toBe('');
+        expect(result.current.imageSrc.iosImageSrc).toBe('');
+        expect(mockMobilePushActions.clearAsset).not.toHaveBeenCalled();
+      });
+
+      it('should default to IMAGE media type when mediaType parameter is not provided', () => {
+        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+
+        act(() => {
+          result.current.setUpdateMpushImageSrc('test-image.jpg', 0); // No mediaType parameter
+        });
+
+        expect(result.current.imageSrc.androidImageSrc).toBe('test-image.jpg');
+        expect(result.current.imageSrc.iosImageSrc).toBe('');
+        expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(0);
+      });
+
+      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)));
+
+        act(() => {
+          result.current.setUpdateMpushImageSrc('test-ios-image.jpg', 1); // No mediaType parameter
+        });
+
+        expect(result.current.imageSrc.androidImageSrc).toBe('');
+        expect(result.current.imageSrc.iosImageSrc).toBe('test-ios-image.jpg');
+        expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(1);
+      });
+
+      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)));
+
+        act(() => {
+          result.current.setUpdateMpushImageSrc('test-image.jpg', 0); // No mediaType parameter
+        });
+
+        expect(result.current.imageSrc.androidImageSrc).toBe('test-image.jpg');
+        expect(result.current.imageSrc.iosImageSrc).toBe('test-image.jpg');
+        expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(0);
+      });
+    });
+
+    describe('updateOnMpushImageReUpload', () => {
+      it('should clear Android platform image when sync is disabled and Android tab is active', () => {
+        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+
+        // Set initial images for both platforms
+        act(() => {
+          result.current.setImageSrc({
+            androidImageSrc: 'test-android-image.jpg',
+            iosImageSrc: 'test-ios-image.jpg',
+          });
+        });
+
+        // Clear image (should only clear Android since activeTab is ANDROID)
+        act(() => {
+          result.current.updateOnMpushImageReUpload();
+        });
+
+        expect(result.current.imageSrc.androidImageSrc).toBe('');
+        expect(result.current.imageSrc.iosImageSrc).toBe('test-ios-image.jpg'); // iOS should remain
+      });
+
+      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)));
+
+        // Set initial images for both platforms
+        act(() => {
+          result.current.setImageSrc({
+            androidImageSrc: 'test-android-image.jpg',
+            iosImageSrc: 'test-ios-image.jpg',
+          });
+        });
+
+        // Clear image (should only clear iOS since activeTab is IOS)
+        act(() => {
+          result.current.updateOnMpushImageReUpload();
+        });
+
+        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 clear both platforms when sync is enabled', () => {
+        const syncProps = { ...defaultProps, sameContent: true };
+        const { result } = renderHook(() => useUpload(...Object.values(syncProps)));
+
+        // Set initial images
+        act(() => {
+          result.current.setUpdateMpushImageSrc('test-image.jpg', IMAGE);
+        });
+
+        // Clear images
+        act(() => {
+          result.current.updateOnMpushImageReUpload();
+        });
+
+        expect(result.current.imageSrc.androidImageSrc).toBe('');
+        expect(result.current.imageSrc.iosImageSrc).toBe('');
+      });
+    });
+  });
+
+  describe('Video Source Management', () => {
+    describe('setUpdateMpushVideoSrc', () => {
+      it('should update video source and asset list', () => {
+        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+
+        const videoData = {
+          videoSrc: 'test-video.mp4',
+          previewUrl: 'test-preview.jpg',
+          videoDuration: 120,
+          videoName: 'test-video.mp4',
+          fileHandle: 'file-handle-123',
+        };
+
+        act(() => {
+          result.current.setUpdateMpushVideoSrc(0, videoData);
+        });
+
+        expect(result.current.mpushVideoSrcAndPreview).toEqual({
+          mpushVideoSrc: 'test-video.mp4',
+          mpushVideoPreviewImg: 'test-preview.jpg',
+          duration: 120,
+        });
+
+        expect(result.current.assetList).toEqual(videoData);
+        expect(mockMobilePushActions.clearAsset).toHaveBeenCalledWith(0);
+      });
+
+      it('should handle partial video data', () => {
+        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+
+        const partialVideoData = {
+          videoSrc: 'test-video.mp4',
+        };
+
+        act(() => {
+          result.current.setUpdateMpushVideoSrc(0, partialVideoData);
+        });
+
+        expect(result.current.mpushVideoSrcAndPreview).toEqual({
+          mpushVideoSrc: 'test-video.mp4',
+          mpushVideoPreviewImg: '',
+          duration: 0,
+        });
+      });
+    });
+
+    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,
+          });
+        });
+
+        // Clear video data
+        act(() => {
+          result.current.updateOnMpushVideoReUpload();
+        });
+
+        expect(result.current.mpushVideoSrcAndPreview).toEqual({
+          mpushVideoSrc: '',
+          mpushVideoPreviewImg: '',
+          duration: 0,
+        });
+
+        expect(result.current.assetList).toEqual([]);
+        expect(mockSetAndroidContent).toHaveBeenCalledWith(expect.any(Function));
+        expect(mockSetIosContent).toHaveBeenCalledWith(expect.any(Function));
+        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)));
+
+      // Set image source
+      act(() => {
+        result.current.setUpdateMpushImageSrc('test-image.jpg', 0, IMAGE);
+      });
+
+      const payload = result.current.getMediaPayload(IMAGE, ANDROID);
+
+      expect(payload).toEqual({
+        imageUrl: 'cdn_test-image.jpg',
+      });
+    });
+
+    it('should generate correct payload for VIDEO media type', () => {
+      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+
+      // Set video source with preview
+      act(() => {
+        result.current.setUpdateMpushVideoSrc(0, {
+          videoSrc: 'test-video.mp4',
+          previewUrl: 'test-preview.jpg',
+          videoDuration: 30,
+        });
+      });
+
+      const payload = result.current.getMediaPayload(VIDEO, ANDROID);
+
+      expect(payload).toEqual({
+        videoUrl: 'cdn_test-video.mp4',
+        videoPreviewImg: 'cdn_test-preview.jpg',
+        duration: 30,
+      });
+    });
+
+    it('should generate correct payload for GIF media type with preview image', () => {
+      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+
+      // Set GIF source with preview
+      act(() => {
+        result.current.setUpdateMpushVideoSrc(0, {
+          videoSrc: 'test-gif.gif',
+          previewUrl: 'test-preview.jpg',
+          videoDuration: 5,
+        });
+      });
+
+      const payload = result.current.getMediaPayload(GIF, ANDROID);
+
+      expect(payload).toEqual({
+        gifUrl: 'cdn_test-gif.gif',
+        gifPreviewImg: 'cdn_test-preview.jpg',
+      });
+    });
+
+    it('should generate correct payload for GIF media type without preview image (covers line 328)', () => {
+      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+
+      // Set GIF source WITHOUT preview to cover the falsy condition on line 328
+      act(() => {
+        result.current.setUpdateMpushVideoSrc(0, {
+          videoSrc: 'test-gif.gif',
+          previewUrl: '', // Empty preview URL to trigger the falsy condition
+          videoDuration: 5,
+        });
+      });
+
+      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
+      });
+    });
+
+    it('should generate correct payload for GIF media type with null preview image (covers line 328)', () => {
+      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+
+      // Set GIF source with null preview to cover the falsy condition on line 328
+      act(() => {
+        result.current.setUpdateMpushVideoSrc(0, {
+          videoSrc: 'test-gif.gif',
+          previewUrl: null, // Null preview URL to trigger the falsy condition
+          videoDuration: 5,
+        });
+      });
+
+      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
+      });
+    });
+
+    it('should generate correct payload for GIF media type with undefined preview image (covers line 328)', () => {
+      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+
+      // Set GIF source with undefined preview to cover the falsy condition on line 328
+      act(() => {
+        result.current.setUpdateMpushVideoSrc(0, {
+          videoSrc: 'test-gif.gif',
+          previewUrl: undefined, // Undefined preview URL to trigger the falsy condition
+          videoDuration: 5,
+        });
+      });
+
+      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
+      });
+    });
+
+    it('should return empty object for unknown media type', () => {
+      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+
+      const payload = result.current.getMediaPayload('UNKNOWN_TYPE', ANDROID);
+
+      expect(payload).toEqual({});
+    });
+
+    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({});
+
+      // Test with VIDEO but no video source set
+      const videoPayload = result.current.getMediaPayload(VIDEO, ANDROID);
+      expect(videoPayload).toEqual({});
+
+      // Test with GIF but no GIF source set
+      const gifPayload = result.current.getMediaPayload(GIF, ANDROID);
+      expect(gifPayload).toEqual({});
+    });
+  });
+
+  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);
+
+        expect(previewData).toEqual({
+          imageSrc: 'test-image.jpg',
+        });
+      });
+
+      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 previewData = result.current.getPreviewData(VIDEO, ANDROID);
+
+        expect(previewData).toEqual({
+          videoSrc: 'test-video.mp4',
+          videoPreviewImg: 'test-preview.jpg',
+          duration: 120,
+        });
+      });
+
+      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 previewData = result.current.getPreviewData(GIF, ANDROID);
+
+        expect(previewData).toEqual({
+          gifSrc: 'test-gif.gif',
+          gifPreviewImg: 'test-preview.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',
+        });
+      });
+
+      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,
+        });
+      });
+
+      it('should generate GIF 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-gif.gif',
+            previewUrl: 'test-ios-preview.jpg',
+          });
+        });
+
+        const previewData = result.current.getPreviewData(GIF, 'IOS');
+
+        expect(previewData).toEqual({
+          gifSrc: 'test-ios-gif.gif',
+          gifPreviewImg: 'test-ios-preview.jpg',
+        });
+      });
+    });
+  });
+
+  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);
+        });
+
+        expect(result.current.isMediaUploaded(IMAGE, ANDROID)).toBe(true);
+      });
+
+      it('should return false for non-uploaded image', () => {
+        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+
+        expect(result.current.isMediaUploaded(IMAGE, ANDROID)).toBe(false);
+      });
+
+      it('should return true for uploaded video', () => {
+        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+
+        act(() => {
+          result.current.setUpdateMpushVideoSrc(0, {
+            videoSrc: 'test-video.mp4',
+          });
+        });
+
+        expect(result.current.isMediaUploaded(VIDEO, ANDROID)).toBe(true);
+        expect(result.current.isMediaUploaded(GIF, ANDROID)).toBe(true);
+      });
+
+      it('should return true for text media types', () => {
+        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+
+        expect(result.current.isMediaUploaded('TEXT', ANDROID)).toBe(true);
+        expect(result.current.isMediaUploaded('NONE', ANDROID)).toBe(true);
+      });
+
+      it('should return true for uploaded image on iOS platform', () => {
+        const iosProps = { ...defaultProps, activeTab: 'IOS' };
+        const { result } = renderHook(() => useUpload(...Object.values(iosProps)));
+
+        act(() => {
+          result.current.setUpdateMpushImageSrc('test-ios-image.jpg', IMAGE);
+        });
+
+        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);
+      });
+
+      it('should return true for uploaded video on iOS platform', () => {
+        const iosProps = { ...defaultProps, activeTab: 'IOS' };
+        const { result } = renderHook(() => useUpload(...Object.values(iosProps)));
+
+        act(() => {
+          result.current.setUpdateMpushVideoSrc(1, {
+            videoSrc: 'test-ios-video.mp4',
+          });
+        });
+
+        expect(result.current.isMediaUploaded(VIDEO, 'IOS')).toBe(true);
+        expect(result.current.isMediaUploaded(GIF, 'IOS')).toBe(true);
+      });
+
+      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);
+      });
+    });
+  });
+
+  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',
+          });
+        });
+
+        // Clear image data (should only clear Android since activeTab is ANDROID and sameContent is false)
+        act(() => {
+          result.current.clearImageDataByMediaType(IMAGE);
+        });
+
+        expect(result.current.imageSrc).toEqual({
+          androidImageSrc: '',
+          iosImageSrc: 'test-ios.jpg', // iOS should remain unchanged
+        });
+      });
+
+      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);
+        });
+
+        expect(result.current.imageSrc.androidImageSrc).toBe('test-image.jpg');
+      });
+    });
+
+    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();
+        });
+
+        expect(result.current.imageSrc).toEqual({
+          androidImageSrc: '',
+          iosImageSrc: '',
+        });
+        expect(result.current.mpushVideoSrcAndPreview).toEqual({
+          mpushVideoSrc: '',
+          mpushVideoPreviewImg: '',
+          duration: 0,
+        });
+        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,
+        });
+      });
+
+      it('should return empty string for empty image URL', () => {
+        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+
+        const cdnUrl = result.current.getCdnImageUrl('');
+
+        expect(cdnUrl).toBe('');
+      });
+
+      it('should generate CDN video URL', () => {
+        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+
+        const cdnUrl = result.current.getCdnVideoUrl('test-video.mp4');
+
+        expect(cdnUrl).toBe('cdn_test-video.mp4');
+        expect(getCdnUrl).toHaveBeenCalledWith({
+          url: 'test-video.mp4',
+          channelName: MOBILE_PUSH_CHANNEL,
+        });
+      });
+
+      it('should return empty string for empty video URL', () => {
+        const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+
+        const cdnUrl = result.current.getCdnVideoUrl('');
+
+        expect(cdnUrl).toBe('');
+      });
+    });
+  });
+
+  describe('useEffect behaviors', () => {
+    it('should call setAndroidContent and setIosContent when imageSrc changes', () => {
+      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+
+      act(() => {
+        result.current.setUpdateMpushImageSrc('test-image.jpg', 0, IMAGE);
+      });
+
+      expect(mockSetAndroidContent).toHaveBeenCalledWith(expect.any(Function));
+      expect(mockSetIosContent).toHaveBeenCalledWith(expect.any(Function));
+    });
+
+    it('should call setAndroidContent and setIosContent when video src changes', () => {
+      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+
+      act(() => {
+        result.current.setUpdateMpushVideoSrc(0, {
+          videoSrc: 'test-video.mp4',
+          previewUrl: 'test-preview.jpg',
+        });
+      });
+
+      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();
+    });
+
+    it('should handle missing file properties gracefully', () => {
+      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+
+      const fileWithoutSize = { name: 'test.jpg' };
+
+      expect(() => {
+        result.current.validateImageFile(fileWithoutSize);
+      }).not.toThrow();
+    });
+
+    it('should handle empty edit data gracefully', () => {
+      const { result } = renderHook(() => useUpload(
+        mockMobilePushActions,
+        { templateDetails: null },
+        {},
+        {},
+        false,
+        false,
+        mockSetAndroidContent,
+        mockSetIosContent,
+        ANDROID,
+        defaultProps.androidContent,
+        defaultProps.iosContent
+      ));
+
+      expect(result.current.imageSrc).toEqual({
+        androidImageSrc: '',
+        iosImageSrc: '',
+      });
+    });
+
+    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
+      ));
+
+      expect(result.current.imageSrc).toEqual({
+        androidImageSrc: '',
+        iosImageSrc: '',
+      });
+    });
+  });
+
+  describe('Additional Edge Cases for Complete Coverage', () => {
+    it('should handle setUpdateMpushVideoSrc with minimal data', () => {
+      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+
+      // Test with minimal data object
+      act(() => {
+        result.current.setUpdateMpushVideoSrc(0, {
+          videoSrc: 'test.mp4',
+        });
+      });
+
+      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,
+      };
+
+      act(() => {
+        result.current.setUpdateMpushVideoSrc(0, extraData);
+      });
+
+      expect(result.current.assetList).toEqual(expect.objectContaining({
+        videoSrc: 'test.mp4',
+        previewUrl: 'preview.jpg',
+        videoDuration: 30,
+        extraField: 'extra-value',
+        anotherField: 123,
+      }));
+    });
+
+    it('should handle clearImageDataByMediaType for non-IMAGE types', () => {
+      const { result } = renderHook(() => useUpload(...Object.values(defaultProps)));
+
+      // Set some image data first
+      act(() => {
+        result.current.setUpdateMpushImageSrc('test-image.jpg', 0, IMAGE);
+      });
+
+      expect(result.current.imageSrc.androidImageSrc).toBe('test-image.jpg');
+
+      // Clear using CAROUSEL type (should not affect image data)
+      act(() => {
+        result.current.clearImageDataByMediaType(CAROUSEL);
+      });
+
+      // 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
+      act(() => {
+        result.current.setImageSrc({
+          androidImageSrc: 'test-android.jpg',
+          iosImageSrc: 'test-ios.jpg',
+        });
+      });
+
+      // Clear using IMAGE type (should clear only Android since activeTab is ANDROID and sameContent is false)
+      act(() => {
+        result.current.clearImageDataByMediaType(IMAGE);
+      });
+
+      // Only Android should be cleared when sameContent=false
+      expect(result.current.imageSrc.androidImageSrc).toBe('');
+      expect(result.current.imageSrc.iosImageSrc).toBe('test-ios.jpg');
+    });
+  });
+});