FileMock-generated files are perfect for testing file upload APIs. This guide shows you how to integrate FileMock files with popular API testing tools for comprehensive endpoint validation.

Why FileMock for API Testing?

Consistent Test Data: Generate identical test files across environments

Realistic Scenarios: Test with real file sizes and formats

Edge Case Coverage: Create specific files for error conditions

Client-Side Generation: Files generated in your browser, no external dependencies

Postman Integration

Step 1: Generate FileMock Test Files

Create a comprehensive test file collection:

# API Testing File Collection
filemock-api-valid-small-100kb.jpg      # Happy path testing
filemock-api-valid-medium-1mb.pdf       # Standard size testing
filemock-api-valid-large-5mb.mp4        # Large file testing
filemock-api-oversized-20mb.jpg         # Size limit testing
filemock-api-invalid-format.txt         # Format validation testing
filemock-api-corrupted-file.jpg         # Error handling testing
filemock-api-empty-file-0kb.txt         # Edge case testing

Step 2: Postman Collection Setup

Create New Collection:

{
  "info": {
    "name": "File Upload API Tests - FileMock",
    "description": "API testing using FileMock generated files"
  },
  "variable": [
    {
      "key": "baseUrl",
      "value": "{{API_BASE_URL}}",
      "type": "string"
    },
    {
      "key": "filemockPath",
      "value": "/path/to/filemock-files",
      "type": "string"
    }
  ]
}

Step 3: File Upload Test Requests

Valid File Upload Test:

// Pre-request Script
pm.test("Setup FileMock file path", function () {
    const filePath = pm.variables.get("filemockPath") + "/filemock-api-valid-small-100kb.jpg";
    pm.variables.set("testFilePath", filePath);
});

// Request Configuration
POST {{baseUrl}}/api/upload
Content-Type: multipart/form-data

// Form Data:
file: {{testFilePath}}
metadata: {"purpose": "api-testing", "source": "filemock"}

// Tests Script
pm.test("Valid file upload succeeds", function () {
    pm.response.to.have.status(200);

    const jsonData = pm.response.json();
    pm.expect(jsonData.success).to.be.true;
    pm.expect(jsonData.file.size).to.be.above(90000); // ~100KB
    pm.expect(jsonData.file.type).to.eql("image/jpeg");
});

pm.test("Response time is acceptable", function () {
    pm.expect(pm.response.responseTime).to.be.below(5000);
});

File Size Validation Test:

// Pre-request Script
pm.test("Setup oversized FileMock file", function () {
    const filePath = pm.variables.get("filemockPath") + "/filemock-api-oversized-20mb.jpg";
    pm.variables.set("testFilePath", filePath);
});

// Request Configuration
POST {{baseUrl}}/api/upload
Content-Type: multipart/form-data

// Form Data:
file: {{testFilePath}}

// Tests Script
pm.test("Oversized file is rejected", function () {
    pm.response.to.have.status(413); // Payload Too Large

    const jsonData = pm.response.json();
    pm.expect(jsonData.error).to.include("file too large");
    pm.expect(jsonData.maxSize).to.exist;
});

Step 4: Automated Test Runner

Environment Variables:

{
  "API_BASE_URL": "https://api.yourapp.com",
  "FILEMOCK_FILES_PATH": "/Users/yourname/project/tests/filemock-files"
}

Collection Runner Configuration:

// Newman (Postman CLI) command
newman run FileMock-API-Tests.postman_collection.json \
  --environment production.postman_environment.json \
  --reporters html,json \
  --reporter-html-export api-test-results.html

Insomnia Integration

Environment Setup

{
  "base_url": "https://api.yourapp.com",
  "filemock_files": "/path/to/filemock-files"
}

Request Templates

Multi-file Upload Test:

POST {{ _.base_url }}/api/upload/multiple
Content-Type: multipart/form-data

--boundary
Content-Disposition: form-data; name="files"; filename="filemock-api-valid-small-100kb.jpg"
Content-Type: image/jpeg

< {{ _.filemock_files }}/filemock-api-valid-small-100kb.jpg

--boundary
Content-Disposition: form-data; name="files"; filename="filemock-api-valid-medium-1mb.pdf"
Content-Type: application/pdf

< {{ _.filemock_files }}/filemock-api-valid-medium-1mb.pdf

--boundary--

Content-Type Validation:

POST {{ _.base_url }}/api/upload
Content-Type: multipart/form-data

# Test with file that has wrong content-type
--boundary
Content-Disposition: form-data; name="file"; filename="filemock-api-invalid-format.txt"
Content-Type: image/jpeg

< {{ _.filemock_files }}/filemock-api-invalid-format.txt
--boundary--

cURL Integration

Basic Upload Testing

#!/bin/bash

# FileMock API Testing Script
FILEMOCK_FILES_PATH="/path/to/filemock-files"
API_BASE_URL="https://api.yourapp.com"

# Test 1: Valid file upload
echo "Testing valid file upload..."
curl -X POST \
  -F "file=@${FILEMOCK_FILES_PATH}/filemock-api-valid-small-100kb.jpg" \
  -F "metadata={\"source\":\"filemock-test\"}" \
  "${API_BASE_URL}/api/upload" \
  -w "\nStatus: %{http_code}\nTime: %{time_total}s\n"

# Test 2: Oversized file
echo "Testing oversized file rejection..."
curl -X POST \
  -F "file=@${FILEMOCK_FILES_PATH}/filemock-api-oversized-20mb.jpg" \
  "${API_BASE_URL}/api/upload" \
  -w "\nStatus: %{http_code}\n"

