JSON Path Finder

Command-line API testing uses jq parsing JSON responses. JSONPath expressions translate to jq syntax selecting specific fields from complex API responses. Visual JSONPath explorer helps construct correct paths for jq commands.

# API returns nested user data
curl https://api.example.com/users/123 | jq

# Response (simplified):
{
  "data": {
    "user": {
      "id": 123,
      "profile": {
        "name": "Alex Developer",
        "email": "alex@example.com",
        "roles": ["admin", "developer"]
      },
      "settings": {
        "theme": "dark",
        "notifications": true
      }
    }
  }
}

# Extract email using JSONPath → jq syntax
# JSONPath: $.data.user.profile.email
# jq: '.data.user.profile.email'
curl https://api.example.com/users/123 | jq '.data.user.profile.email'
# Output: "alex@example.com"

# Extract all roles (array)
# JSONPath: $.data.user.profile.roles[*]
# jq: '.data.user.profile.roles[]'
curl https://api.example.com/users/123 | jq '.data.user.profile.roles[]'
# Output: "admin"
#         "developer"

# Extract first role
# JSONPath: $.data.user.profile.roles[0]
# jq: '.data.user.profile.roles[0]'
curl https://api.example.com/users/123 | jq '.data.user.profile.roles[0]'
# Output: "admin"

# Use JSONPath explorer to find correct paths
# Paste API response, click fields, copy JSONPath
# Convert to jq syntax for command-line use

Kubernetes manifests and live resources output JSON. kubectl supports JSONPath extracting specific fields from complex resource definitions. Use JSONPath explorer finding paths in example resources, then query production clusters.

# Get pod status using JSONPath
# First, inspect pod JSON structure
kubectl get pod my-pod -o json > pod.json

# Paste into JSONPath explorer finding paths:
# Pod status: $.status.phase
# Container image: $.spec.containers[0].image
# Node name: $.spec.nodeName

# Query live pod with JSONPath
kubectl get pod my-pod -o jsonpath='{.status.phase}'
# Output: Running

# Get all container images in pod
kubectl get pod my-pod -o jsonpath='{.spec.containers[*].image}'
# Output: nginx:1.21 sidecar:latest

# Get pod IPs from all pods
kubectl get pods -o jsonpath='{.items[*].status.podIP}'
# Output: 10.0.1.5 10.0.1.6 10.0.1.7

# Complex query: pod name + status
kubectl get pods -o jsonpath='{range .items[*]}{.metadata.name}{" "}{.status.phase}{"\n"}{end}'
# Output:
# pod-1 Running
# pod-2 Pending
# pod-3 Failed

# JSONPath explorer helps construct these queries
# Explore example resource, find paths, use in kubectl

ETL pipelines transform JSON from source APIs to target database format. JSONPath expressions map source fields to destination without hardcoded traversal. Config-driven transformations using JSONPath specifications.

// Data transformation config using JSONPath
const transformConfig = {
  mappings: [
    {
      source: "$.data.user.profile.email",
      destination: "email",
      type: "string"
    },
    {
      source: "$.data.user.profile.name",
      destination: "full_name",
      type: "string"
    },
    {
      source: "$.data.user.settings.theme",
      destination: "preferences.theme",
      type: "string"
    },
    {
      source: "$.data.user.profile.roles[0]",
      destination: "primary_role",
      type: "string"
    }
  ]
};

// Generic transformer using JSONPath
import jsonpath from 'jsonpath';

function transformData(sourceJSON, config) {
  const result = {};

  config.mappings.forEach(mapping => {
    // Extract value using JSONPath
    const values = jsonpath.query(
      sourceJSON,
      mapping.source
    );

    if (values.length > 0) {
      // Set destination field
      setNestedValue(
        result,
        mapping.destination,
        values[0]
      );
    }
  });

  return result;
}

// Example source data (API response)
const apiResponse = {
  data: {
    user: {
      profile: {
        name: "Alex Developer",
        email: "alex@example.com",
        roles: ["admin", "developer"]
      },
      settings: { theme: "dark" }
    }
  }
};

const transformed = transformData(apiResponse, transformConfig);
// Output:
// {
//   email: "alex@example.com",
//   full_name: "Alex Developer",
//   preferences: { theme: "dark" },
//   primary_role: "admin"
// }

// Config-driven transformation
// Change mappings without modifying code
// JSONPath explorer helps define source paths

Integration tests verify API responses contain expected fields and values. JSONPath expressions select data for assertions checking structure, types, and content. Clean test syntax using declarative path specifications.

// Jest/Mocha API integration test with JSONPath
import jsonpath from 'jsonpath';
import { expect } from 'chai';

describe('User API Tests', () => {
  let response;

  beforeEach(async () => {
    response = await fetch('/api/users/123').then(r => r.json());
  });

  it('should return user email', () => {
    const email = jsonpath.query(
      response,
      '$.data.user.profile.email'
    )[0];

    expect(email).to.equal('alex@example.com');
  });

  it('should return admin role', () => {
    const roles = jsonpath.query(
      response,
      '$.data.user.profile.roles[*]'
    );

    expect(roles).to.include('admin');
  });

  it('should have valid theme setting', () => {
    const theme = jsonpath.query(
      response,
      '$.data.user.settings.theme'
    )[0];

    expect(['light', 'dark', 'auto']).to.include(theme);
  });

  it('should have all required fields', () => {
    const requiredPaths = [
      '$.data.user.id',
      '$.data.user.profile.name',
      '$.data.user.profile.email',
      '$.data.user.settings'
    ];

    requiredPaths.forEach(path => {
      const result = jsonpath.query(response, path);
      expect(result.length).to.be.greaterThan(0,
        `Missing required field: ${path}`
      );
    });
  });
});

// JSONPath makes tests declarative and readable
// Easily verify deeply nested response structure
// Use JSONPath explorer to find test assertion paths