sms-verification-api 0.9.1

package/test/api.test.js

@@ -0,0 +1,201 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { createApp } from '../src/verify-phone-server.js';
+
+describe('SMS Verification API', () => {
+  let app;
+
+  beforeEach(() => {
+    // Create a fresh app instance for each test
+    app = createApp(globalThis.env);
+  });
+
+  describe('Health Check', () => {
+    it('should return health status', async () => {
+      const req = new Request('http://localhost/health');
+      const res = await app.request(req, globalThis.env);
+      const data = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(data).toMatchObject({
+        status: 'ok'
+      });
+      expect(data.timestamp).toBeDefined();
+    });
+  });
+
+  describe('Send Verification Code', () => {
+    it('should require API key authentication', async () => {
+      const req = new Request('http://localhost/api/send-verification?phoneNumber=%2B1234567890');
+      const res = await app.request(req, globalThis.env);
+      const data = await res.json();
+
+      expect(res.status).toBe(401);
+      expect(data).toMatchObject({
+        error: 'API key required'
+      });
+    });
+
+    it('should reject invalid API key', async () => {
+      const req = new Request('http://localhost/api/send-verification?phoneNumber=%2B1234567890', {
+        headers: {
+          'X-API-Key': 'invalid-key'
+        }
+      });
+      const res = await app.request(req, globalThis.env);
+      const data = await res.json();
+
+      expect(res.status).toBe(401);
+      expect(data).toMatchObject({
+        error: 'Invalid API key'
+      });
+    });
+
+    it('should accept Bearer token authentication', async () => {
+      const req = new Request('http://localhost/api/send-verification?phoneNumber=%2B1234567890', {
+        headers: {
+          'Authorization': 'Bearer test-api-key'
+        }
+      });
+      const res = await app.request(req, globalThis.env);
+      const data = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(data.success).toBe(true);
+    });
+
+    it('should reject invalid phone number format', async () => {
+      const req = new Request('http://localhost/api/send-verification?phoneNumber=invalid-phone', {
+        headers: {
+          'X-API-Key': 'test-api-key'
+        }
+      });
+      const res = await app.request(req, globalThis.env);
+      const data = await res.json();
+
+      expect(res.status).toBe(400);
+      expect(data).toMatchObject({
+        error: 'Invalid phone number format'
+      });
+    });
+
+    it('should format phone number correctly', async () => {
+      const req = new Request('http://localhost/api/send-verification?phoneNumber=1234567890', {
+        headers: {
+          'X-API-Key': 'test-api-key'
+        }
+      });
+      const res = await app.request(req, globalThis.env);
+      const data = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(data.success).toBe(true);
+    });
+
+    it('should accept blockVoip parameter', async () => {
+      const req = new Request('http://localhost/api/send-verification?phoneNumber=%2B1234567890&blockVoip=true', {
+        headers: {
+          'X-API-Key': 'test-api-key'
+        }
+      });
+      const res = await app.request(req, globalThis.env);
+      const data = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(data.success).toBe(true);
+    });
+
+    it('should handle blockVoip=false parameter', async () => {
+      const req = new Request('http://localhost/api/send-verification?phoneNumber=%2B1234567890&blockVoip=false', {
+        headers: {
+          'X-API-Key': 'test-api-key'
+        }
+      });
+      const res = await app.request(req, globalThis.env);
+      const data = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(data.success).toBe(true);
+    });
+  });
+
+  describe('Verify Code', () => {
+    it('should require API key authentication', async () => {
+      const req = new Request('http://localhost/api/verify-code?phoneNumber=%2B1234567890&code=123456');
+      const res = await app.request(req, globalThis.env);
+      const data = await res.json();
+
+      expect(res.status).toBe(401);
+      expect(data).toMatchObject({
+        error: 'API key required'
+      });
+    });
+
+    it('should reject invalid API key', async () => {
+      const req = new Request('http://localhost/api/verify-code?phoneNumber=%2B1234567890&code=123456', {
+        headers: {
+          'X-API-Key': 'invalid-key'
+        }
+      });
+      const res = await app.request(req, globalThis.env);
+      const data = await res.json();
+
+      expect(res.status).toBe(401);
+      expect(data).toMatchObject({
+        error: 'Invalid API key'
+      });
+    });
+
+    it('should reject invalid phone number format', async () => {
+      const req = new Request('http://localhost/api/verify-code?phoneNumber=invalid-phone&code=123456', {
+        headers: {
+          'X-API-Key': 'test-api-key'
+        }
+      });
+      const res = await app.request(req, globalThis.env);
+      const data = await res.json();
+
+      expect(res.status).toBe(400);
+      expect(data).toMatchObject({
+        error: 'Invalid phone number format'
+      });
+    });
+
+    it('should accept Bearer token authentication', async () => {
+      const req = new Request('http://localhost/api/verify-code?phoneNumber=%2B1234567890&code=123456', {
+        headers: {
+          'Authorization': 'Bearer test-api-key'
+        }
+      });
+      const res = await app.request(req, globalThis.env);
+      const data = await res.json();
+
+      expect(res.status).toBe(400); // Will fail because no code was sent, but auth works
+      expect(data.error).toBeDefined();
+    });
+  });
+
+  describe('Documentation Endpoints', () => {
+    it('should serve OpenAPI documentation', async () => {
+      const req = new Request('http://localhost/openapi.json');
+      const res = await app.request(req, globalThis.env);
+      const data = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(data).toMatchObject({
+        openapi: '3.0.0',
+        info: {
+          title: 'SMS API',
+          version: '1.0.0'
+        }
+      });
+    });
+
+    it('should serve Swagger UI', async () => {
+      const req = new Request('http://localhost/');
+      const res = await app.request(req, globalThis.env);
+
+      expect(res.status).toBe(200);
+      expect(res.headers.get('content-type')).toContain('text/html');
+    });
+  });
+}); 

