Skip to content

Commit e893b6b

Browse files
wupididuwupididu
committed
add tests
1 parent d2f9738 commit e893b6b

File tree

2 files changed

+248
-72
lines changed

2 files changed

+248
-72
lines changed

‎packages/yx_scope/test/scope_state_streamable_test.dart‎

Lines changed: 193 additions & 72 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
11
import 'package:test/test.dart';
22
import 'package:yx_scope/src/base_scope_container.dart';
3+
import 'package:yx_scope/src/core/scope_state.dart';
34
import 'package:yx_scope/yx_scope.dart';
45

56
import 'utils/test_logger.dart';
@@ -9,95 +10,215 @@ void main() {
910
ScopeObservatory.logger = const TestLogger();
1011
});
1112

12-
test('stream for scope happy path', () async {
13-
final holder = _TestScopeHolder();
13+
group('stream of scope', () {
14+
test('stream for scope happy path', () async {
15+
final holder = _TestScopeHolder();
1416

15-
int counter = 0;
16-
holder.stream.listen((scope) {
17-
if (counter % 2 == 0) {
18-
expect(scope, isNotNull);
19-
} else {
20-
expect(scope, isNull);
21-
}
17+
int counter = 0;
18+
holder.stream.listen((scope) {
19+
if (counter % 2 == 0) {
20+
expect(scope, isNotNull);
21+
} else {
22+
expect(scope, isNull);
23+
}
24+
});
25+
26+
await holder.create();
27+
counter++;
28+
await holder.drop();
29+
counter++;
30+
await holder.create();
31+
counter++;
32+
await holder.drop();
33+
counter++;
2234
});
2335

24-
await holder.create();
25-
counter++;
26-
await holder.drop();
27-
counter++;
28-
await holder.create();
29-
counter++;
30-
await holder.drop();
31-
counter++;
32-
});
36+
test('after pausing stream of scope it emits buffered events', () async {
37+
final holder = _TestScopeHolder();
3338

34-
test('after pausing stream of scope it emits buffered events', () async {
35-
final holder = _TestScopeHolder();
39+
int counter = 0;
40+
final subscription = holder.stream.listen((scope) {
41+
if (counter % 2 == 0) {
42+
expect(scope, isNotNull);
43+
} else {
44+
expect(scope, isNull);
45+
}
46+
counter++;
47+
});
3648

37-
int counter = 0;
38-
final subscription = holder.stream.listen((scope) {
39-
if (counter % 2 == 0) {
40-
expect(scope, isNotNull);
41-
} else {
42-
expect(scope, isNull);
43-
}
44-
counter++;
45-
});
49+
await holder.create();
50+
await holder.drop();
4651

47-
await holder.create();
48-
await holder.drop();
52+
subscription.pause();
4953

50-
subscription.pause();
54+
await holder.create();
55+
await holder.drop();
56+
await holder.create();
5157

52-
await holder.create();
53-
await holder.drop();
54-
await holder.create();
58+
subscription.resume();
5559

56-
subscription.resume();
60+
await holder.drop();
61+
await holder.create();
62+
await holder.drop();
63+
64+
expect(counter, 7);
65+
});
5766

58-
await holder.drop();
59-
await holder.create();
60-
await holder.drop();
67+
test('reusing the same instance of stream cause an exception', () async {
68+
final holder = _TestScopeHolder();
69+
final stream = holder.stream;
6170

62-
expect(counter, 7);
71+
stream.listen((_) {});
72+
try {
73+
stream.listen((_) {});
74+
fail('Must throw an exception');
75+
} on StateError catch (e) {
76+
expect(e.message, 'Stream has already been listened to.');
77+
}
78+
});
79+
80+
test('two different get calls return different streams', () async {
81+
final holder = _TestScopeHolder();
82+
final stream1 = holder.stream;
83+
final stream2 = holder.stream;
84+
expect(stream1, isNot(stream2));
85+
});
86+
87+
test('ask for a stream creates new listener and cancelling removes it',
88+
() async {
89+
final holder = _TestScopeHolder();
90+
final testHolder = TestableScopeStateHolder(holder);
91+
final stream1 = holder.stream;
92+
expect(testHolder.listeners.isEmpty, isTrue);
93+
final sub1 = stream1.listen((_) {});
94+
expect(testHolder.listeners.length, 1);
95+
final stream2 = holder.stream;
96+
expect(testHolder.listeners.length, 1);
97+
final sub2 = stream2.listen((_) {});
98+
expect(testHolder.listeners.length, 2);
99+
await sub1.cancel();
100+
expect(testHolder.listeners.length, 1);
101+
await sub2.cancel();
102+
expect(testHolder.listeners.isEmpty, isTrue);
103+
});
63104
});
64105

65-
test('reusing the same instance of stream cause an exception', () async {
66-
final holder = _TestScopeHolder();
67-
final stream = holder.stream;
106+
group('stream of state', () {
107+
test('stream for scope happy path', () async {
108+
final holder = _TestScopeHolder();
109+
110+
int counter = 0;
111+
holder.stateStream.listen((state) {
112+
switch (counter % 4) {
113+
case 0:
114+
expect(state, isA<ScopeStateInitializing<_TestScopeContainer>>());
115+
break;
116+
case 1:
117+
expect(state, isA<ScopeStateAvailable<_TestScopeContainer>>());
118+
expect((state as ScopeStateAvailable).scope,
119+
isA<_TestScopeContainer>());
120+
break;
121+
case 2:
122+
expect(state, isA<ScopeStateDisposing<_TestScopeContainer>>());
123+
break;
124+
case 3:
125+
expect(state, isA<ScopeStateNone<_TestScopeContainer>>());
126+
break;
127+
default:
128+
}
129+
counter++;
130+
});
131+
132+
await holder.create();
133+
await holder.drop();
134+
await holder.create();
135+
await holder.drop();
136+
await holder.create();
137+
await holder.drop();
138+
});
139+
140+
test('after pausing stream of scope it emits buffered events', () async {
141+
final holder = _TestScopeHolder();
142+
143+
int counter = 0;
144+
final subscription = holder.stateStream.listen((state) {
145+
print(counter);
146+
print(state);
147+
switch (counter % 4) {
148+
case 0:
149+
expect(state, isA<ScopeStateInitializing<_TestScopeContainer>>());
150+
break;
151+
case 1:
152+
expect(state, isA<ScopeStateAvailable<_TestScopeContainer>>());
153+
expect((state as ScopeStateAvailable).scope,
154+
isA<_TestScopeContainer>());
155+
break;
156+
case 2:
157+
expect(state, isA<ScopeStateDisposing<_TestScopeContainer>>());
158+
break;
159+
case 3:
160+
expect(state, isA<ScopeStateNone<_TestScopeContainer>>());
161+
break;
162+
default:
163+
}
164+
counter++;
165+
});
166+
167+
await holder.create();
168+
await holder.drop();
169+
170+
subscription.pause();
171+
172+
await holder.create();
173+
await holder.drop();
174+
await holder.create();
175+
176+
subscription.resume();
177+
178+
await holder.drop();
179+
await holder.create();
180+
await holder.drop();
181+
182+
expect(counter, 8);
183+
});
184+
185+
test('reusing the same instance of stream cause an exception', () async {
186+
final holder = _TestScopeHolder();
187+
final stream = holder.stateStream;
68188

69-
stream.listen((_) {});
70-
try {
71189
stream.listen((_) {});
72-
fail('Must throw an exception');
73-
} on StateError catch (e) {
74-
expect(e.message, 'Stream has already been listened to.');
75-
}
76-
});
190+
try {
191+
stream.listen((_) {});
192+
fail('Must throw an exception');
193+
} on StateError catch (e) {
194+
expect(e.message, 'Stream has already been listened to.');
195+
}
196+
});
77197

78-
test('two different get calls return different streams', () async {
79-
final holder = _TestScopeHolder();
80-
final stream1 = holder.stream;
81-
final stream2 = holder.stream;
82-
expect(stream1, isNot(stream2));
83-
});
198+
test('two different get calls return different streams', () async {
199+
final holder = _TestScopeHolder();
200+
final stream1 = holder.stateStream;
201+
final stream2 = holder.stateStream;
202+
expect(stream1, isNot(stream2));
203+
});
84204

85-
test('ask for a stream creates new listener and cancelling removes it',
86-
() async {
87-
final holder = _TestScopeHolder();
88-
final testHolder = TestableScopeStateHolder(holder);
89-
final stream1 = holder.stream;
90-
expect(testHolder.listeners.isEmpty, isTrue);
91-
final sub1 = stream1.listen((_) {});
92-
expect(testHolder.listeners.length, 1);
93-
final stream2 = holder.stream;
94-
expect(testHolder.listeners.length, 1);
95-
final sub2 = stream2.listen((_) {});
96-
expect(testHolder.listeners.length, 2);
97-
await sub1.cancel();
98-
expect(testHolder.listeners.length, 1);
99-
await sub2.cancel();
100-
expect(testHolder.listeners.isEmpty, isTrue);
205+
test('ask for a stream creates new listener and cancelling removes it',
206+
() async {
207+
final holder = _TestScopeHolder();
208+
final testHolder = TestableScopeStateHolder(holder);
209+
final stream1 = holder.stateStream;
210+
expect(testHolder.listeners.isEmpty, isTrue);
211+
final sub1 = stream1.listen((_) {});
212+
expect(testHolder.listeners.length, 1);
213+
final stream2 = holder.stateStream;
214+
expect(testHolder.listeners.length, 1);
215+
final sub2 = stream2.listen((_) {});
216+
expect(testHolder.listeners.length, 2);
217+
await sub1.cancel();
218+
expect(testHolder.listeners.length, 1);
219+
await sub2.cancel();
220+
expect(testHolder.listeners.isEmpty, isTrue);
221+
});
101222
});
102223
}
103224

‎packages/yx_scope/test/scope_state_test.dart‎

Lines changed: 55 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,55 @@
1+
import 'dart:async';
2+
3+
import 'package:test/test.dart';
4+
import 'package:yx_scope/src/core/scope_state.dart';
5+
import 'package:yx_scope/yx_scope.dart';
6+
7+
void main() {
8+
test('scope state is valid according to updates', () async {
9+
final scopeHolder = _TestScopeHolder();
10+
11+
final createCompleter = Completer();
12+
final dropCompleter = Completer();
13+
14+
;
15+
expect(scopeHolder.state, isA<ScopeStateNone<_TestScopeContainer>>());
16+
expect(scopeHolder.state.none, isTrue);
17+
scopeHolder.create().then((_) => createCompleter.complete());
18+
19+
expect(
20+
scopeHolder.state, isA<ScopeStateInitializing<_TestScopeContainer>>());
21+
expect(scopeHolder.state.initializing, isTrue);
22+
await createCompleter.future;
23+
24+
expect(scopeHolder.state, isA<ScopeStateAvailable<_TestScopeContainer>>());
25+
expect(scopeHolder.state.available, isTrue);
26+
27+
scopeHolder.drop().then((_) => dropCompleter.complete());
28+
29+
expect(scopeHolder.state, isA<ScopeStateDisposing<_TestScopeContainer>>());
30+
expect(scopeHolder.state.disposing, isTrue);
31+
32+
await dropCompleter.future;
33+
34+
expect(scopeHolder.state, isA<ScopeStateNone<_TestScopeContainer>>());
35+
expect(scopeHolder.state.none, isTrue);
36+
});
37+
}
38+
39+
class _TestScopeHolder extends ScopeHolder<_TestScopeContainer> {
40+
@override
41+
_TestScopeContainer createContainer() => _TestScopeContainer();
42+
}
43+
44+
class _TestScopeContainer extends ScopeContainer {
45+
@override
46+
List<Set<AsyncDep>> get initializeQueue => [
47+
{_asyncDep}
48+
];
49+
50+
late final _asyncDep = rawAsyncDep(
51+
() => Future.delayed(Duration.zero),
52+
init: (dep) async => await dep,
53+
dispose: (dep) async {},
54+
);
55+
}

0 commit comments

Comments
 (0)