Skip to content

Commit ef09f95

Browse files
GuldemGuldem
committed
✅ Added tests for BoltLogger and memory charge
1 parent 3f2f654 commit ef09f95

File tree

5 files changed

+300
-69
lines changed

5 files changed

+300
-69
lines changed

‎pubspec.yaml‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,7 @@ dev_dependencies:
2222
sdk: flutter
2323
http: ^1.1.2
2424
mocktail: ^1.0.2
25-
parameterized_test: ^1.1.1
25+
parameterized_test: ^1.1.3
2626
very_good_analysis: ^5.1.0
2727

2828

‎test/dcc_logger_test.dart‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,4 @@
1+
//ignore_for_file: deprecated_member_use_from_same_package
12
import 'package:dcc_toolkit/common/dcc_logger.dart';
23
import 'package:flutter_test/flutter_test.dart';
34
import 'package:logging/logging.dart';

‎test/logger/bolt_logger.dart‎

Lines changed: 0 additions & 68 deletions
This file was deleted.

‎test/logger/bolt_logger_test.dart‎

Lines changed: 247 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,247 @@
1+
import 'package:dcc_toolkit/dcc_toolkit.dart';
2+
import 'package:flutter_test/flutter_test.dart';
3+
import 'package:logging/logging.dart';
4+
import 'package:mocktail/mocktail.dart';
5+
import 'package:parameterized_test/parameterized_test.dart';
6+
7+
class _MockCharge extends Mock implements BoltCharge {}
8+
9+
void main() {
10+
tearDown(() => BoltLogger().discharge());
11+
12+
group('charge tests', () {
13+
test('BoltLogger without a charge only redirect log event to root Logger', () {
14+
final records = <LogRecord>[];
15+
Logger.root.level = Level.ALL;
16+
final sub = Logger.root.onRecord.listen(records.add);
17+
18+
BoltLogger.zap('zap1');
19+
BoltLogger.zap('zap2');
20+
BoltLogger.shock('shock1');
21+
BoltLogger.shock('shock2');
22+
23+
expect(records.length, 4);
24+
expect(records[0].message, 'zap1');
25+
expect(records[1].message, 'zap2');
26+
expect(records[2].message, 'shock1');
27+
expect(records[3].message, 'shock2');
28+
29+
sub.cancel();
30+
});
31+
32+
test('BoltLogger can only contain 1 charge of the same type', () {
33+
final memoryCharge1 = MemoryCharge(maxItems: 1);
34+
final memoryCharge2 = MemoryCharge(maxItems: 2);
35+
BoltLogger.charge([memoryCharge1, memoryCharge2]);
36+
37+
BoltLogger.zap('zap');
38+
39+
expect(
40+
BoltLogger.getCharge('MemoryCharge'),
41+
isA<MemoryCharge>().having(
42+
(e) => e.maxItems,
43+
'maxItems',
44+
1,
45+
),
46+
);
47+
expect(memoryCharge1.items.length, 1);
48+
expect(memoryCharge2.items.length, 0);
49+
});
50+
51+
test('BoltLogger discharge, discharges all charges', () {
52+
final charge = _MockCharge();
53+
final charge2 = _MockCharge();
54+
when(() => charge.name).thenReturn('MockCharge');
55+
when(() => charge2.name).thenReturn('MockCharge2');
56+
when(() => charge.discharge()).thenReturn(null);
57+
when(() => charge2.discharge()).thenReturn(null);
58+
59+
BoltLogger.charge([charge, charge2]);
60+
BoltLogger().discharge();
61+
62+
verify(() => charge.discharge()).called(1);
63+
verify(() => charge2.discharge()).called(1);
64+
});
65+
});
66+
67+
group('zap test', () {
68+
late MemoryCharge memoryCharge;
69+
setUp(() {
70+
memoryCharge = MemoryCharge();
71+
BoltLogger.charge([memoryCharge]);
72+
});
73+
74+
parameterizedGroup1('BoltLogger/extension function tests', [true, false], (bool useBoltLogger) {
75+
test('zap/shock sends a message via a ZapEvent to a charge', () {
76+
if (useBoltLogger) {
77+
BoltLogger.zap('zap');
78+
BoltLogger.shock('shock');
79+
} else {
80+
TestReferenceClass().zapExtension('zap');
81+
TestReferenceClass().shockExtension('shock');
82+
}
83+
84+
expect(memoryCharge.items.length, 2);
85+
expect(memoryCharge.items[0].origin.message, 'zap');
86+
expect(memoryCharge.items[0].origin.loggerName, useBoltLogger ? 'BoltLogger' : 'TestReferenceClass');
87+
expect(memoryCharge.items[1].origin.message, 'shock');
88+
expect(memoryCharge.items[1].origin.loggerName, useBoltLogger ? 'BoltLogger' : 'TestReferenceClass');
89+
expect(memoryCharge.items[1].origin.level, Level.SEVERE);
90+
});
91+
92+
test('zap/shock sends a tag via a ZapEvent to a charge', () {
93+
if (useBoltLogger) {
94+
BoltLogger.zap('zap', tag: 'tag1');
95+
BoltLogger.shock('shock', tag: 'tag2');
96+
} else {
97+
TestReferenceClass().zapExtension('zap', tag: 'tag1');
98+
TestReferenceClass().shockExtension('shock', tag: 'tag2');
99+
}
100+
101+
expect(memoryCharge.items.length, 2);
102+
expect(memoryCharge.items[0].origin.loggerName, 'tag1');
103+
expect(memoryCharge.items[1].origin.loggerName, 'tag2');
104+
expect(memoryCharge.items[1].origin.level, Level.SEVERE);
105+
});
106+
107+
parameterizedTest1('zap/shock sends a LogLevel via a ZapEvent to a Charge', [
108+
Level.ALL,
109+
Level.CONFIG,
110+
Level.FINE,
111+
Level.FINER,
112+
Level.FINEST,
113+
Level.INFO,
114+
Level.OFF,
115+
Level.SEVERE,
116+
Level.SHOUT,
117+
Level.WARNING,
118+
], (Level level) {
119+
if (useBoltLogger) {
120+
BoltLogger.zap('zap', level: level);
121+
BoltLogger.zap('shock', level: level);
122+
} else {
123+
TestReferenceClass().zapExtension('zap', level: level);
124+
TestReferenceClass().shockExtension('shock', level: level);
125+
}
126+
127+
expect(memoryCharge.items.length, 2);
128+
expect(memoryCharge.items[0].origin.level, level);
129+
expect(memoryCharge.items[1].origin.level, level);
130+
});
131+
132+
test('zap/shock sends Exception via a ZapEvent to a Charge', () {
133+
final exception = Exception('exception');
134+
if (useBoltLogger) {
135+
BoltLogger.zap(exception);
136+
BoltLogger.shock(exception);
137+
} else {
138+
TestReferenceClass().zapExtension(exception);
139+
TestReferenceClass().shockExtension(exception);
140+
}
141+
142+
expect(memoryCharge.items.length, 2);
143+
expect(memoryCharge.items[0].origin.error, exception);
144+
expect(memoryCharge.items[1].origin.error, exception);
145+
});
146+
147+
test('zap/shock sends Error via a ZapEvent to a Charge', () {
148+
final error = Error();
149+
if (useBoltLogger) {
150+
BoltLogger.zap(error);
151+
BoltLogger.shock(error);
152+
} else {
153+
TestReferenceClass().zapExtension(error);
154+
TestReferenceClass().shockExtension(error);
155+
}
156+
157+
expect(memoryCharge.items.length, 2);
158+
expect(memoryCharge.items[0].origin.error, error);
159+
expect(memoryCharge.items[1].origin.error, error);
160+
});
161+
162+
test('zap/shock sends StackTrace via a ZapEvent to a Charge', () {
163+
final stackTrace = StackTrace.current;
164+
if (useBoltLogger) {
165+
BoltLogger.zap(stackTrace);
166+
BoltLogger.shock(stackTrace);
167+
} else {
168+
TestReferenceClass().zapExtension(stackTrace);
169+
TestReferenceClass().shockExtension(stackTrace);
170+
}
171+
172+
expect(memoryCharge.items.length, 2);
173+
expect(memoryCharge.items[0].origin.stackTrace, stackTrace);
174+
expect(memoryCharge.items[1].origin.stackTrace, stackTrace);
175+
});
176+
177+
test('zap/shock sends Function via a ZapEvent to a Charge', () {
178+
String func() => 'function';
179+
if (useBoltLogger) {
180+
BoltLogger.zap(func);
181+
BoltLogger.shock(func);
182+
} else {
183+
TestReferenceClass().zapExtension(func);
184+
TestReferenceClass().shockExtension(func);
185+
}
186+
187+
expect(memoryCharge.items.length, 2);
188+
expect(memoryCharge.items[0].origin.message, 'function');
189+
expect(memoryCharge.items[1].origin.message, 'function');
190+
});
191+
192+
test('zap/shock sends Object via a ZapEvent to a Charge', () {
193+
if (useBoltLogger) {
194+
BoltLogger.zap(1);
195+
BoltLogger.shock(1);
196+
} else {
197+
TestReferenceClass().zapExtension(1);
198+
TestReferenceClass().shockExtension(1);
199+
}
200+
201+
expect(memoryCharge.items.length, 2);
202+
expect(memoryCharge.items[0].origin.message, '1');
203+
expect(memoryCharge.items[1].origin.message, '1');
204+
});
205+
206+
test('zap/shock sends a List via a ZapEvent to a Charge', () {
207+
final exception = Exception('exception');
208+
final stackTrace = StackTrace.current;
209+
if (useBoltLogger) {
210+
BoltLogger.zap(['zap', exception, stackTrace]);
211+
BoltLogger.shock(['shock', exception, stackTrace]);
212+
} else {
213+
TestReferenceClass().zapExtension(['zap', exception, stackTrace]);
214+
TestReferenceClass().shockExtension(['shock', exception, stackTrace]);
215+
}
216+
217+
expect(memoryCharge.items.length, 2);
218+
expect(memoryCharge.items[0].origin.message, 'zap');
219+
expect(memoryCharge.items[0].origin.error, exception);
220+
expect(memoryCharge.items[0].origin.stackTrace, stackTrace);
221+
expect(memoryCharge.items[1].origin.message, 'shock');
222+
expect(memoryCharge.items[1].origin.error, exception);
223+
expect(memoryCharge.items[1].origin.stackTrace, stackTrace);
224+
});
225+
226+
test('zap/shock sends a List with more than 3 elements via a ZapEvent to a Charge', () {
227+
final exception = Exception('exception');
228+
final stackTrace = StackTrace.current;
229+
final error = Error();
230+
if (useBoltLogger) {
231+
expect(() => BoltLogger.zap(['zap', exception, stackTrace, error]), throwsAssertionError);
232+
expect(() => BoltLogger.shock(['shock', exception, stackTrace, error]), throwsAssertionError);
233+
} else {
234+
expect(() => TestReferenceClass().zapExtension(['zap', exception, stackTrace, error]), throwsAssertionError);
235+
expect(() => TestReferenceClass().shockExtension(['shock', exception, stackTrace, error]), throwsAssertionError);
236+
}
237+
});
238+
});
239+
});
240+
}
241+
242+
class TestReferenceClass {
243+
void zapExtension(Object? message, {String? tag, Level level = Level.INFO}) => zap(message, tag: tag, level: level);
244+
245+
void shockExtension(Object? message, {String? tag, Level level = Level.SEVERE}) =>
246+
shock(message, tag: tag, level: level);
247+
}

