HTTP Server Mocking

/**
 * @typedef {Object} ServerConfig
 * @property {boolean} [autoRespond] - Automatically respond to requests after a delay
 * @property {number} [autoRespondAfter] - Delay in milliseconds for auto-response (default: 10)
 * @property {boolean} [respondImmediately] - Respond to requests immediately when received
 * @property {boolean} [fakeHTTPMethods] - Enable HTTP method override via _method parameter
 * @property {function(string): void} [logger] - Custom logging function
 * @property {boolean} [unsafeHeadersEnabled] - Allow setting unsafe headers
 */

/**
 * Create a new fake server instance
 * @param {ServerConfig} [config] - Optional configuration object
 * @returns {FakeServer} FakeServer instance
 */
function create(config) {
  // Implementation
}

const nise = require("nise");

const server = nise.fakeServer.create({
  autoRespond: true,
  autoRespondAfter: 100
});

/**
 * @typedef {string|Array|Function} ResponseBody - Response body (string, array, or function)
 */

/**
 * Configure response for matching requests
 * @param {string|null} method - HTTP method (GET, POST, etc.) or null for any method
 * @param {string|RegExp|Function|null} url - URL pattern (string, RegExp, or function) or null for any URL
 * @param {ResponseBody} body - Response body (string, array, or function)
 * @returns {void}
 */
respondWith(method, url, body) {
  // Implementation
}

/**
 * Configure response for URL pattern (any method)
 * @param {string|RegExp|Function} url - URL pattern
 * @param {ResponseBody} body - Response body
 * @returns {void}
 */
respondWith(url, body) {
  // Implementation
}

/**
 * Set default response for all requests
 * @param {ResponseBody} body - Response body
 * @returns {void}
 */
respondWith(body) {
  // Implementation
}

// Method and URL specific
server.respondWith("GET", "/api/users", [
  200,
  { "Content-Type": "application/json" },
  JSON.stringify([{ id: 1, name: "Alice" }])
]);

// URL pattern matching with RegExp
server.respondWith("GET", /\/api\/users\/\d+/, [
  200,
  { "Content-Type": "application/json" },
  JSON.stringify({ id: 1, name: "Alice" })
]);

// Function-based responses
server.respondWith("POST", "/api/users", function(request) {
  const userData = JSON.parse(request.requestBody);
  return [201, { "Content-Type": "application/json" }, JSON.stringify({
    id: Date.now(),
    ...userData
  })];
});

// Default response
server.respondWith([404, {}, "Not Found"]);

/**
 * Process all pending requests using configured responses
 * @returns {void}
 */
respond() {
  // Implementation
}

/**
 * Process all requests immediately, bypassing queue
 * @returns {void}
 */
respondAll() {
  // Implementation
}

// Manual response processing
server.autoRespond = false;
// ... make requests in application code ...
server.respond(); // Process all pending requests

/**
 * @typedef {Object} FakeServer - Server properties for request tracking
 * @property {XMLHttpRequest[]} requests - Array of all XMLHttpRequest objects
 * @property {number} requestCount - Total number of requests received
 * @property {boolean} requested - True if any requests have been made
 * @property {boolean} requestedOnce - True if exactly one request has been made
 * @property {boolean} requestedTwice - True if exactly two requests have been made
 * @property {boolean} requestedThrice - True if exactly three requests have been made
 * @property {XMLHttpRequest|null} firstRequest - Reference to the first request
 * @property {XMLHttpRequest|null} secondRequest - Reference to the second request
 * @property {XMLHttpRequest|null} thirdRequest - Reference to the third request
 * @property {XMLHttpRequest|null} lastRequest - Reference to the most recent request
 */

/**
 * Get request by index
 * @param {number} index - Zero-based request index
 * @returns {XMLHttpRequest|null} XMLHttpRequest object or null
 */
getRequest(index) {
  // Implementation
}

// After making requests
console.log(`Total requests: ${server.requestCount}`);
console.log(`First request URL: ${server.firstRequest && server.firstRequest.url}`);
console.log(`Last request method: ${server.lastRequest && server.lastRequest.method}`);

// Access specific request
const thirdRequest = server.getRequest(2);
if (thirdRequest) {
  console.log(`Third request body: ${thirdRequest.requestBody}`);
}

/**
 * Restore original XMLHttpRequest and clean up
 * @returns {void}
 */
restore() {
  // Implementation
}

/**
 * Reset server state (both behavior and history)
 * @returns {void}
 */
reset() {
  // Implementation
}

/**
 * Clear configured responses and request queue
 * @returns {void}
 */
resetBehavior() {
  // Implementation
}

/**
 * Clear request history and counters
 * @returns {void}
 */
resetHistory() {
  // Implementation
}

// Clean up after tests
afterEach(() => {
  server.reset(); // Clear state for next test
});

after(() => {
  server.restore(); // Restore original XMLHttpRequest
});

/**
 * Update server configuration
 * @param {Partial<ServerConfig>} config - Configuration options to update
 * @returns {void}
 */
configure(config) {
  // Implementation
}

// Change configuration dynamically
server.configure({
  autoRespond: false,
  logger: console.log
});

server.respondWith("POST", "/api/echo", function(request) {
  // Access request properties
  const method = request.method;
  const headers = request.requestHeaders;
  const body = request.requestBody;
  
  // Return response array
  return [200, { "Content-Type": "application/json" }, body];
});

server.configure({ fakeHTTPMethods: true });

// POST request with _method=DELETE will be treated as DELETE
server.respondWith("DELETE", "/api/users/1", [204, {}, ""]);