@bernierllc/contentful-cma-client 1.0.2

package/src/__tests__/ContentfulCMAClient.test.ts

@@ -0,0 +1,841 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+import { ContentfulCMAClient } from '../ContentfulCMAClient';
+import * as indexExports from '../index';
+import contentfulManagement from 'contentful-management';
+import {
+  ContentfulEntry,
+  ContentfulAsset,
+  ContentfulContentType
+} from '@bernierllc/contentful-types';
+
+// Mock contentful-management
+jest.mock('contentful-management', () => ({
+  __esModule: true,
+  default: {
+    createClient: jest.fn()
+  }
+}));
+
+// Mock logger
+jest.mock('@bernierllc/logger', () => ({
+  Logger: jest.fn().mockImplementation(() => ({
+    info: jest.fn(),
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn()
+  })),
+  LogLevel: {
+    INFO: 'info',
+    DEBUG: 'debug',
+    WARN: 'warn',
+    ERROR: 'error'
+  },
+  ConsoleTransport: jest.fn()
+}));
+
+describe('Index Exports', () => {
+  it('should export ContentfulCMAClient', () => {
+    expect(indexExports.ContentfulCMAClient).toBeDefined();
+  });
+
+  it('should export types', () => {
+    expect(indexExports).toHaveProperty('ContentfulCMAClient');
+  });
+});
+
+describe('ContentfulCMAClient', () => {
+  let client: ContentfulCMAClient;
+  let mockPlainClient: jest.Mocked<any>;
+
+  const mockConfig = {
+    accessToken: 'test-token',
+    spaceId: 'test-space',
+    environmentId: 'master'
+  };
+
+  const mockEntry: Partial<ContentfulEntry> = {
+    sys: {
+      type: 'Entry',
+      id: 'entry-123',
+      version: 1,
+      space: { sys: { type: 'Link', linkType: 'Space', id: 'test-space' } },
+      environment: { sys: { type: 'Link', linkType: 'Environment', id: 'master' } },
+      contentType: { sys: { type: 'Link', linkType: 'ContentType', id: 'blogPost' } },
+      createdAt: '2025-01-01T00:00:00Z',
+      updatedAt: '2025-01-01T00:00:00Z'
+    },
+    fields: {
+      title: { 'en-US': 'Test Entry' }
+    }
+  };
+
+  const mockAsset: Partial<ContentfulAsset> = {
+    sys: {
+      type: 'Asset',
+      id: 'asset-123',
+      version: 1,
+      space: { sys: { type: 'Link', linkType: 'Space', id: 'test-space' } },
+      environment: { sys: { type: 'Link', linkType: 'Environment', id: 'master' } },
+      createdAt: '2025-01-01T00:00:00Z',
+      updatedAt: '2025-01-01T00:00:00Z'
+    },
+    fields: {
+      title: { 'en-US': 'Test Asset' },
+      file: {
+        'en-US': {
+          url: 'https://example.com/test.jpg',
+          details: { size: 1024 },
+          fileName: 'test.jpg',
+          contentType: 'image/jpeg'
+        }
+      }
+    }
+  };
+
+  const mockContentType: Partial<ContentfulContentType> = {
+    sys: {
+      type: 'ContentType',
+      id: 'blogPost',
+      version: 1,
+      space: { sys: { type: 'Link', linkType: 'Space', id: 'test-space' } },
+      createdAt: '2025-01-01T00:00:00Z',
+      updatedAt: '2025-01-01T00:00:00Z'
+    },
+    name: 'Blog Post',
+    fields: [
+      {
+        id: 'title',
+        name: 'Title',
+        type: 'Symbol',
+        required: true,
+        localized: false,
+        disabled: false,
+        omitted: false
+      }
+    ]
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Create mock plain client
+    mockPlainClient = {
+      entry: {
+        get: jest.fn(),
+        getMany: jest.fn(),
+        create: jest.fn(),
+        update: jest.fn(),
+        publish: jest.fn(),
+        unpublish: jest.fn(),
+        archive: jest.fn(),
+        unarchive: jest.fn(),
+        delete: jest.fn()
+      },
+      asset: {
+        get: jest.fn(),
+        getMany: jest.fn(),
+        create: jest.fn(),
+        processForLocale: jest.fn(),
+        publish: jest.fn(),
+        unpublish: jest.fn(),
+        delete: jest.fn()
+      },
+      contentType: {
+        get: jest.fn(),
+        getMany: jest.fn()
+      }
+    };
+
+    // Mock contentfulManagement.createClient
+    (contentfulManagement.createClient as jest.Mock).mockReturnValue(mockPlainClient);
+
+    // Create client
+    client = new ContentfulCMAClient(mockConfig);
+  });
+
+  describe('Constructor', () => {
+    it('should initialize with provided config', () => {
+      expect(contentfulManagement.createClient).toHaveBeenCalledWith(
+        {
+          accessToken: 'test-token',
+          host: 'api.contentful.com'
+        },
+        {
+          type: 'plain',
+          defaults: {
+            spaceId: 'test-space',
+            environmentId: 'master'
+          }
+        }
+      );
+    });
+
+    it('should use default values for optional config', () => {
+      const minimalConfig = {
+        accessToken: 'test-token',
+        spaceId: 'test-space'
+      };
+
+      const minimalClient = new ContentfulCMAClient(minimalConfig);
+
+      expect(minimalClient.getEnvironmentId()).toBe('master');
+    });
+  });
+
+  describe('Entry Operations', () => {
+    describe('getEntry', () => {
+      it('should get entry by ID', async () => {
+        mockPlainClient.entry.get.mockResolvedValue(mockEntry);
+
+        const result = await client.getEntry('entry-123');
+
+        expect(mockPlainClient.entry.get).toHaveBeenCalledWith({
+          entryId: 'entry-123'
+        });
+        expect(result).toEqual(mockEntry);
+      });
+
+      it('should handle errors when getting entry', async () => {
+        mockPlainClient.entry.get.mockRejectedValue(new Error('Not found'));
+
+        await expect(client.getEntry('entry-123')).rejects.toThrow('Not found');
+      });
+    });
+
+    describe('getEntries', () => {
+      it('should get entries with query', async () => {
+        mockPlainClient.entry.getMany.mockResolvedValue({
+          items: [mockEntry],
+          total: 1,
+          skip: 0,
+          limit: 100
+        });
+
+        const result = await client.getEntries({ content_type: 'blogPost' });
+
+        expect(mockPlainClient.entry.getMany).toHaveBeenCalledWith({
+          query: { content_type: 'blogPost' }
+        });
+        expect(result).toEqual([mockEntry]);
+      });
+
+      it('should get entries without query', async () => {
+        mockPlainClient.entry.getMany.mockResolvedValue({
+          items: [mockEntry],
+          total: 1,
+          skip: 0,
+          limit: 100
+        });
+
+        const result = await client.getEntries();
+
+        expect(mockPlainClient.entry.getMany).toHaveBeenCalledWith({
+          query: undefined
+        });
+        expect(result).toEqual([mockEntry]);
+      });
+    });
+
+    describe('getAllEntries', () => {
+      it('should get all entries with pagination', async () => {
+        // Create 100 entries for first page
+        const firstPageEntries = Array.from({ length: 100 }, (_, i) => ({
+          ...mockEntry,
+          sys: { ...mockEntry.sys, id: `entry-${i}` }
+        }));
+
+        // Create 50 entries for second page (to reach total of 150)
+        const secondPageEntries = Array.from({ length: 50 }, (_, i) => ({
+          ...mockEntry,
+          sys: { ...mockEntry.sys, id: `entry-${100 + i}` }
+        }));
+
+        // First page
+        mockPlainClient.entry.getMany.mockResolvedValueOnce({
+          items: firstPageEntries,
+          total: 150,
+          skip: 0,
+          limit: 100
+        });
+
+        // Second page
+        mockPlainClient.entry.getMany.mockResolvedValueOnce({
+          items: secondPageEntries,
+          total: 150,
+          skip: 100,
+          limit: 100
+        });
+
+        const result = await client.getAllEntries();
+
+        expect(mockPlainClient.entry.getMany).toHaveBeenCalledTimes(2);
+        expect(result).toHaveLength(150);
+      });
+
+      it('should handle single page results', async () => {
+        mockPlainClient.entry.getMany.mockResolvedValue({
+          items: [mockEntry],
+          total: 1,
+          skip: 0,
+          limit: 100
+        });
+
+        const result = await client.getAllEntries();
+
+        expect(mockPlainClient.entry.getMany).toHaveBeenCalledTimes(1);
+        expect(result).toEqual([mockEntry]);
+      });
+    });
+
+    describe('createEntry', () => {
+      it('should create entry', async () => {
+        mockPlainClient.entry.create.mockResolvedValue(mockEntry);
+
+        const fields = { title: { 'en-US': 'New Entry' } };
+        const result = await client.createEntry('blogPost', fields);
+
+        expect(mockPlainClient.entry.create).toHaveBeenCalledWith(
+          { contentTypeId: 'blogPost', entryId: undefined },
+          { fields }
+        );
+        expect(result).toEqual(mockEntry);
+      });
+
+      it('should create entry with custom ID', async () => {
+        mockPlainClient.entry.create.mockResolvedValue(mockEntry);
+
+        const fields = { title: { 'en-US': 'New Entry' } };
+        await client.createEntry('blogPost', fields, {
+          entryId: 'custom-id'
+        });
+
+        expect(mockPlainClient.entry.create).toHaveBeenCalledWith(
+          { contentTypeId: 'blogPost', entryId: 'custom-id' },
+          { fields }
+        );
+      });
+    });
+
+    describe('updateEntry', () => {
+      it('should update entry', async () => {
+        const updatedEntry = { ...mockEntry, sys: { ...mockEntry.sys, version: 2 } };
+        mockPlainClient.entry.update.mockResolvedValue(updatedEntry);
+
+        const fields = { title: { 'en-US': 'Updated Entry' } };
+        const result = await client.updateEntry('entry-123', fields, 1);
+
+        expect(mockPlainClient.entry.update).toHaveBeenCalledWith(
+          { entryId: 'entry-123' },
+          { sys: { version: 1 }, fields }
+        );
+        expect(result).toEqual(updatedEntry);
+      });
+    });
+
+    describe('publishEntry', () => {
+      it('should publish entry', async () => {
+        const publishedEntry = {
+          ...mockEntry,
+          sys: { ...mockEntry.sys, publishedVersion: 1 }
+        };
+        mockPlainClient.entry.publish.mockResolvedValue(publishedEntry);
+
+        const result = await client.publishEntry('entry-123', 1);
+
+        expect(mockPlainClient.entry.publish).toHaveBeenCalledWith(
+          { entryId: 'entry-123' },
+          { sys: { version: 1 } }
+        );
+        expect(result).toEqual(publishedEntry);
+      });
+    });
+
+    describe('unpublishEntry', () => {
+      it('should unpublish entry', async () => {
+        mockPlainClient.entry.unpublish.mockResolvedValue(mockEntry);
+
+        const result = await client.unpublishEntry('entry-123');
+
+        expect(mockPlainClient.entry.unpublish).toHaveBeenCalledWith({
+          entryId: 'entry-123'
+        });
+        expect(result).toEqual(mockEntry);
+      });
+    });
+
+    describe('archiveEntry', () => {
+      it('should archive entry', async () => {
+        mockPlainClient.entry.archive.mockResolvedValue(mockEntry);
+
+        const result = await client.archiveEntry('entry-123', 1);
+
+        expect(mockPlainClient.entry.archive).toHaveBeenCalledWith(
+          { entryId: 'entry-123', version: 1 }
+        );
+        expect(result).toEqual(mockEntry);
+      });
+    });
+
+    describe('unarchiveEntry', () => {
+      it('should unarchive entry', async () => {
+        mockPlainClient.entry.unarchive.mockResolvedValue(mockEntry);
+
+        const result = await client.unarchiveEntry('entry-123');
+
+        expect(mockPlainClient.entry.unarchive).toHaveBeenCalledWith({
+          entryId: 'entry-123'
+        });
+        expect(result).toEqual(mockEntry);
+      });
+    });
+
+    describe('deleteEntry', () => {
+      it('should delete entry', async () => {
+        mockPlainClient.entry.delete.mockResolvedValue(undefined);
+
+        await client.deleteEntry('entry-123');
+
+        expect(mockPlainClient.entry.delete).toHaveBeenCalledWith({
+          entryId: 'entry-123'
+        });
+      });
+    });
+  });
+
+  describe('Asset Operations', () => {
+    describe('getAsset', () => {
+      it('should get asset by ID', async () => {
+        mockPlainClient.asset.get.mockResolvedValue(mockAsset);
+
+        const result = await client.getAsset('asset-123');
+
+        expect(mockPlainClient.asset.get).toHaveBeenCalledWith({
+          assetId: 'asset-123'
+        });
+        expect(result).toEqual(mockAsset);
+      });
+    });
+
+    describe('getAssets', () => {
+      it('should get assets with query', async () => {
+        mockPlainClient.asset.getMany.mockResolvedValue({
+          items: [mockAsset],
+          total: 1,
+          skip: 0,
+          limit: 100
+        });
+
+        const result = await client.getAssets({ locale: 'en-US' });
+
+        expect(mockPlainClient.asset.getMany).toHaveBeenCalledWith({
+          query: { locale: 'en-US' }
+        });
+        expect(result).toEqual([mockAsset]);
+      });
+    });
+
+    describe('getAllAssets', () => {
+      it('should get all assets with pagination', async () => {
+        // Create 100 assets for first page
+        const firstPageAssets = Array.from({ length: 100 }, (_, i) => ({
+          ...mockAsset,
+          sys: { ...mockAsset.sys, id: `asset-${i}` }
+        }));
+
+        // Create 50 assets for second page (to reach total of 150)
+        const secondPageAssets = Array.from({ length: 50 }, (_, i) => ({
+          ...mockAsset,
+          sys: { ...mockAsset.sys, id: `asset-${100 + i}` }
+        }));
+
+        mockPlainClient.asset.getMany.mockResolvedValueOnce({
+          items: firstPageAssets,
+          total: 150,
+          skip: 0,
+          limit: 100
+        });
+
+        mockPlainClient.asset.getMany.mockResolvedValueOnce({
+          items: secondPageAssets,
+          total: 150,
+          skip: 100,
+          limit: 100
+        });
+
+        const result = await client.getAllAssets();
+
+        expect(mockPlainClient.asset.getMany).toHaveBeenCalledTimes(2);
+        expect(result).toHaveLength(150);
+      });
+    });
+
+    describe('createAsset', () => {
+      it('should create asset', async () => {
+        mockPlainClient.asset.create.mockResolvedValue(mockAsset);
+
+        const fields = mockAsset.fields!;
+        const result = await client.createAsset(fields);
+
+        expect(mockPlainClient.asset.create).toHaveBeenCalledWith(
+          { assetId: undefined },
+          { fields }
+        );
+        expect(result).toEqual(mockAsset);
+      });
+    });
+
+    describe('processAsset', () => {
+      it('should process asset', async () => {
+        mockPlainClient.asset.processForLocale.mockResolvedValue(mockAsset);
+
+        const result = await client.processAsset('asset-123', 1, 'en-US');
+
+        expect(mockPlainClient.asset.processForLocale).toHaveBeenCalledWith(
+          { assetId: 'asset-123', version: 1 },
+          { sys: { version: 1 } },
+          'en-US'
+        );
+        expect(result).toEqual(mockAsset);
+      });
+
+      it('should use default locale', async () => {
+        mockPlainClient.asset.processForLocale.mockResolvedValue(mockAsset);
+
+        await client.processAsset('asset-123', 1);
+
+        expect(mockPlainClient.asset.processForLocale).toHaveBeenCalledWith(
+          { assetId: 'asset-123', version: 1 },
+          { sys: { version: 1 } },
+          'en-US'
+        );
+      });
+    });
+
+    describe('publishAsset', () => {
+      it('should publish asset', async () => {
+        const publishedAsset = {
+          ...mockAsset,
+          sys: { ...mockAsset.sys, publishedVersion: 1 }
+        };
+        mockPlainClient.asset.publish.mockResolvedValue(publishedAsset);
+
+        const result = await client.publishAsset('asset-123', 1);
+
+        expect(mockPlainClient.asset.publish).toHaveBeenCalledWith(
+          { assetId: 'asset-123' },
+          { sys: { version: 1 } }
+        );
+        expect(result).toEqual(publishedAsset);
+      });
+    });
+
+    describe('unpublishAsset', () => {
+      it('should unpublish asset', async () => {
+        mockPlainClient.asset.unpublish.mockResolvedValue(mockAsset);
+
+        const result = await client.unpublishAsset('asset-123');
+
+        expect(mockPlainClient.asset.unpublish).toHaveBeenCalledWith({
+          assetId: 'asset-123'
+        });
+        expect(result).toEqual(mockAsset);
+      });
+    });
+
+    describe('deleteAsset', () => {
+      it('should delete asset', async () => {
+        mockPlainClient.asset.delete.mockResolvedValue(undefined);
+
+        await client.deleteAsset('asset-123');
+
+        expect(mockPlainClient.asset.delete).toHaveBeenCalledWith({
+          assetId: 'asset-123'
+        });
+      });
+    });
+  });
+
+  describe('Content Type Operations', () => {
+    describe('getContentType', () => {
+      it('should get content type by ID', async () => {
+        mockPlainClient.contentType.get.mockResolvedValue(mockContentType);
+
+        const result = await client.getContentType('blogPost');
+
+        expect(mockPlainClient.contentType.get).toHaveBeenCalledWith({
+          contentTypeId: 'blogPost'
+        });
+        expect(result).toEqual(mockContentType);
+      });
+    });
+
+    describe('getContentTypes', () => {
+      it('should get all content types', async () => {
+        mockPlainClient.contentType.getMany.mockResolvedValue({
+          items: [mockContentType],
+          total: 1,
+          skip: 0,
+          limit: 100
+        });
+
+        const result = await client.getContentTypes();
+
+        expect(mockPlainClient.contentType.getMany).toHaveBeenCalledWith({
+          query: undefined
+        });
+        expect(result).toEqual([mockContentType]);
+      });
+
+      it('should get content types with query', async () => {
+        mockPlainClient.contentType.getMany.mockResolvedValue({
+          items: [mockContentType],
+          total: 1,
+          skip: 0,
+          limit: 100
+        });
+
+        await client.getContentTypes({ limit: 10 });
+
+        expect(mockPlainClient.contentType.getMany).toHaveBeenCalledWith({
+          query: { limit: 10 }
+        });
+      });
+    });
+  });
+
+  describe('Bulk Operations', () => {
+    describe('bulkCreateEntries', () => {
+      it('should create multiple entries successfully', async () => {
+        mockPlainClient.entry.create.mockResolvedValue(mockEntry);
+
+        const entries = [
+          { contentTypeId: 'blogPost', fields: { title: { 'en-US': 'Entry 1' } } },
+          { contentTypeId: 'blogPost', fields: { title: { 'en-US': 'Entry 2' } } }
+        ];
+
+        const result = await client.bulkCreateEntries(entries);
+
+        expect(mockPlainClient.entry.create).toHaveBeenCalledTimes(2);
+        expect(result.successful).toHaveLength(2);
+        expect(result.failed).toHaveLength(0);
+      });
+
+      it('should handle partial failures', async () => {
+        mockPlainClient.entry.create
+          .mockResolvedValueOnce(mockEntry)
+          .mockRejectedValueOnce(new Error('Failed to create'));
+
+        const entries = [
+          { contentTypeId: 'blogPost', fields: { title: { 'en-US': 'Entry 1' } } },
+          { contentTypeId: 'blogPost', fields: { title: { 'en-US': 'Entry 2' } } }
+        ];
+
+        const result = await client.bulkCreateEntries(entries);
+
+        expect(result.successful).toHaveLength(1);
+        expect(result.failed).toHaveLength(1);
+        expect(result.failed[0].error).toBe('Failed to create');
+      });
+    });
+
+    describe('bulkDeleteEntries', () => {
+      it('should delete multiple entries successfully', async () => {
+        mockPlainClient.entry.delete.mockResolvedValue(undefined);
+
+        const entryIds = ['entry-1', 'entry-2', 'entry-3'];
+        const result = await client.bulkDeleteEntries(entryIds);
+
+        expect(mockPlainClient.entry.delete).toHaveBeenCalledTimes(3);
+        expect(result.successful).toEqual(entryIds);
+        expect(result.failed).toHaveLength(0);
+      });
+
+      it('should handle partial failures', async () => {
+        mockPlainClient.entry.delete
+          .mockResolvedValueOnce(undefined)
+          .mockRejectedValueOnce(new Error('Not found'));
+
+        const entryIds = ['entry-1', 'entry-2'];
+        const result = await client.bulkDeleteEntries(entryIds);
+
+        expect(result.successful).toEqual(['entry-1']);
+        expect(result.failed).toHaveLength(1);
+        expect(result.failed[0].item).toBe('entry-2');
+      });
+    });
+
+    describe('bulkPublishEntries', () => {
+      it('should publish multiple entries successfully', async () => {
+        mockPlainClient.entry.publish.mockResolvedValue(mockEntry);
+
+        const entries = [
+          { entryId: 'entry-1', version: 1 },
+          { entryId: 'entry-2', version: 1 }
+        ];
+
+        const result = await client.bulkPublishEntries(entries);
+
+        expect(mockPlainClient.entry.publish).toHaveBeenCalledTimes(2);
+        expect(result.successful).toHaveLength(2);
+        expect(result.failed).toHaveLength(0);
+      });
+
+      it('should handle version conflicts', async () => {
+        mockPlainClient.entry.publish
+          .mockResolvedValueOnce(mockEntry)
+          .mockRejectedValueOnce(new Error('Version mismatch'));
+
+        const entries = [
+          { entryId: 'entry-1', version: 1 },
+          { entryId: 'entry-2', version: 1 }
+        ];
+
+        const result = await client.bulkPublishEntries(entries);
+
+        expect(result.successful).toHaveLength(1);
+        expect(result.failed).toHaveLength(1);
+        expect(result.failed[0].error).toBe('Version mismatch');
+      });
+    });
+  });
+
+  describe('Configuration Getters', () => {
+    it('should return spaceId', () => {
+      expect(client.getSpaceId()).toBe('test-space');
+    });
+
+    it('should return environmentId', () => {
+      expect(client.getEnvironmentId()).toBe('master');
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle string errors', async () => {
+      mockPlainClient.entry.get.mockRejectedValue('String error');
+
+      await expect(client.getEntry('entry-123')).rejects.toBe('String error');
+    });
+
+    it('should handle Error objects', async () => {
+      const error = new Error('Test error');
+      mockPlainClient.entry.get.mockRejectedValue(error);
+
+      await expect(client.getEntry('entry-123')).rejects.toThrow('Test error');
+    });
+
+    it('should handle unknown error types', async () => {
+      mockPlainClient.entry.get.mockRejectedValue({ code: 'UNKNOWN' });
+
+      await expect(client.getEntry('entry-123')).rejects.toEqual({ code: 'UNKNOWN' });
+    });
+
+    it('should handle errors in getEntries', async () => {
+      mockPlainClient.entry.getMany.mockRejectedValue(new Error('API error'));
+
+      await expect(client.getEntries()).rejects.toThrow('API error');
+    });
+
+    it('should handle errors in createEntry', async () => {
+      mockPlainClient.entry.create.mockRejectedValue(new Error('Create failed'));
+
+      await expect(client.createEntry('blogPost', {})).rejects.toThrow('Create failed');
+    });
+
+    it('should handle errors in updateEntry', async () => {
+      mockPlainClient.entry.update.mockRejectedValue(new Error('Update failed'));
+
+      await expect(client.updateEntry('entry-123', {}, 1)).rejects.toThrow('Update failed');
+    });
+
+    it('should handle errors in publishEntry', async () => {
+      mockPlainClient.entry.publish.mockRejectedValue(new Error('Publish failed'));
+
+      await expect(client.publishEntry('entry-123', 1)).rejects.toThrow('Publish failed');
+    });
+
+    it('should handle errors in unpublishEntry', async () => {
+      mockPlainClient.entry.unpublish.mockRejectedValue(new Error('Unpublish failed'));
+
+      await expect(client.unpublishEntry('entry-123')).rejects.toThrow('Unpublish failed');
+    });
+
+    it('should handle errors in archiveEntry', async () => {
+      mockPlainClient.entry.archive.mockRejectedValue(new Error('Archive failed'));
+
+      await expect(client.archiveEntry('entry-123', 1)).rejects.toThrow('Archive failed');
+    });
+
+    it('should handle errors in unarchiveEntry', async () => {
+      mockPlainClient.entry.unarchive.mockRejectedValue(new Error('Unarchive failed'));
+
+      await expect(client.unarchiveEntry('entry-123')).rejects.toThrow('Unarchive failed');
+    });
+
+    it('should handle errors in deleteEntry', async () => {
+      mockPlainClient.entry.delete.mockRejectedValue(new Error('Delete failed'));
+
+      await expect(client.deleteEntry('entry-123')).rejects.toThrow('Delete failed');
+    });
+
+    it('should handle errors in getAsset', async () => {
+      mockPlainClient.asset.get.mockRejectedValue(new Error('Asset not found'));
+
+      await expect(client.getAsset('asset-123')).rejects.toThrow('Asset not found');
+    });
+
+    it('should handle errors in getAssets', async () => {
+      mockPlainClient.asset.getMany.mockRejectedValue(new Error('Assets error'));
+
+      await expect(client.getAssets()).rejects.toThrow('Assets error');
+    });
+
+    it('should handle errors in createAsset', async () => {
+      mockPlainClient.asset.create.mockRejectedValue(new Error('Asset creation failed'));
+
+      await expect(client.createAsset({})).rejects.toThrow('Asset creation failed');
+    });
+
+    it('should handle errors in processAsset', async () => {
+      mockPlainClient.asset.processForLocale.mockRejectedValue(new Error('Processing failed'));
+
+      await expect(client.processAsset('asset-123', 1)).rejects.toThrow('Processing failed');
+    });
+
+    it('should handle errors in publishAsset', async () => {
+      mockPlainClient.asset.publish.mockRejectedValue(new Error('Asset publish failed'));
+
+      await expect(client.publishAsset('asset-123', 1)).rejects.toThrow('Asset publish failed');
+    });
+
+    it('should handle errors in unpublishAsset', async () => {
+      mockPlainClient.asset.unpublish.mockRejectedValue(new Error('Asset unpublish failed'));
+
+      await expect(client.unpublishAsset('asset-123')).rejects.toThrow('Asset unpublish failed');
+    });
+
+    it('should handle errors in deleteAsset', async () => {
+      mockPlainClient.asset.delete.mockRejectedValue(new Error('Asset delete failed'));
+
+      await expect(client.deleteAsset('asset-123')).rejects.toThrow('Asset delete failed');
+    });
+
+    it('should handle errors in getContentType', async () => {
+      mockPlainClient.contentType.get.mockRejectedValue(new Error('ContentType not found'));
+
+      await expect(client.getContentType('blogPost')).rejects.toThrow('ContentType not found');
+    });
+
+    it('should handle errors in getContentTypes', async () => {
+      mockPlainClient.contentType.getMany.mockRejectedValue(new Error('ContentTypes error'));
+
+      await expect(client.getContentTypes()).rejects.toThrow('ContentTypes error');
+    });
+  });
+});