Revision 5b798711

b/test/py/ganeti.config_unittest.py
124 124
    self.failUnlessEqual(1, len(cfg.GetNodeList()))
125 125
    self.failUnlessEqual(0, len(cfg.GetInstanceList()))
126 126

  
127
  def _GenericNodesCheck(self, inst, all_nodes, secondary_nodes):
128
    for i in [all_nodes, secondary_nodes]:
129
      self.assertTrue(isinstance(i, (list, tuple)),
130
                      msg="Data type doesn't guarantee order")
131

  
132
    self.assertTrue(inst.primary_node not in secondary_nodes)
133
    self.assertEqual(all_nodes[0], inst.primary_node,
134
                     msg="Primary node not first node in list")
135

  
136
  def testInstNodesNoDisks(self):
137
    """Test all_nodes/secondary_nodes when there are no disks"""
138
    # construct instance
139
    cfg = self._get_object()
140
    inst = self._create_instance(cfg)
141
    cfg.AddInstance(inst, "my-job")
142

  
143
    # No disks
144
    all_nodes = cfg.GetInstanceNodes(inst)
145
    secondary_nodes = cfg.GetInstanceSecondaryNodes(inst)
146
    self._GenericNodesCheck(inst, all_nodes, secondary_nodes)
147
    self.assertEqual(len(secondary_nodes), 0)
148
    self.assertEqual(set(all_nodes), set([inst.primary_node]))
149
    self.assertEqual(cfg.GetInstanceLVsByNode(inst), {
150
      inst.primary_node: [],
151
      })
152

  
153
  def testInstNodesPlainDisks(self):
154
    # construct instance
155
    cfg = self._get_object()
156
    inst = self._create_instance(cfg)
157
    disks = [
158
      objects.Disk(dev_type=constants.DT_PLAIN, size=128,
159
                   logical_id=("myxenvg", "disk25494")),
160
      objects.Disk(dev_type=constants.DT_PLAIN, size=512,
161
                   logical_id=("myxenvg", "disk29071")),
162
      ]
163
    inst.disks = disks
164
    cfg.AddInstance(inst, "my-job")
165

  
166
    # Plain disks
167
    all_nodes = cfg.GetInstanceNodes(inst)
168
    secondary_nodes = cfg.GetInstanceSecondaryNodes(inst)
169
    self._GenericNodesCheck(inst, all_nodes, secondary_nodes)
170
    self.assertEqual(len(secondary_nodes), 0)
171
    self.assertEqual(set(all_nodes), set([inst.primary_node]))
172
    self.assertEqual(cfg.GetInstanceLVsByNode(inst), {
173
      inst.primary_node: ["myxenvg/disk25494", "myxenvg/disk29071"],
174
      })
175

  
176
  def testInstNodesDrbdDisks(self):
177
    # construct a second node
178
    cfg = self._get_object()
179
    node_group = cfg.LookupNodeGroup(None)
180
    master_uuid = cfg.GetMasterNode()
181
    node2 = objects.Node(name="node2.example.com", group=node_group,
182
                         ndparams={}, uuid="node2-uuid")
183
    cfg.AddNode(node2, "my-job")
184

  
185
    # construct instance
186
    inst = self._create_instance(cfg)
187
    disks = [
188
      objects.Disk(dev_type=constants.DT_DRBD8, size=786432,
189
                   logical_id=(master_uuid, node2.uuid,
190
                               12300, 0, 0, "secret"),
191
                   children=[
192
                     objects.Disk(dev_type=constants.DT_PLAIN, size=786432,
193
                                  logical_id=("myxenvg", "disk0")),
194
                     objects.Disk(dev_type=constants.DT_PLAIN, size=128,
195
                                  logical_id=("myxenvg", "meta0"))
196
                   ],
197
                   iv_name="disk/0")
198
      ]
199
    inst.disks = disks
200
    cfg.AddInstance(inst, "my-job")
201

  
202
    # Drbd Disks
