Add backend tests

Author: smessmer

.github/workflows/backend.yml

@@ -28,6 +28,9 @@ jobs:
       - name: Install Dependencies
         working-directory: backend
         run: npm install
+      - name: Run Tests
+        working-directory: backend
+        run: npm test
       - name: Build
         working-directory: backend
         run: ./serverless package --package /tmp/artifacts --stage prod

.gitignore

@@ -7,4 +7,5 @@ jspm_packages
 .serverless
 .webpack
 backend/artifacts
-frontend/next-env.d.ts
+backend/coverage
+frontend/next-env.d.ts

backend/.babelrc

@@ -6,12 +6,26 @@
       {
         "modules": false,
         "targets": {
-          "node": "20",
-        },
+          "node": "20"
+        }
       }
-    ],
+    ]
   ],
   "plugins": [
-    "@babel/plugin-transform-class-properties",
-  ]
-}
+    "@babel/plugin-transform-class-properties"
+  ],
+  "env": {
+    "test": {
+      "presets": [
+        [
+          "@babel/preset-env",
+          {
+            "targets": {
+              "node": "current"
+            }
+          }
+        ]
+      ]
+    }
+  }
+}

backend/README.md

@@ -17,3 +17,10 @@ Deploy one function: $ ./serverless deploy function -f [functionName] [--stage p
 Invoke a remote function: $ ./serverless invoke -f [functionName] -l [--stage prod]
 Display remote logs: $ ./serverless logs -f [functionName] -t [--stage prod]
 Delete remote function: $ ./serverless remove
+
+
+Testing
+-------------
+Run tests: $ npm test
+Run tests in watch mode: $ npm run test:watch
+Run tests with coverage: $ npm run test:coverage

backend/__mocks__/@sendgrid/mail.js

@@ -0,0 +1,9 @@
+const mockSend = jest.fn().mockResolvedValue([{ statusCode: 202 }]);
+const mockSetApiKey = jest.fn();
+
+module.exports = {
+  setApiKey: mockSetApiKey,
+  send: mockSend,
+  __mockSend: mockSend,
+  __mockSetApiKey: mockSetApiKey,
+};

backend/__mocks__/aws-sdk.js

@@ -0,0 +1,24 @@
+const mockGetParameters = jest.fn((params, callback) => {
+  // Default implementation that can be overridden in tests
+  callback(null, { Parameters: [] });
+});
+
+class SSM {
+  constructor() {
+    this.getParameters = mockGetParameters;
+  }
+}
+
+// Reset helper
+const resetMock = () => {
+  mockGetParameters.mockClear();
+  mockGetParameters.mockImplementation((params, callback) => {
+    callback(null, { Parameters: [] });
+  });
+};
+
+module.exports = {
+  SSM,
+  __mockGetParameters: mockGetParameters,
+  __resetMock: resetMock,
+};

backend/__mocks__/mailchimp-api-v3.js

@@ -0,0 +1,18 @@
+const mockGet = jest.fn();
+const mockPost = jest.fn();
+const mockPut = jest.fn();
+
+class MockMailchimp {
+  constructor(apiToken) {
+    this.apiToken = apiToken;
+    this.get = mockGet;
+    this.post = mockPost;
+    this.put = mockPut;
+  }
+}
+
+MockMailchimp.__mockGet = mockGet;
+MockMailchimp.__mockPost = mockPost;
+MockMailchimp.__mockPut = mockPut;
+
+module.exports = MockMailchimp;

backend/cached_value.test.js

@@ -0,0 +1,69 @@
+"use strict";
+
+import CachedValue from './cached_value';
+
+describe('CachedValue', () => {
+  test('creator is called only once on first access', async () => {
+    const creator = jest.fn().mockResolvedValue('test-value');
+    const cached = new CachedValue(creator);
+
+    const result = await cached.get();
+
+    expect(result).toBe('test-value');
+    expect(creator).toHaveBeenCalledTimes(1);
+  });
+
+  test('value is cached for subsequent accesses', async () => {
+    const creator = jest.fn().mockResolvedValue('cached-value');
+    const cached = new CachedValue(creator);
+
+    const result1 = await cached.get();
+    const result2 = await cached.get();
+    const result3 = await cached.get();
+
+    expect(result1).toBe('cached-value');
+    expect(result2).toBe('cached-value');
+    expect(result3).toBe('cached-value');
+    expect(creator).toHaveBeenCalledTimes(1);
+  });
+
+  test('concurrent access calls creator only once', async () => {
+    let callCount = 0;
+    const creator = jest.fn(async () => {
+      callCount++;
+      // Simulate async work
+      await new Promise(resolve => setTimeout(resolve, 10));
+      return `value-${callCount}`;
+    });
+    const cached = new CachedValue(creator);
+
+    // Call get() multiple times concurrently
+    const results = await Promise.all([
+      cached.get(),
+      cached.get(),
+      cached.get(),
+    ]);
+
+    expect(creator).toHaveBeenCalledTimes(1);
+    expect(results).toEqual(['value-1', 'value-1', 'value-1']);
+  });
+
+  test('creator returning different types works correctly', async () => {
+    const objectValue = { foo: 'bar', count: 42 };
+    const creator = jest.fn().mockResolvedValue(objectValue);
+    const cached = new CachedValue(creator);
+
+    const result = await cached.get();
+
+    expect(result).toEqual(objectValue);
+    expect(result).toBe(objectValue); // Same reference
+  });
+
+  test('creator error propagates correctly', async () => {
+    const error = new Error('Creator failed');
+    const creator = jest.fn().mockRejectedValue(error);
+    const cached = new CachedValue(creator);
+
+    await expect(cached.get()).rejects.toThrow('Creator failed');
+  });
+});

backend/contact.test.js

@@ -0,0 +1,128 @@
+"use strict";
+
+jest.mock('./email', () => ({
+  email_myself: jest.fn().mockResolvedValue(undefined),
+}));
+
+import { send } from './contact';
+import { email_myself } from './email';
+
+describe('contact send', () => {
+  const validToken = 'fd0kAn1zns';
+
+  beforeEach(() => {
+    email_myself.mockClear();
+  });
+
+  test('sends contact email with sender email in subject', async () => {
+    const event = {
+      body: JSON.stringify({
+        token: validToken,
+        email: 'visitor@example.com',
+        message: 'Hello, I have a question.',
+      }),
+    };
+
+    const result = await send(event, {});
+
+    expect(result.statusCode).toBe(200);
+    expect(JSON.parse(result.body)).toEqual({ success: true });
+    expect(email_myself).toHaveBeenCalledWith(
+      'CryFS Contact Form',
+      'CryFS Contact Form  (from visitor@example.com)',
+      'Hello, I have a question.',
+      'visitor@example.com'
+    );
+  });
+
+  test('shows "(from unknown)" when email is empty string', async () => {
+    const event = {
+      body: JSON.stringify({
+        token: validToken,
+        email: '',
+        message: 'Anonymous message',
+      }),
+    };
+
+    const result = await send(event, {});
+
+    expect(result.statusCode).toBe(200);
+    expect(email_myself).toHaveBeenCalledWith(
+      'CryFS Contact Form',
+      'CryFS Contact Form  (from unknown)',
+      'Anonymous message',
+      ''
+    );
+  });
+
+  test('handles undefined email', async () => {
+    const event = {
+      body: JSON.stringify({
+        token: validToken,
+        message: 'Message without email',
+      }),
+    };
+
+    const result = await send(event, {});
+
+    expect(result.statusCode).toBe(200);
+    // When email is undefined, it's passed as undefined to do_send
+    expect(email_myself).toHaveBeenCalledWith(
+      'CryFS Contact Form',
+      expect.stringContaining('CryFS Contact Form'),
+      'Message without email',
+      undefined
+    );
+  });
+
+  test('returns 200 on success', async () => {
+    const event = {
+      body: JSON.stringify({
+        token: validToken,
+        email: 'test@test.com',
+        message: 'Test message',
+      }),
+    };
+
+    const result = await send(event, {});
+
+    expect(result.statusCode).toBe(200);
+    expect(JSON.parse(result.body)).toEqual({ success: true });
+  });
+
+  test('includes CORS headers in response', async () => {
+    const event = {
+      body: JSON.stringify({
+        token: validToken,
+        email: 'test@test.com',
+        message: 'Test message',
+      }),
+    };
+
+    const result = await send(event, {});
+
+    expect(result.headers).toEqual({
+      'Access-Control-Allow-Origin': 'https://www.cryfs.org',
+      'Access-Control-Allow-Credentials': false,
+      'Vary': 'Origin',
+    });
+  });
+
+  test('rejects invalid token', async () => {
+    const event = {
+      body: JSON.stringify({
+        token: 'invalid-token',
+        email: 'test@test.com',
+        message: 'Test message',
+      }),
+    };
+
+    const result = await send(event, {});
+
+    expect(result.statusCode).toBe(400);
+    expect(JSON.parse(result.body)).toEqual({
+      success: false,
+      error: 'Wrong token',
+    });
+  });
+});

backend/email.test.js

@@ -0,0 +1,72 @@
+"use strict";
+
+jest.mock('@sendgrid/mail');
+jest.mock('./secret', () => jest.fn().mockResolvedValue('test-sendgrid-key'));
+
+describe('email_myself', () => {
+  let sendgrid;
+  let email_myself;
+
+  beforeEach(() => {
+    jest.resetModules();
+    sendgrid = require('@sendgrid/mail');
+    sendgrid.__mockSend.mockClear();
+    sendgrid.__mockSetApiKey.mockClear();
+    email_myself = require('./email').email_myself;
+  });
+
+  test('sends email with correct payload', async () => {
+    await email_myself('Test Sender', 'Test Subject', 'Test message body');
+
+    expect(sendgrid.setApiKey).toHaveBeenCalledWith('test-sendgrid-key');
+    expect(sendgrid.send).toHaveBeenCalledWith({
+      to: 'messmer@cryfs.org',
+      from: {
+        email: 'messmer@cryfs.org',
+        name: 'Test Sender',
+      },
+      subject: 'Test Subject',
+      text: 'Test message body',
+    });
+  });
+
+  test('includes reply_to when provided', async () => {
+    await email_myself('Sender', 'Subject', 'Message', 'reply@example.com');
+
+    expect(sendgrid.send).toHaveBeenCalledWith({
+      to: 'messmer@cryfs.org',
+      from: {
+        email: 'messmer@cryfs.org',
+        name: 'Sender',
+      },
+      subject: 'Subject',
+      text: 'Message',
+      reply_to: 'reply@example.com',
+    });
+  });
+
+  test('excludes reply_to when undefined', async () => {
+    await email_myself('Sender', 'Subject', 'Message', undefined);
+
+    const callArgs = sendgrid.send.mock.calls[0][0];
+    expect(callArgs).not.toHaveProperty('reply_to');
+  });
+
+  test('excludes reply_to when empty string', async () => {
+    await email_myself('Sender', 'Subject', 'Message', '');
+
+    const callArgs = sendgrid.send.mock.calls[0][0];
+    expect(callArgs).not.toHaveProperty('reply_to');
+  });
+
+  test('caches SendGrid instance across calls', async () => {
+    // Within this single test, make multiple calls
+    await email_myself('Sender1', 'Subject1', 'Message1');
+    await email_myself('Sender2', 'Subject2', 'Message2');
+    await email_myself('Sender3', 'Subject3', 'Message3');
+
+    // setApiKey should only be called once due to CachedValue
+    expect(sendgrid.setApiKey).toHaveBeenCalledTimes(1);
+    expect(sendgrid.send).toHaveBeenCalledTimes(3);
+  });
+});