pkg/polymer/test/paths_test.dart - Issue 23445009: Prune the old deploy code. This CL does a few changes:

Side by Side Diff: pkg/polymer/test/paths_test.dart

Issue 23445009: Prune the old deploy code. This CL does a few changes: (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart

Patch Set: Created 7 years, 3 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch | Annotate | Revision Log

OLD	NEW
	(Empty)
1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file

2 // for details. All rights reserved. Use of this source code is governed by a

3 // BSD-style license that can be found in the LICENSE file.

4

5 /** Tests for [PathMapper]. */

6 library path_info_test;

7

8 import 'package:path/path.dart' as path;

9 import 'package:polymer/src/info.dart';

10 import 'package:polymer/src/paths.dart';

11 import 'package:polymer/src/utils.dart' as utils;

12 import 'package:unittest/compact_vm_config.dart';

13 import 'package:unittest/unittest.dart';

14

15 main() {

16 useCompactVMConfiguration();

17 group('paths', () {

18 setUp(() {

19 utils.path = new path.Builder(style: path.Style.posix);

20 });

21

22 tearDown(() {

23 utils.path = new path.Builder();

24 });

25

26 testPaths();

27 });

28 }

29

30 testPaths() {

31 group('outdir == basedir:', () {

32 group('outputPath', () {

33 test('mangle automatic', () {

34 var pathMapper = _newPathMapper('a', 'a', false);

35 var file = _mockFile('a/b.dart', pathMapper);

36 expect(file.dartCodeUrl.resolvedPath, 'a/b.dart');

37 expect(pathMapper.outputPath(file.dartCodeUrl.resolvedPath, '.dart'),

38 'a/_b.dart.dart');

39 });

40

41 test('within packages/', () {

42 var pathMapper = _newPathMapper('a', 'a', false);

43 var file = _mockFile('a/packages/b.dart', pathMapper);

44 expect(file.dartCodeUrl.resolvedPath, 'a/packages/b.dart');

45 expect(pathMapper.outputPath(file.dartCodeUrl.resolvedPath, '.dart'),

46 'a/_from_packages/_b.dart.dart');

47 });

48 });

49

50 group('importUrlFor', () {

51 test('simple pathMapper', () {

52 var pathMapper = _newPathMapper('a', 'a', false);

53 var file1 = _mockFile('a/b.dart', pathMapper);

54 var file2 = _mockFile('a/c/d.dart', pathMapper);

55 var file3 = _mockFile('a/e/f.dart', pathMapper);

56 expect(pathMapper.importUrlFor(file1, file2), 'c/_d.dart.dart');

57 expect(pathMapper.importUrlFor(file1, file3), 'e/_f.dart.dart');

58 expect(pathMapper.importUrlFor(file2, file1), '../_b.dart.dart');

59 expect(pathMapper.importUrlFor(file2, file3), '../e/_f.dart.dart');

60 expect(pathMapper.importUrlFor(file3, file2), '../c/_d.dart.dart');

61 expect(pathMapper.importUrlFor(file3, file1), '../_b.dart.dart');

62 });

63

64 test('include packages/', () {

65 var pathMapper = _newPathMapper('a', 'a', false);

66 var file1 = _mockFile('a/b.dart', pathMapper);

67 var file2 = _mockFile('a/c/d.dart', pathMapper);

68 var file3 = _mockFile('a/packages/f.dart', pathMapper);

69 expect(pathMapper.importUrlFor(file1, file2), 'c/_d.dart.dart');

70 expect(pathMapper.importUrlFor(file1, file3),

71 '_from_packages/_f.dart.dart');

72 expect(pathMapper.importUrlFor(file2, file1), '../_b.dart.dart');

73 expect(pathMapper.importUrlFor(file2, file3),

74 '../_from_packages/_f.dart.dart');

75 expect(pathMapper.importUrlFor(file3, file2), '../c/_d.dart.dart');

76 expect(pathMapper.importUrlFor(file3, file1), '../_b.dart.dart');

77 });

78

79 test('packages, but no rewrite', () {

80 var pathMapper = _newPathMapper('a', 'a', false, rewriteUrls: false);

81 var file1 = _mockFile('a/b.dart', pathMapper);

82 var file2 = _mockFile('a/c/d.dart', pathMapper);

83 var file3 = _mockFile('a/packages/c/f.dart', pathMapper,

84 url: 'package:e/f.dart');

85 expect(pathMapper.importUrlFor(file1, file2), 'c/_d.dart.dart');

86 expect(pathMapper.importUrlFor(file1, file3),

87 'package:e/_f.dart.dart');

88 expect(pathMapper.importUrlFor(file2, file1), '../_b.dart.dart');

89 expect(pathMapper.importUrlFor(file2, file3),

90 'package:e/_f.dart.dart');

91 });

92

93 test('windows paths', () {

94 try {

95 utils.path = new path.Builder(style: path.Style.windows);

96 var pathMapper = _newPathMapper('a', 'a', false);

97 var file1 = _mockFile('a\\b.dart', pathMapper);

98 var file2 = _mockFile('a\\c\\d.dart', pathMapper);

99 var file3 = _mockFile('a\\packages\\f.dart', pathMapper);

100 expect(pathMapper.importUrlFor(file1, file2), 'c/_d.dart.dart');

101 expect(pathMapper.importUrlFor(file1, file3),

102 '_from_packages/_f.dart.dart');

103 expect(pathMapper.importUrlFor(file2, file1), '../_b.dart.dart');

104 expect(pathMapper.importUrlFor(file2, file3),

105 '../_from_packages/_f.dart.dart');

106 expect(pathMapper.importUrlFor(file3, file2), '../c/_d.dart.dart');

107 expect(pathMapper.importUrlFor(file3, file1), '../_b.dart.dart');

108 } finally {

109 utils.path = new path.Builder();

110 }

111 });

112 });

113

114 test('transformUrl simple paths', () {

115 var pathMapper = _newPathMapper('a', 'a', false);

116 var file1 = 'a/b.dart';

117 var file2 = 'a/c/d.html';

118 // when the output == input directory, no paths should be rewritten

119 expect(pathMapper.transformUrl(file1, '/a.dart'), '/a.dart');

120 expect(pathMapper.transformUrl(file1, 'c.dart'), 'c.dart');

121 expect(pathMapper.transformUrl(file1, '../c/d.dart'), '../c/d.dart');

122 expect(pathMapper.transformUrl(file1, 'packages/c.dart'),

123 'packages/c.dart');

124 expect(pathMapper.transformUrl(file2, 'e.css'), 'e.css');

125 expect(pathMapper.transformUrl(file2, '../c/e.css'), 'e.css');

126 expect(pathMapper.transformUrl(file2, '../q/e.css'), '../q/e.css');

127 expect(pathMapper.transformUrl(file2, 'packages/c.css'),

128 'packages/c.css');

129 expect(pathMapper.transformUrl(file2, '../packages/c.css'),

130 '../packages/c.css');

131 });

132

133 test('transformUrl with source in packages/', () {

134 var pathMapper = _newPathMapper('a', 'a', false);

135 var file = 'a/packages/e.html';

136 // Even when output == base, files under packages/ are moved to

137 // _from_packages, so all imports are affected:

138 expect(pathMapper.transformUrl(file, 'e.css'), '../packages/e.css');

139 expect(pathMapper.transformUrl(file, '../packages/e.css'),

140 '../packages/e.css');

141 expect(pathMapper.transformUrl(file, '../q/e.css'), '../q/e.css');

142 expect(pathMapper.transformUrl(file, 'packages/c.css'),

143 '../packages/packages/c.css');

144 });

145 });

146

147 group('outdir != basedir:', () {

148 group('outputPath', (){

149 test('no force mangle', () {

150 var pathMapper = _newPathMapper('a', 'out', false);

151 var file = _mockFile('a/b.dart', pathMapper);

152 expect(file.dartCodeUrl.resolvedPath, 'a/b.dart');

153 expect(pathMapper.outputPath(file.dartCodeUrl.resolvedPath, '.dart'),

154 'out/b.dart');

155 });

156

157 test('force mangling', () {

158 var pathMapper = _newPathMapper('a', 'out', true);

159 var file = _mockFile('a/b.dart', pathMapper);

160 expect(file.dartCodeUrl.resolvedPath, 'a/b.dart');

161 expect(pathMapper.outputPath(file.dartCodeUrl.resolvedPath, '.dart'),

162 'out/_b.dart.dart');

163 });

164

165 test('within packages/, no mangle', () {

166 var pathMapper = _newPathMapper('a', 'out', false);

167 var file = _mockFile('a/packages/b.dart', pathMapper);

168 expect(file.dartCodeUrl.resolvedPath, 'a/packages/b.dart');

169 expect(pathMapper.outputPath(file.dartCodeUrl.resolvedPath, '.dart'),

170 'out/_from_packages/b.dart');

171 });

172

173 test('within packages/, mangle', () {

174 var pathMapper = _newPathMapper('a', 'out', true);

175 var file = _mockFile('a/packages/b.dart', pathMapper);

176 expect(file.dartCodeUrl.resolvedPath, 'a/packages/b.dart');

177 expect(pathMapper.outputPath(file.dartCodeUrl.resolvedPath, '.dart'),

178 'out/_from_packages/_b.dart.dart');

179 });

180 });

181

182 group('importUrlFor', (){

183 test('simple paths, no mangle', () {

184 var pathMapper = _newPathMapper('a', 'out', false);

185 var file1 = _mockFile('a/b.dart', pathMapper);

186 var file2 = _mockFile('a/c/d.dart', pathMapper);

187 var file3 = _mockFile('a/e/f.dart', pathMapper);

188 expect(pathMapper.importUrlFor(file1, file2), 'c/d.dart');

189 expect(pathMapper.importUrlFor(file1, file3), 'e/f.dart');

190 expect(pathMapper.importUrlFor(file2, file1), '../b.dart');

191 expect(pathMapper.importUrlFor(file2, file3), '../e/f.dart');

192 expect(pathMapper.importUrlFor(file3, file2), '../c/d.dart');

193 expect(pathMapper.importUrlFor(file3, file1), '../b.dart');

194 });

195

196 test('simple paths, mangle', () {

197 var pathMapper = _newPathMapper('a', 'out', true);

198 var file1 = _mockFile('a/b.dart', pathMapper);

199 var file2 = _mockFile('a/c/d.dart', pathMapper);

200 var file3 = _mockFile('a/e/f.dart', pathMapper);

201 expect(pathMapper.importUrlFor(file1, file2), 'c/_d.dart.dart');

202 expect(pathMapper.importUrlFor(file1, file3), 'e/_f.dart.dart');

203 expect(pathMapper.importUrlFor(file2, file1), '../_b.dart.dart');

204 expect(pathMapper.importUrlFor(file2, file3), '../e/_f.dart.dart');

205 expect(pathMapper.importUrlFor(file3, file2), '../c/_d.dart.dart');

206 expect(pathMapper.importUrlFor(file3, file1), '../_b.dart.dart');

207 });

208

209 test('include packages/, no mangle', () {

210 var pathMapper = _newPathMapper('a', 'out', false);

211 var file1 = _mockFile('a/b.dart', pathMapper);

212 var file2 = _mockFile('a/c/d.dart', pathMapper);

213 var file3 = _mockFile('a/packages/e/f.dart', pathMapper,

214 url: 'package:e/f.dart');

215 expect(pathMapper.importUrlFor(file1, file2), 'c/d.dart');

216 expect(pathMapper.importUrlFor(file1, file3),

217 '_from_packages/e/f.dart');

218 expect(pathMapper.importUrlFor(file2, file1), '../b.dart');

219 expect(pathMapper.importUrlFor(file2, file3),

220 '../_from_packages/e/f.dart');

221 expect(pathMapper.importUrlFor(file3, file2), '../../c/d.dart');

222 expect(pathMapper.importUrlFor(file3, file1), '../../b.dart');

223 });

224

225 test('include packages/, mangle', () {

226 var pathMapper = _newPathMapper('a', 'out', true);

227 var file1 = _mockFile('a/b.dart', pathMapper);

228 var file2 = _mockFile('a/c/d.dart', pathMapper);

229 var file3 = _mockFile('a/packages/e/f.dart', pathMapper,

230 url: 'package:e/f.dart');

231 expect(pathMapper.importUrlFor(file1, file2), 'c/_d.dart.dart');

232 expect(pathMapper.importUrlFor(file1, file3),

233 '_from_packages/e/_f.dart.dart');

234 expect(pathMapper.importUrlFor(file2, file1), '../_b.dart.dart');

235 expect(pathMapper.importUrlFor(file2, file3),

236 '../_from_packages/e/_f.dart.dart');

237 expect(pathMapper.importUrlFor(file3, file2), '../../c/_d.dart.dart');

238 expect(pathMapper.importUrlFor(file3, file1), '../../_b.dart.dart');

239 });

240

241 test('windows paths', () {

242 try {

243 utils.path = new path.Builder(style: path.Style.windows);

244 var pathMapper = _newPathMapper('a', 'out', true);

245 var file1 = _mockFile('a\\b.dart', pathMapper);

246 var file2 = _mockFile('a\\c\\d.dart', pathMapper);

247 var file3 = _mockFile('a\\packages\\f.dart', pathMapper);

248 expect(pathMapper.importUrlFor(file1, file2), 'c/_d.dart.dart');

249 expect(pathMapper.importUrlFor(file1, file3),

250 '_from_packages/_f.dart.dart');

251 expect(pathMapper.importUrlFor(file2, file1), '../_b.dart.dart');

252 expect(pathMapper.importUrlFor(file2, file3),

253 '../_from_packages/_f.dart.dart');

254 expect(pathMapper.importUrlFor(file3, file2), '../c/_d.dart.dart');

255 expect(pathMapper.importUrlFor(file3, file1), '../_b.dart.dart');

256 } finally {

257 utils.path = new path.Builder();

258 }

259 });

260 });

261

262 group('transformUrl', () {

263 test('simple source, not in packages/', () {

264 var pathMapper = _newPathMapper('a', 'out', false);

265 var file1 = 'a/b.dart';

266 var file2 = 'a/c/d.html';

267 // when the output == input directory, no paths should be rewritten

268 expect(pathMapper.transformUrl(file1, '/a.dart'), '/a.dart');

269 expect(pathMapper.transformUrl(file1, 'c.dart'), '../a/c.dart');

270

271 // reach out from basedir:

272 expect(pathMapper.transformUrl(file1, '../c/d.dart'), '../c/d.dart');

273

274 // reach into packages dir:

275 expect(pathMapper.transformUrl(file1, 'packages/c.dart'),

276 '../a/packages/c.dart');

277

278 expect(pathMapper.transformUrl(file2, 'e.css'), '../../a/c/e.css');

279

280 _checkPath('../../a/c/../c/e.css', '../../a/c/e.css');

281 expect(pathMapper.transformUrl(file2, '../c/e.css'), '../../a/c/e.css');

282

283 _checkPath('../../a/c/../q/e.css', '../../a/q/e.css');

284 expect(pathMapper.transformUrl(file2, '../q/e.css'), '../../a/q/e.css');

285

286 expect(pathMapper.transformUrl(file2, 'packages/c.css'),

287 '../../a/c/packages/c.css');

288 _checkPath('../../a/c/../packages/c.css', '../../a/packages/c.css');

289 expect(pathMapper.transformUrl(file2, '../packages/c.css'),

290 '../../a/packages/c.css');

291 });

292

293 test('input in packages/', () {

294 var pathMapper = _newPathMapper('a', 'out', true);

295 var file = 'a/packages/e.html';

296 expect(pathMapper.transformUrl(file, 'e.css'),

297 '../../a/packages/e.css');

298 expect(pathMapper.transformUrl(file, '../packages/e.css'),

299 '../../a/packages/e.css');

300 expect(pathMapper.transformUrl(file, '../q/e.css'), '../../a/q/e.css');

301 expect(pathMapper.transformUrl(file, 'packages/c.css'),

302 '../../a/packages/packages/c.css');

303 });

304

305 test('src fragments', () {

306 var pathMapper = _newPathMapper('a', 'out', false);

307 var file1 = 'a/b.dart';

308 var file2 = 'a/c/html.html';

309 // when the output == input directory, no paths should be rewritten

310 expect(pathMapper.transformUrl(file1, '#tips'), '#tips');

311 expect(pathMapper.transformUrl(file1,

312 'http://www.w3schools.com/html_links.htm#tips'),

313 'http://www.w3schools.com/html_links.htm#tips');

314 expect(pathMapper.transformUrl(file2,

315 'html_links.html'),

316 '../../a/c/html_links.html');

317 expect(pathMapper.transformUrl(file2,

318 'html_links.html#tips'),

319 '../../a/c/html_links.html#tips');

320 });

321 });

322 });

323 }

324

325 _newPathMapper(String baseDir, String outDir, bool forceMangle,

326 {bool rewriteUrls: true}) =>

327 new PathMapper(baseDir, outDir, 'packages', forceMangle, rewriteUrls);

328

329 _mockFile(String filePath, PathMapper pathMapper, {String url}) {

330 var file = new FileInfo(new UrlInfo(

331 url == null ? filePath : url, filePath, null));

332 file.outputFilename = pathMapper.mangle(

333 utils.path.basename(filePath), '.dart', false);

334 return file;

335 }

336

337 _checkPath(String filePath, String expected) {

338 expect(utils.path.normalize(filePath), expected);

339 }

OLD	NEW

« pkg/polymer/lib/src/transform/polyfill_injector.dart ('K') | « pkg/polymer/test/css_test.dart ('k') | pkg/polymer/test/run.sh » ('j') | no next file with comments »