@lgriffin/esi.ts 1.0.0

package/tests/tdd/mail/MailApiBuilder.test.ts

@@ -0,0 +1,20 @@
+import { MailApiBuilder } from '../../../src/builders/MailApiBuilder';
+import { ApiClientBuilder } from '../../../src/core/ApiClientBuilder';
+import { getConfig } from '../../../src/config/configManager';
+import { MailClient } from '../../../src/clients/MailClient';
+
+const config = getConfig();
+const client = new ApiClientBuilder()
+    .setClientId(config.projectName)
+    .setLink(config.link)
+    .setAccessToken(config.authToken || undefined)
+    .build();
+
+describe('MailApiBuilder', () => {
+    it('should build and return a MailClient instance', () => {
+        const builder = new MailApiBuilder(client);
+        const mailClient = builder.build();
+
+        expect(mailClient).toBeInstanceOf(MailClient);
+    });
+});

package/tests/tdd/mail/MailClient.test.ts

@@ -0,0 +1,189 @@
+import { MailClient } from '../../../src/clients/MailClient';
+import { ApiClientBuilder } from '../../../src/core/ApiClientBuilder';
+import { getConfig } from '../../../src/config/configManager';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const config = getConfig();
+const client = new ApiClientBuilder()
+    .setClientId(config.projectName)
+    .setLink(config.link)
+    .setAccessToken(config.authToken || undefined)
+    .build();
+
+const mailClient = new MailClient(client);
+
+describe('MailClient', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return mail headers', async () => {
+        const mockResponse = [
+            {
+                mail_id: 1,
+                subject: 'Test Mail',
+                from: 123456,
+                timestamp: '2024-01-01T00:00:00Z'
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => mailClient.getMailHeaders(123456789));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((mail: { mail_id: number, subject: string, from: number, timestamp: string }) => {
+            expect(mail).toHaveProperty('mail_id');
+            expect(typeof mail.mail_id).toBe('number');
+            expect(mail).toHaveProperty('subject');
+            expect(typeof mail.subject).toBe('string');
+            expect(mail).toHaveProperty('from');
+            expect(typeof mail.from).toBe('number');
+            expect(mail).toHaveProperty('timestamp');
+            expect(typeof mail.timestamp).toBe('string');
+        });
+    });
+
+    it('should send a new mail', async () => {
+        const mockResponse = {
+            mail_id: 1
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const body = {
+            recipients: [{ recipient_id: 123, recipient_type: 'character' }],
+            subject: 'Test Mail',
+            body: 'This is a test mail'
+        };
+
+        const result = await getBody(() => mailClient.sendMail(123456, body));
+
+        expect(result).toHaveProperty('mail_id');
+        expect(typeof result.mail_id).toBe('number');
+    });
+
+    it('should delete a mail', async () => {
+        fetchMock.mockResponseOnce('', { status: 204 });
+
+        const result = await getBody(() => mailClient.deleteMail(123456, 1));
+
+        expect(result).toEqual({ error: 'no content' });
+    });
+
+    it('should return a mail', async () => {
+        const mockResponse = {
+            mail_id: 1,
+            subject: 'Test Mail',
+            body: 'This is a test mail',
+            from: 123456,
+            timestamp: '2024-01-01T00:00:00Z'
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => mailClient.getMail(123456, 1));
+
+        expect(result).toHaveProperty('mail_id');
+        expect(typeof result.mail_id).toBe('number');
+        expect(result).toHaveProperty('subject');
+        expect(typeof result.subject).toBe('string');
+        expect(result).toHaveProperty('body');
+        expect(typeof result.body).toBe('string');
+        expect(result).toHaveProperty('from');
+        expect(typeof result.from).toBe('number');
+        expect(result).toHaveProperty('timestamp');
+        expect(typeof result.timestamp).toBe('string');
+    });
+
+    it('should update mail metadata', async () => {
+        fetchMock.mockResponseOnce('', { status: 204 });
+
+        const body = {
+            labels: [1, 2],
+            read: true
+        };
+
+        const result = await getBody(() => mailClient.updateMailMetadata(123456, 1, body));
+
+        expect(result).toEqual({ error: 'no content' });
+    });
+
+    it('should return mail labels and unread counts', async () => {
+        const mockResponse = {
+            labels: [
+                {
+                    label_id: 1,
+                    name: "Label 1",
+                    unread_count: 5
+                }
+            ],
+            total_unread_count: 5
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => mailClient.getMailLabels(123456789));
+
+        expect(result).toHaveProperty('labels');
+        expect(Array.isArray(result.labels)).toBe(true);
+        result.labels.forEach((label: { label_id: number, name: string, unread_count: number }) => {
+            expect(label).toHaveProperty('label_id');
+            expect(typeof label.label_id).toBe('number');
+            expect(label).toHaveProperty('name');
+            expect(typeof label.name).toBe('string');
+            expect(label).toHaveProperty('unread_count');
+            expect(typeof label.unread_count).toBe('number');
+        });
+        expect(result).toHaveProperty('total_unread_count');
+        expect(typeof result.total_unread_count).toBe('number');
+    });
+
+    it('should create a mail label', async () => {
+        const mockResponse = {
+            label_id: 1
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const body = {
+            name: "New Label"
+        };
+
+        const result = await getBody(() => mailClient.createMailLabel(123456, body));
+
+        expect(result).toHaveProperty('label_id');
+        expect(typeof result.label_id).toBe('number');
+    });
+
+    it('should delete a mail label', async () => {
+        fetchMock.mockResponseOnce('', { status: 204 });
+
+        const result = await getBody(() => mailClient.deleteMailLabel(123456, 1));
+
+        expect(result).toEqual({ error: 'no content' });
+    });
+
+    it('should return mailing list subscriptions', async () => {
+        const mockResponse = [
+            {
+                mailing_list_id: 1,
+                name: "Test List"
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => mailClient.getMailingLists(123456789));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((list: { mailing_list_id: number, name: string }) => {
+            expect(list).toHaveProperty('mailing_list_id');
+            expect(typeof list.mailing_list_id).toBe('number');
+            expect(list).toHaveProperty('name');
+            expect(typeof list.name).toBe('string');
+        });
+    });
+});

package/tests/tdd/mail/deleteCharacterMail.test.ts

@@ -0,0 +1,22 @@
+import { DeleteCharacterMailApi } from '../../../src/api/mail/deleteCharacterMail';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const client = getClient();
+const deleteMailApi = new DeleteCharacterMailApi(client);
+
+describe('DeleteCharacterMailApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should delete a mail', async () => {
+        fetchMock.mockResponseOnce('', { status: 204 });
+
+        const result = await getBody(() => deleteMailApi.deleteMail(123456, 1));
+
+        expect(result).toEqual({ error: 'no content' });
+    });
+});