# Test 3: Invalid format
echo "Testing invalid format rejection..."
curl -X POST \
  -F "file=@${FILEMOCK_FILES_PATH}/filemock-api-invalid-format.txt" \
  "${API_BASE_URL}/api/upload" \
  -w "\nStatus: %{http_code}\n"

Performance Testing Script

#!/bin/bash

# FileMock Performance Testing
CONCURRENT_UPLOADS=10
FILEMOCK_FILES_PATH="/path/to/filemock-files"

# Function to upload file
upload_file() {
  local file_path=$1
  local upload_id=$2

  curl -X POST \
    -F "file=@${file_path}" \
    -F "uploadId=${upload_id}" \
    "${API_BASE_URL}/api/upload" \
    -s -w "%{http_code},%{time_total}" \
    -o /dev/null
}

# Concurrent uploads test
echo "Starting concurrent upload test..."
for i in $(seq 1 $CONCURRENT_UPLOADS); do
  upload_file "${FILEMOCK_FILES_PATH}/filemock-api-valid-medium-1mb.pdf" $i &
done

wait
echo "All uploads completed"

REST Client (VS Code) Integration

.http File Templates

### Variables
@baseUrl = https://api.yourapp.com
@filemockPath = /Users/yourname/project/tests/filemock-files

### Test 1: Valid Image Upload
POST {{baseUrl}}/api/upload
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW

------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="file"; filename="filemock-api-valid-small-100kb.jpg"
Content-Type: image/jpeg

< {{filemockPath}}/filemock-api-valid-small-100kb.jpg
------WebKitFormBoundary7MA4YWxkTrZu0gW--

### Test 2: Document Upload
POST {{baseUrl}}/api/upload
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW

------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="file"; filename="filemock-api-valid-medium-1mb.pdf"
Content-Type: application/pdf

< {{filemockPath}}/filemock-api-valid-medium-1mb.pdf
------WebKitFormBoundary7MA4YWxkTrZu0gW--

### Test 3: Oversized File (Should Fail)
POST {{baseUrl}}/api/upload
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW

------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="file"; filename="filemock-api-oversized-20mb.jpg"
Content-Type: image/jpeg

< {{filemockPath}}/filemock-api-oversized-20mb.jpg
------WebKitFormBoundary7MA4YWxkTrZu0gW--

CI/CD Integration

GitHub Actions Example

name: API Tests with FileMock

on: [push, pull_request]

jobs:
  api-tests:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3

      - name: Generate FileMock test files
        run: |
          # In a real scenario, you'd download pre-generated FileMock files
          mkdir -p tests/filemock-files
          # Copy your FileMock generated files here

      - name: Run API tests with Newman
        run: |
          npm install -g newman
          newman run postman/FileMock-API-Tests.postman_collection.json \
            --environment postman/test.postman_environment.json \
            --reporters json \
            --reporter-json-export test-results.json

      - name: Upload test results
        uses: actions/upload-artifact@v3
        if: always()
        with:
          name: api-test-results
          path: test-results.json

Advanced Testing Scenarios

Authentication Testing

// Postman Pre-request Script for Auth + FileMock
pm.test("Get auth token", function () {
    pm.sendRequest({
        url: pm.variables.get("baseUrl") + "/auth/login",
        method: 'POST',
        header: {
            'Content-Type': 'application/json',
        },
        body: {
            mode: 'raw',
            raw: JSON.stringify({
                username: pm.environment.get("username"),
                password: pm.environment.get("password")
            })
        }
    }, function (err, response) {
        if (response.code === 200) {
            const token = response.json().token;
            pm.variables.set("authToken", token);
        }
    });
});

// Upload request with auth
POST {{baseUrl}}/api/protected/upload
Authorization: Bearer {{authToken}}
Content-Type: multipart/form-data

file: {{filemockPath}}/filemock-api-valid-small-100kb.jpg

Error Scenario Testing

### Test malformed file
POST {{baseUrl}}/api/upload
Content-Type: multipart/form-data

file: {{filemockPath}}/filemock-api-corrupted-file.jpg

### Test virus scanning (if implemented)
POST {{baseUrl}}/api/upload
Content-Type: multipart/form-data

file: {{filemockPath}}/filemock-api-suspicious-file.exe

### Test empty file handling
POST {{baseUrl}}/api/upload
Content-Type: multipart/form-data

file: {{filemockPath}}/filemock-api-empty-file-0kb.txt

Monitoring & Metrics

Response Time Tracking

// Postman test for performance monitoring
pm.test("Upload performance is acceptable", function () {
  const responseTime = pm.response.responseTime;
  const fileSize = pm.variables.get("expectedFileSize");

  // Calculate acceptable response time based on file size
  const maxTime = Math.max(1000, fileSize / 1000); // 1ms per KB, min 1s

  pm.expect(responseTime).to.be.below(maxTime);

  // Log metrics for monitoring
  console.log(`File: ${pm.variables.get("testFileName")}`);
  console.log(`Size: ${fileSize} bytes`);
  console.log(`Response Time: ${responseTime}ms`);
  console.log(`Rate: ${(((fileSize / responseTime) * 1000) / 1024).toFixed(2)} KB/s`);
});

FileMock provides the perfect foundation for comprehensive API testing with realistic, reproducible test files that cover all your upload scenarios and edge cases.

FileMock

FileMock API Testing: Postman & REST Client Integration