← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to fai/arch/tests/test_namespace.py

  • Committer: Robert Collins
  • Date: 2005-09-13 12:39:26 UTC
  • mto: (147.2.6) (364.1.3 bzrtools)
  • mto: This revision was merged to the branch mainline in revision 324.
  • Revision ID: robertc@robertcollins.net-20050913123926-b72242bdacc1ae52
create the output directory

Show diffs side-by-side

added added

removed removed

Lines of Context:
fai/arch/tests/test_namespace.py
 
1
#!/usr/bin/env python
 
2
# arch-tag: fb639c6b-566d-4b7c-be27-cfc406fc2fb8
 
3
# Copyright (C) 2004 David Allouche <david@allouche.net>
 
4
#                    Canonical Ltd.
 
5
#
 
6
#    This program is free software; you can redistribute it and/or modify
 
7
#    it under the terms of the GNU General Public License as published by
 
8
#    the Free Software Foundation; either version 2 of the License, or
 
9
#    (at your option) any later version.
 
10
#
 
11
#    This program is distributed in the hope that it will be useful,
 
12
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
#    GNU General Public License for more details.
 
15
#
 
16
#    You should have received a copy of the GNU General Public License
 
17
#    along with this program; if not, write to the Free Software
 
18
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
19
 
 
20
"""Test access to containers and name part properties of namespace classes.
 
21
"""
 
22
 
 
23
import sys
 
24
import arch
 
25
from arch.tests import framework
 
26
from arch.tests.framework import TestCase, TestParams
 
27
 
 
28
 
 
29
class ArchNameProperties(TestCase):
 
30
 
 
31
    """Test cases access to container and name part properties
 
32
 
 
33
    Check the availability and correctness of the "archive",
 
34
    "category", "branch", "version", "nonarch", and "patchlevel" of
 
35
    archive objects.
 
36
    """
 
37
 
 
38
    def setUp(self):
 
39
        self.params = TestParams()
 
40
        def set(**kw):
 
41
            for k, v in kw.items():
 
42
                v = v % self.__dict__
 
43
                setattr(self, k, v)
 
44
                setattr(self, k+'_full', '%s/%s' % (self.arch_name, v))
 
45
        set(category='frob')
 
46
        set(branch='%(category)s--devo')
 
47
        set(version='%(branch)s--1.0')
 
48
        self.patchlevel = 'patch-1'
 
49
        set(revision='%(version)s--%(patchlevel)s')
 
50
        set(nameless_branch='%(category)s')
 
51
        set(nameless_version='%(category)s--1.0')
 
52
        set(nameless_revision='%(nameless_version)s--%(patchlevel)s')
 
53
 
 
54
    tests = []
 
55
 
 
56
    def readonly(self, obj, *attrs):
 
57
        for attr in attrs:
 
58
            def try_set(): setattr(obj, attr, 'error')
 
59
            self.assertRaises(AttributeError, try_set)
 
60
 
 
61
    def check_hasnot(self, obj, *attrs):
 
62
        for attr in attrs:
 
63
            self.assert_(not hasattr(obj, attr))
 
64
 
 
65
    def assertInstance(self, obj, cls):
 
66
        self.assert_(isinstance(obj, cls))
 
67
 
 
68
    def check_names(self, obj, namekind):
 
69
        self.readonly(obj, 'nonarch', 'fullname')
 
70
        self.assertEqual(obj.nonarch, getattr(self, namekind))
 
71
        self.assertEqual(str(obj), obj.fullname)
 
72
        self.assertEqual(obj.fullname, getattr(self, namekind+'_full'))
 
73
 
 
74
    enclosing = {'category': 'archive', 'branch': 'category',
 
75
                 'version': 'branch', 'revision': 'version'}
 
76
 
 
77
    def check_init(self, cls, kind, nameless=''):
 
78
        def check_names(obj): self.check_names(obj, nameless+kind)
 
79
        obj = cls(getattr(self, nameless+kind+'_full'))
 
80
        check_names(obj)
 
81
        def unsafe_ctor(*args): return cls(arch._builtin._unsafe(args))
 
82
        if kind != 'revision':
 
83
            obj = unsafe_ctor(self.arch_name, getattr(self, nameless+kind))
 
84
        else:
 
85
            obj = unsafe_ctor(self.arch_name,
 
86
                              getattr(self, nameless+self.enclosing[kind]),
 
87
                              self.patchlevel)
 
88
        check_names(obj)
 