203
    all_nodes = cfg.GetInstanceNodes(inst)
204
    secondary_nodes = cfg.GetInstanceSecondaryNodes(inst)
205
    self._GenericNodesCheck(inst, all_nodes, secondary_nodes)
206
    self.assertEqual(set(secondary_nodes), set([node2.uuid]))
207
    self.assertEqual(set(all_nodes),
208
                     set([inst.primary_node, node2.uuid]))
209
    self.assertEqual(cfg.GetInstanceLVsByNode(inst), {
210
      master_uuid: ["myxenvg/disk0", "myxenvg/meta0"],
211
      node2.uuid: ["myxenvg/disk0", "myxenvg/meta0"],
212
      })
213

  
127 214
  def testUpdateCluster(self):
128 215
    """Test updates on the cluster object"""
129 216
    cfg = self._get_object()
b/test/py/ganeti.objects_unittest.py
321 321

  
322 322

  
323 323
class TestInstance(unittest.TestCase):
324
  def _GenericCheck(self, inst):
325
    for i in [inst.all_nodes, inst.secondary_nodes]:
326
      self.assertTrue(isinstance(inst.all_nodes, (list, tuple)),
327
                      msg="Data type doesn't guarantee order")
328

  
329
    self.assertTrue(inst.primary_node not in inst.secondary_nodes)
330
    self.assertEqual(inst.all_nodes[0], inst.primary_node,
331
                     msg="Primary node not first node in list")
332

  
333
  def testNodesNoDisks(self):
334
    inst = objects.Instance(name="fakeinst.example.com",
335
      primary_node="pnode.example.com",
336
      disks=[
337
        ])
338

  
339
    self._GenericCheck(inst)
340
    self.assertEqual(len(inst.secondary_nodes), 0)
341
    self.assertEqual(set(inst.all_nodes), set([inst.primary_node]))
342
    self.assertEqual(inst.MapLVsByNode(), {
343
      inst.primary_node: [],
344
      })
345

  
346
  def testNodesPlainDisks(self):
347
    inst = objects.Instance(name="fakeinstplain.example.com",
348
      primary_node="node3.example.com",
349
      disks=[
350
        objects.Disk(dev_type=constants.DT_PLAIN, size=128,
351
                     logical_id=("myxenvg", "disk25494")),
352
        objects.Disk(dev_type=constants.DT_PLAIN, size=512,
353
                     logical_id=("myxenvg", "disk29071")),
354
        ])
355

  
356
    self._GenericCheck(inst)
357
    self.assertEqual(len(inst.secondary_nodes), 0)
358
    self.assertEqual(set(inst.all_nodes), set([inst.primary_node]))
359
    self.assertEqual(inst.MapLVsByNode(), {
360
      inst.primary_node: ["myxenvg/disk25494", "myxenvg/disk29071"],
361
      })
362

  
363
  def testNodesDrbdDisks(self):
324
  def testFindDisk(self):
364 325
    inst = objects.Instance(name="fakeinstdrbd.example.com",
365 326
      primary_node="node10.example.com",
366 327
      disks=[
......
376 337
          iv_name="disk/0")
377 338
        ])
378 339

  
379
    self._GenericCheck(inst)
380
    self.assertEqual(set(inst.secondary_nodes), set(["node15.example.com"]))
381
    self.assertEqual(set(inst.all_nodes),
382
                     set([inst.primary_node, "node15.example.com"]))
383
    self.assertEqual(inst.MapLVsByNode(), {
384
      inst.primary_node: ["myxenvg/disk0", "myxenvg/meta0"],
385
      "node15.example.com": ["myxenvg/disk0", "myxenvg/meta0"],
386
      })
387

  
388 340
    self.assertEqual(inst.FindDisk(0), inst.disks[0])
389 341
    self.assertRaises(errors.OpPrereqError, inst.FindDisk, "hello")
390 342
    self.assertRaises(errors.OpPrereqError, inst.FindDisk, 100)

Also available in: Unified diff