eduvia/workavia-mail-front
11
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

TF-1008 Unit-test for handleSetErrors()

Browse Source
This commit is contained in:
Dat PHAM HOANG
2022-11-14 22:53:07 +07:00
committed by Dat H. Pham
parent e2d9f4e6ee
commit 7f62d8257d
2 changed files with 469 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/features/base/mixin/handle_error_mixin.dart
+6 -3
View File
@@ -17,19 +17,22 @@ mixin HandleSetErrorMixin {
if (notDestroyedError != null && notDestroyedError.isNotEmpty) {
notDestroyedError.entries
.map((e) => _handleInChain(e, notDestroyedHandlers))
.map((optionError) => _handleRemainedError(unCatchErrorHandler, optionError));
.map((optionError) => _handleRemainedError(unCatchErrorHandler, optionError))
.toSet();
}
if (notCreatedError != null && notCreatedError.isNotEmpty) {
notCreatedError.entries
.map((e) => _handleInChain(e, notCreatedHandlers))
.map((optionError) => _handleRemainedError(unCatchErrorHandler, optionError));
.map((optionError) => _handleRemainedError(unCatchErrorHandler, optionError))
.toSet();
}
if (notUpdatedError != null && notUpdatedError.isNotEmpty) {
notUpdatedError.entries
.map((e) => _handleInChain(e, notUpdatedHandlers))
.map((optionError) => _handleRemainedError(unCatchErrorHandler, optionError));
.map((optionError) => _handleRemainedError(unCatchErrorHandler, optionError))
.toSet();
}
}
test/features/base/mixin/handle_error_mixin_test.dart
+463
View File
@@ -0,0 +1,463 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:jmap_dart_client/jmap/core/error/set_error.dart';
import 'package:jmap_dart_client/jmap/core/id.dart';
import 'package:model/error_type_handler/set_method_error_handler_mixin.dart';
import 'package:tmail_ui_user/features/base/mixin/handle_error_mixin.dart';
class TestSetErrorHandler with HandleSetErrorMixin {}
void main() {
late TestSetErrorHandler testHandler;
setUp(() {
testHandler = TestSetErrorHandler();
});
group('Handle Not Destroyed Error', () {
test('should not invoke notDestroyedHandler when notDestroyedError null but notDestroyedHandlers non-null', () {
var counterWillNotBeChange = 0;
bool notDestroyedHandler(MapEntry<Id, SetError> setError) {
counterWillNotBeChange++;
return false;
}
testHandler.handleSetErrors(
notDestroyedError: null,
notDestroyedHandlers: {notDestroyedHandler}
);
expect(counterWillNotBeChange, equals(0));
});
test('should invoke unCatchErrorHandler when notDestroyedError null but notDestroyedHandlers null', () {
SetMethodErrors? notDestroyedError = {
Id("c1"): SetError(SetError.notFound),
};
var counterWillBeEqualOne = 0;
bool unCatchErrorHandler(MapEntry<Id, SetError> setError) {
counterWillBeEqualOne++;
return false;
}
testHandler.handleSetErrors(
notDestroyedError: notDestroyedError,
notDestroyedHandlers: null,
unCatchErrorHandler: unCatchErrorHandler
);
expect(counterWillBeEqualOne, equals(1));
});
test('should handle error successfully when notDestroyedHandlers non-null and one of them handle notDestroyedError', () {
SetMethodErrors? notDestroyedError = {
Id("c1"): SetError(SetError.notFound),
};
var counterWillBeIncreaseWhenHandleSucceeded = 0;
bool notDestroyedHandler1(MapEntry<Id, SetError> setError) {
return false;
}
bool notDestroyedHandler2(MapEntry<Id, SetError> setError) {
if (setError.value.type == SetError.notFound) {
counterWillBeIncreaseWhenHandleSucceeded++;
return true;
}
return false;
}
bool unCatchErrorHandler(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenHandleSucceeded++;
return false;
}
testHandler.handleSetErrors(
notDestroyedError: notDestroyedError,
notDestroyedHandlers: {notDestroyedHandler1, notDestroyedHandler2},
unCatchErrorHandler: unCatchErrorHandler
);
expect(counterWillBeIncreaseWhenHandleSucceeded, equals(1));
});
test('should stop handler error when notDestroyedHandlers non-null and one of them handle notDestroyedError successfully', () {
SetMethodErrors? notDestroyedError = {
Id("c1"): SetError(SetError.notFound),
};
var counterWillBeIncreaseWhenInvokeHandler = 0;
bool notDestroyedHandler1(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
return false;
}
bool notDestroyedHandler2(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
if (setError.value.type == SetError.notFound) {
return true;
}
return false;
}
bool notDestroyedHandler3(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
return false;
}
bool unCatchErrorHandler(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
return false;
}
testHandler.handleSetErrors(
notDestroyedError: notDestroyedError,
notDestroyedHandlers: {notDestroyedHandler1, notDestroyedHandler2, notDestroyedHandler3},
unCatchErrorHandler: unCatchErrorHandler
);
expect(counterWillBeIncreaseWhenInvokeHandler, equals(2));
});
test('should call unCatchErrorHandler when notDestroyedHandlers non-null and no-one can handle notDestroyedError', () {
SetMethodErrors? notDestroyedError = {
Id("c1"): SetError(SetError.notFound),
};
var counterWillBeIncreaseWhenInvokeHandler = 0;
bool notDestroyedHandler1(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
return false;
}
bool notDestroyedHandler2(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
return false;
}
bool unCatchErrorHandler(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
return false;
}
testHandler.handleSetErrors(
notDestroyedError: notDestroyedError,
notDestroyedHandlers: {notDestroyedHandler1, notDestroyedHandler2},
unCatchErrorHandler: unCatchErrorHandler
);
expect(counterWillBeIncreaseWhenInvokeHandler, equals(3));
});
test('should invoke both unCatchErrorHandler and handler when have some kinds of error were handle successfully', () {
SetMethodErrors? notDestroyedError = {
Id("c1"): SetError(SetError.notFound),
Id("c2"): SetError(SetError.forbidden),
};
var counterWillBeIncreaseWhenInvokeHandler = 0;
var counterWillBeIncreaseWhenInvokeUnCatchHandler = 0;
bool notDestroyedHandler1(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
return false;
}
bool notDestroyedHandler2(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
if (setError.value.type == SetError.notFound) {
return true;
}
return false;
}
bool notDestroyedHandler3(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
return false;
}
bool unCatchErrorHandler(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeUnCatchHandler++;
return false;
}
testHandler.handleSetErrors(
notDestroyedError: notDestroyedError,
notDestroyedHandlers: {notDestroyedHandler1, notDestroyedHandler2, notDestroyedHandler3},
unCatchErrorHandler: unCatchErrorHandler
);
expect(counterWillBeIncreaseWhenInvokeHandler, equals(5));
expect(counterWillBeIncreaseWhenInvokeUnCatchHandler, equals(1));
});
});
group('Handle Not Updated Error', () {
test('should not invoke notUpdatedHandlers when notUpdatedError null but notUpdatedHandlers non-null', () {
var counterWillNotBeChange = 0;
bool notUpdateHandler(MapEntry<Id, SetError> setError) {
counterWillNotBeChange++;
return false;
}
testHandler.handleSetErrors(
notUpdatedError: null,
notUpdatedHandlers: {notUpdateHandler}
);
expect(counterWillNotBeChange, equals(0));
});
test('should invoke unCatchErrorHandler when notUpdatedError null but notUpdatedHandlers null', () {
SetMethodErrors? notUpdatedError = {
Id("c1"): SetError(SetError.notFound),
};
var counterWillBeEqualOne = 0;
bool unCatchErrorHandler(MapEntry<Id, SetError> setError) {
counterWillBeEqualOne++;
return false;
}
testHandler.handleSetErrors(
notUpdatedError: notUpdatedError,
notUpdatedHandlers: null,
unCatchErrorHandler: unCatchErrorHandler
);
expect(counterWillBeEqualOne, equals(1));
});
test('should handle error successfully when notUpdatedHandlers non-null and one of them handle notUpdatedError', () {
SetMethodErrors? notUpdatedError = {
Id("c1"): SetError(SetError.notFound),
};
var counterWillBeIncreaseWhenInvokeHandler = 0;
bool notUpdatedHandler1(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
return false;
}
bool notUpdatedHandler2(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
if (setError.value.type == SetError.notFound) {
return true;
}
return false;
}
bool unCatchErrorHandler(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
return false;
}
testHandler.handleSetErrors(
notUpdatedError: notUpdatedError,
notUpdatedHandlers: {notUpdatedHandler1, notUpdatedHandler2},
unCatchErrorHandler: unCatchErrorHandler
);
expect(counterWillBeIncreaseWhenInvokeHandler, equals(2));
});
test('should stop handler error when notUpdatedHandlers non-null and one of them handle notUpdatedError successfully', () {
SetMethodErrors? notUpdatedError = {
Id("c1"): SetError(SetError.notFound),
};
var counterWillBeIncreaseWhenInvokeHandler = 0;
bool notUpdatedHandler1(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
return false;
}
bool notUpdatedHandler2(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
if (setError.value.type == SetError.notFound) {
return true;
}
return false;
}
bool notUpdatedHandler3(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
return false;
}
bool unCatchErrorHandler(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
return false;
}
testHandler.handleSetErrors(
notUpdatedError: notUpdatedError,
notUpdatedHandlers: {notUpdatedHandler1, notUpdatedHandler2, notUpdatedHandler3},
unCatchErrorHandler: unCatchErrorHandler
);
expect(counterWillBeIncreaseWhenInvokeHandler, equals(2));
});
test('should call unCatchErrorHandler when notUpdatedHandlers non-null and no-one can handle notUpdatedError', () {
SetMethodErrors? notUpdatedError = {
Id("c1"): SetError(SetError.notFound),
};
var counterWillBeIncreaseWhenInvokeHandler = 0;
bool notUpdatedHandler1(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
return false;
}
bool notUpdatedHandler2(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
return false;
}
bool unCatchErrorHandler(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
return false;
}
testHandler.handleSetErrors(
notUpdatedError: notUpdatedError,
notUpdatedHandlers: {notUpdatedHandler1, notUpdatedHandler2},
unCatchErrorHandler: unCatchErrorHandler
);
expect(counterWillBeIncreaseWhenInvokeHandler, equals(3));
});
});
group('Handle Not Created Error', () {
test('should not invoke notCreatedHandlers when notCreatedError null but notCreatedHandlers non-null', () {
var counterWillNotBeChange = 0;
bool notCreatedHandler(MapEntry<Id, SetError> setError) {
counterWillNotBeChange++;
return false;
}
testHandler.handleSetErrors(
notCreatedError: null,
notCreatedHandlers: {notCreatedHandler}
);
expect(counterWillNotBeChange, equals(0));
});
test('should invoke unCatchErrorHandler when notCreatedError null but notCreatedHandlers null', () {
SetMethodErrors? notCreatedError = {
Id("c1"): SetError(SetError.notFound),
};
var counterWillBeEqualOne = 0;
bool unCatchErrorHandler(MapEntry<Id, SetError> setError) {
counterWillBeEqualOne++;
return false;
}
testHandler.handleSetErrors(
notCreatedError: notCreatedError,
notCreatedHandlers: null,
unCatchErrorHandler: unCatchErrorHandler
);
expect(counterWillBeEqualOne, equals(1));
});
test('should handle error successfully when notCreatedHandlers non-null and one of them handle notCreatedError', () {
SetMethodErrors? notCreatedError = {
Id("c1"): SetError(SetError.notFound),
};
var counterWillBeIncreaseWhenInvokeHandler = 0;
bool notCreatedHandler1(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
return false;
}
bool notCreatedHandler2(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
if (setError.value.type == SetError.notFound) {
return true;
}
return false;
}
bool unCatchErrorHandler(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
return false;
}
testHandler.handleSetErrors(
notCreatedError: notCreatedError,
notCreatedHandlers: {notCreatedHandler1, notCreatedHandler2},
unCatchErrorHandler: unCatchErrorHandler
);
expect(counterWillBeIncreaseWhenInvokeHandler, equals(2));
});
test('should stop handler error when notCreatedHandlers non-null and one of them handle notCreatedError successfully', () {
SetMethodErrors? notCreatedError = {
Id("c1"): SetError(SetError.notFound),
};
var counterWillBeIncreaseWhenInvokeHandler = 0;
bool notCreatedHandler1(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
return false;
}
bool notCreatedHandler2(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
if (setError.value.type == SetError.notFound) {
return true;
}
return false;
}
bool notCreatedHandler3(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
return false;
}
bool unCatchErrorHandler(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
return false;
}
testHandler.handleSetErrors(
notCreatedError: notCreatedError,
notCreatedHandlers: {notCreatedHandler1, notCreatedHandler2, notCreatedHandler3},
unCatchErrorHandler: unCatchErrorHandler
);
expect(counterWillBeIncreaseWhenInvokeHandler, equals(2));
});
test('should call unCatchErrorHandler when notCreatedHandlers non-null and no-one can handle notCreatedError', () {
SetMethodErrors? notCreatedError = {
Id("c1"): SetError(SetError.notFound),
};
var counterWillBeIncreaseWhenInvokeHandler = 0;
bool notCreatedHandler1(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
return false;
}
bool notCreatedHandler2(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
return false;
}
bool unCatchErrorHandler(MapEntry<Id, SetError> setError) {
counterWillBeIncreaseWhenInvokeHandler++;
return false;
}
testHandler.handleSetErrors(
notCreatedError: notCreatedError,
notCreatedHandlers: {notCreatedHandler1, notCreatedHandler2},
unCatchErrorHandler: unCatchErrorHandler
);
expect(counterWillBeIncreaseWhenInvokeHandler, equals(3));
});
});
}