package/tests/tdd/mail/getCharacterMail.test.ts

@@ -0,0 +1,46 @@
+import { GetCharacterMailApi } from '../../../src/api/mail/getCharacterMail';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const client = getClient();
+const characterMailApi = new GetCharacterMailApi(client);
+
+describe('GetCharacterMailApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return a mail', async () => {
+        const mockResponse = {
+            mail_id: 1,
+            subject: "Test Mail",
+            from: 12345,
+            to: {
+                recipients: [12345],
+                mailing_list_ids: []
+            },
+            timestamp: "2024-07-01T12:00:00Z",
+            body: "This is a test mail."
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => characterMailApi.getMail(123456, 1));
+
+        expect(result).toHaveProperty('mail_id');
+        expect(typeof result.mail_id).toBe('number');
+        expect(result).toHaveProperty('subject');
+        expect(typeof result.subject).toBe('string');
+        expect(result).toHaveProperty('from');
+        expect(typeof result.from).toBe('number');
+        expect(result).toHaveProperty('to');
+        expect(Array.isArray(result.to.recipients)).toBe(true);
+        expect(Array.isArray(result.to.mailing_list_ids)).toBe(true);
+        expect(result).toHaveProperty('timestamp');
+        expect(typeof result.timestamp).toBe('string');
+        expect(result).toHaveProperty('body');
+        expect(typeof result.body).toBe('string');
+    });
+});

package/tests/tdd/mail/getCharacterMailHeaders.ts

@@ -0,0 +1,51 @@
+import { GetCharacterMailHeadersApi } from '../../../src/api/mail/getCharacterMailHeaders';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const client = getClient();
+const mailHeadersApi = new GetCharacterMailHeadersApi(client);
+
+describe('GetCharacterMailHeadersApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return mail headers', async () => {
+        const mockResponse = [
+            {
+                mail_id: 1,
+                subject: "Test Mail",
+                from: 12345,
+                to: {
+                    recipients: [12345],
+                    mailing_list_ids: []
+                },
+                timestamp: "2024-07-01T12:00:00Z",
+                is_read: false,
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => mailHeadersApi.getCharacterMailHeaders(123456789));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((mailHeader: { mail_id: number, subject: string, from: number, to: { recipients: number[], mailing_list_ids: number[] }, timestamp: string, is_read: boolean }) => {
+            expect(mailHeader).toHaveProperty('mail_id');
+            expect(typeof mailHeader.mail_id).toBe('number');
+            expect(mailHeader).toHaveProperty('subject');
+            expect(typeof mailHeader.subject).toBe('string');
+            expect(mailHeader).toHaveProperty('from');
+            expect(typeof mailHeader.from).toBe('number');
+            expect(mailHeader).toHaveProperty('to');
+            expect(Array.isArray(mailHeader.to.recipients)).toBe(true);
+            expect(Array.isArray(mailHeader.to.mailing_list_ids)).toBe(true);
+            expect(mailHeader).toHaveProperty('timestamp');
+            expect(typeof mailHeader.timestamp).toBe('string');
+            expect(mailHeader).toHaveProperty('is_read');
+            expect(typeof mailHeader.is_read).toBe('boolean');
+        });
+    });
+});

