Testing

Azure Functions Testing Strategies

HelpMeTest

HelpMeTest

— 6 min read
Azure Functions Testing Strategies

Azure Functions testing has a specific challenge that Lambda doesn't: the binding system. Azure Functions uses input/output bindings to connect triggers (HTTP, Queue, Timer) to your function code, and the binding infrastructure is part of the runtime — not something you can easily swap out in unit tests.

The solution is dependency injection and binding abstraction. This guide covers how to structure Azure Functions for testability and what to test at each layer.

The Testability Problem with Azure Functions

An unstructured Azure Function looks like this:

// Hard to test — bindings are injected by the runtime
export default async function (context: Context, req: HttpRequest): Promise<void> {
  const userId = req.params.userId;
  
  const user = await database.getUser(userId); // Hard dependency
  
  if (!user) {
    context.res = { status: 404, body: 'Not found' };
    return;
  }
  
  context.res = { status: 200, body: user };
  context.bindings.outputBlob = JSON.stringify(user); // Output binding
}

The context object is created by the Azure Functions runtime. In tests, you'd need to mock it perfectly to avoid undefined access errors. The database dependency is also hard-coded.

The fix: extract business logic into a pure, dependency-injectable service:

// user.service.ts — testable
export interface UserRepository {
  getUser(id: string): Promise<User | null>;
}

export async function getUserById(
  userId: string,
  repo: UserRepository
): Promise<{ status: number; body: unknown }> {
  if (!userId) {
    return { status: 400, body: { error: 'Missing userId' } };
  }
  
  const user = await repo.getUser(userId);
  
  if (!user) {
    return { status: 404, body: { error: 'Not found' } };
  }
  
  return { status: 200, body: user };
}

// function.ts — thin adapter
import { getUserById } from './user.service';
import { createDatabaseRepository } from './database.repository';

export default async function (context: Context, req: HttpRequest): Promise<void> {
  const repo = createDatabaseRepository(process.env.CONNECTION_STRING);
  const result = await getUserById(req.params.userId, repo);
  context.res = result;
}

Now getUserById is a pure function you can test without any Azure infrastructure.

Unit Testing the Service Layer

// user.service.test.ts
import { getUserById, UserRepository } from './user.service';

const mockRepo: UserRepository = {
  getUser: jest.fn(),
};

describe('getUserById', () => {
  beforeEach(() => jest.clearAllMocks());
  
  test('returns 400 when userId is empty', async () => {
    const result = await getUserById('', mockRepo);
    expect(result.status).toBe(400);
    expect((result.body as any).error).toBe('Missing userId');
  });
  
  test('returns 404 when user not found', async () => {
    (mockRepo.getUser as jest.Mock).mockResolvedValue(null);
    
    const result = await getUserById('unknown-user', mockRepo);
    expect(result.status).toBe(404);
  });
  
  test('returns 200 with user data when found', async () => {
    const user = { id: 'user-1', email: 'test@example.com' };
    (mockRepo.getUser as jest.Mock).mockResolvedValue(user);
    
    const result = await getUserById('user-1', mockRepo);
    expect(result.status).toBe(200);
    expect(result.body).toEqual(user);
  });
  
  test('propagates repository errors', async () => {
    (mockRepo.getUser as jest.Mock).mockRejectedValue(new Error('DB timeout'));
    
    await expect(getUserById('user-1', mockRepo)).rejects.toThrow('DB timeout');
  });
});

Mocking the Context Object

For tests that need the context object directly:

// test/helpers/mock-context.ts
import { Context } from '@azure/functions';

export function createMockContext(overrides?: Partial<Context>): Context {
  return {
    log: Object.assign(jest.fn(), {
      info: jest.fn(),
      warn: jest.fn(),
      error: jest.fn(),
      verbose: jest.fn(),
    }),
    res: undefined,
    bindings: {},
    bindingData: {},
    bindingDefinitions: [],
    executionContext: {
      invocationId: 'test-invocation-id',
      functionName: 'TestFunction',
      functionDirectory: '/functions/TestFunction',
      retryContext: null,
    },
    traceContext: {
      traceparent: '00-test',
      tracestate: '',
      attributes: {},
    },
    done: jest.fn(),
    ...overrides,
  } as unknown as Context;
}
// Testing the function adapter directly
import { default as handler } from './function';
import { createMockContext } from '../test/helpers/mock-context';

