← Back to branch summary

~jml/pkgme/0.4.1

« back to all changes in this revision

Viewing changes to pkgme/tests/test_backend.py

  • Committer: Tarmac
  • Author(s): Jonathan Lange
  • Date: 2012-09-04 15:27:39 UTC
  • mfrom: (136.4.25 imports-and-tempdir)
  • Revision ID: tarmac-20120904152739-lvhce4cmr06ot2e0
[r=jml] Deprecate TempdirFixture. Use treeshape 0.2.1 instead.

Show diffs side-by-side

added added

removed removed

Lines of Context:
pkgme/tests/test_backend.py
1
1
import os
2
2
import sys
3
3
 
4
 
from fixtures import TestWithFixtures
 
4
from fixtures import TempDir
5
5
from testtools import TestCase
 
6
from treeshape import (
 
7
    FileTree,
 
8
    from_rough_spec,
 
9
    )
6
10
 
7
 
from pkgme.backend import (
 
11
from ..backend import (
8
12
    Backend,
9
13
    BackendSelector,
10
14
    EXTERNAL_BACKEND_PATHS,
19
23
    StaticLoader,
20
24
    WantError,
21
25
    )
22
 
from pkgme.project_info import (
 
26
from ..project_info import (
23
27
    MultipleExternalHelpersInfo,
24
28
    SingleExternalHelperInfo,
25
29
    )
26
 
from pkgme.run_script import ScriptUserError
27
 
from pkgme.testing import (
28
 
    ExecutableFileFixture,
29
 
    FileFixture,
30
 
    StaticLoaderFixture,
31
 
    TempdirFixture,
32
 
    )
 
30
from ..run_script import ScriptUserError
 
31
from ..testing import StaticLoaderFixture
33
32
 
34
33
 
35
34
class TestBackend(TestCase):
40
39
        self.assertEqual(backend.name, backend.describe())
41
40
 
42
41
 
43
 
class ExternalHelpersBackendTests(TestCase, TestWithFixtures):
 
42
class ExternalHelpersBackendTests(TestCase):
44
43
 
45
44
    def make_want_script(self, script, executable=True):
46
 
        tempdir = self.useFixture(TempdirFixture())
47
 
        script_name = ExternalHelpersBackend.WANT_SCRIPT_NAME
48
 
        script_path = os.path.join(tempdir.path, script_name)
49
45
        if executable:
50
 
            cls = ExecutableFileFixture
 
46
            permissions = 0700
51
47
        else:
52
 
            cls = FileFixture
53
 
        self.useFixture(cls(script_path, script))
54
 
        return tempdir
 
48
            permissions = 0600
 
49
        script_name = ExternalHelpersBackend.WANT_SCRIPT_NAME
 
50
        return self.useFixture(
 
51
            FileTree({script_name: {'content': script,
 
52
                                    'permissions': permissions}}))
55
53
 
56
54
    def test_describe(self):
57
55
        backend = ExternalHelpersBackend(
145
143
        self.assertEqual((10, None), backend.want(tempdir.path))
146
144
 
147
145
    def test_missing_want_script(self):
148
 
        tempdir = self.useFixture(TempdirFixture())
 
146
        path = self.useFixture(TempDir()).path
149
147
        name = self.getUniqueString()
150
 
        backend = ExternalHelpersBackend(name, tempdir.path)
151
 
        e = self.assertRaises(AssertionError, backend.want, tempdir.path)
 
148
        backend = ExternalHelpersBackend(name, path)
 
149
        e = self.assertRaises(AssertionError, backend.want, path)
152
150
        self.assertEqual(
153
151
            "Backend %s (%s) has no '%s' script"
154
 
            % (name, tempdir.path, ExternalHelpersBackend.WANT_SCRIPT_NAME),
 
152
            % (name, path, ExternalHelpersBackend.WANT_SCRIPT_NAME),
155
153
            str(e))
156
154
 
157
155
    def test_want_script_not_executable(self):
219
217
            str(e))
220
218
 
221
219
    def test_want_script_run_in_correct_dir(self):
222
 
        cwd_tempdir = self.useFixture(TempdirFixture())
 
220
        cwd_tempdir = self.useFixture(TempDir()).path
223
221
        script = """#!%s
224
222
import os
225
223
if os.getcwd() != '%s':
226
224
    print "Backend was called in %%s rather than %%s" %% (os.getcwd(), '%s')
227
225
else:
228
226
    print 10
229
 
""" % (sys.executable, cwd_tempdir.path, cwd_tempdir.path)
 
227
""" % (sys.executable, cwd_tempdir, cwd_tempdir)
230
228
        backend_tempdir = self.make_want_script(script)
231
229
        backend = ExternalHelpersBackend(
232
230
            self.getUniqueString(), backend_tempdir.path)
233
 
        self.assertEqual((10, None), backend.want(cwd_tempdir.path))
 
231
        self.assertEqual((10, None), backend.want(cwd_tempdir))
234
232
 
235
233
    def test_get_info_with_multiple(self):
236
234
        helpers_path = self.getUniqueString()
242
240
        self.assertEqual(cwd_path, project_info.cwd)
243
241
 
244
242
    def test_get_info_with_single(self):
245
 
        helpers_tempdir = self.useFixture(TempdirFixture())
 
243
        helpers_tempdir = self.useFixture(TempDir()).path
246
244
        info_script_path = os.path.join(
247
 
            helpers_tempdir.path,
 
245
            helpers_tempdir,
248
246
            SingleExternalHelperInfo.INFO_SCRIPT_NAME)
249
247
        with open(info_script_path, "w"):
250
248
            pass
251
249
        cwd_path = self.getUniqueString()
252
250
        backend = ExternalHelpersBackend(
253
 
            self.getUniqueString(), helpers_tempdir.path)
 
251
            self.getUniqueString(), helpers_tempdir)
254
252
        project_info = backend.get_info(cwd_path)
255
253
        self.assertIsInstance(project_info, SingleExternalHelperInfo)
256
 
        self.assertEqual(helpers_tempdir.path, project_info.basepath)
 
254
        self.assertEqual(helpers_tempdir, project_info.basepath)
257
255
        self.assertEqual(cwd_path, project_info.cwd)
258
256
 
259
257
 
415
413
            selector.get_eligible_backends(path))
416
414
 
417
415
 
418
 
class ExternalHelpersBackendLoaderTests(TestCase, TestWithFixtures):
 
416
class ExternalHelpersBackendLoaderTests(TestCase):
 
417
 
 
418
    def make_tree(self, *args):
 
419
        return self.useFixture(FileTree(from_rough_spec(args)))
419
420
 
420
421
    def test_loads_no_backends(self):
421
 
        tempdir = self.useFixture(TempdirFixture())
422
 
        loader = ExternalHelpersBackendLoader([tempdir.path])
 
422
        loader = ExternalHelpersBackendLoader([])
423
423
        self.assertEqual([], loader.load())
424
424
 
425
425
    def test_loads_from_one_dir(self):
426
 
        tempdir = self.useFixture(TempdirFixture())
427
426
        backend_name = self.getUniqueString()
428
 
        basepath = tempdir.mkdir(backend_name)
429
 
        loader = ExternalHelpersBackendLoader([tempdir.path])
 
427
        tree = self.make_tree(backend_name + '/')
 
428
        loader = ExternalHelpersBackendLoader([tree.path])
430
429
        backends = loader.load()
431
430
        self.assertEqual(1, len(backends))
432
431
        self.assertIsInstance(backends[0], ExternalHelpersBackend)
433
432
        self.assertEqual(backend_name, backends[0].name)
434
 
        self.assertEqual(basepath, backends[0].basepath)
 
433
        self.assertEqual(tree.join(backend_name), backends[0].basepath)
435
434
 
436
435
    def test_loads_from_two_dirs(self):
437
 
        tempdir1 = self.useFixture(TempdirFixture())
438
 
        tempdir2 = self.useFixture(TempdirFixture())
439
436
        backend_name1 = self.getUniqueString()
440
437
        backend_name2 = self.getUniqueString()
441
 
        tempdir1.mkdir(backend_name1)
442
 
        tempdir2.mkdir(backend_name2)
 
438
        tempdir1 = self.make_tree(backend_name1 + '/')
 
439
        tempdir2 = self.make_tree(backend_name2 + '/')
443
440
        loader = ExternalHelpersBackendLoader(
444
441
            [tempdir1.path, tempdir2.path])
445
442
        backends = loader.load()
446
443
        self.assertEqual(2, len(backends))
447
444
 
448
445
    def test_loads_only_one_instance_of_each_name(self):
449
 
        tempdir1 = self.useFixture(TempdirFixture())
450
 
        tempdir2 = self.useFixture(TempdirFixture())
451
446
        backend_name = self.getUniqueString()
452
 
        basepath1 = tempdir1.mkdir(backend_name)
453
 
        tempdir2.mkdir(backend_name)
 
447
        tempdir1 = self.make_tree(backend_name + '/')
 
448
        tempdir2 = self.make_tree(backend_name + '/')
 
449
        basepath1 = tempdir1.join(backend_name)
454
450
        loader = ExternalHelpersBackendLoader(
455
451
            [tempdir1.path, tempdir2.path])
456
452
        backends = loader.load()
458
454
        self.assertEqual(basepath1, backends[0].basepath)
459
455
 
460
456
    def test_loads_only_dirs(self):
461
 
        tempdir = self.useFixture(TempdirFixture())
462
 
        tempdir.touch(self.getUniqueString())
463
 
        loader = ExternalHelpersBackendLoader([tempdir.path])
 
457
        path = self.make_tree(self.getUniqueString()).path
 
458
        loader = ExternalHelpersBackendLoader([path])
464
459
        self.assertEqual([], loader.load())
465
460
 
466
461
    def test_ignores_dotdirs(self):
467
 
        tempdir = self.useFixture(TempdirFixture())
468
 
        tempdir.mkdir("." + self.getUniqueString())
469
 
        loader = ExternalHelpersBackendLoader([tempdir.path])
 
462
        dirname = '.%s/' % (self.getUniqueString(),)
 
463
        tempdir = self.make_tree(dirname).path
 
464
        loader = ExternalHelpersBackendLoader([tempdir])
470
465
        self.assertEqual([], loader.load())
471
466
 
472
467
    def test_ignores_missing_dirs(self):
473
 
        self.useFixture(TempdirFixture())
474
468
        loader = ExternalHelpersBackendLoader([self.getUniqueString()])
475
469
        self.assertEqual([], loader.load())
476
470