package/test/integration.test.js

@@ -0,0 +1,152 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { createApp } from '../src/verify-phone-server.js';
+
+describe('SMS Verification API Integration Tests', () => {
+  let app;
+
+  beforeEach(() => {
+    app = createApp(globalThis.env);
+  });
+
+  describe('Authentication Methods', () => {
+    it('should accept both X-API-Key and Bearer token headers', async () => {
+      const phoneNumber = '+1234567890';
+
+      // Test X-API-Key header
+      const req1 = new Request(`http://localhost/api/send-verification?phoneNumber=${encodeURIComponent(phoneNumber)}`, {
+        headers: {
+          'X-API-Key': 'test-api-key'
+        }
+      });
+      const res1 = await app.request(req1, globalThis.env);
+      const data1 = await res1.json();
+
+      expect(res1.status).toBe(200);
+      expect(data1.success).toBe(true);
+
+      // Test Bearer token header
+      const req2 = new Request(`http://localhost/api/send-verification?phoneNumber=${encodeURIComponent(phoneNumber)}`, {
+        headers: {
+          'Authorization': 'Bearer test-api-key'
+        }
+      });
+      const res2 = await app.request(req2, globalThis.env);
+      const data2 = await res2.json();
+
+      expect(res2.status).toBe(200);
+      expect(data2.success).toBe(true);
+    });
+
+    it('should reject requests without authentication', async () => {
+      const phoneNumber = '+1234567890';
+
+      const req = new Request(`http://localhost/api/send-verification?phoneNumber=${encodeURIComponent(phoneNumber)}`);
+      const res = await app.request(req, globalThis.env);
+      const data = await res.json();
+
+      expect(res.status).toBe(401);
+      expect(data.error).toBe('API key required');
+    });
+
+    it('should reject requests with invalid authentication', async () => {
+      const phoneNumber = '+1234567890';
+
+      const req = new Request(`http://localhost/api/send-verification?phoneNumber=${encodeURIComponent(phoneNumber)}`, {
+        headers: {
+          'X-API-Key': 'invalid-key'
+        }
+      });
+      const res = await app.request(req, globalThis.env);
+      const data = await res.json();
+
+      expect(res.status).toBe(401);
+      expect(data.error).toBe('Invalid API key');
+    });
+  });
+
+  describe('Phone Number Formatting', () => {
+    it('should format various phone number formats correctly', async () => {
+      const testCases = [
+        '1234567890',
+        '11234567890',
+        '+1234567890',
+        '(123) 456-7890',
+        '123-456-7890',
+      ];
+
+      for (const phoneNumber of testCases) {
+        const req = new Request(`http://localhost/api/send-verification?phoneNumber=${encodeURIComponent(phoneNumber)}`, {
+          headers: {
+            'X-API-Key': 'test-api-key'
+          }
+        });
+        const res = await app.request(req, globalThis.env);
+        const data = await res.json();
+
+        expect(res.status).toBe(200);
+        expect(data.success).toBe(true);
+      }
+    });
+
+    it('should reject clearly invalid phone numbers', async () => {
+      const invalidNumbers = [
+        'not-a-number',
+        '123',
+        '12345678901234567890', // Too long
+        '+', // Just plus sign
+        'abc123def',
+      ];
+
+      for (const invalidNumber of invalidNumbers) {
+        const req = new Request(`http://localhost/api/send-verification?phoneNumber=${encodeURIComponent(invalidNumber)}`, {
+          headers: {
+            'X-API-Key': 'test-api-key'
+          }
+        });
+        const res = await app.request(req, globalThis.env);
+        const data = await res.json();
+
+        expect(res.status).toBe(400);
+        expect(data.error).toBe('Invalid phone number format');
+      }
+    });
+  });
+
+  describe('API Endpoints', () => {
+    it('should handle send verification endpoint', async () => {
+      const phoneNumber = '+1234567890';
+
+      const req = new Request(`http://localhost/api/send-verification?phoneNumber=${encodeURIComponent(phoneNumber)}`, {
+        headers: {
+          'X-API-Key': 'test-api-key'
+        }
+      });
+      const res = await app.request(req, globalThis.env);
+      const data = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(data).toMatchObject({
+        success: true,
+        message: 'Verification code sent successfully',
+        expiresIn: 600
+      });
+      expect(data.messageId).toBeDefined();
+    });
+
+    it('should handle verify code endpoint', async () => {
+      const phoneNumber = '+1234567890';
+      const code = '123456';
+
+      const req = new Request(`http://localhost/api/verify-code?phoneNumber=${encodeURIComponent(phoneNumber)}&code=${code}`, {
+        headers: {
+          'X-API-Key': 'test-api-key'
+        }
+      });
+      const res = await app.request(req, globalThis.env);
+      const data = await res.json();
+
+      expect(res.status).toBe(400); // Will fail because no code was sent, but endpoint works
+      expect(data.error).toBeDefined();
+    });
+  });
+}); 

