code.grnet.gr Git - ganeti-local/blob - test/ganeti.objects_unittest.py

   1 #!/usr/bin/python
   2 #
   3
   4 # Copyright (C) 2006, 2007, 2008, 2010 Google Inc.
   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, 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.
  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., 51 Franklin Street, Fifth Floor, Boston, MA
  19 # 0.0510-1301, USA.
  20
  21
  22 """Script for unittesting the objects module"""
  23
  24
  25 import unittest
  26
  27 from ganeti import constants
  28 from ganeti import objects
  29
  30 import testutils
  31
  32
  33 class SimpleObject(objects.ConfigObject):
  34   __slots__ = ['a', 'b']
  35
  36
  37 class TestDictState(unittest.TestCase):
  38   """Simple dict tansformation tests"""
  39
  40   def testSimpleObjectToDict(self):
  41     o1 = SimpleObject(a='1')
  42     self.assertEquals(o1.ToDict(), {'a': '1'})
  43     self.assertEquals(o1.__getstate__(), {'a': '1'})
  44     self.assertEquals(o1.__getstate__(), o1.ToDict())
  45     o1.a = 2
  46     o1.b = 5
  47     self.assertEquals(o1.ToDict(), {'a': 2, 'b': 5})
  48     o2 = SimpleObject.FromDict(o1.ToDict())
  49     self.assertEquals(o1.ToDict(), {'a': 2, 'b': 5})
  50
  51
  52 class TestClusterObject(unittest.TestCase):
  53   """Tests done on a L{objects.Cluster}"""
  54
  55   def setUp(self):
  56     hvparams = {
  57       constants.HT_FAKE: {
  58         "foo": "bar",
  59         "bar": "foo",
  60         "foobar": "barfoo",
  61         },
  62       }
  63     os_hvp = {
  64       "lenny-image": {
  65         constants.HT_FAKE: {
  66           "foo": "baz",
  67           "foobar": "foobar",
  68           "blah": "blibb",
  69           "blubb": "blah",
  70           },
  71         constants.HT_XEN_PVM: {
  72           "root_path": "/dev/sda5",
  73           "foo": "foobar",
  74           },
  75         },
  76       "ubuntu-hardy": {
  77         },
  78       }
  79     ndparams = {
  80         constants.ND_OOB_PROGRAM: "/bin/cluster-oob"
  81         }
  82
  83     self.fake_cl = objects.Cluster(hvparams=hvparams, os_hvp=os_hvp,
  84                                    ndparams=ndparams)
  85     self.fake_cl.UpgradeConfig()
  86
  87   def testGetHVDefaults(self):
  88     cl = self.fake_cl
  89     self.failUnlessEqual(cl.GetHVDefaults(constants.HT_FAKE),
  90                          cl.hvparams[constants.HT_FAKE])
  91     self.failUnlessEqual(cl.GetHVDefaults(None), {})
  92     self.failUnlessEqual(cl.GetHVDefaults(constants.HT_XEN_PVM,
  93                                           os_name="lenny-image"),
  94                          cl.os_hvp["lenny-image"][constants.HT_XEN_PVM])
  95
  96
  97   def testFillHvFullMerge(self):
  98     inst_hvparams = {
  99       "blah": "blubb",
 100       }
 101
 102     fake_dict = {
 103       "foo": "baz",
 104       "bar": "foo",
 105       "foobar": "foobar",
 106       "blah": "blubb",
 107       "blubb": "blah",
 108       }
 109     fake_inst = objects.Instance(name="foobar",
 110                                  os="lenny-image",
 111                                  hypervisor=constants.HT_FAKE,
 112                                  hvparams=inst_hvparams)
 113     self.assertEqual(fake_dict, self.fake_cl.FillHV(fake_inst))
 114
 115   def testFillHvGlobalParams(self):
 116     fake_inst = objects.Instance(name="foobar",
 117                                  os="ubuntu-hardy",
 118                                  hypervisor=constants.HT_FAKE,
 119                                  hvparams={})
 120     self.assertEqual(self.fake_cl.hvparams[constants.HT_FAKE],
 121                      self.fake_cl.FillHV(fake_inst))
 122
 123   def testFillHvInstParams(self):
 124     inst_hvparams = {
 125       "blah": "blubb",
 126       }
 127     fake_inst = objects.Instance(name="foobar",
 128                                  os="ubuntu-hardy",
 129                                  hypervisor=constants.HT_XEN_PVM,
 130                                  hvparams=inst_hvparams)
 131     self.assertEqual(inst_hvparams, self.fake_cl.FillHV(fake_inst))
 132
 133   def testFillHvEmptyParams(self):
 134     fake_inst = objects.Instance(name="foobar",
 135                                  os="ubuntu-hardy",
 136                                  hypervisor=constants.HT_XEN_PVM,
 137                                  hvparams={})
 138     self.assertEqual({}, self.fake_cl.FillHV(fake_inst))
 139
 140   def testFillHvPartialParams(self):
 141     os = "lenny-image"
 142     fake_inst = objects.Instance(name="foobar",
 143                                  os=os,
 144                                  hypervisor=constants.HT_XEN_PVM,
 145                                  hvparams={})
 146     self.assertEqual(self.fake_cl.os_hvp[os][constants.HT_XEN_PVM],
 147                      self.fake_cl.FillHV(fake_inst))
 148
 149   def testFillNdParamsCluster(self):
 150     fake_node = objects.Node(name="test",
 151                              ndparams={},
 152                              group="testgroup")
 153     fake_group = objects.NodeGroup(name="testgroup",
 154                                    ndparams={})
 155     self.assertEqual(self.fake_cl.ndparams,
 156                      self.fake_cl.FillND(fake_node, fake_group))
 157
 158   def testFillNdParamsNodeGroup(self):
 159     fake_node = objects.Node(name="test",
 160                              ndparams={},
 161                              group="testgroup")
 162     group_ndparams = {
 163         constants.ND_OOB_PROGRAM: "/bin/group-oob"
 164         }
 165     fake_group = objects.NodeGroup(name="testgroup",
 166                                    ndparams=group_ndparams)
 167     self.assertEqual(group_ndparams,
 168                      self.fake_cl.FillND(fake_node, fake_group))
 169
 170   def testFillNdParamsNode(self):
 171     node_ndparams = {
 172         constants.ND_OOB_PROGRAM: "/bin/node-oob"
 173         }
 174     fake_node = objects.Node(name="test",
 175                              ndparams=node_ndparams,
 176                              group="testgroup")
 177     fake_group = objects.NodeGroup(name="testgroup",
 178                                    ndparams={})
 179     self.assertEqual(node_ndparams,
 180                      self.fake_cl.FillND(fake_node, fake_group))
 181
 182   def testFillNdParamsAll(self):
 183     node_ndparams = {
 184         constants.ND_OOB_PROGRAM: "/bin/node-oob"
 185         }
 186     fake_node = objects.Node(name="test",
 187                              ndparams=node_ndparams,
 188                              group="testgroup")
 189     group_ndparams = {
 190         constants.ND_OOB_PROGRAM: "/bin/group-oob"
 191         }
 192     fake_group = objects.NodeGroup(name="testgroup",
 193                                    ndparams=group_ndparams)
 194     self.assertEqual(node_ndparams,
 195                      self.fake_cl.FillND(fake_node, fake_group))
 196
 197
 198 class TestOS(unittest.TestCase):
 199   ALL_DATA = [
 200     "debootstrap",
 201     "debootstrap+default",
 202     "debootstrap++default",
 203     ]
 204
 205   def testSplitNameVariant(self):
 206     for name in self.ALL_DATA:
 207       self.assertEqual(len(objects.OS.SplitNameVariant(name)), 2)
 208
 209   def testVariant(self):
 210     self.assertEqual(objects.OS.GetVariant("debootstrap"), "")
 211     self.assertEqual(objects.OS.GetVariant("debootstrap+default"), "default")
 212
 213
 214 if __name__ == '__main__':
 215   testutils.GanetiTestProgram()