test('function sets response from service result', async () => {
  const context = createMockContext();
  const req = {
    params: { userId: 'user-1' },
    headers: {},
    method: 'GET',
    url: 'http://localhost/api/users/user-1',
    query: {},
    body: undefined,
  } as any;
  
  await handler(context, req);
  
  expect(context.res).toBeDefined();
  expect(context.res!.status).toBe(200);
});

Integration Testing with Azure Functions Core Tools

For integration tests that run your function in the actual Azure Functions runtime locally:

# Install Core Tools
npm install -g azure-functions-core-tools@4

# Start functions locally
func start --port 7071
// integration/functions.test.ts
import fetch from 'node-fetch';

const BASE_URL = 'http://localhost:7071/api';

describe('Azure Functions integration', () => {
  // Start func host in beforeAll if running in CI
  // For local dev, assume it's already running
  
  test('GET /users/:id returns user', async () => {
    const response = await fetch(`${BASE_URL}/users/test-user`);
    expect(response.status).toBe(200);
    
    const data = await response.json();
    expect(data.id).toBe('test-user');
  });
  
  test('GET /users/:id returns 404 for unknown user', async () => {
    const response = await fetch(`${BASE_URL}/users/absolutely-does-not-exist`);
    expect(response.status).toBe(404);
  });
  
  test('function handles malformed request body', async () => {
    const response = await fetch(`${BASE_URL}/users`, {
      method: 'POST',
      body: 'not json at all{{{',
      headers: { 'Content-Type': 'application/json' },
    });
    expect(response.status).toBe(400);
  });
});

Automating Core Tools Startup

// jest.setup.js
const { spawn } = require('child_process');

let funcProcess;

module.exports = async () => {
  funcProcess = spawn('func', ['start', '--port', '7071'], {
    cwd: process.cwd(),
    stdio: 'pipe',
  });
  
  await new Promise((resolve, reject) => {
    const timeout = setTimeout(() => reject(new Error('func start timeout')), 30000);
    
    funcProcess.stdout.on('data', (data) => {
      if (data.toString().includes('Host started')) {
        clearTimeout(timeout);
        resolve();
      }
    });
    
    funcProcess.stderr.on('data', (data) => {
      if (data.toString().includes('error')) {
        reject(new Error(data.toString()));
      }
    });
  });
  
  global.__funcProcess = funcProcess;
};

Testing Different Trigger Types

Queue Trigger Testing

Queue triggers receive messages from Azure Storage Queue or Service Bus. Test the message processing logic:

// queue-processor.ts
export async function processOrderMessage(
  message: { orderId: string; items: Array<{ id: string; qty: number }> },
  orderService: OrderService
): Promise<void> {
  if (!message.orderId) {
    throw new Error('Invalid message: missing orderId');
  }
  
  await orderService.processOrder(message.orderId, message.items);
}

// queue-processor.test.ts
test('throws on message without orderId', async () => {
  const mockService = { processOrder: jest.fn() };
  
  await expect(
    processOrderMessage({ orderId: '', items: [] }, mockService)
  ).rejects.toThrow('Invalid message');
  
  expect(mockService.processOrder).not.toHaveBeenCalled();
});

test('processes valid message', async () => {
  const mockService = { processOrder: jest.fn().mockResolvedValue(undefined) };
  const message = { orderId: 'order-1', items: [{ id: 'item-1', qty: 2 }] };
  
  await processOrderMessage(message, mockService);
  
  expect(mockService.processOrder).toHaveBeenCalledWith('order-1', message.items);
});

Timer Trigger Testing

Timer triggers run on a schedule. Test the scheduled logic independently:

