4 # Copyright (C) 2006, 2007, 2008, 2010 Google Inc.
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.
11 # This program is distributed in the hope that it will be useful, but
12 # WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 # General Public License for more details.
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., 51 Franklin Street, Fifth Floor, Boston, MA
22 """Script for unittesting the objects module"""
27 from ganeti import constants
28 from ganeti import objects
29 from ganeti import errors
34 class SimpleObject(objects.ConfigObject):
35 __slots__ = ['a', 'b']
38 class TestDictState(unittest.TestCase):
39 """Simple dict tansformation tests"""
41 def testSimpleObjectToDict(self):
42 o1 = SimpleObject(a='1')
43 self.assertEquals(o1.ToDict(), {'a': '1'})
44 self.assertEquals(o1.__getstate__(), {'a': '1'})
45 self.assertEquals(o1.__getstate__(), o1.ToDict())
48 self.assertEquals(o1.ToDict(), {'a': 2, 'b': 5})
49 o2 = SimpleObject.FromDict(o1.ToDict())
50 self.assertEquals(o1.ToDict(), {'a': 2, 'b': 5})
53 class TestClusterObject(unittest.TestCase):
54 """Tests done on a L{objects.Cluster}"""
72 constants.HT_XEN_PVM: {
73 "root_path": "/dev/sda5",
81 constants.ND_OOB_PROGRAM: "/bin/cluster-oob"
84 self.fake_cl = objects.Cluster(hvparams=hvparams, os_hvp=os_hvp,
86 self.fake_cl.UpgradeConfig()
88 def testGetHVDefaults(self):
90 self.failUnlessEqual(cl.GetHVDefaults(constants.HT_FAKE),
91 cl.hvparams[constants.HT_FAKE])
92 self.failUnlessEqual(cl.GetHVDefaults(None), {})
93 self.failUnlessEqual(cl.GetHVDefaults(constants.HT_XEN_PVM,
94 os_name="lenny-image"),
95 cl.os_hvp["lenny-image"][constants.HT_XEN_PVM])
98 def testFillHvFullMerge(self):
110 fake_inst = objects.Instance(name="foobar",
112 hypervisor=constants.HT_FAKE,
113 hvparams=inst_hvparams)
114 self.assertEqual(fake_dict, self.fake_cl.FillHV(fake_inst))
116 def testFillHvGlobalParams(self):
117 fake_inst = objects.Instance(name="foobar",
119 hypervisor=constants.HT_FAKE,
121 self.assertEqual(self.fake_cl.hvparams[constants.HT_FAKE],
122 self.fake_cl.FillHV(fake_inst))
124 def testFillHvInstParams(self):
128 fake_inst = objects.Instance(name="foobar",
130 hypervisor=constants.HT_XEN_PVM,
131 hvparams=inst_hvparams)
132 self.assertEqual(inst_hvparams, self.fake_cl.FillHV(fake_inst))
134 def testFillHvEmptyParams(self):
135 fake_inst = objects.Instance(name="foobar",
137 hypervisor=constants.HT_XEN_PVM,
139 self.assertEqual({}, self.fake_cl.FillHV(fake_inst))
141 def testFillHvPartialParams(self):
143 fake_inst = objects.Instance(name="foobar",
145 hypervisor=constants.HT_XEN_PVM,
147 self.assertEqual(self.fake_cl.os_hvp[os][constants.HT_XEN_PVM],
148 self.fake_cl.FillHV(fake_inst))
150 def testFillNdParamsCluster(self):
151 fake_node = objects.Node(name="test",
154 fake_group = objects.NodeGroup(name="testgroup",
156 self.assertEqual(self.fake_cl.ndparams,
157 self.fake_cl.FillND(fake_node, fake_group))
159 def testFillNdParamsNodeGroup(self):
160 fake_node = objects.Node(name="test",
164 constants.ND_OOB_PROGRAM: "/bin/group-oob"
166 fake_group = objects.NodeGroup(name="testgroup",
167 ndparams=group_ndparams)
168 self.assertEqual(group_ndparams,
169 self.fake_cl.FillND(fake_node, fake_group))
171 def testFillNdParamsNode(self):
173 constants.ND_OOB_PROGRAM: "/bin/node-oob"
175 fake_node = objects.Node(name="test",
176 ndparams=node_ndparams,
178 fake_group = objects.NodeGroup(name="testgroup",
180 self.assertEqual(node_ndparams,
181 self.fake_cl.FillND(fake_node, fake_group))
183 def testFillNdParamsAll(self):
185 constants.ND_OOB_PROGRAM: "/bin/node-oob"
187 fake_node = objects.Node(name="test",
188 ndparams=node_ndparams,
191 constants.ND_OOB_PROGRAM: "/bin/group-oob"
193 fake_group = objects.NodeGroup(name="testgroup",
194 ndparams=group_ndparams)
195 self.assertEqual(node_ndparams,
196 self.fake_cl.FillND(fake_node, fake_group))
199 class TestOS(unittest.TestCase):
202 "debootstrap+default",
203 "debootstrap++default",
206 def testSplitNameVariant(self):
207 for name in self.ALL_DATA:
208 self.assertEqual(len(objects.OS.SplitNameVariant(name)), 2)
210 def testVariant(self):
211 self.assertEqual(objects.OS.GetVariant("debootstrap"), "")
212 self.assertEqual(objects.OS.GetVariant("debootstrap+default"), "default")
215 class TestInstance(unittest.TestCase):
216 def _GenericCheck(self, inst):
217 for i in [inst.all_nodes, inst.secondary_nodes]:
218 self.assertTrue(isinstance(inst.all_nodes, (list, tuple)),
219 msg="Data type doesn't guarantee order")
221 self.assertTrue(inst.primary_node not in inst.secondary_nodes)
222 self.assertEqual(inst.all_nodes[0], inst.primary_node,
223 msg="Primary node not first node in list")
225 def testNodesNoDisks(self):
226 inst = objects.Instance(name="fakeinst.example.com",
227 primary_node="pnode.example.com",
231 self._GenericCheck(inst)
232 self.assertEqual(len(inst.secondary_nodes), 0)
233 self.assertEqual(set(inst.all_nodes), set([inst.primary_node]))
234 self.assertEqual(inst.MapLVsByNode(), {
235 inst.primary_node: [],
238 def testNodesPlainDisks(self):
239 inst = objects.Instance(name="fakeinstplain.example.com",
240 primary_node="node3.example.com",
242 objects.Disk(dev_type=constants.LD_LV, size=128,
243 logical_id=("myxenvg", "disk25494")),
244 objects.Disk(dev_type=constants.LD_LV, size=512,
245 logical_id=("myxenvg", "disk29071")),
248 self._GenericCheck(inst)
249 self.assertEqual(len(inst.secondary_nodes), 0)
250 self.assertEqual(set(inst.all_nodes), set([inst.primary_node]))
251 self.assertEqual(inst.MapLVsByNode(), {
252 inst.primary_node: ["myxenvg/disk25494", "myxenvg/disk29071"],
255 def testNodesDrbdDisks(self):
256 inst = objects.Instance(name="fakeinstdrbd.example.com",
257 primary_node="node10.example.com",
259 objects.Disk(dev_type=constants.LD_DRBD8, size=786432,
260 logical_id=("node10.example.com", "node15.example.com",
261 12300, 0, 0, "secret"),
263 objects.Disk(dev_type=constants.LD_LV, size=786432,
264 logical_id=("myxenvg", "disk0")),
265 objects.Disk(dev_type=constants.LD_LV, size=128,
266 logical_id=("myxenvg", "meta0"))
271 self._GenericCheck(inst)
272 self.assertEqual(set(inst.secondary_nodes), set(["node15.example.com"]))
273 self.assertEqual(set(inst.all_nodes),
274 set([inst.primary_node, "node15.example.com"]))
275 self.assertEqual(inst.MapLVsByNode(), {
276 inst.primary_node: ["myxenvg/disk0", "myxenvg/meta0"],
277 "node15.example.com": ["myxenvg/disk0", "myxenvg/meta0"],
280 self.assertEqual(inst.FindDisk(0), inst.disks[0])
281 self.assertRaises(errors.OpPrereqError, inst.FindDisk, "hello")
282 self.assertRaises(errors.OpPrereqError, inst.FindDisk, 100)
283 self.assertRaises(errors.OpPrereqError, inst.FindDisk, 1)
286 if __name__ == '__main__':
287 testutils.GanetiTestProgram()