fixup! hotfix: Set NOT event-email when search email as default

Signed-off-by: dab246 <tdvu@linagora.com>

Author: dab246

test/features/search/search_email_filter_test.dart

@@ -5,6 +5,7 @@ import 'package:jmap_dart_client/jmap/core/id.dart';
 import 'package:jmap_dart_client/jmap/core/utc_date.dart';
 import 'package:jmap_dart_client/jmap/mail/email/email_filter_condition.dart';
 import 'package:jmap_dart_client/jmap/mail/mailbox/mailbox.dart';
+import 'package:model/extensions/keyword_identifier_extension.dart';
 import 'package:model/mailbox/presentation_mailbox.dart';
 import 'package:tmail_ui_user/features/mailbox_dashboard/presentation/model/search/email_receive_time_type.dart';
 import 'package:tmail_ui_user/features/mailbox_dashboard/presentation/model/search/email_sort_order_type.dart';
@@ -78,18 +79,21 @@ void main() {
     });
 
     group('mappingToEmailFilterCondition::test', () {
-      test('SHOULD returns null WHEN there are no conditions', () {
+      test('SHOULD return an EmailFilterCondition excluding events WHEN there are no other conditions', () {
         // Arrange
         final filter = SearchEmailFilter.initial();
 
         // Act
         final result = filter.mappingToEmailFilterCondition();
 
         // Assert
-        expect(result, isNull);
+        // Events are excluded by default even when no other filter is set.
+        expect(result, isA<EmailFilterCondition>());
+        final emailCondition = result as EmailFilterCondition;
+        expect(emailCondition.notKeyword, KeyWordIdentifierExtension.eventsMail.value);
       });
 
-      test('SHOULD creates a simple filter WHEN text is provided', () {
+      test('SHOULD creates a filter combined with events-exclusion WHEN text is provided', () {
         // Arrange
         final filter = SearchEmailFilter(
           text: SearchQuery('example'),
@@ -99,9 +103,19 @@ void main() {
         final result = filter.mappingToEmailFilterCondition();
 
         // Assert
-        expect(result, isA<EmailFilterCondition>());
-        final emailCondition = result as EmailFilterCondition;
-        expect(emailCondition.text, 'example');
+        // Events are excluded by default, so result is AND(text=example, notKeyword=event).
+        expect(result, isA<LogicFilterOperator>());
+        final andFilter = result as LogicFilterOperator;
+        expect(andFilter.operator, Operator.AND);
+        expect(andFilter.conditions.length, equals(2));
+
+        final textCondition = andFilter.conditions.whereType<EmailFilterCondition>()
+            .firstWhere((c) => c.text != null);
+        expect(textCondition.text, 'example');
+
+        final eventsExclusion = andFilter.conditions.whereType<EmailFilterCondition>()
+            .firstWhere((c) => c.notKeyword != null);
+        expect(eventsExclusion.notKeyword, KeyWordIdentifierExtension.eventsMail.value);
       });
 
       test('SHOULD creates a filter with multiple "to" values using AND logic operator', () {
@@ -114,10 +128,11 @@ void main() {
         final result = filter.mappingToEmailFilterCondition();
 
         // Assert
+        // 2 "to" OR-conditions + events-exclusion = 3 conditions under AND.
         expect(result, isA<LogicFilterOperator>());
         final logicOperator = result as LogicFilterOperator;
         expect(logicOperator.operator, Operator.AND);
-        expect(logicOperator.conditions.length, equals(2));
+        expect(logicOperator.conditions.length, equals(3));
       });
 
       test('SHOULD includes moreFilterCondition WHEN provided', () {
@@ -165,7 +180,7 @@ void main() {
         expect(logicOperator.conditions.length, greaterThan(1));
       });
 
-      test('SHOULD wrap a simple EmailFilterCondition inside a NOT LogicFilterOperator when notKeyword is given', () {
+      test('SHOULD combine a NOT LogicFilterOperator for notKeyword with an events-exclusion condition using AND WHEN notKeyword is given', () {
         // Arrange
         final filter = SearchEmailFilter(
           notKeyword: {'hello'},
@@ -175,43 +190,46 @@ void main() {
         final result = filter.mappingToEmailFilterCondition();
 
         // Assert
+        // The result is AND(NOT(text=hello), notKeyword=event) because events are excluded by default.
         expect(result, isA<LogicFilterOperator>());
-        final logicFilter = result as LogicFilterOperator;
-        expect(result.conditions.length, equals(1));
-        expect(logicFilter.operator, equals(Operator.NOT));
-
-        final emailCondition = result.conditions.first as EmailFilterCondition;
-        expect(emailCondition.text, 'hello');
-        expect(emailCondition.notKeyword, isNull);
+        final andFilter = result as LogicFilterOperator;
+        expect(andFilter.operator, equals(Operator.AND));
+        expect(andFilter.conditions.length, equals(2));
+
+        final notFilter = andFilter.conditions.whereType<LogicFilterOperator>().first;
+        expect(notFilter.operator, equals(Operator.NOT));
+        expect(notFilter.conditions.length, equals(1));
+        final notCondition = notFilter.conditions.first as EmailFilterCondition;
+        expect(notCondition.text, 'hello');
+        expect(notCondition.notKeyword, isNull);
+
+        final eventsExclusion = andFilter.conditions.whereType<EmailFilterCondition>().first;
+        expect(eventsExclusion.notKeyword, KeyWordIdentifierExtension.eventsMail.value);
       });
 
       test(
-        'SHOULD convert the notKeyword set into a NOT LogicFilterOperator containing multiple EmailFilterCondition instances,\n'
-        'each representing a keyword from the set',
+        'SHOULD combine a NOT LogicFilterOperator with multiple keywords and an events-exclusion condition using AND',
       () {
         // Arrange
-        // Create a SearchEmailFilter with three keywords in the notKeyword field
         final filter = SearchEmailFilter(
           notKeyword: {'hello', 'hi', 'bye'},
         );
 
         // Act
-        // Call mappingToEmailFilterCondition to transform it into filter conditions
         final result = filter.mappingToEmailFilterCondition();
 
         // Assert
-        // The result should be a LogicFilterOperator with the NOT operator
+        // The result is AND(NOT(text=hello, text=hi, text=bye), notKeyword=event).
         expect(result, isA<LogicFilterOperator>());
-        final logicFilter = result as LogicFilterOperator;
-        expect(logicFilter.operator, equals(Operator.NOT));
+        final andFilter = result as LogicFilterOperator;
+        expect(andFilter.operator, equals(Operator.AND));
+        expect(andFilter.conditions.length, equals(2));
 
-        // The LogicFilterOperator should contain 3 EmailFilterCondition objects, one for each keyword
-        expect(logicFilter.conditions.isNotEmpty, equals(true));
-        expect(logicFilter.conditions.length, equals(3));
-
-        // Verify each EmailFilterCondition's content
-        final listEmailCondition = logicFilter.conditions.map((e) => e as EmailFilterCondition).toList();
+        final notFilter = andFilter.conditions.whereType<LogicFilterOperator>().first;
+        expect(notFilter.operator, equals(Operator.NOT));
+        expect(notFilter.conditions.length, equals(3));
 
+        final listEmailCondition = notFilter.conditions.map((e) => e as EmailFilterCondition).toList();
         expect(listEmailCondition[0].text, 'hello');
         expect(listEmailCondition[0].notKeyword, isNull);
 
@@ -220,6 +238,26 @@ void main() {
 
         expect(listEmailCondition[2].text, 'bye');
         expect(listEmailCondition[2].notKeyword, isNull);
+
+        final eventsExclusion = andFilter.conditions.whereType<EmailFilterCondition>().first;
+        expect(eventsExclusion.notKeyword, KeyWordIdentifierExtension.eventsMail.value);
+      });
+
+      test('SHOULD NOT add an events-exclusion condition WHEN hasKeyword explicitly includes the events keyword', () {
+        // Arrange
+        final filter = SearchEmailFilter(
+          hasKeyword: {KeyWordIdentifierExtension.eventsMail.value},
+        );
+
+        // Act
+        final result = filter.mappingToEmailFilterCondition();
+
+        // Assert
+        // With events explicitly included, no notKeyword=event condition should appear.
+        expect(result, isA<EmailFilterCondition>());
+        final emailCondition = result as EmailFilterCondition;
+        expect(emailCondition.hasKeyword, KeyWordIdentifierExtension.eventsMail.value);
+        expect(emailCondition.notKeyword, isNull);
       });
     });
   });