package/tests/tdd/mail/getCharacterMailLabels.test.ts

@@ -0,0 +1,44 @@
+import { GetCharacterMailLabelsApi } from '../../../src/api/mail/getCharacterMailLabels';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const client = getClient();
+const mailLabelsApi = new GetCharacterMailLabelsApi(client);
+
+describe('GetCharacterMailLabelsApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return mail labels and unread counts', async () => {
+        const mockResponse = {
+            labels: [
+                {
+                    label_id: 1,
+                    name: "Label 1",
+                    unread_count: 5
+                }
+            ],
+            total_unread_count: 5
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => mailLabelsApi.getMailLabels(123456789));
+
+        expect(result).toHaveProperty('labels');
+        expect(Array.isArray(result.labels)).toBe(true);
+        result.labels.forEach((label: { label_id: number, name: string, unread_count: number }) => {
+            expect(label).toHaveProperty('label_id');
+            expect(typeof label.label_id).toBe('number');
+            expect(label).toHaveProperty('name');
+            expect(typeof label.name).toBe('string');
+            expect(label).toHaveProperty('unread_count');
+            expect(typeof label.unread_count).toBe('number');
+        });
+        expect(result).toHaveProperty('total_unread_count');
+        expect(typeof result.total_unread_count).toBe('number');
+    });
+});

package/tests/tdd/mail/postCharacterMail.test.ts

@@ -0,0 +1,40 @@
+import { PostCharacterMailApi } from '../../../src/api/mail/postCharacterMail';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const client = getClient();
+const characterMailApi = new PostCharacterMailApi(client);
+
+describe('PostCharacterMailApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should send a mail', async () => {
+        const mockResponse = {
+            mail_id: 12345
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const body = {
+            recipients: [
+                {
+                    recipient_id: 123456789,
+                    recipient_type: 'character'
+                }
+            ],
+            subject: 'Test Mail',
+            body: 'This is a test mail.',
+            approved_cost: 0,
+            labels: []
+        };
+
+        const result = await getBody(() => characterMailApi.sendMail(123456, body));
+
+        expect(result).toHaveProperty('mail_id');
+        expect(typeof result.mail_id).toBe('number');
+    });
+});

package/tests/tdd/mail/postCharacterMailLabels.test.ts

@@ -0,0 +1,31 @@
+import { PostCharacterMailLabelsApi } from '../../../src/api/mail/postCharacterMailLabels';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const client = getClient();
+const mailLabelsApi = new PostCharacterMailLabelsApi(client);
+
+describe('PostCharacterMailLabelsApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should create a mail label', async () => {
+        const mockResponse = {
+            label_id: 1
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const body = {
+            name: "New Label"
+        };
+
+        const result = await getBody(() => mailLabelsApi.createMailLabel(123456, body));
+
+        expect(result).toHaveProperty('label_id');
+        expect(typeof result.label_id).toBe('number');
+    });
+});

package/tests/tdd/mail/putCharacterMail.test.ts

@@ -0,0 +1,27 @@
+import { PutCharacterMailApi } from '../../../src/api/mail/putCharacterMail';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const client = getClient();
+const characterMailApi = new PutCharacterMailApi(client);
+
+describe('PutCharacterMailApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should update mail metadata', async () => {
+        fetchMock.mockResponseOnce('', { status: 204 });
+
+        const body = {
+            labels: [1, 2],
+            read: true
+        };
+
+        const result = await getBody(() => characterMailApi.updateMailMetadata(123456, 1, body));
+
+        expect(result).toEqual({ error: 'no content' });
+    });
+});

package/tests/tdd/market/MarketApiBuilder.test.ts

@@ -0,0 +1,20 @@
+import { MarketApiBuilder } from '../../../src/builders/MarketApiBuilder';
+import { ApiClientBuilder } from '../../../src/core/ApiClientBuilder';
+import { getConfig } from '../../../src/config/configManager';
+import { MarketClient } from '../../../src/clients/MarketClient';
+
+const config = getConfig();
+const client = new ApiClientBuilder()
+    .setClientId(config.projectName)
+    .setLink(config.link)
+    .setAccessToken(config.authToken || undefined)
+    .build();
+
+describe('MarketApiBuilder', () => {
+    it('should build and return a MarketClient instance', () => {
+        const builder = new MarketApiBuilder(client);
+        const marketClient = builder.build();
+
+        expect(marketClient).toBeInstanceOf(MarketClient);
+    });
+});