package/test/metadata-test.js

@@ -0,0 +1,73 @@
+import { parsePhoneNumber, getNumberType } from 'libphonenumber-js';
+
+// Test the metadata functionality
+console.log('=== Testing libphonenumber-js Metadata Functionality ===\n');
+
+// Test 1: US toll-free number
+console.log('Test 1: US Toll-free number (+1-800-555-0123)');
+try {
+    const phone1 = parsePhoneNumber('+1-800-555-0123');
+    console.log('  Parsed:', phone1 ? 'Success' : 'Failed');
+    console.log('  Valid:', phone1?.isValid());
+    console.log('  Country:', phone1?.country);
+    console.log('  National Number:', phone1?.nationalNumber);
+    console.log('  Non-geographic:', phone1?.isNonGeographic());
+    
+    // Test getNumberType (requires full metadata)
+    try {
+        const type1 = getNumberType('+1-800-555-0123');
+        console.log('  Number Type:', type1);
+    } catch (error) {
+        console.log('  Number Type: Error -', error.message);
+    }
+} catch (error) {
+    console.log('  Parse Error:', error.message);
+}
+
+console.log('\n---\n');
+
+// Test 2: US mobile number
+console.log('Test 2: US Mobile number (+1-555-123-4567)');
+try {
+    const phone2 = parsePhoneNumber('+1-555-123-4567');
+    console.log('  Parsed:', phone2 ? 'Success' : 'Failed');
+    console.log('  Valid:', phone2?.isValid());
+    console.log('  Country:', phone2?.country);
+    console.log('  National Number:', phone2?.nationalNumber);
+    console.log('  Non-geographic:', phone2?.isNonGeographic());
+    
+    try {
+        const type2 = getNumberType('+1-555-123-4567');
+        console.log('  Number Type:', type2);
+    } catch (error) {
+        console.log('  Number Type: Error -', error.message);
+    }
+} catch (error) {
+    console.log('  Parse Error:', error.message);
+}
+
+console.log('\n---\n');
+
+// Test 3: UK number
+console.log('Test 3: UK number (+44 20 7946 0958)');
+try {
+    const phone3 = parsePhoneNumber('+44 20 7946 0958');
+    console.log('  Parsed:', phone3 ? 'Success' : 'Failed');
+    console.log('  Valid:', phone3?.isValid());
+    console.log('  Country:', phone3?.country);
+    console.log('  National Number:', phone3?.nationalNumber);
+    console.log('  Non-geographic:', phone3?.isNonGeographic());
+    
+    try {
+        const type3 = getNumberType('+44 20 7946 0958');
+        console.log('  Number Type:', type3);
+    } catch (error) {
+        console.log('  Number Type: Error -', error.message);
+    }
+} catch (error) {
+    console.log('  Parse Error:', error.message);
+}
+
+console.log('\n=== Metadata Test Complete ===');
+console.log('\nNote: Number type detection may return undefined with minimal metadata.');
+console.log('Use metadataType: "full" for better phone number type detection.');

