Flutter插件charlatan的使用_charlatan 是一个用于配置和返回伪造 HTTP 响应的包

注意：由于插件介绍为undefined，以下基于插件名称进行合理推测。

简介

charlatan 是一个用于配置和返回伪造 HTTP 响应的包。它主要用于测试与 HTTP 服务交互的代码，而不需要使用 mocks。该插件适用于 Dio HTTP Client。

主要组件

1. Charlatan - 配置和提供基于 HTTP 方法和 URI 模板的伪造 HTTP 响应。
2. CharlatanHttpClientAdapter - Dio 的 HttpClientAdapter 实现，从配置的 Charlatan 实例返回响应。
3. charlatanResponse 和请求匹配助手 - 匹配 HTTP 请求并生成伪造响应的实用工具。

使用方法

添加依赖

首先，在 pubspec.yaml 文件中添加 charlatan 到 dev_dependencies：

dev_dependencies:
  charlatan:

配置伪造响应

创建一个 Charlatan 实例，并调用相应的配置方法来映射 HTTP 请求到特定的响应。

示例代码

import 'package:charlatan/charlatan.dart';
import 'package:dio/dio.dart';
import 'package:test/test.dart';

void main() {
  late Dio client;
  late Charlatan charlatan;

  setUp(() {
    charlatan = Charlatan();
    client = Dio()..httpClientAdapter = charlatan.toFakeHttpClientAdapter();
  });

  test('Create a plain fake response', () async {
    charlatan.whenGet(
      '/user',
      charlatanResponse(statusCode: 200, body: {'name': 'frodo'}),
    );

    final plain = await client.get<Object?>('/user');
    expect(plain.data, {'name': 'frodo'});
  });

  test('Use a URI template', () async {
    final pathWithTemplate = '/users/{id}';
    charlatan.whenGet(
      pathWithTemplate,
      (request) {
        final uri = Uri.parse(request.path);
        final template = UriTemplate(pathWithTemplate);
        final parser = UriParser(template);
        final pathParameters = parser.parse(uri);
        return CharlatanHttpResponse(
          statusCode: 200,
          body: {
            'id': pathParameters['id'],
            'name': 'frodo',
          },
        );
      },
    );

    final withPathParams = await client.get<Object?>('/users/12');
    expect(withPathParams.data, {'id': '12', 'name': 'frodo'});
  });

  test('Use a custom status code and an empty body', () async {
    charlatan.whenGet(
      '/posts',
      charlatanResponse(statusCode: 204),
    );

    final emptyBody = await client.get<Object?>('/posts');
    expect(emptyBody.data, null);
    expect(emptyBody.statusCode, 204);
  });

  test('Return a complicated response based on conditions', () async {
    charlatan.whenPost('/users', (req) {
      final data = req.body as Map<String, Object?>? ?? {};
      final name = data['name'] as String?;
      if (name == null) {
        return CharlatanHttpResponse(
          statusCode: 422,
          body: {
            'errors': {
              'name': ['cannot be blank'],
            },
          },
        );
      }

      return CharlatanHttpResponse(
        statusCode: 201,
        body: {'id': 1, 'name': name},
      );
    });

    final invalidResponse = await client.post<Object?>(
      '/users',
      data: {'name': null},
      options: Options(validateStatus: (_) => true),
    );
    expect(invalidResponse.data, {
      'errors': {
        'name': ['cannot be blank']
      }
    });
    expect(invalidResponse.statusCode, 422);

    final validResponse = await client.post<Object?>(
      '/users',
      data: {'name': 'frodo'},
    );
    expect(validResponse.data, {'id': 1, 'name': 'frodo'});
    expect(validResponse.statusCode, 201);
  });

  test('Handle a POST and then a GET with shared state', () async {
    final posts = <Object>[];
    charlatan
      ..whenPost(
        '/posts',
        (request) {
          final params = request.body as Map<String, Object?>? ?? {};
          posts.add({'name': params['name']});
          return CharlatanHttpResponse(statusCode: 204);
        },
      )
      ..whenGet(
        '/posts',
        charlatanResponse(body: {'posts': posts}),
      );

    final beforeCreatePost = await client.get<Object?>('/posts');
    expect(beforeCreatePost.data, {'posts': <Object?>[]});

    final createPost = await client.post<Object?>(
      '/posts',
      data: {'name': 'bilbo'},
    );
    expect(createPost.statusCode, 204);

    final afterCreatePost = await client.get<Object?>('/posts');
    expect(afterCreatePost.data, {
      'posts': [
        {'name': 'bilbo'},
      ]
    });
  });
}

构建伪造 HTTP 客户端

构建 CharlatanHttpClientAdapter 并将其分配给 Dio 实例的 httpClientAdapter 属性。

final charlatan = Charlatan();
// ... configure fake responses ...
final dio = Dio()..httpClientAdapter = charlatan.toFakeHttpClientAdapter();

现在可以像平常一样发起 HTTP 请求，这些请求将通过配置的伪造响应路由。

final result = await dio.get<Object?>('/users/1');
expect(result.data, {'id': 1, 'name': 'bilbo'});

FAQ

如果我发起一个没有匹配伪造响应的请求会发生什么？

你会收到一个有用的错误信息：

Unable to find matching fake http response definition for:

GET /blahhhh

Did you configure it?

The fake http response definitions configured were:
GET /users
POST /users
PUT /users
DELETE /users

如何配置一个依赖于另一个伪造请求结果的伪造响应？例如，一个 POST 请求后跟一个可以“读取自己的写入”的 GET 请求。

请参阅示例目录中的例子。

以上是基于插件名称 charlatan 进行的合理推测和整理的内容。希望对你有所帮助！