Skip to content

Commit 0e22b45

Browse files
kevmookevmoo
authored
Cleanup structure of build_step_impl_test (#306)
Remove one layer of nesting Removed variables that don't need to be shared
1 parent eac6ce0 commit 0e22b45

File tree

1 file changed

+152
-163
lines changed

1 file changed

+152
-163
lines changed

‎build/test/builder/build_step_impl_test.dart‎

Lines changed: 152 additions & 163 deletions
Original file line numberDiff line numberDiff line change
@@ -13,198 +13,187 @@ import 'package:build/build.dart';
1313
import 'package:build/src/builder/build_step_impl.dart';
1414

1515
void main() {
16-
group('BuildStepImpl ', () {
17-
AssetWriter writer;
18-
AssetReader reader;
19-
20-
group('with reader/writer stub', () {
21-
AssetId primary;
22-
BuildStepImpl buildStep;
23-
24-
setUp(() {
25-
reader = new StubAssetReader();
26-
writer = new StubAssetWriter();
27-
primary = makeAssetId();
28-
buildStep = new BuildStepImpl(primary, [], reader, writer,
29-
primary.package, const BarbackResolvers());
30-
});
31-
32-
test('doesnt allow non-expected outputs', () {
33-
var id = makeAssetId();
34-
expect(() => buildStep.writeAsString(id, '$id'),
35-
throwsA(new isInstanceOf<UnexpectedOutputException>()));
36-
});
37-
38-
test('canRead throws invalidInputExceptions', () async {
39-
expect(() => buildStep.canRead(makeAssetId('b|web/a.txt')),
40-
throwsA(invalidInputException));
41-
expect(() => buildStep.canRead(makeAssetId('b|a.txt')),
42-
throwsA(invalidInputException));
43-
expect(() => buildStep.canRead(makeAssetId('foo|bar.txt')),
44-
throwsA(invalidInputException));
45-
});
16+
group('with reader/writer stub', () {
17+
AssetId primary;
18+
BuildStepImpl buildStep;
19+
20+
setUp(() {
21+
var reader = new StubAssetReader();
22+
var writer = new StubAssetWriter();
23+
primary = makeAssetId();
24+
buildStep = new BuildStepImpl(primary, [], reader, writer,
25+
primary.package, const BarbackResolvers());
26+
});
4627

47-
test('hasInput behaves like canRead', () async {
48-
expect(() => buildStep.hasInput(makeAssetId('b|web/a.txt')),
49-
throwsA(invalidInputException));
50-
expect(() => buildStep.hasInput(makeAssetId('b|a.txt')),
51-
throwsA(invalidInputException));
52-
expect(() => buildStep.hasInput(makeAssetId('foo|bar.txt')),
53-
throwsA(invalidInputException));
54-
});
28+
test('doesnt allow non-expected outputs', () {
29+
var id = makeAssetId();
30+
expect(() => buildStep.writeAsString(id, '$id'),
31+
throwsA(new isInstanceOf<UnexpectedOutputException>()));
32+
});
5533

56-
test('readAs* throws InvalidInputExceptions', () async {
57-
var invalidInputs = [
58-
makeAssetId('b|web/a.txt'),
59-
makeAssetId('b|a.txt'),
60-
makeAssetId('foo|bar.txt')
61-
];
62-
for (var id in invalidInputs) {
63-
expect(
64-
() => buildStep.readAsString(id), throwsA(invalidInputException));
65-
expect(
66-
() => buildStep.readAsBytes(id), throwsA(invalidInputException));
67-
}
68-
});
34+
test('canRead throws invalidInputExceptions', () async {
35+
expect(() => buildStep.canRead(makeAssetId('b|web/a.txt')),
36+
throwsA(invalidInputException));
37+
expect(() => buildStep.canRead(makeAssetId('b|a.txt')),
38+
throwsA(invalidInputException));
39+
expect(() => buildStep.canRead(makeAssetId('foo|bar.txt')),
40+
throwsA(invalidInputException));
41+
});
6942

70-
test('writeAs* throws InvalidOutputExceptions', () async {
71-
var invalidOutputIds = [
72-
makeAssetId('b|test.txt'),
73-
makeAssetId('foo|bar.txt'),
74-
];
75-
for (var id in invalidOutputIds) {
76-
expect(() => buildStep.writeAsString(id, 'foo'),
77-
throwsA(invalidOutputException));
78-
expect(() => buildStep.writeAsBytes(id, [0]),
79-
throwsA(invalidOutputException));
80-
}
81-
});
43+
test('hasInput behaves like canRead', () async {
44+
expect(() => buildStep.hasInput(makeAssetId('b|web/a.txt')),
45+
throwsA(invalidInputException));
46+
expect(() => buildStep.hasInput(makeAssetId('b|a.txt')),
47+
throwsA(invalidInputException));
48+
expect(() => buildStep.hasInput(makeAssetId('foo|bar.txt')),
49+
throwsA(invalidInputException));
8250
});
8351

84-
group('with in memory file system', () {
85-
InMemoryAssetWriter writer;
86-
InMemoryAssetReader reader;
52+
test('readAs* throws InvalidInputExceptions', () async {
53+
var invalidInputs = [
54+
makeAssetId('b|web/a.txt'),
55+
makeAssetId('b|a.txt'),
56+
makeAssetId('foo|bar.txt')
57+
];
58+
for (var id in invalidInputs) {
59+
expect(
60+
() => buildStep.readAsString(id), throwsA(invalidInputException));
61+
expect(() => buildStep.readAsBytes(id), throwsA(invalidInputException));
62+
}
63+
});
8764

88-
setUp(() {
89-
writer = new InMemoryAssetWriter();
90-
reader = new InMemoryAssetReader(sourceAssets: writer.assets);
91-
});
65+
test('writeAs* throws InvalidOutputExceptions', () async {
66+
var invalidOutputIds = [
67+
makeAssetId('b|test.txt'),
68+
makeAssetId('foo|bar.txt'),
69+
];
70+
for (var id in invalidOutputIds) {
71+
expect(() => buildStep.writeAsString(id, 'foo'),
72+
throwsA(invalidOutputException));
73+
expect(() => buildStep.writeAsBytes(id, [0]),
74+
throwsA(invalidOutputException));
75+
}
76+
});
77+
});
9278

93-
test('tracks outputs created by a builder', () async {
94-
var builder = new CopyBuilder();
95-
var primary = makeAssetId('a|web/primary.txt');
96-
var inputs = {
97-
primary: 'foo',
98-
};
99-
addAssets(inputs, writer);
100-
var outputId = new AssetId.parse('$primary.copy');
101-
var buildStep = new BuildStepImpl(
102-
primary, [outputId], reader, writer, 'a', const BarbackResolvers());
79+
group('with in memory file system', () {
80+
InMemoryAssetWriter writer;
81+
InMemoryAssetReader reader;
10382

104-
await builder.build(buildStep);
105-
await buildStep.complete();
83+
setUp(() {
84+
writer = new InMemoryAssetWriter();
85+
reader = new InMemoryAssetReader(sourceAssets: writer.assets);
86+
});
10687

107-
// One output.
108-
expect(writer.assets[outputId].stringValue, 'foo');
109-
});
88+
test('tracks outputs created by a builder', () async {
89+
var builder = new CopyBuilder();
90+
var primary = makeAssetId('a|web/primary.txt');
91+
var inputs = {
92+
primary: 'foo',
93+
};
94+
addAssets(inputs, writer);
95+
var outputId = new AssetId.parse('$primary.copy');
96+
var buildStep = new BuildStepImpl(
97+
primary, [outputId], reader, writer, 'a', const BarbackResolvers());
98+
99+
await builder.build(buildStep);
100+
await buildStep.complete();
101+
102+
// One output.
103+
expect(writer.assets[outputId].stringValue, 'foo');
104+
});
110105

111-
group('resolve', () {
112-
test('can resolve assets', () async {
113-
var inputs = {
114-
makeAssetId('a|web/a.dart'): '''
106+
group('resolve', () {
107+
test('can resolve assets', () async {
108+
var inputs = {
109+
makeAssetId('a|web/a.dart'): '''
115110
library a;
116111
117112
import 'b.dart';
118113
''',
119-
makeAssetId('a|web/b.dart'): '''
114+
makeAssetId('a|web/b.dart'): '''
120115
library b;
121116
''',
122-
};
123-
addAssets(inputs, writer);
124-
125-
var primary = makeAssetId('a|web/a.dart');
126-
var buildStep = new BuildStepImpl(primary, [], reader, writer,
127-
primary.package, const BarbackResolvers());
128-
var resolver = await buildStep.resolver;
129-
130-
var aLib = resolver.getLibrary(primary);
131-
expect(aLib.name, 'a');
132-
expect(aLib.importedLibraries.length, 2);
133-
expect(aLib.importedLibraries.any((library) => library.name == 'b'),
134-
isTrue);
135-
136-
var bLib = resolver.getLibraryByName('b');
137-
expect(bLib.name, 'b');
138-
expect(bLib.importedLibraries.length, 1);
139-
140-
await buildStep.complete();
141-
});
117+
};
118+
addAssets(inputs, writer);
119+
120+
var primary = makeAssetId('a|web/a.dart');
121+
var buildStep = new BuildStepImpl(primary, [], reader, writer,
122+
primary.package, const BarbackResolvers());
123+
var resolver = await buildStep.resolver;
124+
125+
var aLib = resolver.getLibrary(primary);
126+
expect(aLib.name, 'a');
127+
expect(aLib.importedLibraries.length, 2);
128+
expect(aLib.importedLibraries.any((library) => library.name == 'b'),
129+
isTrue);
130+
131+
var bLib = resolver.getLibraryByName('b');
132+
expect(bLib.name, 'b');
133+
expect(bLib.importedLibraries.length, 1);
134+
135+
await buildStep.complete();
142136
});
143137
});
138+
});
144139

145-
group('With slow writes', () {
146-
BuildStepImpl buildStep;
147-
SlowAssetWriter assetWriter;
148-
AssetId outputId;
149-
String outputContent;
150-
151-
setUp(() async {
152-
var primary = makeAssetId();
153-
assetWriter = new SlowAssetWriter();
154-
outputId = makeAssetId('a|test.txt');
155-
outputContent = '$outputId';
156-
buildStep = new BuildStepImpl(
157-
primary,
158-
[outputId],
159-
new StubAssetReader(),
160-
assetWriter,
161-
primary.package,
162-
const BarbackResolvers());
163-
});
140+
group('With slow writes', () {
141+
BuildStepImpl buildStep;
142+
SlowAssetWriter assetWriter;
143+
AssetId outputId;
144+
String outputContent;
145+
146+
setUp(() async {
147+
var primary = makeAssetId();
148+
assetWriter = new SlowAssetWriter();
149+
outputId = makeAssetId('a|test.txt');
150+
outputContent = '$outputId';
151+
buildStep = new BuildStepImpl(primary, [outputId], new StubAssetReader(),
152+
assetWriter, primary.package, const BarbackResolvers());
153+
});
164154

165-
test('Completes only after writes finish', () async {
166-
// ignore: unawaited_futures
167-
buildStep.writeAsString(outputId, outputContent);
168-
var isComplete = false;
169-
// ignore: unawaited_futures
170-
buildStep.complete().then((_) {
171-
isComplete = true;
172-
});
173-
await new Future(() {});
174-
expect(isComplete, false,
175-
reason: 'File has not written, should not be complete');
176-
assetWriter.finishWrite();
177-
await new Future(() {});
178-
expect(isComplete, true, reason: 'File is written, should be complete');
155+
test('Completes only after writes finish', () async {
156+
// ignore: unawaited_futures
157+
buildStep.writeAsString(outputId, outputContent);
158+
var isComplete = false;
159+
// ignore: unawaited_futures
160+
buildStep.complete().then((_) {
161+
isComplete = true;
179162
});
163+
await new Future(() {});
164+
expect(isComplete, false,
165+
reason: 'File has not written, should not be complete');
166+
assetWriter.finishWrite();
167+
await new Future(() {});
168+
expect(isComplete, true, reason: 'File is written, should be complete');
169+
});
180170

181-
test('Completes only after async writes finish', () async {
182-
var outputCompleter = new Completer<String>();
183-
// ignore: unawaited_futures
184-
buildStep.writeAsString(outputId, outputCompleter.future);
185-
var isComplete = false;
186-
// ignore: unawaited_futures
187-
buildStep.complete().then((_) {
188-
isComplete = true;
189-
});
190-
await new Future(() {});
191-
expect(isComplete, false,
192-
reason: 'File has not resolved, should not be complete');
193-
outputCompleter.complete(outputContent);
194-
await new Future(() {});
195-
expect(isComplete, false,
196-
reason: 'File has not written, should not be complete');
197-
assetWriter.finishWrite();
198-
await new Future(() {});
199-
expect(isComplete, true, reason: 'File is written, should be complete');
171+
test('Completes only after async writes finish', () async {
172+
var outputCompleter = new Completer<String>();
173+
// ignore: unawaited_futures
174+
buildStep.writeAsString(outputId, outputCompleter.future);
175+
var isComplete = false;
176+
// ignore: unawaited_futures
177+
buildStep.complete().then((_) {
178+
isComplete = true;
200179
});
180+
await new Future(() {});
181+
expect(isComplete, false,
182+
reason: 'File has not resolved, should not be complete');
183+
outputCompleter.complete(outputContent);
184+
await new Future(() {});
185+
expect(isComplete, false,
186+
reason: 'File has not written, should not be complete');
187+
assetWriter.finishWrite();
188+
await new Future(() {});
189+
expect(isComplete, true, reason: 'File is written, should be complete');
201190
});
202191
});
203192
}
204193

205194
class SlowAssetWriter implements AssetWriter {
206195
final _writeCompleter = new Completer<Null>();
207-
196+
208197
void finishWrite() {
209198
_writeCompleter.complete(null);
210199
}

0 commit comments

Comments
 (0)