Como Consumir a API de CPF em Dart Usando http Package

class CPFResponse {
    final bool success;
    final CPFData data;

    CPFResponse({required this.success, required this.data});

    factory CPFResponse.fromJson(Map<String, dynamic> json) {
    return CPFResponse(
    success: json['success'] as bool,
    data: CPFData.fromJson(json['data'] as Map<String, dynamic>),
    );
    }
}

class CPFData {
    final String cpf;
    final String name;
    final String nameUpper;
    final String gender;
    final String birthDate;
    final String day;
    final String month;
    final String year;

    CPFData({
    required this.cpf,
    required this.name,
    required this.nameUpper,
    required this.gender,
    required this.birthDate,
    required this.day,
    required this.month,
    required this.year,
    });

    factory CPFData.fromJson(Map<String, dynamic> json) {
    return CPFData(
    cpf: json['cpf'] as String,
    name: json['name'] as String,
    nameUpper: json['nameUpper'] as String,
    gender: json['gender'] as String,
    birthDate: json['birthDate'] as String,
    day: json['day'] as String,
    month: json['month'] as String,
    year: json['year'] as String,
    );
    }

    Map<String, dynamic> toJson() => {
    'cpf': cpf, 'name': name, 'nameUpper': nameUpper,
    'gender': gender, 'birthDate': birthDate,
    'day': day, 'month': month, 'year': year,
    };
}

import 'dart:convert';
import 'package:http/http.dart' as http;

class CPFServiceException implements Exception {
    final String message;
    final int? statusCode;

    CPFServiceException(this.message, {this.statusCode});

    @override
    String toString() => 'CPFServiceException: $message (status: $statusCode)';
}

class CPFService {
    final String _apiKey;
    final http.Client _client;
    final String _baseUrl = 'https://api.cpfhub.io/cpf';

    CPFService({
    required String apiKey,
    http.Client? client,
    }) : _apiKey = apiKey,
    _client = client ?? http.Client();

    Future<CPFData> consultarCPF(String cpf) async {
    final cpfLimpo = cpf.replaceAll(RegExp(r'[^0-9]'), '');

    if (cpfLimpo.length != 11) {
    throw CPFServiceException('CPF deve conter 11 dígitos');
    }

    try {
    final response = await _client
    .get(
    Uri.parse('$_baseUrl/$cpfLimpo'),
    headers: {'x-api-key': _apiKey},
    )
    .timeout(const Duration(seconds: 15));

    if (response.statusCode == 200) {
    final json = jsonDecode(response.body) as Map<String, dynamic>;
    final cpfResponse = CPFResponse.fromJson(json);

    if (!cpfResponse.success) {
    throw CPFServiceException('CPF não encontrado');
    }

    return cpfResponse.data;
    } else if (response.statusCode == 401) {
    throw CPFServiceException(
    'Chave de API inválida',
    statusCode: 401,
    );
    } else {
    // A API do CPFHub.io não retorna 429 nem bloqueia requisições;
    // consultas acima do plano são cobradas a R$0,15 cada.
    throw CPFServiceException(
    'Erro na API',
    statusCode: response.statusCode,
    );
    }
    } on CPFServiceException {
    rethrow;
    } catch (e) {
    throw CPFServiceException('Erro de conexão: $e');
    }
    }

    void dispose() {
    _client.close();
    }
}

class CPFValidator {
    static bool validar(String cpf) {
    final numeros = cpf.replaceAll(RegExp(r'[^0-9]'), '');

    if (numeros.length != 11) return false;

    // Rejeitar sequências repetidas
    if (RegExp(r'^(\d)\1{10}$').hasMatch(numeros)) return false;

    final digits = numeros.split('').map(int.parse).toList();

    // Primeiro dígito verificador
    int soma1 = 0;
    for (int i = 0; i < 9; i++) {
    soma1 += digits[i] * (10 - i);
    }
    final check1 = (soma1 % 11 < 2) ? 0 : 11 - (soma1 % 11);
    if (digits[9] != check1) return false;

    // Segundo dígito verificador
    int soma2 = 0;
    for (int i = 0; i < 10; i++) {
    soma2 += digits[i] * (11 - i);
    }
    final check2 = (soma2 % 11 < 2) ? 0 : 11 - (soma2 % 11);
    if (digits[10] != check2) return false;

    return true;
    }

    static String formatar(String cpf) {
    final n = cpf.replaceAll(RegExp(r'[^0-9]'), '');
    if (n.length != 11) return cpf;
    return '${n.substring(0, 3)}.${n.substring(3, 6)}'
    '.${n.substring(6, 9)}-${n.substring(9, 11)}';
    }
}

// Uso combinado
Future<void> validarEConsultar(String cpf) async {
    if (!CPFValidator.validar(cpf)) {
    print('CPF inválido localmente');
    return;
    }

    final service = CPFService(apiKey: 'sua-chave-aqui');
    try {
    final dados = await service.consultarCPF(cpf);
    print('Nome: ${dados.name}');
    print('CPF: ${CPFValidator.formatar(dados.cpf)}');
    print('Nascimento: ${dados.birthDate}');
    } on CPFServiceException catch (e) {
    print('Erro: ${e.message}');
    } finally {
    service.dispose();
    }
}

import 'dart:convert';
import 'package:http/http.dart' as http;
import 'package:http/testing.dart';
import 'package:test/test.dart';

void main() {
    group('CPFService', () {
    test('deve retornar dados quando CPF é válido', () async {
    final mockClient = MockClient((request) async {
    expect(request.url.path, contains('/cpf/12345678909'));
    expect(request.headers['x-api-key'], equals('test-key'));

    return http.Response(
    jsonEncode({
    'success': true,
    'data': {
    'cpf': '12345678909',
    'name': 'João da Silva',
    'nameUpper': 'JOÃO DA SILVA',
    'gender': 'M',
    'birthDate': '01/01/1990',
    'day': '01',
    'month': '01',
    'year': '1990',
    }
    }),
    200,
    );
    });

    final service = CPFService(apiKey: 'test-key', client: mockClient);
    final result = await service.consultarCPF('12345678909');

    expect(result.name, equals('João da Silva'));
    expect(result.gender, equals('M'));
    });

    test('deve lançar exceção para CPF inválido', () async {
    final service = CPFService(apiKey: 'test-key');
    expect(
    () => service.consultarCPF('123'),
    throwsA(isA<CPFServiceException>()),
    );
    });
    });
}