onFakeRequest method

FutureOr<FakeHttpResponse> onFakeRequest(dynamic request, dynamic client)

Implementation

FutureOr<FakeHttpResponse> onFakeRequest(request, client) async {
  final requestPath = request.uri.toString();
  final requestHeaders = _extractHeaders(request);
  final requestBody = await _parseRequestBody(request);
  final requestMethod = HttpMethod.fromString(request.method);

  debugPrint('📤 Request: ${request.method} $requestPath');

  // Store request for verification
  _requests.add(RequestVerification(
    method: requestMethod,
    path: requestPath,
    body: requestBody,
    headers: requestHeaders,
  ));

  try {
    // Check queued responses first (priority)
    final queuedKey = _findMatchingKey(requestPath, _queuedResponses, requestMethod);
    if (queuedKey.isNotEmpty && _queuedResponses[queuedKey]!.isNotEmpty) {
      final queuedResponse = _queuedResponses[queuedKey]!.removeAt(0);
      if (_queuedResponses[queuedKey]!.isEmpty) {
        _queuedResponses.remove(queuedKey);
      }

      debugPrint('📥 Response found (queued): ${queuedResponse.statusCode}');

      // Apply delay if specified
      if (queuedResponse.delay != null) {
        debugPrint('⏳ Delaying response by ${queuedResponse.delay}');
        await Future.delayed(queuedResponse.delay!);
      }

      return FakeHttpResponse(
        statusCode: queuedResponse.statusCode,
        body: jsonEncode(queuedResponse.body),
        headers: {
          'Content-Type': 'application/json',
          if (queuedResponse.headers != null)
            ...Map<String, String>.from(queuedResponse.headers!),
        },
      );
    }

    // Check permanent responses
    final permanentKey = _findMatchingKey(requestPath, _permanentResponses, requestMethod);
    if (permanentKey.isNotEmpty) {
      final permanentResponse = _permanentResponses[permanentKey]!;

      debugPrint('📥 Response found (permanent): ${permanentResponse.statusCode}');

      // Apply delay if specified
      if (permanentResponse.delay != null) {
        debugPrint('⏳ Delaying response by ${permanentResponse.delay}');
        await Future.delayed(permanentResponse.delay!);
      }

      return FakeHttpResponse(
        statusCode: permanentResponse.statusCode,
        body: jsonEncode(permanentResponse.body),
        headers: {
          'Content-Type': 'application/json',
          if (permanentResponse.headers != null)
            ...Map<String, String>.from(permanentResponse.headers!),
        },
      );
    }

    // No mock found
    debugPrint('❌ Mock not found: ${request.method} $requestPath');

    return FakeHttpResponse(
      statusCode: HttpStatus.notFound,
      body: jsonEncode({
        'message': 'Mock response not found for $requestPath',
      }),
      headers: {
        'Content-Type': 'application/json',
      },
    );
  } catch (e) {
    debugPrint('🔴 Error processing request: $e');
    rethrow;
  }
}