API Development: Testing and Debugging JSON Responses

# GET request
curl https://api.example.com/users

# POST with JSON data
curl -X POST https://api.example.com/users \
  -H "Content-Type: application/json" \
  -d '{"name":"John","email":"[email protected]"}'

# With authentication
curl -H "Authorization: Bearer TOKEN" \
  https://api.example.com/users/1

# Pretty print JSON response
curl https://api.example.com/users | jq

# Save response
curl -o response.json https://api.example.com/users

# Include headers in output
curl -i https://api.example.com/users

# GET request (simpler syntax)
http https://api.example.com/users

# POST with JSON
http POST https://api.example.com/users name=John [email protected]

# With authentication
http https://api.example.com/users/1 Authorization:"Bearer TOKEN"

# Form data
http --form POST https://api.example.com/upload [email protected]

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "required": ["id", "name", "email"],
  "properties": {
    "id": {
      "type": "integer",
      "minimum": 1
    },
    "name": {
      "type": "string",
      "minLength": 1
    },
    "email": {
      "type": "string",
      "format": "email"
    },
    "age": {
      "type": "integer",
      "minimum": 0,
      "maximum": 150
    }
  }
}

const Ajv = require('ajv');
const ajv = new Ajv();

const schema = {
  type: 'object',
  required: ['id', 'name', 'email'],
  properties: {
    id: { type: 'integer' },
    name: { type: 'string' },
    email: { type: 'string', format: 'email' }
  }
};

const validate = ajv.compile(schema);

// Test valid data
const data = { id: 1, name: 'John', email: '[email protected]' };
const valid = validate(data);

if (!valid) {
  console.log('Validation errors:', validate.errors);
}

from jsonschema import validate, ValidationError

schema = {
    "type": "object",
    "required": ["id", "name", "email"],
    "properties": {
        "id": {"type": "integer"},
        "name": {"type": "string"},
        "email": {"type": "string", "format": "email"}
    }
}

data = {"id": 1, "name": "John", "email": "[email protected]"}

try:
    validate(instance=data, schema=schema)
    print("Valid JSON!")
except ValidationError as e:
    print(f"Validation error: {e.message}")

describe('API Tests', () => {
  test('GET /users returns array', async () => {
    const response = await fetch('https://api.example.com/users');
    const data = await response.json();

    expect(response.status).toBe(200);
    expect(Array.isArray(data)).toBe(true);
  });

  test('POST /users creates user', async () => {
    const newUser = { name: 'John', email: '[email protected]' };

    const response = await fetch('https://api.example.com/users', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(newUser)
    });

    expect(response.status).toBe(201);
    const data = await response.json();
    expect(data).toHaveProperty('id');
    expect(data.name).toBe('John');
  });
});

import pytest
import requests

BASE_URL = "https://api.example.com"

def test_get_users():
    response = requests.get(f"{BASE_URL}/users")
    assert response.status_code == 200
    assert isinstance(response.json(), list)

def test_create_user():
    new_user = {"name": "John", "email": "[email protected]"}
    response = requests.post(
        f"{BASE_URL}/users",
        json=new_user
    )
    assert response.status_code == 201
    data = response.json()
    assert "id" in data
    assert data["name"] == "John"

// Postman test script
pm.test("Status code is 200", function () {
    pm.response.to.have.status(200);
});

pm.test("Response is JSON", function () {
    pm.response.to.be.json;
});

pm.test("Response has required fields", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData).to.have.property('id');
    pm.expect(jsonData).to.have.property('name');
    pm.expect(jsonData).to.have.property('email');
});

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

// Common JSON syntax errors and fixes

// ❌ Trailing comma
const bad = { "name": "John", "age": 30, };

// ✅ Fixed
const good = { "name": "John", "age": 30 };

// ❌ Single quotes
const bad2 = { 'name': 'John' };

// ✅ Fixed
const good2 = { "name": "John" };

// Validate JSON
try {
    JSON.parse(response);
} catch (error) {
    console.error("Invalid JSON:", error.message);
}

// Wrong Content-Type causes parsing issues

// ❌ Wrong: Server sends text/html instead of application/json
fetch('/api/users')
  .then(res => res.json())  // Fails if Content-Type is wrong
  .then(data => console.log(data));

// ✅ Check Content-Type before parsing
fetch('/api/users')
  .then(res => {
    const contentType = res.headers.get('content-type');
    if (contentType && contentType.includes('application/json')) {
      return res.json();
    }
    throw new Error('Response is not JSON');
  })
  .then(data => console.log(data));

// CORS issue in browser console:
// "Access to fetch at 'https://api.example.com' has been blocked by CORS policy"

// Server-side fix (Express.js):
const express = require('express');
const cors = require('cors');
const app = express();

// Enable CORS for all origins
app.use(cors());

// Or specific origin
app.use(cors({
  origin: 'https://example.com',
  credentials: true
}));

// Or manual headers
app.use((req, res, next) => {
  res.header('Access-Control-Allow-Origin', '*');
  res.header('Access-Control-Allow-Methods', 'GET,POST,PUT,DELETE');
  res.header('Access-Control-Allow-Headers', 'Content-Type,Authorization');
  next();
});

// Validate response structure
function validateUserResponse(data) {
  const errors = [];

  if (typeof data.id !== 'number') {
    errors.push('id must be a number');
  }

  if (typeof data.name !== 'string' || data.name.length === 0) {
    errors.push('name must be a non-empty string');
  }

  if (!data.email || !data.email.includes('@')) {
    errors.push('email must be a valid email address');
  }

  return {
    valid: errors.length === 0,
    errors
  };
}

// Usage
const response = await fetch('/api/users/1').then(r => r.json());
const validation = validateUserResponse(response);

if (!validation.valid) {
  console.error('Invalid response:', validation.errors);
}