fix(chat): Correction race condition + Implémentation TODOs

## Corrections Critiques

### Race Condition - Statuts de Messages
- Fix : Les icônes de statut (✓, ✓✓, ✓✓ bleu) ne s'affichaient pas
- Cause : WebSocket delivery confirmations arrivaient avant messages locaux
- Solution : Pattern Optimistic UI dans chat_bloc.dart
  - Création message temporaire immédiate
  - Ajout à la liste AVANT requête HTTP
  - Remplacement par message serveur à la réponse
- Fichier : lib/presentation/state_management/chat_bloc.dart

## Implémentation TODOs (13/21)

### Social (social_header_widget.dart)
-  Copier lien du post dans presse-papiers
-  Partage natif via Share.share()
-  Dialogue de signalement avec 5 raisons

### Partage (share_post_dialog.dart)
-  Interface sélection d'amis avec checkboxes
-  Partage externe via Share API

### Média (media_upload_service.dart)
-  Parsing JSON réponse backend
-  Méthode deleteMedia() pour suppression
-  Génération miniature vidéo

### Posts (create_post_dialog.dart, edit_post_dialog.dart)
-  Extraction URL depuis uploads
-  Documentation chargement médias

### Chat (conversations_screen.dart)
-  Navigation vers notifications
-  ConversationSearchDelegate pour recherche

## Nouveaux Fichiers

### Configuration
- build-prod.ps1 : Script build production avec dart-define
- lib/core/constants/env_config.dart : Gestion environnements

### Documentation
- TODOS_IMPLEMENTED.md : Documentation complète TODOs

## Améliorations

### Architecture
- Refactoring injection de dépendances
- Amélioration routing et navigation
- Optimisation providers (UserProvider, FriendsProvider)

### UI/UX
- Amélioration thème et couleurs
- Optimisation animations
- Meilleure gestion erreurs

### Services
- Configuration API avec env_config
- Amélioration datasources (events, users)
- Optimisation modèles de données
This commit is contained in:
dahoud
2026-01-10 10:43:17 +00:00
parent 06031b01f2
commit 92612abbd7
321 changed files with 43137 additions and 4285 deletions

View File