package/test/server.test.js

@@ -0,0 +1,143 @@
+/**
+ * Test file for the SMS Verification API server
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { Hono } from 'hono';
+import app from '../src/verify-phone-server.js';
+
+describe('SMS Verification API Server', () => {
+  let server;
+
+  beforeAll(() => {
+    server = new Hono();
+    server.route('/', app);
+  });
+
+  afterAll(() => {
+    // Cleanup if needed
+  });
+
+  describe('Health Check Endpoints', () => {
+    it('should return API info on root endpoint', async () => {
+      const res = await server.request('/');
+      const data = await res.json();
+      
+      expect(res.status).toBe(200);
+      expect(data.success).toBe(true);
+      expect(data.message).toBe('SMS Verification API');
+      expect(data.endpoints).toBeDefined();
+    });
+
+    it('should return health status', async () => {
+      const res = await server.request('/health');
+      const data = await res.json();
+      
+      expect(res.status).toBe(200);
+      expect(data.success).toBe(true);
+      expect(data.status).toBe('healthy');
+      expect(data.timestamp).toBeDefined();
+    });
+  });
+
+  describe('API Authentication', () => {
+    it('should require API key for protected endpoints', async () => {
+      const res = await server.request('/api/send', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          phoneNumber: '+1234567890'
+        })
+      });
+      
+      expect(res.status).toBe(401);
+    });
+
+    it('should accept valid API key', async () => {
+      const res = await server.request('/api/send', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-API-Key': 'sms_1234567890abcdef1234567890abcdef'
+        },
+        body: JSON.stringify({
+          phoneNumber: '+1234567890'
+        })
+      });
+      
+      // Should not be 401 (unauthorized) - might be 500 due to missing AWS credentials
+      expect(res.status).not.toBe(401);
+    });
+  });
+
+  describe('Documentation', () => {
+    it('should serve OpenAPI documentation', async () => {
+      const res = await server.request('/docs');
+      expect(res.status).toBe(200);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should return 404 for non-existent endpoints', async () => {
+      const res = await server.request('/nonexistent');
+      const data = await res.json();
+      
+      expect(res.status).toBe(404);
+      expect(data.success).toBe(false);
+      expect(data.error).toBe('Not found');
+    });
+  });
+});
+
+// Example usage functions
+export async function sendVerificationCode(phoneNumber, apiKey) {
+  const response = await fetch('http://localhost:8787/api/send', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'X-API-Key': apiKey
+    },
+    body: JSON.stringify({
+      phoneNumber,
+      blockVoip: true,
+      senderId: 'MyApp'
+    })
+  });
+  
+  return response.json();
+}
+
+export async function verifyCode(phoneNumber, code, apiKey) {
+  const response = await fetch('http://localhost:8787/api/verify', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'X-API-Key': apiKey
+    },
+    body: JSON.stringify({
+      phoneNumber,
+      code
+    })
+  });
+  
+  return response.json();
+}
+
+export async function sendGeneralSMS(phoneNumber, message, apiKey) {
+  const response = await fetch('http://localhost:8787/api/sms', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'X-API-Key': apiKey
+    },
+    body: JSON.stringify({
+      phoneNumber,
+      message,
+      senderId: 'MyApp'
+    })
+  });
+  
+  return response.json();
+} 

package/test/setup.js

@@ -0,0 +1,32 @@
+// Test setup file
+import { beforeAll, afterAll } from 'vitest';
+
+// Set up global environment variables for testing
+globalThis.env = {
+  API_KEY: 'test-api-key',
+  AWS_ACCESS_KEY_ID: 'test-access-key',
+  AWS_SECRET_ACCESS_KEY: 'test-secret-key',
+  AWS_REGION: 'us-east-1',
+  SMS_SENDER_ID: 'TestVerify',
+};
+
+console.log('Test setup - globalThis.env set to:', globalThis.env);
+
+// Global test setup
+beforeAll(() => {
+  // Ensure environment is set
+  if (!globalThis.env) {
+    globalThis.env = {
+      API_KEY: 'test-api-key',
+      AWS_ACCESS_KEY_ID: 'test-access-key',
+      AWS_SECRET_ACCESS_KEY: 'test-secret-key',
+      AWS_REGION: 'us-east-1',
+      SMS_SENDER_ID: 'TestVerify',
+    };
+  }
+  console.log('beforeAll - globalThis.env:', globalThis.env);
+});
+
+afterAll(() => {
+  // Any global cleanup needed
+});