fastcomments-sdk
Version:
FastComments API Client - A SDK for interacting with the FastComments API
249 lines • 11.4 kB
JavaScript
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const node_test_1 = require("node:test");
const node_assert_1 = __importDefault(require("node:assert"));
const index_1 = require("../index");
const env_1 = require("./env");
// Test against the real FastComments API
(0, node_test_1.describe)('FastComments SSO Integration Tests', () => {
let sdk;
let publicApi;
let defaultApi;
(0, node_test_1.beforeEach)(() => {
sdk = (0, index_1.createFastCommentsSDK)({
apiKey: env_1.API_KEY,
basePath: env_1.BASE_URL
});
publicApi = new index_1.PublicApi(new index_1.Configuration({ basePath: env_1.BASE_URL }));
defaultApi = new index_1.DefaultApi(new index_1.Configuration({
apiKey: env_1.API_KEY,
basePath: env_1.BASE_URL
}));
});
const mockSecureUser = {
id: `test-user-${Date.now()}`,
email: `test-${Date.now()}@example.com`,
username: `testuser${Date.now()}`,
displayName: 'Test User',
avatar: 'https://example.com/avatar.jpg',
optedInNotifications: true,
displayLabel: 'SDK Test User',
websiteUrl: 'https://example.com',
isAdmin: false,
isModerator: false,
isProfileActivityPrivate: true
};
const mockSimpleUser = {
id: `simple-user-${Date.now()}`,
email: `simple-${Date.now()}@example.com`,
username: `simpleuser${Date.now()}`,
displayName: 'Simple Test User',
avatar: 'https://example.com/simple-avatar.jpg',
optedInNotifications: false,
displayLabel: 'Simple SDK Test User'
};
(0, node_test_1.describe)('Secure SSO API Integration', () => {
(0, node_test_1.it)('should work with PublicApi.getCommentsPublic using secure SSO', async () => {
const sso = index_1.FastCommentsSSO.createSecure(env_1.API_KEY, mockSecureUser);
const ssoConfig = sso.prepareToSend();
try {
const response = await publicApi.getCommentsPublic({
tenantId: env_1.TENANT_ID,
urlId: 'sdk-test-page-secure',
sso: JSON.stringify(ssoConfig)
});
node_assert_1.default.ok(response);
node_assert_1.default.strictEqual(response.status, 200);
node_assert_1.default.ok(response.data);
}
catch (error) {
// Check if it's a known/expected error vs a real failure
if (error.response?.status === 404) {
// Page not found is acceptable for test
node_assert_1.default.strictEqual(error.response.status, 404);
}
else if (error.response?.status === 401) {
// Auth error might indicate API key issues
console.warn('Auth error - check API key and tenant ID');
node_assert_1.default.strictEqual(error.response.status, 401);
}
else {
throw error;
}
}
});
(0, node_test_1.it)('should work with DefaultApi.getComments using secure SSO', async () => {
try {
const response = await defaultApi.getComments({
tenantId: env_1.TENANT_ID,
urlId: 'sdk-test-page-secure-admin',
contextUserId: mockSecureUser.id // so blocked/flagged comments are handled etc
});
node_assert_1.default.ok(response);
node_assert_1.default.strictEqual(response.status, 200);
node_assert_1.default.ok(response.data);
}
catch (error) {
if (error.response?.status === 404 || error.response?.status === 401) {
node_assert_1.default.ok([404, 401].includes(error.response.status));
}
else {
throw error;
}
}
});
(0, node_test_1.it)('should create comment with secure SSO', async () => {
const sso = index_1.FastCommentsSSO.createSecure(env_1.API_KEY, mockSecureUser);
const ssoConfig = sso.prepareToSend();
try {
const response = await publicApi.createCommentPublic({
tenantId: env_1.TENANT_ID,
urlId: 'sdk-test-page-secure-comment',
broadcastId: `test-${Date.now()}`,
commentData: {
comment: 'Test comment with secure SSO from Node.js SDK',
date: Date.now(),
commenterName: mockSecureUser.username,
url: 'https://example.com/test-page',
urlId: 'sdk-test-page-secure-comment'
},
sso: JSON.stringify(ssoConfig)
});
node_assert_1.default.ok(response);
node_assert_1.default.strictEqual(response.status, 200);
node_assert_1.default.ok(response.data);
if (response.data && typeof response.data === 'object') {
const responseData = response.data;
// Response has structure: { status: "success", comment: { commentHTML: "..." } }
if (responseData.comment && responseData.comment.commentHTML) {
node_assert_1.default.ok(responseData.comment.commentHTML.includes('Test comment with secure SSO'));
}
}
}
catch (error) {
// Accept certain expected errors in test environment
if (error.response?.status === 401 || error.response?.status === 403 || error.response?.status === 422) {
node_assert_1.default.ok([401, 403, 422].includes(error.response.status));
}
else {
throw error;
}
}
});
});
(0, node_test_1.describe)('Simple SSO API Integration', () => {
(0, node_test_1.it)('should work with PublicApi.getCommentsPublic using simple SSO', async () => {
const sso = index_1.FastCommentsSSO.createSimple(mockSimpleUser);
const ssoToken = sso.createToken();
try {
const response = await publicApi.getCommentsPublic({
tenantId: env_1.TENANT_ID,
urlId: 'sdk-test-page-simple',
sso: ssoToken
});
node_assert_1.default.ok(response);
node_assert_1.default.strictEqual(response.status, 200);
node_assert_1.default.ok(response.data);
}
catch (error) {
if (error.response?.status === 404 || error.response?.status === 401) {
node_assert_1.default.ok([404, 401].includes(error.response.status));
}
else {
throw error;
}
}
});
(0, node_test_1.it)('should create comment with simple SSO', async () => {
const sso = index_1.FastCommentsSSO.createSimple(mockSimpleUser);
const ssoToken = sso.createToken();
try {
const response = await publicApi.createCommentPublic({
tenantId: env_1.TENANT_ID,
urlId: 'sdk-test-page-simple-comment',
broadcastId: `simple-test-${Date.now()}`,
commentData: {
comment: 'Test comment with simple SSO from Node.js SDK',
date: Date.now(),
commenterName: mockSimpleUser.username,
commenterEmail: mockSimpleUser.email,
url: 'https://example.com/test-page',
urlId: 'sdk-test-page-simple-comment'
},
sso: ssoToken
});
node_assert_1.default.ok(response);
node_assert_1.default.strictEqual(response.status, 200);
node_assert_1.default.ok(response.data);
if (response.data && typeof response.data === 'object') {
const responseData = response.data;
// Response has structure: { status: "success", comment: { commentHTML: "..." } }
if (responseData.comment && responseData.comment.commentHTML) {
node_assert_1.default.ok(responseData.comment.commentHTML.includes('Test comment with simple SSO'));
}
}
}
catch (error) {
if (error.response?.status === 401 || error.response?.status === 403 || error.response?.status === 422) {
node_assert_1.default.ok([401, 403, 422].includes(error.response.status));
}
else {
throw error;
}
}
});
});
(0, node_test_1.describe)('SDK Integration', () => {
(0, node_test_1.it)('should authenticate with DefaultApi using API key', async () => {
try {
const response = await sdk.defaultApi.getComments({
tenantId: env_1.TENANT_ID,
urlId: 'test-page'
});
node_assert_1.default.ok(response);
node_assert_1.default.strictEqual(response.status, 200);
}
catch (error) {
// API key might not have user search permissions, which is OK
if (error.response?.status === 401 || error.response?.status === 403) {
node_assert_1.default.ok([401, 403].includes(error.response.status));
}
else {
throw error;
}
}
});
});
(0, node_test_1.describe)('Error Handling', () => {
(0, node_test_1.it)('should handle invalid tenant ID gracefully', async () => {
const sso = index_1.FastCommentsSSO.createSecure(env_1.API_KEY, mockSecureUser);
const ssoConfig = sso.prepareToSend();
try {
await publicApi.getCommentsPublic({
tenantId: 'invalid-tenant-id',
urlId: 'test-page',
sso: JSON.stringify(ssoConfig)
});
}
catch (error) {
node_assert_1.default.ok(error.response?.status >= 400);
}
});
(0, node_test_1.it)('should handle malformed SSO data gracefully', async () => {
try {
await publicApi.getCommentsPublic({
tenantId: env_1.TENANT_ID,
urlId: 'test-page',
sso: 'invalid-sso-data'
});
}
catch (error) {
node_assert_1.default.ok(error.response?.status >= 400);
}
});
});
});
//# sourceMappingURL=sso.integration.test.js.map