/
hooks_test.dart
153 lines (131 loc) · 4.28 KB
/
hooks_test.dart
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
import 'dart:io';
import 'package:mason/mason.dart';
import 'package:mason/src/generator.dart';
import 'package:path/path.dart' as path;
import 'package:test/test.dart';
void main() {
group('Hooks', () {
test(
'throws HookInvalidCharactersException '
'when containining non-ascii characters', () async {
final brick = Brick.path(
path.join('test', 'fixtures', 'unicode_hook'),
);
final generator = await MasonGenerator.fromBrick(brick);
try {
await generator.hooks.preGen();
fail('should throw');
} catch (error) {
expect(error, isA<HookInvalidCharactersException>());
}
});
test(
'throws HookDependencyInstallFailure '
'when pubspec is malformed', () async {
final brick = Brick.path(
path.join('test', 'fixtures', 'malformed_pubspec'),
);
final generator = await MasonGenerator.fromBrick(brick);
try {
await generator.hooks.preGen();
fail('should throw');
} catch (error) {
expect(error, isA<HookDependencyInstallFailure>());
}
});
test(
'throws HookRunException '
'when unable to resolve a type', () async {
final brick = Brick.path(
path.join('test', 'fixtures', 'spawn_exception'),
);
final generator = await MasonGenerator.fromBrick(brick);
try {
await generator.hooks.preGen();
fail('should throw');
} catch (error) {
expect(error, isA<HookRunException>());
}
});
test(
'throws HookRunException '
'when unable to resolve a type (back-to-back)', () async {
final brick = Brick.path(
path.join('test', 'fixtures', 'spawn_exception'),
);
final generator = await MasonGenerator.fromBrick(brick);
try {
await generator.hooks.preGen();
fail('should throw');
} catch (error) {
expect(error, isA<HookRunException>());
}
try {
await generator.hooks.preGen();
fail('should throw');
} catch (error) {
expect(error, isA<HookRunException>());
}
});
test(
'throws HookMissingRunException '
'when hook does not contain a valid run method', () async {
final brick = Brick.path(
path.join('test', 'fixtures', 'missing_run'),
);
final generator = await MasonGenerator.fromBrick(brick);
try {
await generator.hooks.preGen();
fail('should throw');
} catch (error) {
expect(error, isA<HookMissingRunException>());
}
});
test('throws HookRunException when hook cannot be run', () async {
final brick = Brick.path(
path.join('test', 'fixtures', 'run_exception'),
);
final generator = await MasonGenerator.fromBrick(brick);
try {
await generator.hooks.preGen();
fail('should throw');
} catch (error) {
expect(error, isA<HookRunException>());
}
});
test('throws HookExecutionException when hook throws', () async {
final brick = Brick.path(
path.join('test', 'fixtures', 'execution_exception'),
);
final generator = await MasonGenerator.fromBrick(brick);
try {
await generator.hooks.preGen();
fail('should throw');
} catch (error) {
expect(error, isA<HookExecutionException>());
}
});
test(
'throws HookDependencyInstallFailure '
'when dependencies cannot be resolved', () async {
final brick = Brick.path(
path.join('test', 'fixtures', 'dependency_install_failure'),
);
final generator = await MasonGenerator.fromBrick(brick);
try {
await generator.hooks.preGen();
fail('should throw');
} catch (error) {
expect(error, isA<HookDependencyInstallFailure>());
}
});
test('recovers from cleared pub cache', () async {
final brick = Brick.path(path.join('test', 'fixtures', 'basic'));
final generator = await MasonGenerator.fromBrick(brick);
await expectLater(generator.hooks.preGen(), completes);
final result = await Process.run('dart', ['pub', 'cache', 'clean']);
expect(result.exitCode, equals(ExitCode.success.code));
await expectLater(generator.hooks.preGen(), completes);
});
});
}