From 9147eed30c3ff587ba410ddbb942409e7a1073e9 Mon Sep 17 00:00:00 2001 From: sherlockvn Date: Mon, 16 Jan 2023 16:55:01 +0700 Subject: [PATCH] TF-1194: create new default identity: add function getSmallestIdentities and sortListIdentities --- .../identities/utils/identity_utils.dart | 46 ++++++ .../identity/identity_utils_test.dart | 132 ++++++++++++++++++ 2 files changed, 178 insertions(+) create mode 100644 lib/features/manage_account/presentation/profiles/identities/utils/identity_utils.dart create mode 100644 test/features/manage_account/identity/identity_utils_test.dart diff --git a/lib/features/manage_account/presentation/profiles/identities/utils/identity_utils.dart b/lib/features/manage_account/presentation/profiles/identities/utils/identity_utils.dart new file mode 100644 index 000000000..367a0f922 --- /dev/null +++ b/lib/features/manage_account/presentation/profiles/identities/utils/identity_utils.dart @@ -0,0 +1,46 @@ +import 'package:jmap_dart_client/jmap/core/unsigned_int.dart'; +import 'package:jmap_dart_client/jmap/identities/identity.dart'; + +class IdentityUtils { + + List? getSmallestOrderedIdentity(List? identities) { + if (identities == null || identities.isEmpty) { + return identities; + } + final initialIdentity = Identity(sortOrder: UnsignedInt(9007199254740991)); + final smallestIdentity = identities.fold( + initialIdentity, + (previousIdentity, nextIdentity) { + if (previousIdentity.sortOrder == null && nextIdentity.sortOrder == null) { + return initialIdentity; + } else if (previousIdentity.sortOrder == null) { + return nextIdentity; + } else if (nextIdentity.sortOrder == null) { + return previousIdentity; + } + + return previousIdentity.sortOrder!.value < nextIdentity.sortOrder!.value + ? previousIdentity : nextIdentity; + }); + + if (smallestIdentity == initialIdentity) { + return identities; + } + + return identities.where((element) => element.sortOrder == smallestIdentity.sortOrder).toList(); + } + + void sortListIdentities(List identities) { + identities.sort((identity1, identity2) { + var sortOrder1 = identity1.sortOrder; + var sortOrder2 = identity2.sortOrder; + if (identity1.sortOrder == null) { + sortOrder1 = UnsignedInt(2147483647); // 2^31 - 1 + } + if (identity2.sortOrder == null) { + sortOrder2 = UnsignedInt(2147483647); + } + return sortOrder1!.value < sortOrder2!.value ? -1 : 1 ; + }); + } +} \ No newline at end of file diff --git a/test/features/manage_account/identity/identity_utils_test.dart b/test/features/manage_account/identity/identity_utils_test.dart new file mode 100644 index 000000000..cfe1ff3bd --- /dev/null +++ b/test/features/manage_account/identity/identity_utils_test.dart @@ -0,0 +1,132 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:jmap_dart_client/jmap/core/unsigned_int.dart'; +import 'package:jmap_dart_client/jmap/identities/identity.dart'; +import 'package:tmail_ui_user/features/manage_account/presentation/profiles/identities/utils/identity_utils.dart'; + +void main() { + final _identityUtils = IdentityUtils(); + group('get smallest sortOrder identity test', () { + test('getSmallestOrderedIdentity return identity with sortOrder equals to 1', () { + final sortOrders = [1,99, 999, 100, 201]; + final listIdentities1 = sortOrders.map((e) => Identity(sortOrder: UnsignedInt(e))).toList(); + final actual1 = _identityUtils.getSmallestOrderedIdentity(listIdentities1); + + expect(actual1, [listIdentities1[0]]); + }); + + test('getSmallestOrderedIdentity return list identities with sortOrder equals to 1', () { + final sortOrders = [1, 1, 23, 2, 3, 4]; + final listIdentities1 = sortOrders.map((e) => Identity(sortOrder: UnsignedInt(e))).toList(); + final actual1 = _identityUtils.getSmallestOrderedIdentity(listIdentities1); + + expect(actual1, [listIdentities1[0], listIdentities1[1]]); + }); + + test('getSmallestOrderedIdentity return identity with sortOrder equals to 1', () { + final sortOrders = [null, 1, 2, 3, 5, 99]; + final listIdentities1 = sortOrders.map((e) { + if(e != null){ + return Identity(sortOrder: UnsignedInt(e)); + } + return Identity(); + }).toList(); + final actual1 = _identityUtils.getSmallestOrderedIdentity(listIdentities1); + + expect(actual1, [listIdentities1[1]]); + }); + + test('getSmallestOrderedIdentity return identity with sortOrder equals to 2', () { + final sortOrders = [null, null, 2, 3, 5, 99]; + final listIdentities1 = sortOrders.map((e) { + if(e != null){ + return Identity(sortOrder: UnsignedInt(e)); + } + return Identity(); + }).toList(); + final actual1 = _identityUtils.getSmallestOrderedIdentity(listIdentities1); + + expect(actual1, [listIdentities1[2]]); + }); + + test('getSmallestOrderedIdentity return list identities with sortOrder equals to null', () { + final sortOrders = [null, null, null, null, null]; + final listIdentities1 = sortOrders.map((e) { + if(e != null){ + return Identity(sortOrder: UnsignedInt(e as num)); + } + return Identity(); + }).toList(); + final actual1 = _identityUtils.getSmallestOrderedIdentity(listIdentities1); + + expect(actual1!.length, 5); + expect(actual1[1], Identity(sortOrder: null)); + }); + + test('getSmallestOrderedIdentity return list identities with sortOrder equals to 0', () { + final sortOrders = [0, 0, 0, 0 ,0 ,0]; + final listIdentities1 = sortOrders.map((e) { + if(e != null){ + return Identity(sortOrder: UnsignedInt(e)); + } + return Identity(); + }).toList(); + final actual1 = _identityUtils.getSmallestOrderedIdentity(listIdentities1); + + expect(actual1!.length, 6); + expect(actual1[1], Identity(sortOrder: UnsignedInt(0))); + }); + + test('getSmallestOrderedIdentity return identity with sortOrder equals to 0', () { + final sortOrders = [0, 99, 999, 100, 12]; + final listIdentities1 = sortOrders.map((e) => Identity(sortOrder: UnsignedInt(e))).toList(); + final actual1 = _identityUtils.getSmallestOrderedIdentity(listIdentities1); + + expect(actual1, [listIdentities1[0]]); + }); + }); + + group('test sort list of all identities', () { + test('should return a list of identities with increasing sortOrder of identities', () { + final sortOrders = [9, 1, 99, 98, 95, 0, 12]; + final listIdentities1 = sortOrders.map((e) => Identity(sortOrder: UnsignedInt(e))).toList(); + _identityUtils.sortListIdentities(listIdentities1); + expect(listIdentities1, [0, 1, 9, 12, 95, 98, 99].map((e) => Identity(sortOrder: UnsignedInt(e))).toList()); + }); + + test('should return a list of identities with increasing sortOrder of identities, null identity will be put at the end of list', () { + final sortOrders = [9, 1, 99, 98, 95, null, 12]; + final listIdentities1 = sortOrders.map((e) { + if(e != null){ + return Identity(sortOrder: UnsignedInt(e)); + } + return Identity(); + }).toList(); + _identityUtils.sortListIdentities(listIdentities1); + expect(listIdentities1, [1, 9, 12, 95, 98, 99, null].map((e) => Identity(sortOrder: e != null ? UnsignedInt(e) : null)).toList()); + }); + + test('return a list of identities with all null value at the end of list and 999 is the first identities in list', () { + final sortOrders = [null, 999, null, null, null, null, null]; + final listIdentities1 = sortOrders.map((e) { + if(e != null){ + return Identity(sortOrder: UnsignedInt(e)); + } + return Identity(); + }).toList(); + _identityUtils.sortListIdentities(listIdentities1); + expect(listIdentities1, [999, null, null, null, null, null, null].map((e) => Identity(sortOrder: e != null ? UnsignedInt(e) : null)).toList()); + }); + + test('should return a list of null value', () { + final sortOrders = [null, null, null, null, null, null, null]; + final listIdentities1 = sortOrders.map((e) { + if(e != null){ + return Identity(sortOrder: null); + } + return Identity(); + }).toList(); + _identityUtils.sortListIdentities(listIdentities1); + expect(listIdentities1, [null, null, null, null, null, null, null].map((e) => Identity()).toList()); + }); + }); +} \ No newline at end of file