// data-cleanup.ts
export async function cleanupExpiredSessions(
  cutoffDate: Date,
  sessionRepo: SessionRepository
): Promise<{ deleted: number }> {
  const expired = await sessionRepo.findExpired(cutoffDate);
  await sessionRepo.deleteMany(expired.map(s => s.id));
  return { deleted: expired.length };
}

// data-cleanup.test.ts
test('deletes all sessions before cutoff date', async () => {
  const mockRepo = {
    findExpired: jest.fn().mockResolvedValue([
      { id: 'session-1' },
      { id: 'session-2' },
    ]),
    deleteMany: jest.fn().mockResolvedValue(undefined),
  };
  
  const cutoff = new Date('2024-01-01');
  const result = await cleanupExpiredSessions(cutoff, mockRepo);
  
  expect(result.deleted).toBe(2);
  expect(mockRepo.deleteMany).toHaveBeenCalledWith(['session-1', 'session-2']);
});

test('returns 0 when no expired sessions', async () => {
  const mockRepo = {
    findExpired: jest.fn().mockResolvedValue([]),
    deleteMany: jest.fn(),
  };
  
  const result = await cleanupExpiredSessions(new Date(), mockRepo);
  
  expect(result.deleted).toBe(0);
  expect(mockRepo.deleteMany).not.toHaveBeenCalled();
});

Testing Output Bindings

Output bindings (writing to Blob Storage, queues, etc.) are set via the context.bindings object. Test that your function sets them correctly:

test('writes processed result to output blob binding', async () => {
  const context = createMockContext();
  const req = createMockRequest({ params: { orderId: 'order-1' } });
  
  await handler(context, req);
  
  // Verify output binding was set
  expect(context.bindings.outputBlob).toBeDefined();
  const output = JSON.parse(context.bindings.outputBlob);
  expect(output.orderId).toBe('order-1');
  expect(output.processedAt).toBeDefined();
});

Continuous Monitoring with HelpMeTest

Azure Functions need production monitoring beyond what integration tests provide. Functions can silently fail, cold start times can spike after deployments, or queue backlogs can grow unnoticed.

*** Test Cases ***
Azure Function HTTP Trigger Health Check
    [Documentation]    Monitor deployed Azure Function endpoint
    ${response}=    GET    https://myfunctions.azurewebsites.net/api/health
    ...    headers=x-functions-key=${FUNCTION_KEY}
    Status Code Should Be    ${response}    200
    Response Time Should Be Under    2s
    ${body}=    Parse JSON    ${response.body}
    Should Be Equal    ${body}[status]    healthy

Run this every 2 minutes. Azure Functions cold starts after 20+ minutes of inactivity can push response times to 5–10 seconds. Monitor response time to catch cold start regressions and scale-out issues before users encounter them.

Testing Azure Functions with Managed Identity

In production, functions use Managed Identity instead of connection strings. Test the authentication setup:

test('function accepts requests using managed identity credentials', async () => {
  // In CI, use service principal credentials via environment variables
  // In production, managed identity is automatic
  process.env.AZURE_CLIENT_ID = process.env.TEST_CLIENT_ID;
  process.env.AZURE_CLIENT_SECRET = process.env.TEST_CLIENT_SECRET;
  process.env.AZURE_TENANT_ID = process.env.TEST_TENANT_ID;
  
  const response = await fetch(`${BASE_URL}/secured-endpoint`);
  expect(response.status).toBe(200);
});

What to Test

For every Azure Function:

  1. Service layer unit tests: cover all branches in business logic
  2. Context mock tests: verify bindings and response are set correctly
  3. Integration tests: run against Core Tools for HTTP triggers
  4. Queue/Timer trigger tests: unit test processing logic with mocked repositories
  5. Error handling: missing input, downstream failures, malformed data
  6. Output bindings: verify all bindings are populated correctly
  7. Environment configuration: function behavior changes based on settings

The service layer is where your tests give the most value. Keep function adapters thin — if your business logic is in the function file itself, refactor it out before writing tests.

Read more

Start now free