@usepoodle/poodle-js
Version:
Poodle JavaScript and TypeScript SDK
110 lines (109 loc) • 4.18 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const axios_1 = __importDefault(require("axios"));
const src_1 = require("../src");
jest.mock('axios');
const mockedAxios = axios_1.default;
describe('PoodleClient', () => {
const defaultOptions = {
apiKey: 'test-api-key',
};
let mockPost;
beforeEach(() => {
mockPost = jest.fn();
mockedAxios.create.mockReturnValue({
post: mockPost,
defaults: {
baseURL: 'https://api.usepoodle.com/v1',
},
});
mockedAxios.isAxiosError.mockImplementation((payload) => {
return (typeof payload === 'object' &&
payload !== null &&
payload.isAxiosError === true);
});
});
afterEach(() => {
jest.clearAllMocks();
});
describe('constructor', () => {
it('should throw error if apiKey is not provided', () => {
expect(() => new src_1.PoodleClient({})).toThrow('API key is required');
});
it('should create axios instance with correct config', () => {
new src_1.PoodleClient(defaultOptions);
expect(mockedAxios.create).toHaveBeenCalledWith({
baseURL: 'https://api.usepoodle.com/v1',
headers: {
Authorization: 'Bearer test-api-key',
'Content-Type': 'application/json',
'User-Agent': 'poodle-js/1.0.0',
},
});
});
});
describe('sendEmail', () => {
let client;
const validEmailOptions = {
from: 'sender@example.com',
to: 'recipient@example.com',
subject: 'Test Email',
text: 'Hello World',
};
beforeEach(() => {
client = new src_1.PoodleClient(defaultOptions);
});
it('should validate required fields', async () => {
await expect(client.sendEmail({})).rejects.toThrow('From address is required');
await expect(client.sendEmail({
from: 'test@example.com',
})).rejects.toThrow('To address is required');
await expect(client.sendEmail({
from: 'test@example.com',
to: 'test@example.com',
})).rejects.toThrow('Subject is required');
await expect(client.sendEmail({
from: 'test@example.com',
to: 'test@example.com',
subject: 'Test',
})).rejects.toThrow('Either html or text content is required');
});
it('should send email successfully', async () => {
const responseData = {
success: true,
message: 'Email queued for sending',
};
mockPost.mockResolvedValueOnce({ data: responseData });
const result = await client.sendEmail(validEmailOptions);
expect(result).toEqual(responseData);
expect(mockPost).toHaveBeenCalledWith('/send-email', validEmailOptions);
});
it('should handle API errors', async () => {
const errorData = {
message: 'Invalid email address',
error: 'You used an invalid email address for the "to" field',
};
const axiosError = {
isAxiosError: true,
response: {
status: 400,
data: errorData,
},
config: {},
request: {},
name: 'AxiosError',
message: 'Request failed with status code 400',
toJSON: () => ({}),
};
mockPost.mockRejectedValueOnce(axiosError);
await expect(client.sendEmail(validEmailOptions)).rejects.toEqual(expect.objectContaining({
message: errorData.message,
statusCode: 400,
details: errorData.error,
}));
});
});
});