@@ -0,0 +1,323 @@
import 'package:afterwork/data/models/user_model.dart';
import 'package:afterwork/domain/entities/user.dart';
import 'package:flutter_test/flutter_test.dart';
void main() {
group('UserModel', () {
const tUserModel = UserModel(
userId: '123',
userLastName: 'Doe',
userFirstName: 'John',
email: 'john.doe@example.com',
motDePasse: 'hashedPassword123',
profileImageUrl: 'https://example.com/profile.jpg',
);
final tUserModelJson = {
'userId': '123',
'nom': 'Doe',
'prenoms': 'John',
'email': 'john.doe@example.com',
'motDePasse': 'hashedPassword123',
'profileImageUrl': 'https://example.com/profile.jpg',
};
test('should be a subclass of User entity', () {
// Assert
expect(tUserModel, isA<User>());
});
test('should extend User with all its properties', () {
// Assert
expect(tUserModel.userId, '123');
expect(tUserModel.userLastName, 'Doe');
expect(tUserModel.userFirstName, 'John');
expect(tUserModel.email, 'john.doe@example.com');
expect(tUserModel.motDePasse, 'hashedPassword123');
expect(tUserModel.profileImageUrl, 'https://example.com/profile.jpg');
});
group('fromJson', () {
test('should return a valid UserModel from JSON', () {
// Act
final result = UserModel.fromJson(tUserModelJson);
// Assert
expect(result, isA<UserModel>());
expect(result.userId, '123');
expect(result.userLastName, 'Doe');
expect(result.userFirstName, 'John');
expect(result.email, 'john.doe@example.com');
expect(result.motDePasse, 'hashedPassword123');
expect(result.profileImageUrl, 'https://example.com/profile.jpg');
});
test('should use default values for missing fields', () {
// Arrange
final minimalJson = <String, dynamic>{};
// Act
final result = UserModel.fromJson(minimalJson);
// Assert
expect(result.userId, '');
expect(result.userLastName, 'Inconnu');
expect(result.userFirstName, 'Inconnu');
expect(result.email, 'inconnu@example.com');
expect(result.motDePasse, '');
expect(result.profileImageUrl, '');
});
test('should handle partial JSON data', () {
// Arrange
final partialJson = {
'userId': '456',
'email': 'partial@example.com',
};
// Act
final result = UserModel.fromJson(partialJson);
// Assert
expect(result.userId, '456');
expect(result.email, 'partial@example.com');
expect(result.userLastName, 'Inconnu'); // Default
expect(result.userFirstName, 'Inconnu'); // Default
expect(result.motDePasse, ''); // Default
});
test('should handle null values in JSON', () {
// Arrange
final jsonWithNulls = {
'userId': null,
'nom': null,
'prenoms': null,
'email': null,
'motDePasse': null,
'profileImageUrl': null,
};
// Act
final result = UserModel.fromJson(jsonWithNulls);
// Assert
expect(result.userId, '');
expect(result.userLastName, 'Inconnu');
expect(result.userFirstName, 'Inconnu');
expect(result.email, 'inconnu@example.com');
expect(result.motDePasse, '');
expect(result.profileImageUrl, '');
});
});
group('toJson', () {
test('should return a JSON map containing proper data', () {
// Act
final result = tUserModel.toJson();
// Assert
expect(result, isA<Map<String, dynamic>>());
expect(result['id'], '123');
expect(result['nom'], 'Doe');
expect(result['prenoms'], 'John');
expect(result['email'], 'john.doe@example.com');
expect(result['motDePasse'], 'hashedPassword123');
expect(result['profileImageUrl'], 'https://example.com/profile.jpg');
});
test('should map field names correctly (userId -> id, etc.)', () {
// Act
final result = tUserModel.toJson();
// Assert
// Vérifie que le mapping des champs est correct
expect(result.containsKey('id'), isTrue);
expect(result.containsKey('nom'), isTrue);
expect(result.containsKey('prenoms'), isTrue);
// Ne doit PAS contenir les noms de propriétés Dart
expect(result.containsKey('userId'), isFalse);
expect(result.containsKey('userLastName'), isFalse);
expect(result.containsKey('userFirstName'), isFalse);
});
test('should be reversible (fromJson -> toJson)', () {
// Act
final json = tUserModel.toJson();
// Adapter le JSON pour fromJson (id -> userId)
json['userId'] = json['id'];
final model = UserModel.fromJson(json);
// Assert
expect(model.userId, tUserModel.userId);
expect(model.userLastName, tUserModel.userLastName);
expect(model.userFirstName, tUserModel.userFirstName);
expect(model.email, tUserModel.email);
expect(model.motDePasse, tUserModel.motDePasse);
});
});
group('Equality', () {
test('should support value equality (from Equatable)', () {
// Arrange
const user1 = UserModel(
userId: '123',
userLastName: 'Doe',
userFirstName: 'John',
email: 'john@example.com',
motDePasse: 'password',
profileImageUrl: 'profile.jpg',
);
const user2 = UserModel(
userId: '123',
userLastName: 'Doe',
userFirstName: 'John',
email: 'john@example.com',
motDePasse: 'password',
profileImageUrl: 'profile.jpg',
);
// Assert
expect(user1, equals(user2));
expect(user1.hashCode, equals(user2.hashCode));
});
test('should not be equal when fields are different', () {
// Arrange
const user1 = UserModel(
userId: '123',
userLastName: 'Doe',
userFirstName: 'John',
email: 'john@example.com',
motDePasse: 'password',
profileImageUrl: 'profile.jpg',
);
const user2 = UserModel(
userId: '456', // Different ID
userLastName: 'Doe',
userFirstName: 'John',
email: 'john@example.com',
motDePasse: 'password',
profileImageUrl: 'profile.jpg',
);
// Assert
expect(user1, isNot(equals(user2)));
});
});
group('API Integration', () {
test('should correctly map API field names', () {
// Arrange
final apiResponse = {
'userId': 'api-123',
'nom': 'APILastName',
'prenoms': 'APIFirstName',
'email': 'api@example.com',
'motDePasse': 'api-password',
'profileImageUrl': 'https://api.com/profile.jpg',
};
// Act
final user = UserModel.fromJson(apiResponse);
final jsonForApi = user.toJson();
// Assert
expect(user.userId, 'api-123');
expect(user.userLastName, 'APILastName');
expect(user.userFirstName, 'APIFirstName');
expect(jsonForApi['id'], 'api-123');
expect(jsonForApi['nom'], 'APILastName');
expect(jsonForApi['prenoms'], 'APIFirstName');
});
test('should handle empty strings from API', () {
// Arrange
final apiResponse = {
'userId': '',
'nom': '',
'prenoms': '',
'email': '',
'motDePasse': '',
'profileImageUrl': '',
};
// Act
final user = UserModel.fromJson(apiResponse);
// Assert
expect(user.userId, '');
expect(user.userLastName, ''); // Utilise la valeur vide, pas le défaut
expect(user.userFirstName, '');
expect(user.email, '');
});
});
group('Edge Cases', () {
test('should handle very long strings', () {
// Arrange
final longString = 'A' * 1000;
final jsonWithLongStrings = {
'userId': longString,
'nom': longString,
'prenoms': longString,
'email': '$longString@example.com',
'motDePasse': longString,
'profileImageUrl': 'https://example.com/$longString.jpg',
};
// Act
final user = UserModel.fromJson(jsonWithLongStrings);
// Assert
expect(user.userId.length, 1000);
expect(user.userLastName.length, 1000);
expect(user.userFirstName.length, 1000);
});
test('should handle special characters', () {
// Arrange
final jsonWithSpecialChars = {
'userId': '123',
'nom': 'Dôe-Smîth',
'prenoms': 'Jöhn',
'email': 'john+test@example.com',
'motDePasse': 'P@ssw0rd!#\$',
'profileImageUrl': 'https://example.com/profile.jpg',
};
// Act
final user = UserModel.fromJson(jsonWithSpecialChars);
// Assert
expect(user.userLastName, 'Dôe-Smîth');
expect(user.userFirstName, 'Jöhn');
expect(user.email, 'john+test@example.com');
expect(user.motDePasse, 'P@ssw0rd!#\$');
});
test('should handle unicode characters', () {
// Arrange
final jsonWithUnicode = {
'userId': '123',
'nom': '山田',
'prenoms': '太郎',
'email': 'yamada@example.jp',
'motDePasse': 'パスワード',
'profileImageUrl': 'https://example.jp/山田.jpg',
};
// Act
final user = UserModel.fromJson(jsonWithUnicode);
// Assert
expect(user.userLastName, '山田');
expect(user.userFirstName, '太郎');
expect(user.motDePasse, 'パスワード');
});
});
});
}