← Back to branch summary

~ubuntu-branches/ubuntu/saucy/nova/saucy-proposed

« back to all changes in this revision

Viewing changes to nova/tests/test_flags.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short, Dave Walker (Daviey), Chuck Short
  • Date: 2012-02-17 10:59:59 UTC
  • mfrom: (1.1.45)
  • Revision ID: package-import@ubuntu.com-20120217105959-ut218n638vv7cre0
Tags: 2012.1~e4~20120217.12709-0ubuntu1
https://launchpad.net/bugs/929127
https://launchpad.net/bugs/923681
https://launchpad.net/bugs/932787
[ Dave Walker (Daviey) ]
* New upstream snapshot
* debian/patches/temp_fix_linux_net.patch:
  - Dropped, applied upstream. LP: #929127
* debian/patches/libvirt-use-console-pipe.patch:
  - Rebased against latest trunk

[ Chuck Short ]
* debian/nova.conf: Re-enable default iscsi_helper.
* debian/nova.conf: More fixups.
* debian/control: Dont depend and conflicts on nova-compute-
  hypervisor. (LP: #923681)
* debian/patches/libvirt-us-console-pipe.patch: Refreshed.
* Temporarily disable console patch. (LP: #932787)
* New usptream version.

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/test_flags.py
17
17
#    License for the specific language governing permissions and limitations
18
18
#    under the License.
19
19
 
20
 
import exceptions
21
20
import os
22
21
import tempfile
23
22
 
26
25
from nova import test
27
26
 
28
27
FLAGS = flags.FLAGS
29
 
FLAGS.add_option(cfg.StrOpt('flags_unittest',
30
 
                            default='foo',
31
 
                            help='for testing purposes only'))
32
 
 
33
 
test_opts = [
34
 
    cfg.StrOpt('string', default='default', help='desc'),
35
 
    cfg.IntOpt('int', default=1, help='desc'),
36
 
    cfg.BoolOpt('false', default=False, help='desc'),
37
 
    cfg.BoolOpt('true', default=True, help='desc'),
38
 
    ]
39
 
 
40
 
float_opt = cfg.FloatOpt('float', default=6.66, help='desc')
41
 
multistr_opt = cfg.MultiStrOpt('multi', default=['blaa'], help='desc')
42
 
list_opt = cfg.ListOpt('list', default=['foo'], help='desc')
 
28
FLAGS.register_opt(cfg.StrOpt('flags_unittest',
 
29
                              default='foo',
 
30
                              help='for testing purposes only'))
43
31
 
44
32
 
45
33
class FlagsTestCase(test.TestCase):
46
34
 
47
35
    def setUp(self):
48
36
        super(FlagsTestCase, self).setUp()
49
 
        self.FLAGS = flags.FlagValues()
 
37
        self.FLAGS = flags.NovaConfigOpts()
50
38
        self.global_FLAGS = flags.FLAGS
51
39
 
52
 
    def test_define(self):
53
 
        self.FLAGS.add_cli_options(test_opts)
54
 
 
55
 
        self.assert_(self.FLAGS['string'])
56
 
        self.assert_(self.FLAGS['int'])
57
 
        self.assert_(self.FLAGS['false'])
58
 
        self.assert_(self.FLAGS['true'])
59
 
        self.assertEqual(self.FLAGS.string, 'default')
60
 
        self.assertEqual(self.FLAGS.int, 1)
61
 
        self.assertEqual(self.FLAGS.false, False)
62
 
        self.assertEqual(self.FLAGS.true, True)
63
 
 
64
 
        argv = ['flags_test',
65
 
                '--string', 'foo',
66
 
                '--int', '2',
67
 
                '--false',
68
 
                '--notrue']
69
 
 
70
 
        self.FLAGS(argv)
71
 
        self.assertEqual(self.FLAGS.string, 'foo')
72
 
        self.assertEqual(self.FLAGS.int, 2)
73
 
        self.assertEqual(self.FLAGS.false, True)
74
 
        self.assertEqual(self.FLAGS.true, False)
75
 
 
76
 
    def test_define_float(self):
77
 
        self.FLAGS.add_cli_options(test_opts)
78
 
        self.FLAGS.add_option(float_opt)
79
 
        self.assertEqual(self.FLAGS.float, 6.66)
80
 
 
81
 
    def test_define_multistring(self):
82
 
        self.FLAGS.add_cli_option(multistr_opt)
83
 
 
84
 
        self.assert_(self.FLAGS['multi'])
85
 
        self.assertEqual(self.FLAGS.multi, ['blaa'])
86
 
 
87
 
        argv = ['flags_test', '--multi', 'foo', '--multi', 'bar']
88
 
        self.FLAGS(argv)
89
 
 
90
 
        self.assertEqual(self.FLAGS.multi, ['foo', 'bar'])
91
 
 
92
 
    def test_define_list(self):
93
 
        self.FLAGS.add_cli_option(list_opt)
94
 
 
95
 
        self.assert_(self.FLAGS['list'])
96
 
        self.assertEqual(self.FLAGS.list, ['foo'])
97
 
 
98
 
        argv = ['flags_test', '--list=a,b,c,d']
99
 
        self.FLAGS(argv)
100
 
 
101
 
        self.assertEqual(self.FLAGS.list, ['a', 'b', 'c', 'd'])
102
 
 
103
 
    def test_error(self):
104
 
        self.FLAGS.add_cli_option(float_opt)
105
 
 
106
 
        self.assertEqual(self.FLAGS.float, 6.66)
107
 
 
108
 
        argv = ['flags_test', '--float=foo']
109
 
        self.assertRaises(exceptions.SystemExit, self.FLAGS, argv)
110
 
 
111
40
    def test_declare(self):
112
41
        self.assert_('answer' not in self.global_FLAGS)
113
42
        flags.DECLARE('answer', 'nova.tests.declare_flags')
115
44
        self.assertEqual(self.global_FLAGS.answer, 42)
116
45
 
117
46
        # Make sure we don't overwrite anything
118
 
        self.global_FLAGS.answer = 256
 
47
        self.global_FLAGS.set_override('answer', 256)
119
48
        self.assertEqual(self.global_FLAGS.answer, 256)
120
49
        flags.DECLARE('answer', 'nova.tests.declare_flags')
121
50
        self.assertEqual(self.global_FLAGS.answer, 256)
135
64
        self.assertEqual(self.global_FLAGS.runtime_answer, 54)
136
65
 
137
66
    def test_long_vs_short_flags(self):
138
 
        self.global_FLAGS.Reset()
139
 
        self.global_FLAGS.add_cli_option(cfg.StrOpt('duplicate_answer_long',
140
 
                                                    default='val',
141
 
                                                    help='desc'))
 
67
        self.global_FLAGS.reset()
 
68
        self.global_FLAGS.register_cli_opt(cfg.StrOpt('duplicate_answer_long',
 
69
                                                      default='val',
 
70
                                                      help='desc'))
142
71
        argv = ['flags_test', '--duplicate_answer=60', 'extra_arg']
143
72
        args = self.global_FLAGS(argv)
144
73
 
145
74
        self.assert_('duplicate_answer' not in self.global_FLAGS)
146
75
        self.assert_(self.global_FLAGS.duplicate_answer_long, 60)
147
76
 
148
 
        self.global_FLAGS.Reset()
149
 
        self.global_FLAGS.add_cli_option(cfg.IntOpt('duplicate_answer',
150
 
                                                    default=60,
151
 
                                                    help='desc'))
 
77
        self.global_FLAGS.reset()
 
78
        self.global_FLAGS.register_cli_opt(cfg.IntOpt('duplicate_answer',
 
79
                                                      default=60,
 
80
                                                      help='desc'))
152
81
        args = self.global_FLAGS(argv)
153
82
        self.assertEqual(self.global_FLAGS.duplicate_answer, 60)
154
83
        self.assertEqual(self.global_FLAGS.duplicate_answer_long, 'val')
155
84
 
156
85
    def test_flag_leak_left(self):
157
86
        self.assertEqual(FLAGS.flags_unittest, 'foo')
158
 
        FLAGS.flags_unittest = 'bar'
 
87
        self.flags(flags_unittest='bar')
159
88
        self.assertEqual(FLAGS.flags_unittest, 'bar')
160
89
 
161
90
    def test_flag_leak_right(self):
162
91
        self.assertEqual(FLAGS.flags_unittest, 'foo')
163
 
        FLAGS.flags_unittest = 'bar'
 
92
        self.flags(flags_unittest='bar')
164
93
        self.assertEqual(FLAGS.flags_unittest, 'bar')
165
94
 
166
95
    def test_flag_overrides(self):
167
96
        self.assertEqual(FLAGS.flags_unittest, 'foo')
168
97
        self.flags(flags_unittest='bar')
169
98
        self.assertEqual(FLAGS.flags_unittest, 'bar')
170
 
        self.assertEqual(FLAGS['flags_unittest'].value, 'bar')
171
 
        self.assertEqual(FLAGS.FlagValuesDict()['flags_unittest'], 'bar')
172
99
        self.reset_flags()
173
100
        self.assertEqual(FLAGS.flags_unittest, 'foo')
174
 
        self.assertEqual(FLAGS['flags_unittest'].value, 'foo')
175
 
        self.assertEqual(FLAGS.FlagValuesDict()['flags_unittest'], 'foo')
176
101
 
177
102
    def test_flagfile(self):
178
 
        self.FLAGS.add_options(test_opts)
179
 
        self.FLAGS.add_option(multistr_opt)
 
103
        opts = [
 
104
            cfg.StrOpt('string', default='default', help='desc'),
 
105
            cfg.IntOpt('int', default=1, help='desc'),
 
106
            cfg.BoolOpt('false', default=False, help='desc'),
 
107
            cfg.BoolOpt('true', default=True, help='desc'),
 
108
            cfg.MultiStrOpt('multi', default=['blaa'], help='desc'),
 
109
            ]
 
110
 
 
111
        self.FLAGS.register_opts(opts)
180
112
 
181
113
        (fd, path) = tempfile.mkstemp(prefix='nova', suffix='.flags')
182
114
 
200
132
            os.remove(path)
201
133
 
202
134
    def test_defaults(self):
203
 
        self.FLAGS.add_option(cfg.StrOpt('foo', default='bar', help='desc'))
 
135
        self.FLAGS.register_opt(cfg.StrOpt('foo', default='bar', help='desc'))
204
136
        self.assertEqual(self.FLAGS.foo, 'bar')
205
137
 
206
 
        self.FLAGS['foo'].SetDefault('blaa')
 
138
        self.FLAGS.set_default('foo', 'blaa')
207
139
        self.assertEqual(self.FLAGS.foo, 'blaa')
208
140
 
209
141
    def test_templated_values(self):
210
 
        self.FLAGS.add_option(cfg.StrOpt('foo', default='foo', help='desc'))
211
 
        self.FLAGS.add_option(cfg.StrOpt('bar', default='bar', help='desc'))
212
 
        self.FLAGS.add_option(cfg.StrOpt('blaa',
213
 
                                         default='$foo$bar', help='desc'))
 
142
        self.FLAGS.register_opt(cfg.StrOpt('foo', default='foo', help='desc'))
 
143
        self.FLAGS.register_opt(cfg.StrOpt('bar', default='bar', help='desc'))
 
144
        self.FLAGS.register_opt(cfg.StrOpt('blaa',
 
145
                                           default='$foo$bar', help='desc'))
214
146
        self.assertEqual(self.FLAGS.blaa, 'foobar')