@congminh1254/shopee-sdk 1.6.2 → 1.7.0

package/lib/__tests__/managers/media.manager.test.js

@@ -0,0 +1,681 @@
+import { jest } from "@jest/globals";
+import { MediaManager } from "../../managers/media.manager.js";
+import { ShopeeRegion } from "../../schemas/region.js";
+import { ShopeeFetch } from "../../fetch.js";
+// Mock ShopeeFetch.fetch static method
+const mockFetch = jest.fn();
+ShopeeFetch.fetch = mockFetch;
+describe("MediaManager", () => {
+    let mediaManager;
+    let mockConfig;
+    const mockShopeeFetch = mockFetch;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockConfig = {
+            partner_id: 12345,
+            partner_key: "test_partner_key",
+            shop_id: 67890,
+            region: ShopeeRegion.GLOBAL,
+            base_url: "https://partner.test-stable.shopeemobile.com/api/v2",
+        };
+        mediaManager = new MediaManager(mockConfig);
+    });
+    describe("uploadMediaImage", () => {
+        it("should upload images for returns business scenario", async () => {
+            const mockResponse = {
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+                response: {
+                    image_list: [
+                        {
+                            image_id: "test_image_id_1",
+                            image_url: "https://cf.shopee.sg/file/test_image_1",
+                        },
+                        {
+                            image_id: "test_image_id_2",
+                            image_url: "https://cf.shopee.sg/file/test_image_2",
+                        },
+                    ],
+                },
+            };
+            mockShopeeFetch.mockResolvedValue(mockResponse);
+            const result = await mediaManager.uploadMediaImage({
+                business: 2,
+                scene: 1,
+                images: Buffer.from("image-bytes"),
+            });
+            expect(mockShopeeFetch).toHaveBeenCalledWith(mockConfig, "/media/upload_image", {
+                method: "POST",
+                body: {
+                    business: 2,
+                    scene: 1,
+                    images: Buffer.from("image-bytes"),
+                },
+            });
+            expect(result).toEqual(mockResponse);
+            expect(result.response.image_list).toHaveLength(2);
+            expect(result.response.image_list[0].image_id).toBe("test_image_id_1");
+        });
+        it("should upload multiple images for returns", async () => {
+            const mockResponse = {
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+                response: {
+                    image_list: [
+                        {
+                            image_id: "test_image_id_1",
+                            image_url: "https://cf.shopee.sg/file/test_image_1",
+                        },
+                        {
+                            image_id: "test_image_id_2",
+                            image_url: "https://cf.shopee.sg/file/test_image_2",
+                        },
+                        {
+                            image_id: "test_image_id_3",
+                            image_url: "https://cf.shopee.sg/file/test_image_3",
+                        },
+                    ],
+                },
+            };
+            mockShopeeFetch.mockResolvedValue(mockResponse);
+            const result = await mediaManager.uploadMediaImage({
+                business: 2,
+                scene: 1,
+                images: [Buffer.from("image1"), Buffer.from("image2"), Buffer.from("image3")],
+            });
+            expect(mockShopeeFetch).toHaveBeenCalledWith(mockConfig, "/media/upload_image", {
+                method: "POST",
+                body: {
+                    business: 2,
+                    scene: 1,
+                    images: [Buffer.from("image1"), Buffer.from("image2"), Buffer.from("image3")],
+                },
+            });
+            expect(result.response.image_list).toHaveLength(3);
+        });
+    });
+    describe("uploadImage", () => {
+        it("should upload a single image with default settings", async () => {
+            const mockResponse = {
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+                response: {
+                    image_info_list: [
+                        {
+                            id: 0,
+                            error: "",
+                            message: "",
+                            image_info: {
+                                image_id: "test_image_id",
+                                image_url_list: [
+                                    {
+                                        image_url_region: "SG",
+                                        image_url: "https://cf.shopee.sg/file/test_image",
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                },
+            };
+            mockShopeeFetch.mockResolvedValue(mockResponse);
+            const result = await mediaManager.uploadImage({
+                image: Buffer.from("image-bytes"),
+            });
+            expect(mockShopeeFetch).toHaveBeenCalledWith(mockConfig, "/media_space/upload_image", {
+                method: "POST",
+                auth: true,
+                body: {
+                    image: Buffer.from("image-bytes"),
+                },
+            });
+            expect(result).toEqual(mockResponse);
+            expect(result.response.image_info_list).toHaveLength(1);
+            expect(result.response.image_info_list[0].image_info.image_id).toBe("test_image_id");
+        });
+        it("should upload multiple images with scene and ratio", async () => {
+            const mockResponse = {
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+                response: {
+                    image_info_list: [
+                        {
+                            id: 0,
+                            error: "",
+                            message: "",
+                            image_info: {
+                                image_id: "test_image_id_1",
+                                image_url_list: [
+                                    {
+                                        image_url_region: "SG",
+                                        image_url: "https://cf.shopee.sg/file/test_image_1",
+                                    },
+                                ],
+                            },
+                        },
+                        {
+                            id: 1,
+                            error: "",
+                            message: "",
+                            image_info: {
+                                image_id: "test_image_id_2",
+                                image_url_list: [
+                                    {
+                                        image_url_region: "SG",
+                                        image_url: "https://cf.shopee.sg/file/test_image_2",
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                },
+            };
+            mockShopeeFetch.mockResolvedValue(mockResponse);
+            const result = await mediaManager.uploadImage({
+                image: [Buffer.from("image1"), Buffer.from("image2")],
+                scene: "normal",
+                ratio: "1:1",
+            });
+            expect(mockShopeeFetch).toHaveBeenCalledWith(mockConfig, "/media_space/upload_image", {
+                method: "POST",
+                auth: true,
+                body: {
+                    image: [Buffer.from("image1"), Buffer.from("image2")],
+                    scene: "normal",
+                    ratio: "1:1",
+                },
+            });
+            expect(result.response.image_info_list).toHaveLength(2);
+        });
+        it("should upload description image without processing", async () => {
+            const mockResponse = {
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+                response: {
+                    image_info_list: [
+                        {
+                            id: 0,
+                            error: "",
+                            message: "",
+                            image_info: {
+                                image_id: "desc_image_id",
+                                image_url_list: [
+                                    {
+                                        image_url_region: "SG",
+                                        image_url: "https://cf.shopee.sg/file/desc_image",
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                },
+            };
+            mockShopeeFetch.mockResolvedValue(mockResponse);
+            const result = await mediaManager.uploadImage({
+                image: Buffer.from("desc-image-bytes"),
+                scene: "desc",
+            });
+            expect(mockShopeeFetch).toHaveBeenCalledWith(mockConfig, "/media_space/upload_image", {
+                method: "POST",
+                auth: true,
+                body: {
+                    image: Buffer.from("desc-image-bytes"),
+                    scene: "desc",
+                },
+            });
+            expect(result.response.image_info_list[0].image_info.image_id).toBe("desc_image_id");
+        });
+    });
+    describe("initVideoUpload", () => {
+        it("should initiate video upload session", async () => {
+            const mockResponse = {
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+                response: {
+                    video_upload_id: "sg_90ce045e-fd92-4f0b-97a4-eda40546cd9f_000000",
+                },
+            };
+            mockShopeeFetch.mockResolvedValue(mockResponse);
+            const result = await mediaManager.initVideoUpload({
+                file_md5: "2abf0b6e5ff90ff24437a0808f171a93",
+                file_size: 1261876,
+            });
+            expect(mockShopeeFetch).toHaveBeenCalledWith(mockConfig, "/media_space/init_video_upload", {
+                method: "POST",
+                auth: true,
+                body: {
+                    file_md5: "2abf0b6e5ff90ff24437a0808f171a93",
+                    file_size: 1261876,
+                },
+            });
+            expect(result).toEqual(mockResponse);
+            expect(result.response.video_upload_id).toBe("sg_90ce045e-fd92-4f0b-97a4-eda40546cd9f_000000");
+        });
+        it("should handle video upload initialization with max file size", async () => {
+            const mockResponse = {
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+                response: {
+                    video_upload_id: "sg_test_video_id",
+                },
+            };
+            mockShopeeFetch.mockResolvedValue(mockResponse);
+            const result = await mediaManager.initVideoUpload({
+                file_md5: "abcdef1234567890",
+                file_size: 30 * 1024 * 1024, // 30MB
+            });
+            expect(mockShopeeFetch).toHaveBeenCalledWith(mockConfig, "/media_space/init_video_upload", {
+                method: "POST",
+                auth: true,
+                body: {
+                    file_md5: "abcdef1234567890",
+                    file_size: 30 * 1024 * 1024,
+                },
+            });
+            expect(result.response.video_upload_id).toBe("sg_test_video_id");
+        });
+    });
+    describe("uploadVideoPart", () => {
+        it("should upload a video part", async () => {
+            const mockResponse = {
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+            };
+            mockShopeeFetch.mockResolvedValue(mockResponse);
+            const result = await mediaManager.uploadVideoPart({
+                video_upload_id: "sg_90ce045e-fd92-4f0b-97a4-eda40546cd9f_000000",
+                part_seq: 0,
+                content_md5: "3bb08579fffbfc13ed9d23cda8bbb46d",
+                part_content: Buffer.from("part0"),
+            });
+            expect(mockShopeeFetch).toHaveBeenCalledWith(mockConfig, "/media_space/upload_video_part", {
+                method: "POST",
+                body: {
+                    video_upload_id: "sg_90ce045e-fd92-4f0b-97a4-eda40546cd9f_000000",
+                    part_seq: 0,
+                    content_md5: "3bb08579fffbfc13ed9d23cda8bbb46d",
+                    part_content: Buffer.from("part0"),
+                },
+            });
+            expect(result).toEqual(mockResponse);
+        });
+        it("should upload multiple video parts sequentially", async () => {
+            const mockResponse = {
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+            };
+            mockShopeeFetch.mockResolvedValue(mockResponse);
+            const videoUploadId = "sg_test_upload_id";
+            // Upload part 0
+            await mediaManager.uploadVideoPart({
+                video_upload_id: videoUploadId,
+                part_seq: 0,
+                content_md5: "md5_part_0",
+                part_content: Buffer.from("part0"),
+            });
+            // Upload part 1
+            await mediaManager.uploadVideoPart({
+                video_upload_id: videoUploadId,
+                part_seq: 1,
+                content_md5: "md5_part_1",
+                part_content: Buffer.from("part1"),
+            });
+            expect(mockShopeeFetch).toHaveBeenCalledTimes(2);
+            expect(mockShopeeFetch).toHaveBeenNthCalledWith(1, mockConfig, "/media_space/upload_video_part", {
+                method: "POST",
+                body: {
+                    video_upload_id: videoUploadId,
+                    part_seq: 0,
+                    content_md5: "md5_part_0",
+                    part_content: Buffer.from("part0"),
+                },
+            });
+            expect(mockShopeeFetch).toHaveBeenNthCalledWith(2, mockConfig, "/media_space/upload_video_part", {
+                method: "POST",
+                body: {
+                    video_upload_id: videoUploadId,
+                    part_seq: 1,
+                    content_md5: "md5_part_1",
+                    part_content: Buffer.from("part1"),
+                },
+            });
+        });
+    });
+    describe("completeVideoUpload", () => {
+        it("should complete video upload", async () => {
+            const mockResponse = {
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+            };
+            mockShopeeFetch.mockResolvedValue(mockResponse);
+            const result = await mediaManager.completeVideoUpload({
+                video_upload_id: "sg_90ce045e-fd92-4f0b-97a4-eda40546cd9f_000000",
+                part_seq_list: [0, 1, 2, 3],
+                report_data: {
+                    upload_cost: 11832,
+                },
+            });
+            expect(mockShopeeFetch).toHaveBeenCalledWith(mockConfig, "/media_space/complete_video_upload", {
+                method: "POST",
+                body: {
+                    video_upload_id: "sg_90ce045e-fd92-4f0b-97a4-eda40546cd9f_000000",
+                    part_seq_list: [0, 1, 2, 3],
+                    report_data: {
+                        upload_cost: 11832,
+                    },
+                },
+            });
+            expect(result).toEqual(mockResponse);
+        });
+        it("should complete video upload with single part", async () => {
+            const mockResponse = {
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+            };
+            mockShopeeFetch.mockResolvedValue(mockResponse);
+            const result = await mediaManager.completeVideoUpload({
+                video_upload_id: "sg_small_video_id",
+                part_seq_list: [0],
+                report_data: {
+                    upload_cost: 2500,
+                },
+            });
+            expect(mockShopeeFetch).toHaveBeenCalledWith(mockConfig, "/media_space/complete_video_upload", {
+                method: "POST",
+                body: {
+                    video_upload_id: "sg_small_video_id",
+                    part_seq_list: [0],
+                    report_data: {
+                        upload_cost: 2500,
+                    },
+                },
+            });
+            expect(result).toEqual(mockResponse);
+        });
+    });
+    describe("getVideoUploadResult", () => {
+        it("should get video upload result with SUCCEEDED status", async () => {
+            const mockResponse = {
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+                response: {
+                    status: "SUCCEEDED",
+                    message: "success",
+                    video_info: {
+                        video_url_list: [
+                            {
+                                video_url_region: "SG",
+                                video_url: "https://cvf.shopee.sg/file/ddb50833eee1c9fda5c522a2e6fc0ea6",
+                            },
+                            {
+                                video_url_region: "VN",
+                                video_url: "https://cvf.shopee.vn/file/ddb50833eee1c9fda5c522a2e6fc0ea6",
+                            },
+                        ],
+                        thumbnail_url_list: [
+                            {
+                                image_url_region: "SG",
+                                image_url: "https://cf.shopee.sg/file/75eba55932c987851abc39895047dd54",
+                            },
+                            {
+                                image_url_region: "VN",
+                                image_url: "https://cf.shopee.vn/file/75eba55932c987851abc39895047dd54",
+                            },
+                        ],
+                        duration: 15,
+                    },
+                },
+            };
+            mockShopeeFetch.mockResolvedValue(mockResponse);
+            const result = await mediaManager.getVideoUploadResult({
+                video_upload_id: "sg_90ce045e-fd92-4f0b-97a4-eda40546cd9f_000000",
+            });
+            expect(mockShopeeFetch).toHaveBeenCalledWith(mockConfig, "/media_space/get_video_upload_result", {
+                method: "GET",
+                auth: true,
+                params: {
+                    video_upload_id: "sg_90ce045e-fd92-4f0b-97a4-eda40546cd9f_000000",
+                },
+            });
+            expect(result).toEqual(mockResponse);
+            expect(result.response.status).toBe("SUCCEEDED");
+            expect(result.response.video_info).toBeDefined();
+            expect(result.response.video_info?.duration).toBe(15);
+            expect(result.response.video_info?.video_url_list).toHaveLength(2);
+        });
+        it("should get video upload result with TRANSCODING status", async () => {
+            const mockResponse = {
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+                response: {
+                    status: "TRANSCODING",
+                },
+            };
+            mockShopeeFetch.mockResolvedValue(mockResponse);
+            const result = await mediaManager.getVideoUploadResult({
+                video_upload_id: "sg_transcoding_video_id",
+            });
+            expect(result.response.status).toBe("TRANSCODING");
+            expect(result.response.video_info).toBeUndefined();
+        });
+        it("should get video upload result with FAILED status", async () => {
+            const mockResponse = {
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+                response: {
+                    status: "FAILED",
+                    message: "Video is too short",
+                },
+            };
+            mockShopeeFetch.mockResolvedValue(mockResponse);
+            const result = await mediaManager.getVideoUploadResult({
+                video_upload_id: "sg_failed_video_id",
+            });
+            expect(result.response.status).toBe("FAILED");
+            expect(result.response.message).toBe("Video is too short");
+            expect(result.response.video_info).toBeUndefined();
+        });
+        it("should get video upload result with INITIATED status", async () => {
+            const mockResponse = {
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+                response: {
+                    status: "INITIATED",
+                },
+            };
+            mockShopeeFetch.mockResolvedValue(mockResponse);
+            const result = await mediaManager.getVideoUploadResult({
+                video_upload_id: "sg_initiated_video_id",
+            });
+            expect(result.response.status).toBe("INITIATED");
+        });
+    });
+    describe("cancelVideoUpload", () => {
+        it("should cancel video upload session", async () => {
+            const mockResponse = {
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+            };
+            mockShopeeFetch.mockResolvedValue(mockResponse);
+            const result = await mediaManager.cancelVideoUpload({
+                video_upload_id: "sg_90ce045e-fd92-4f0b-97a4-eda40546cd9f_000000",
+            });
+            expect(mockShopeeFetch).toHaveBeenCalledWith(mockConfig, "/media_space/cancel_video_upload", {
+                method: "POST",
+                auth: true,
+                body: {
+                    video_upload_id: "sg_90ce045e-fd92-4f0b-97a4-eda40546cd9f_000000",
+                },
+            });
+            expect(result).toEqual(mockResponse);
+        });
+        it("should cancel video upload during upload", async () => {
+            const mockResponse = {
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+            };
+            mockShopeeFetch.mockResolvedValue(mockResponse);
+            const result = await mediaManager.cancelVideoUpload({
+                video_upload_id: "sg_cancel_during_upload_id",
+            });
+            expect(mockShopeeFetch).toHaveBeenCalledWith(mockConfig, "/media_space/cancel_video_upload", {
+                method: "POST",
+                auth: true,
+                body: {
+                    video_upload_id: "sg_cancel_during_upload_id",
+                },
+            });
+            expect(result).toEqual(mockResponse);
+        });
+    });
+    describe("initMediaVideoUpload", () => {
+        it("should initiate media video upload session", async () => {
+            const mockResponse = {
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+                response: {
+                    video_upload_id: "sg_media_video_123",
+                    part_size: 4194304,
+                },
+            };
+            mockShopeeFetch.mockResolvedValue(mockResponse);
+            const result = await mediaManager.initMediaVideoUpload({
+                business: 3,
+                scene: 1,
+                file_name: "test.mp4",
+                file_size: 10485760,
+                duration: 30,
+            });
+            expect(mockShopeeFetch).toHaveBeenCalledWith(mockConfig, "/media/init_video_upload", {
+                method: "POST",
+                auth: true,
+                body: {
+                    business: 3,
+                    scene: 1,
+                    file_name: "test.mp4",
+                    file_size: 10485760,
+                    duration: 30,
+                },
+            });
+            expect(result).toEqual(mockResponse);
+        });
+    });
+    describe("uploadMediaVideoPart", () => {
+        it("should upload a media video part", async () => {
+            const mockResponse = {
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+            };
+            mockShopeeFetch.mockResolvedValue(mockResponse);
+            const result = await mediaManager.uploadMediaVideoPart({
+                video_upload_id: "sg_media_video_123",
+                part_seq: 0,
+                part_content: "base64-data",
+                part_md5: "md5checksum",
+            });
+            expect(mockShopeeFetch).toHaveBeenCalledWith(mockConfig, "/media/upload_video_part", {
+                method: "POST",
+                body: {
+                    video_upload_id: "sg_media_video_123",
+                    part_seq: 0,
+                    part_content: "base64-data",
+                    part_md5: "md5checksum",
+                },
+            });
+            expect(result).toEqual(mockResponse);
+        });
+    });
+    describe("completeMediaVideoUpload", () => {
+        it("should complete media video upload session", async () => {
+            const mockResponse = {
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+            };
+            mockShopeeFetch.mockResolvedValue(mockResponse);
+            const result = await mediaManager.completeMediaVideoUpload({
+                video_upload_id: "sg_media_video_123",
+            });
+            expect(mockShopeeFetch).toHaveBeenCalledWith(mockConfig, "/media/complete_video_upload", {
+                method: "POST",
+                body: {
+                    video_upload_id: "sg_media_video_123",
+                },
+            });
+            expect(result).toEqual(mockResponse);
+        });
+    });
+    describe("getMediaVideoUploadResult", () => {
+        it("should retrieve media video upload result", async () => {
+            const mockResponse = {
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+                response: {
+                    status: "SUCCEEDED",
+                    video_info: {
+                        video_url: "https://shopee.com/video.mp4",
+                        video_thumbnail_url: "https://shopee.com/thumb.jpg",
+                        thumbnail_width: 720,
+                        thumbnail_height: 1280,
+                        duration: 30,
+                        resolution: "720x1280",
+                    },
+                },
+            };
+            mockShopeeFetch.mockResolvedValue(mockResponse);
+            const result = await mediaManager.getMediaVideoUploadResult({
+                video_upload_id: "sg_media_video_123",
+            });
+            expect(mockShopeeFetch).toHaveBeenCalledWith(mockConfig, "/media/get_video_upload_result", {
+                method: "GET",
+                auth: true,
+                params: {
+                    video_upload_id: "sg_media_video_123",
+                },
+            });
+            expect(result).toEqual(mockResponse);
+        });
+    });
+    describe("cancelMediaVideoUpload", () => {
+        it("should cancel media video upload session", async () => {
+            const mockResponse = {
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+            };
+            mockShopeeFetch.mockResolvedValue(mockResponse);
+            const result = await mediaManager.cancelMediaVideoUpload({
+                video_upload_id: "sg_media_video_123",
+            });
+            expect(mockShopeeFetch).toHaveBeenCalledWith(mockConfig, "/media/cancel_video_upload", {
+                method: "POST",
+                auth: true,
+                body: {
+                    video_upload_id: "sg_media_video_123",
+                },
+            });
+            expect(result).toEqual(mockResponse);
+        });
+    });
+});
+//# sourceMappingURL=media.manager.test.js.map