89
        obj = cls(obj)
 
90
        check_names(obj)
 
91
        return obj
 
92
 
 
93
    def check_badinit(self, cls, *names):
 
94
        for name in names:
 
95
            func = lambda: cls(getattr(self, name))
 
96
            self.assertRaises(arch.errors.NamespaceError, func)
 
97
 
 
98
    def check_container_helper(self, obj, prop, strval):
 
99
        self.readonly(obj, prop)
 
100
        val = getattr(obj, prop)
 
101
        typ = getattr(arch, prop.capitalize())
 
102
        self.assertInstance(val, typ)
 
103
        self.assertEqual(str(val), strval)
 
104
 
 
105
    def check_containers(self, obj, kind, nameless=''):
 
106
        if kind == 'archive':
 
107
            self.check_container_helper(obj, 'archive', self.arch_name)
 
108
            return
 
109
        self.check_containers(obj, self.enclosing[kind], nameless)
 
110
        if kind == 'category': namekind=kind
 
111
        else: namekind = nameless+kind
 
112
        self.check_container_helper(obj, kind, getattr(self, namekind+'_full'))
 
113
 
 
114
    def test_category(self):
 
115
        """Category has correct constructor and properties."""
 
116
        cat = self.check_init(arch.Category, 'category')
 
117
        self.check_containers(cat, 'archive')
 
118
        self.check_badinit(arch.Category, 'arch_name', 'branch_full')
 
119
        self.check_hasnot(cat, 'category', 'branch', 'version', 'patchlevel')
 
120
 
 
121
    tests.append('test_category')
 
122
 
 
123
    def test_branch(self, nameless=False):
 
124
        """Branch has correct constructor and properties."""
 
125
        nameless = nameless and 'nameless_' or ''
 
126
        brn = self.check_init(arch.Branch, 'branch', nameless)
 
127
        self.check_containers(brn, 'category')
 
128
        self.check_badinit(arch.Branch, 'arch_name',
 
129
                           nameless+'version_full')
 
130
        self.check_hasnot(brn, 'branch', 'version', 'patchlevel')
 
131
 
 
132
    tests.append('test_branch')
 
133
 
 
134
    def test_version(self, nameless=False):
 
135
        """Version has correct constructor and properties."""
 
136
        nameless = nameless and 'nameless_' or ''
 
137
        vsn = self.check_init(arch.Version, 'version', nameless)
 
138
        self.check_containers(vsn, 'branch', nameless)
 
139
        self.check_badinit(arch.Version, nameless+'branch_full',
 
140
                           nameless+'revision_full')
 
141
        self.check_hasnot(vsn, 'version', 'patchlevel')
 
142
 
 
143
    tests.append('test_version')
 
144
 
 
145
    def test_revision(self, nameless=False):
 
146
        """Revision has correct constructor and properties."""
 
147
        nameless = nameless and 'nameless_' or ''
 
148
        rvsn = self.check_init(arch.Revision, 'revision', nameless)
 
149
        self.check_containers(rvsn, 'version', nameless)
 
150
        self.check_badinit(arch.Revision, nameless+'version_full')
 
151
        self.readonly(rvsn, 'patchlevel')
 
152
        self.assertEqual(rvsn.patchlevel, self.patchlevel)
 
153
 
 
154
    tests.append('test_revision')
 
155
 
 
156
    def test_nameless_branch(self):
 
157
        """Branch (nameless branch) has correct ctor and properties."""
 
158
        self.test_branch(nameless=True)
 
159
    tests.append('test_nameless_branch')
 
160
 
 
161
    def test_nameless_version(self):
 
162
        """Version (nameless branch) has correct ctor and properties."""
 
163
        self.test_version(nameless=True)
 
164
    tests.append('test_nameless_version')
 
165
 
 
166
    def test_nameless_revision(self):
 
167
        """Revision (nameless branch) has correct ctor and properties."""
 
168
        self.test_revision(nameless=True)
 
169
    tests.append('test_nameless_revision')
 
170
 
 
171
 
 
172
def test_suite(limit=()):
 
173
    classes = (
 
174
        'ArchNameProperties',
 
175
        )
 
176
    return framework.make_test_suite(globals(), classes, limit)
 
177
 
 
178
def main(argv):
 
179
    return framework.run_test_suite(argv, test_suite)
 
180
 
 
181
if __name__ == "__main__":
 
182
    sys.exit(main(sys.argv))
 
183