Line data    Source code

       1              : import 'dart:io';
       2              : 
       3              : import 'package:agattp/agattp.dart';
       4              : import 'package:agattp/src/agattp_utils.dart';
       5              : import 'package:test/test.dart';
       6              : import 'package:testainers/testainers.dart';
       7              : 
       8              : ///
       9              : ///
      10              : ///
      11            1 : void main() {
      12            1 :   group(
      13              :     'Agattp Local',
      14            1 :     () {
      15              :       const String server = 'localhost';
      16            1 :       final TestainersHttpbucket container = TestainersHttpbucket();
      17              : 
      18              :       ///
      19            2 :       setUpAll(() async {
      20            1 :         await container.start();
      21              :       });
      22              : 
      23            2 :       test('Capitalize Headers', () async {
      24            1 :         final Map<String, String> extraHeaders = <String, String>{
      25              :           HttpHeaders.acceptHeader: '*/*',
      26              :           'accept-encoding': 'gzip',
      27              :           'User-Agent': 'Agattp',
      28            2 :           'Host': '$server:${container.httpPort}',
      29              :           'X-tesT': 'test',
      30              :         };
      31              : 
      32            1 :         final List<String> results = <String>[
      33              :           'Accept',
      34              :           'Accept-Encoding',
      35              :           'User-Agent',
      36              :           'Host',
      37              :           'X-Test',
      38              :         ];
      39              : 
      40              :         final AgattpJsonResponse<Map<String, dynamic>> response =
      41            2 :             await Agattp().getJson(
      42            3 :           Uri.parse('http://$server:${container.httpPort}/status/200'),
      43              :           extraHeaders: extraHeaders,
      44              :         );
      45              : 
      46            2 :         expect(response.statusCode, 200);
      47            2 :         expect(response.reasonPhrase, 'OK');
      48            2 :         expect(response.isRedirect, false);
      49            4 :         expect(response.json['headers'] is Map<String, dynamic>, true);
      50              : 
      51            2 :         final Map<String, dynamic> headers = response.json['headers'];
      52              : 
      53            2 :         for (final String key in headers.keys) {
      54            2 :           expect(results.contains(key), true);
      55              :         }
      56              :       });
      57              : 
      58            2 :       test('Lowercase Headers', () async {
      59            1 :         final Map<String, String> extraHeaders = <String, String>{
      60              :           HttpHeaders.acceptHeader: '*/*',
      61              :           'accept-encoding': 'gzip',
      62              :           'User-Agent': 'Agattp',
      63            2 :           'Host': '$server:${container.httpPort}',
      64              :           'X-tesT': 'test',
      65              :         };
      66              : 
      67            1 :         final List<String> results = <String>[
      68              :           'accept',
      69              :           'accept-encoding',
      70              :           'user-agent',
      71              :           'host',
      72              :           'x-test',
      73              :         ];
      74              : 
      75            1 :         final AgattpJsonResponse<Map<String, dynamic>> response = await Agattp(
      76              :           config: const AgattpConfig(
      77              :             headerKeyCase: HeaderKeyCase.lowercase,
      78              :           ),
      79            1 :         ).getJson(
      80            3 :           Uri.parse('http://$server:${container.httpPort}/status/200'),
      81              :           extraHeaders: extraHeaders,
      82              :         );
      83              : 
      84            2 :         expect(response.statusCode, 200);
      85            2 :         expect(response.reasonPhrase, 'OK');
      86            2 :         expect(response.isRedirect, false);
      87            4 :         expect(response.json['headers'] is Map<String, dynamic>, true);
      88              : 
      89            2 :         final Map<String, dynamic> headers = response.json['headers'];
      90              : 
      91            2 :         for (final String key in headers.keys) {
      92            2 :           expect(results.contains(key), true);
      93              :         }
      94              :       });
      95              : 
      96            2 :       test('Preserve Headers', () async {
      97            1 :         final Map<String, String> extraHeaders = <String, String>{
      98              :           HttpHeaders.acceptHeader: '*/*',
      99              :           'accept-encoding': 'gzip',
     100              :           'User-Agent': 'Agattp',
     101            2 :           'Host': '$server:${container.httpPort}',
     102              :           'X-tesT': 'test',
     103              :         };
     104              : 
     105            1 :         final List<String> results = <String>[
     106              :           'accept',
     107              :           'accept-encoding',
     108              :           'User-Agent',
     109              :           'Host',
     110              :           'X-tesT',
     111              :         ];
     112              : 
     113            1 :         final AgattpJsonResponse<Map<String, dynamic>> response = await Agattp(
     114              :           config: const AgattpConfig(
     115              :             headerKeyCase: HeaderKeyCase.preserve,
     116              :           ),
     117            1 :         ).getJson(
     118            3 :           Uri.parse('http://$server:${container.httpPort}/status/200'),
     119              :           extraHeaders: extraHeaders,
     120              :         );
     121              : 
     122            2 :         expect(response.statusCode, 200);
     123            2 :         expect(response.reasonPhrase, 'OK');
     124            2 :         expect(response.isRedirect, false);
     125            4 :         expect(response.json['headers'] is Map<String, dynamic>, true);
     126              : 
     127            2 :         final Map<String, dynamic> headers = response.json['headers'];
     128              : 
     129            2 :         for (final String key in headers.keys) {
     130            2 :           expect(results.contains(key), true);
     131              :         }
     132              :       });
     133              : 
     134              :       ///
     135            2 :       tearDownAll(container.stop);
     136              :     },
     137            1 :     onPlatform: <String, dynamic>{
     138              :       'mac-os': const Skip('No docker installed on GitHub actions.'),
     139              :       'windows': const Skip('Need a windows container image.'),
     140              :     },
     141              :   );
     142              : }