| commit | author | age | ||
| 47106c | 1 | import unittest |
| CM | 2 | |
| 589a39 | 3 | |
| 47106c | 4 | class TestPCreateCommand(unittest.TestCase): |
| CM | 5 | def setUp(self): |
| 6 | from pyramid.compat import NativeIO | |
| 0c29cf | 7 | |
| 47106c | 8 | self.out_ = NativeIO() |
| CM | 9 | |
| 10 | def out(self, msg): | |
| 11 | self.out_.write(msg) | |
| 0eff66 | 12 | |
| 47106c | 13 | def _getTargetClass(self): |
| CM | 14 | from pyramid.scripts.pcreate import PCreateCommand |
| 0c29cf | 15 | |
| 47106c | 16 | return PCreateCommand |
| CM | 17 | |
| 58b8ad | 18 | def _makeOne(self, *args, **kw): |
| 47106c | 19 | effargs = ['pcreate'] |
| CM | 20 | effargs.extend(args) |
| 589a39 | 21 | tgt_class = kw.pop('target_class', self._getTargetClass()) |
| IS | 22 | cmd = tgt_class(effargs, **kw) |
| 47106c | 23 | cmd.out = self.out |
| CM | 24 | return cmd |
| 25 | ||
| 26 | def test_run_show_scaffolds_exist(self): | |
| 27 | cmd = self._makeOne('-l') | |
| 28 | result = cmd.run() | |
| d58614 | 29 | self.assertEqual(result, 0) |
| 47106c | 30 | out = self.out_.getvalue() |
| a53db7 | 31 | self.assertTrue(out.count('Available scaffolds')) |
| 0eff66 | 32 | |
| 47106c | 33 | def test_run_show_scaffolds_none_exist(self): |
| CM | 34 | cmd = self._makeOne('-l') |
| 35 | cmd.scaffolds = [] | |
| 36 | result = cmd.run() | |
| d58614 | 37 | self.assertEqual(result, 0) |
| 47106c | 38 | out = self.out_.getvalue() |
| a53db7 | 39 | self.assertTrue(out.count('No scaffolds available')) |
| 0eff66 | 40 | |
| 58b8ad | 41 | def test_run_no_scaffold_no_args(self): |
| BJR | 42 | cmd = self._makeOne(quiet=True) |
| 43 | result = cmd.run() | |
| 44 | self.assertEqual(result, 2) | |
| 45 | ||
| 47106c | 46 | def test_run_no_scaffold_name(self): |
| 972dfa | 47 | cmd = self._makeOne('dummy') |
| 47106c | 48 | result = cmd.run() |
| d58614 | 49 | self.assertEqual(result, 2) |
| 47106c | 50 | out = self.out_.getvalue() |
| 0c29cf | 51 | self.assertTrue( |
| MM | 52 | out.count('You must provide at least one scaffold name') |
| 53 | ) | |
| 47106c | 54 | |
| CM | 55 | def test_no_project_name(self): |
| 56 | cmd = self._makeOne('-s', 'dummy') | |
| 57 | result = cmd.run() | |
| d58614 | 58 | self.assertEqual(result, 2) |
| 47106c | 59 | out = self.out_.getvalue() |
| a53db7 | 60 | self.assertTrue(out.count('You must provide a project name')) |
| 47106c | 61 | |
| CM | 62 | def test_unknown_scaffold_name(self): |
| c1ef71 | 63 | cmd = self._makeOne('-s', 'dummyXX', 'distro') |
| 47106c | 64 | result = cmd.run() |
| d58614 | 65 | self.assertEqual(result, 2) |
| 47106c | 66 | out = self.out_.getvalue() |
| a53db7 | 67 | self.assertTrue(out.count('Unavailable scaffolds')) |
| 47106c | 68 | |
| CM | 69 | def test_known_scaffold_single_rendered(self): |
| c1ef71 | 70 | import os |
| 0c29cf | 71 | |
| 47106c | 72 | cmd = self._makeOne('-s', 'dummy', 'Distro') |
| CM | 73 | scaffold = DummyScaffold('dummy') |
| 74 | cmd.scaffolds = [scaffold] | |
| c1ef71 | 75 | cmd.pyramid_dist = DummyDist("0.1") |
| 47106c | 76 | result = cmd.run() |
| d58614 | 77 | self.assertEqual(result, 0) |
| 47106c | 78 | self.assertEqual( |
| c1ef71 | 79 | scaffold.output_dir, |
| 0c29cf | 80 | os.path.normpath(os.path.join(os.getcwd(), 'Distro')), |
| MM | 81 | ) |
| 47106c | 82 | self.assertEqual( |
| CM | 83 | scaffold.vars, |
| 0c29cf | 84 | { |
| MM | 85 | 'project': 'Distro', |
| 86 | 'egg': 'Distro', | |
| 87 | 'package': 'distro', | |
| 88 | 'pyramid_version': '0.1', | |
| 89 | 'pyramid_docs_branch': '0.1-branch', | |
| 90 | }, | |
| 91 | ) | |
| 47106c | 92 | |
| 24c635 | 93 | def test_scaffold_with_package_name(self): |
| G | 94 | import os |
| 0c29cf | 95 | |
| MM | 96 | cmd = self._makeOne( |
| 97 | '-s', 'dummy', '--package-name', 'dummy_package', 'Distro' | |
| 98 | ) | |
| 24c635 | 99 | scaffold = DummyScaffold('dummy') |
| G | 100 | cmd.scaffolds = [scaffold] |
| 101 | cmd.pyramid_dist = DummyDist("0.1") | |
| 102 | result = cmd.run() | |
| 103 | ||
| 104 | self.assertEqual(result, 0) | |
| 105 | self.assertEqual( | |
| 106 | scaffold.output_dir, | |
| 0c29cf | 107 | os.path.normpath(os.path.join(os.getcwd(), 'Distro')), |
| MM | 108 | ) |
| 24c635 | 109 | self.assertEqual( |
| G | 110 | scaffold.vars, |
| 0c29cf | 111 | { |
| MM | 112 | 'project': 'Distro', |
| 113 | 'egg': 'dummy_package', | |
| 114 | 'package': 'dummy_package', | |
| 115 | 'pyramid_version': '0.1', | |
| 116 | 'pyramid_docs_branch': '0.1-branch', | |
| 117 | }, | |
| 118 | ) | |
| 24c635 | 119 | |
| d47b36 | 120 | def test_scaffold_with_hyphen_in_project_name(self): |
| c1ef71 | 121 | import os |
| 0c29cf | 122 | |
| d47b36 | 123 | cmd = self._makeOne('-s', 'dummy', 'Distro-') |
| 60d3c1 | 124 | scaffold = DummyScaffold('dummy') |
| RB | 125 | cmd.scaffolds = [scaffold] |
| c1ef71 | 126 | cmd.pyramid_dist = DummyDist("0.1") |
| 60d3c1 | 127 | result = cmd.run() |
| d58614 | 128 | self.assertEqual(result, 0) |
| 60d3c1 | 129 | self.assertEqual( |
| c1ef71 | 130 | scaffold.output_dir, |
| 0c29cf | 131 | os.path.normpath(os.path.join(os.getcwd(), 'Distro-')), |
| MM | 132 | ) |
| d47b36 | 133 | self.assertEqual( |
| RHH | 134 | scaffold.vars, |
| 0c29cf | 135 | { |
| MM | 136 | 'project': 'Distro-', |
| 137 | 'egg': 'Distro_', | |
| 138 | 'package': 'distro_', | |
| 139 | 'pyramid_version': '0.1', | |
| 140 | 'pyramid_docs_branch': '0.1-branch', | |
| 141 | }, | |
| 142 | ) | |
| d47b36 | 143 | |
| RHH | 144 | def test_known_scaffold_absolute_path(self): |
| c1ef71 | 145 | import os |
| 0c29cf | 146 | |
| c1ef71 | 147 | path = os.path.abspath('Distro') |
| d47b36 | 148 | cmd = self._makeOne('-s', 'dummy', path) |
| c1ef71 | 149 | cmd.pyramid_dist = DummyDist("0.1") |
| d47b36 | 150 | scaffold = DummyScaffold('dummy') |
| RHH | 151 | cmd.scaffolds = [scaffold] |
| c1ef71 | 152 | cmd.pyramid_dist = DummyDist("0.1") |
| d47b36 | 153 | result = cmd.run() |
| RHH | 154 | self.assertEqual(result, 0) |
| 155 | self.assertEqual( | |
| c1ef71 | 156 | scaffold.output_dir, |
| 0c29cf | 157 | os.path.normpath(os.path.join(os.getcwd(), 'Distro')), |
| MM | 158 | ) |
| 60d3c1 | 159 | self.assertEqual( |
| RB | 160 | scaffold.vars, |
| 0c29cf | 161 | { |
| MM | 162 | 'project': 'Distro', |
| 163 | 'egg': 'Distro', | |
| 164 | 'package': 'distro', | |
| 165 | 'pyramid_version': '0.1', | |
| 166 | 'pyramid_docs_branch': '0.1-branch', | |
| 167 | }, | |
| 168 | ) | |
| 60d3c1 | 169 | |
| 47106c | 170 | def test_known_scaffold_multiple_rendered(self): |
| c1ef71 | 171 | import os |
| 0c29cf | 172 | |
| 47106c | 173 | cmd = self._makeOne('-s', 'dummy1', '-s', 'dummy2', 'Distro') |
| CM | 174 | scaffold1 = DummyScaffold('dummy1') |
| 175 | scaffold2 = DummyScaffold('dummy2') | |
| 176 | cmd.scaffolds = [scaffold1, scaffold2] | |
| c1ef71 | 177 | cmd.pyramid_dist = DummyDist("0.1") |
| 47106c | 178 | result = cmd.run() |
| d58614 | 179 | self.assertEqual(result, 0) |
| 47106c | 180 | self.assertEqual( |
| c1ef71 | 181 | scaffold1.output_dir, |
| 0c29cf | 182 | os.path.normpath(os.path.join(os.getcwd(), 'Distro')), |
| MM | 183 | ) |
| 47106c | 184 | self.assertEqual( |
| CM | 185 | scaffold1.vars, |
| 0c29cf | 186 | { |
| MM | 187 | 'project': 'Distro', |
| 188 | 'egg': 'Distro', | |
| 189 | 'package': 'distro', | |
| 190 | 'pyramid_version': '0.1', | |
| 191 | 'pyramid_docs_branch': '0.1-branch', | |
| 192 | }, | |
| 193 | ) | |
| 47106c | 194 | self.assertEqual( |
| c1ef71 | 195 | scaffold2.output_dir, |
| 0c29cf | 196 | os.path.normpath(os.path.join(os.getcwd(), 'Distro')), |
| MM | 197 | ) |
| 47106c | 198 | self.assertEqual( |
| CM | 199 | scaffold2.vars, |
| 0c29cf | 200 | { |
| MM | 201 | 'project': 'Distro', |
| 202 | 'egg': 'Distro', | |
| 203 | 'package': 'distro', | |
| 204 | 'pyramid_version': '0.1', | |
| 205 | 'pyramid_docs_branch': '0.1-branch', | |
| 206 | }, | |
| 207 | ) | |
| 47106c | 208 | |
| 073e52 | 209 | def test_known_scaffold_with_path_as_project_target_rendered(self): |
| c1ef71 | 210 | import os |
| 0c29cf | 211 | |
| 073e52 | 212 | cmd = self._makeOne('-s', 'dummy', '/tmp/foo/Distro/') |
| CM | 213 | scaffold = DummyScaffold('dummy') |
| 214 | cmd.scaffolds = [scaffold] | |
| c1ef71 | 215 | cmd.pyramid_dist = DummyDist("0.1") |
| 073e52 | 216 | result = cmd.run() |
| CM | 217 | self.assertEqual(result, 0) |
| 218 | self.assertEqual( | |
| c1ef71 | 219 | scaffold.output_dir, |
| 0c29cf | 220 | os.path.normpath(os.path.join(os.getcwd(), '/tmp/foo/Distro')), |
| MM | 221 | ) |
| 073e52 | 222 | self.assertEqual( |
| CM | 223 | scaffold.vars, |
| 0c29cf | 224 | { |
| MM | 225 | 'project': 'Distro', |
| 226 | 'egg': 'Distro', | |
| 227 | 'package': 'distro', | |
| 228 | 'pyramid_version': '0.1', | |
| 229 | 'pyramid_docs_branch': '0.1-branch', | |
| 230 | }, | |
| 231 | ) | |
| 0eff66 | 232 | |
| MR | 233 | def test_scaffold_with_prod_pyramid_version(self): |
| 234 | cmd = self._makeOne('-s', 'dummy', 'Distro') | |
| 235 | scaffold = DummyScaffold('dummy') | |
| 236 | cmd.scaffolds = [scaffold] | |
| c1ef71 | 237 | cmd.pyramid_dist = DummyDist("0.2") |
| 0eff66 | 238 | result = cmd.run() |
| MR | 239 | self.assertEqual(result, 0) |
| 240 | self.assertEqual( | |
| 241 | scaffold.vars, | |
| 0c29cf | 242 | { |
| MM | 243 | 'project': 'Distro', |
| 244 | 'egg': 'Distro', | |
| 245 | 'package': 'distro', | |
| 246 | 'pyramid_version': '0.2', | |
| 247 | 'pyramid_docs_branch': '0.2-branch', | |
| 248 | }, | |
| 249 | ) | |
| 0eff66 | 250 | |
| e18b5f | 251 | def test_scaffold_with_prod_pyramid_long_version(self): |
| G | 252 | cmd = self._makeOne('-s', 'dummy', 'Distro') |
| 253 | scaffold = DummyScaffold('dummy') | |
| 254 | cmd.scaffolds = [scaffold] | |
| c1ef71 | 255 | cmd.pyramid_dist = DummyDist("0.2.1") |
| e18b5f | 256 | result = cmd.run() |
| G | 257 | self.assertEqual(result, 0) |
| 258 | self.assertEqual( | |
| 259 | scaffold.vars, | |
| 0c29cf | 260 | { |
| MM | 261 | 'project': 'Distro', |
| 262 | 'egg': 'Distro', | |
| 263 | 'package': 'distro', | |
| 264 | 'pyramid_version': '0.2.1', | |
| 265 | 'pyramid_docs_branch': '0.2-branch', | |
| 266 | }, | |
| 267 | ) | |
| e18b5f | 268 | |
| G | 269 | def test_scaffold_with_prod_pyramid_unparsable_version(self): |
| 270 | cmd = self._makeOne('-s', 'dummy', 'Distro') | |
| 271 | scaffold = DummyScaffold('dummy') | |
| 272 | cmd.scaffolds = [scaffold] | |
| c1ef71 | 273 | cmd.pyramid_dist = DummyDist("abc") |
| e18b5f | 274 | result = cmd.run() |
| G | 275 | self.assertEqual(result, 0) |
| 276 | self.assertEqual( | |
| 277 | scaffold.vars, | |
| 0c29cf | 278 | { |
| MM | 279 | 'project': 'Distro', |
| 280 | 'egg': 'Distro', | |
| 281 | 'package': 'distro', | |
| 282 | 'pyramid_version': 'abc', | |
| 283 | 'pyramid_docs_branch': 'latest', | |
| 284 | }, | |
| 285 | ) | |
| e18b5f | 286 | |
| 0eff66 | 287 | def test_scaffold_with_dev_pyramid_version(self): |
| MR | 288 | cmd = self._makeOne('-s', 'dummy', 'Distro') |
| 289 | scaffold = DummyScaffold('dummy') | |
| 290 | cmd.scaffolds = [scaffold] | |
| c1ef71 | 291 | cmd.pyramid_dist = DummyDist("0.12dev") |
| 0eff66 | 292 | result = cmd.run() |
| MR | 293 | self.assertEqual(result, 0) |
| 294 | self.assertEqual( | |
| 295 | scaffold.vars, | |
| 0c29cf | 296 | { |
| MM | 297 | 'project': 'Distro', |
| 298 | 'egg': 'Distro', | |
| 299 | 'package': 'distro', | |
| 300 | 'pyramid_version': '0.12dev', | |
| 301 | 'pyramid_docs_branch': 'master', | |
| 302 | }, | |
| 303 | ) | |
| 0eff66 | 304 | |
| e18b5f | 305 | def test_scaffold_with_dev_pyramid_long_version(self): |
| G | 306 | cmd = self._makeOne('-s', 'dummy', 'Distro') |
| 307 | scaffold = DummyScaffold('dummy') | |
| 308 | cmd.scaffolds = [scaffold] | |
| c1ef71 | 309 | cmd.pyramid_dist = DummyDist("0.10.1dev") |
| e18b5f | 310 | result = cmd.run() |
| G | 311 | self.assertEqual(result, 0) |
| 312 | self.assertEqual( | |
| 313 | scaffold.vars, | |
| 0c29cf | 314 | { |
| MM | 315 | 'project': 'Distro', |
| 316 | 'egg': 'Distro', | |
| 317 | 'package': 'distro', | |
| 318 | 'pyramid_version': '0.10.1dev', | |
| 319 | 'pyramid_docs_branch': 'master', | |
| 320 | }, | |
| 321 | ) | |
| e18b5f | 322 | |
| 589a39 | 323 | def test_confirm_override_conflicting_name(self): |
| IS | 324 | from pyramid.scripts.pcreate import PCreateCommand |
| 0c29cf | 325 | |
| 589a39 | 326 | class YahInputPCreateCommand(PCreateCommand): |
| IS | 327 | def confirm_bad_name(self, pkg_name): |
| 328 | return True | |
| 0c29cf | 329 | |
| MM | 330 | cmd = self._makeOne( |
| 331 | '-s', 'dummy', 'Unittest', target_class=YahInputPCreateCommand | |
| 332 | ) | |
| 589a39 | 333 | scaffold = DummyScaffold('dummy') |
| IS | 334 | cmd.scaffolds = [scaffold] |
| 335 | cmd.pyramid_dist = DummyDist("0.10.1dev") | |
| 336 | result = cmd.run() | |
| 337 | self.assertEqual(result, 0) | |
| 338 | self.assertEqual( | |
| 339 | scaffold.vars, | |
| 0c29cf | 340 | { |
| MM | 341 | 'project': 'Unittest', |
| 342 | 'egg': 'Unittest', | |
| 343 | 'package': 'unittest', | |
| 344 | 'pyramid_version': '0.10.1dev', | |
| 345 | 'pyramid_docs_branch': 'master', | |
| 346 | }, | |
| 347 | ) | |
| 589a39 | 348 | |
| IS | 349 | def test_force_override_conflicting_name(self): |
| 0c29cf | 350 | cmd = self._makeOne( |
| MM | 351 | '-s', 'dummy', 'Unittest', '--ignore-conflicting-name' |
| 352 | ) | |
| 589a39 | 353 | scaffold = DummyScaffold('dummy') |
| IS | 354 | cmd.scaffolds = [scaffold] |
| 355 | cmd.pyramid_dist = DummyDist("0.10.1dev") | |
| 356 | result = cmd.run() | |
| 357 | self.assertEqual(result, 0) | |
| 358 | self.assertEqual( | |
| 359 | scaffold.vars, | |
| 0c29cf | 360 | { |
| MM | 361 | 'project': 'Unittest', |
| 362 | 'egg': 'Unittest', | |
| 363 | 'package': 'unittest', | |
| 364 | 'pyramid_version': '0.10.1dev', | |
| 365 | 'pyramid_docs_branch': 'master', | |
| 366 | }, | |
| 367 | ) | |
| 589a39 | 368 | |
| IS | 369 | def test_force_override_site_name(self): |
| 370 | from pyramid.scripts.pcreate import PCreateCommand | |
| 0c29cf | 371 | |
| 589a39 | 372 | class NayInputPCreateCommand(PCreateCommand): |
| IS | 373 | def confirm_bad_name(self, pkg_name): |
| 374 | return False | |
| 0c29cf | 375 | |
| MM | 376 | cmd = self._makeOne( |
| 377 | '-s', 'dummy', 'Site', target_class=NayInputPCreateCommand | |
| 378 | ) | |
| 589a39 | 379 | scaffold = DummyScaffold('dummy') |
| IS | 380 | cmd.scaffolds = [scaffold] |
| 381 | cmd.pyramid_dist = DummyDist("0.10.1dev") | |
| 382 | result = cmd.run() | |
| 383 | self.assertEqual(result, 2) | |
| 384 | ||
| e18b5f | 385 | |
| 47106c | 386 | class Test_main(unittest.TestCase): |
| CM | 387 | def _callFUT(self, argv): |
| 388 | from pyramid.scripts.pcreate import main | |
| 0c29cf | 389 | |
| d29151 | 390 | return main(argv, quiet=True) |
| 47106c | 391 | |
| CM | 392 | def test_it(self): |
| d29151 | 393 | result = self._callFUT(['pcreate']) |
| d58614 | 394 | self.assertEqual(result, 2) |
| 0c29cf | 395 | |
| 47106c | 396 | |
| CM | 397 | class DummyScaffold(object): |
| 398 | def __init__(self, name): | |
| 399 | self.name = name | |
| 400 | ||
| 401 | def run(self, command, output_dir, vars): | |
| 402 | self.command = command | |
| 403 | self.output_dir = output_dir | |
| 404 | self.vars = vars | |
| 0eff66 | 405 | |
| 0c29cf | 406 | |
| 0eff66 | 407 | class DummyDist(object): |
| MR | 408 | def __init__(self, version): |
| 409 | self.version = version | |