‎test/logger/memory_charge_test.dart‎

Lines changed: 51 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,51 @@
1+
import 'package:dcc_toolkit/dcc_toolkit.dart';
2+
import 'package:flutter_test/flutter_test.dart';
3+
import 'package:logging/logging.dart';
4+
5+
void main() {
6+
test('ZapEvents are added to the items and stream', () async {
7+
final memoryCharge = MemoryCharge();
8+
final streamedEvents = <ZapEvent>[];
9+
memoryCharge.stream.listen(streamedEvents.add);
10+
11+
expect(memoryCharge.items, isEmpty);
12+
13+
memoryCharge.logOutput(_produceEvent('test event'));
14+
await Future<void>.delayed(Duration.zero);
15+
16+
expect(memoryCharge.items.length, 1);
17+
expect(streamedEvents.length, 1);
18+
19+
memoryCharge.discharge();
20+
});
21+
22+
test('ZapEvents dont exceed limit', () async {
23+
final memoryCharge = MemoryCharge(maxItems: 5);
24+
final streamedEvents = <ZapEvent>[];
25+
memoryCharge.stream.listen(streamedEvents.add);
26+
27+
expect(memoryCharge.items, isEmpty);
28+
29+
for (var i = 0; i < 10; i++) {
30+
memoryCharge.logOutput(_produceEvent('$i'));
31+
await Future<void>.delayed(Duration.zero);
32+
}
33+
34+
expect(memoryCharge.items.length, 5);
35+
expect(memoryCharge.items.first.origin.message, '5');
36+
expect(memoryCharge.items.last.origin.message, '9');
37+
expect(streamedEvents.length, 10);
38+
39+
memoryCharge.discharge();
40+
});
41+
}
42+
43+
ZapEvent _produceEvent(String input) {
44+
return ZapEvent.fromRecord(
45+
LogRecord(
46+
Level.INFO,
47+
input,
48+
'test',
49+
),
50+
);
51+
}

0 commit comments

Comments
 (0)