Revision 8c114acd

b/test/ganeti.bdev_unittest.py
312 312
      stats = bdev.DRBD8Status(data[4])
313 313
      self.failUnless(stats.is_in_use)
314 314
      self.failUnless(stats.is_wfconn and stats.is_primary and
315
                      stats.rrole == 'Unknown' and
315
                      stats.rrole == "Unknown" and
316 316
                      stats.is_disk_uptodate)
317 317

  
318 318
  def testMinor6(self):
......
329 329
      stats = bdev.DRBD8Status(data[8])
330 330
      self.failUnless(stats.is_in_use)
331 331
      self.failUnless(stats.is_standalone and
332
                      stats.rrole == 'Unknown' and
332
                      stats.rrole == "Unknown" and
333 333
                      stats.is_disk_uptodate)
334 334

  
335 335
  def testDRBD83SyncFine(self):
b/test/ganeti.cli_unittest.py
43 43
  def testValidTimes(self):
44 44
    """Test valid timespecs"""
45 45
    test_data = [
46
      ('1s', 1),
47
      ('1', 1),
48
      ('1m', 60),
49
      ('1h', 60 * 60),
50
      ('1d', 60 * 60 * 24),
51
      ('1w', 60 * 60 * 24 * 7),
52
      ('4h', 4 * 60 * 60),
53
      ('61m', 61 * 60),
46
      ("1s", 1),
47
      ("1", 1),
48
      ("1m", 60),
49
      ("1h", 60 * 60),
50
      ("1d", 60 * 60 * 24),
51
      ("1w", 60 * 60 * 24 * 7),
52
      ("4h", 4 * 60 * 60),
53
      ("61m", 61 * 60),
54 54
      ]
55 55
    for value, expected_result in test_data:
56 56
      self.failUnlessEqual(cli.ParseTimespec(value), expected_result)
......
58 58
  def testInvalidTime(self):
59 59
    """Test invalid timespecs"""
60 60
    test_data = [
61
      '1y',
62
      '',
63
      'aaa',
64
      's',
61
      "1y",
62
      "",
63
      "aaa",
64
      "s",
65 65
      ]
66 66
    for value in test_data:
67 67
      self.failUnlessRaises(OpPrereqError, cli.ParseTimespec, value)
......
128 128
                 ]:
129 129
      buf = StringIO()
130 130
      cli._ToStream(buf, data)
131
      self.failUnlessEqual(buf.getvalue(), data+'\n')
131
      self.failUnlessEqual(buf.getvalue(), data + "\n")
132 132

  
133 133
  def testParams(self):
134 134
      buf = StringIO()
b/test/ganeti.config_unittest.py
183 183
    CheckSyntax = objects.NIC.CheckParameterSyntax
184 184

  
185 185
    CheckSyntax(constants.NICC_DEFAULTS)
186
    CheckSyntax({mode: m_bridged, link: 'br1'})
187
    CheckSyntax({mode: m_routed, link: 'default'})
186
    CheckSyntax({mode: m_bridged, link: "br1"})
187
    CheckSyntax({mode: m_routed, link: "default"})
188 188
    self.assertRaises(errors.ConfigurationError,
189
                      CheckSyntax, {mode: '000invalid', link: 'any'})
189
                      CheckSyntax, {mode: "000invalid", link: "any"})
190 190
    self.assertRaises(errors.ConfigurationError,
191 191
                      CheckSyntax, {mode: m_bridged, link: None})
192 192
    self.assertRaises(errors.ConfigurationError,
193
                      CheckSyntax, {mode: m_bridged, link: ''})
193
                      CheckSyntax, {mode: m_bridged, link: ""})
194 194

  
195 195
  def testGetNdParamsDefault(self):
196 196
    cfg = self._get_object()
b/test/ganeti.constants_unittest.py
115 115
  VALID_NAME = re.compile("^[a-zA-Z_][a-zA-Z0-9_]*$")
116 116

  
117 117
  def testNoDashes(self):
118
    for kind, source in [('hypervisor', constants.HVS_PARAMETER_TYPES),
119
                         ('backend', constants.BES_PARAMETER_TYPES),
120
                         ('nic', constants.NICS_PARAMETER_TYPES),
118
    for kind, source in [("hypervisor", constants.HVS_PARAMETER_TYPES),
119
                         ("backend", constants.BES_PARAMETER_TYPES),
120
                         ("nic", constants.NICS_PARAMETER_TYPES),
121 121
                         ("instdisk", constants.IDISK_PARAMS_TYPES),
122 122
                         ("instnic", constants.INIC_PARAMS_TYPES),
123 123
                        ]:
b/test/ganeti.hooks_unittest.py
206 206
  """
207 207
  rr = rpc.RpcResult
208 208
  return dict([(node, rr((True, [("utest", constants.HKR_SUCCESS, "ok")]),
209
                         node=node, call='FakeScriptOk'))
209
                         node=node, call="FakeScriptOk"))
210 210
               for node in node_list])
211 211

  
212 212

  
......
225 225
    @return: rpc failure from all nodes
226 226

  
227 227
    """
228
    return dict([(node, rpc.RpcResult('error', failed=True,
229
                  node=node, call='FakeError')) for node in node_list])
228
    return dict([(node, rpc.RpcResult("error", failed=True,
229
                  node=node, call="FakeError")) for node in node_list])
230 230

  
231 231
  @staticmethod
232 232
  def _call_script_fail(node_list, hpath, phase, env):
......
238 238
    """
239 239
    rr = rpc.RpcResult
240 240
    return dict([(node, rr((True, [("utest", constants.HKR_FAIL, "err")]),
241
                           node=node, call='FakeScriptFail'))
241
                           node=node, call="FakeScriptFail"))
242 242
                  for node in node_list])
243 243

  
244 244
  def setUp(self):
b/test/ganeti.locking_unittest.py
317 317
  def _doItSharer(self):
318 318
    try:
319 319
      self.sl.acquire(shared=1)
320
      self.done.put('SHR')
320
      self.done.put("SHR")
321 321
      self.sl.release()
322 322
    except errors.LockError:
323
      self.done.put('ERR')
323
      self.done.put("ERR")
324 324

  
325 325
  def _doItExclusive(self):
326 326
    try:
327 327
      self.sl.acquire()
328
      self.done.put('EXC')
328
      self.done.put("EXC")
329 329
      self.sl.release()
330 330
    except errors.LockError:
331
      self.done.put('ERR')
331
      self.done.put("ERR")
332 332

  
333 333
  def _doItDelete(self):
334 334
    try:
335 335
      self.sl.delete()
336
      self.done.put('DEL')
336
      self.done.put("DEL")
337 337
    except errors.LockError:
338
      self.done.put('ERR')
338
      self.done.put("ERR")
339 339

  
340 340
  def testSharersCanCoexist(self):
341 341
    self.sl.acquire(shared=1)
......
350 350
    self.assertRaises(Queue.Empty, self.done.get_nowait)
351 351
    self.sl.release()
352 352
    self._waitThreads()
353
    self.failUnlessEqual(self.done.get_nowait(), 'EXC')
353
    self.failUnlessEqual(self.done.get_nowait(), "EXC")
354 354

  
355 355
  @_Repeat
356 356
  def testExclusiveBlocksDelete(self):
......
359 359
    self.assertRaises(Queue.Empty, self.done.get_nowait)
360 360
    self.sl.release()
361 361
    self._waitThreads()
362
    self.failUnlessEqual(self.done.get_nowait(), 'DEL')
362
    self.failUnlessEqual(self.done.get_nowait(), "DEL")
363 363
    self.sl = locking.SharedLock(self.sl.name)
364 364

  
365 365
  @_Repeat
......
369 369
    self.assertRaises(Queue.Empty, self.done.get_nowait)
370 370
    self.sl.release()
371 371
    self._waitThreads()
372
    self.failUnlessEqual(self.done.get_nowait(), 'SHR')
372
    self.failUnlessEqual(self.done.get_nowait(), "SHR")
373 373

  
374 374
  @_Repeat
375 375
  def testSharerBlocksExclusive(self):
......
378 378
    self.assertRaises(Queue.Empty, self.done.get_nowait)
379 379
    self.sl.release()
380 380
    self._waitThreads()
381
    self.failUnlessEqual(self.done.get_nowait(), 'EXC')
381
    self.failUnlessEqual(self.done.get_nowait(), "EXC")
382 382

  
383 383
  @_Repeat
384 384
  def testSharerBlocksDelete(self):
......
387 387
    self.assertRaises(Queue.Empty, self.done.get_nowait)
388 388
    self.sl.release()
389 389
    self._waitThreads()
390
    self.failUnlessEqual(self.done.get_nowait(), 'DEL')
390
    self.failUnlessEqual(self.done.get_nowait(), "DEL")
391 391
    self.sl = locking.SharedLock(self.sl.name)
392 392

  
393 393
  @_Repeat
......
405 405
    self.sl.release()
406 406
    self._waitThreads()
407 407
    # The exclusive passed before
408
    self.failUnlessEqual(self.done.get_nowait(), 'EXC')
409
    self.failUnlessEqual(self.done.get_nowait(), 'SHR')
408
    self.failUnlessEqual(self.done.get_nowait(), "EXC")
409
    self.failUnlessEqual(self.done.get_nowait(), "SHR")
410 410

  
411 411
  @_Repeat
412 412
  def testWaitingSharerBlocksExclusive(self):
......
423 423
    self.sl.release()
424 424
    self._waitThreads()
425 425
    # The sharer passed before
426
    self.assertEqual(self.done.get_nowait(), 'SHR')
427
    self.assertEqual(self.done.get_nowait(), 'EXC')
426
    self.assertEqual(self.done.get_nowait(), "SHR")
427
    self.assertEqual(self.done.get_nowait(), "EXC")
428 428

  
429 429
  def testDelete(self):
430 430
    self.sl.delete()
......
474 474
    self._waitThreads()
475 475
    # The threads who were pending return ERR
476 476
    for _ in range(4):
477
      self.assertEqual(self.done.get_nowait(), 'ERR')
477
      self.assertEqual(self.done.get_nowait(), "ERR")
478 478
    self.sl = locking.SharedLock(self.sl.name)
479 479

  
480 480
  @_Repeat
......
487 487
    self.sl.delete()
488 488
    self._waitThreads()
489 489
    # The two threads who were pending return both ERR
490
    self.assertEqual(self.done.get_nowait(), 'ERR')
491
    self.assertEqual(self.done.get_nowait(), 'ERR')
492
    self.assertEqual(self.done.get_nowait(), 'ERR')
493
    self.assertEqual(self.done.get_nowait(), 'ERR')
490
    self.assertEqual(self.done.get_nowait(), "ERR")
491
    self.assertEqual(self.done.get_nowait(), "ERR")
492
    self.assertEqual(self.done.get_nowait(), "ERR")
493
    self.assertEqual(self.done.get_nowait(), "ERR")
494 494
    self.sl = locking.SharedLock(self.sl.name)
495 495

  
496 496
  @_Repeat
......
1072 1072
  @locking.ssynchronized(_decoratorlock)
1073 1073
  def _doItExclusive(self):
1074 1074
    self.assert_(_decoratorlock.is_owned())
1075
    self.done.put('EXC')
1075
    self.done.put("EXC")
1076 1076

  
1077 1077
  @locking.ssynchronized(_decoratorlock, shared=1)
1078 1078
  def _doItSharer(self):
1079 1079
    self.assert_(_decoratorlock.is_owned(shared=1))
1080
    self.done.put('SHR')
1080
    self.done.put("SHR")
1081 1081

  
1082 1082
  def testDecoratedFunctions(self):
1083 1083
    self._doItExclusive()
......
1099 1099
    self.assertRaises(Queue.Empty, self.done.get_nowait)
1100 1100
    _decoratorlock.release()
1101 1101
    self._waitThreads()
1102
    self.failUnlessEqual(self.done.get_nowait(), 'EXC')
1102
    self.failUnlessEqual(self.done.get_nowait(), "EXC")
1103 1103

  
1104 1104
  @_Repeat
1105 1105
  def testExclusiveBlocksSharer(self):
......
1108 1108
    self.assertRaises(Queue.Empty, self.done.get_nowait)
1109 1109
    _decoratorlock.release()
1110 1110
    self._waitThreads()
1111
    self.failUnlessEqual(self.done.get_nowait(), 'SHR')
1111
    self.failUnlessEqual(self.done.get_nowait(), "SHR")
1112 1112

  
1113 1113
  @_Repeat
1114 1114
  def testSharerBlocksExclusive(self):
......
1117 1117
    self.assertRaises(Queue.Empty, self.done.get_nowait)
1118 1118
    _decoratorlock.release()
1119 1119
    self._waitThreads()
1120
    self.failUnlessEqual(self.done.get_nowait(), 'EXC')
1120
    self.failUnlessEqual(self.done.get_nowait(), "EXC")
1121 1121

  
1122 1122

  
1123 1123
class TestLockSet(_ThreadedTestCase):
......
1129 1129

  
1130 1130
  def _setUpLS(self):
1131 1131
    """Helper to (re)initialize the lock set"""
1132
    self.resources = ['one', 'two', 'three']
1132
    self.resources = ["one", "two", "three"]
1133 1133
    self.ls = locking.LockSet(self.resources, "TestLockSet")
1134 1134

  
1135 1135
  def testResources(self):
......
1159 1159

  
1160 1160
  def testAcquireRelease(self):
1161 1161
    self.assertFalse(self.ls.check_owned(self.ls._names()))
1162
    self.assert_(self.ls.acquire('one'))
1163
    self.assertEquals(self.ls.list_owned(), set(['one']))
1162
    self.assert_(self.ls.acquire("one"))
1163
    self.assertEquals(self.ls.list_owned(), set(["one"]))
1164 1164
    self.assertTrue(self.ls.check_owned("one"))
1165 1165
    self.assertTrue(self.ls.check_owned("one", shared=0))
1166 1166
    self.assertFalse(self.ls.check_owned("one", shared=1))
1167 1167
    self.ls.release()
1168 1168
    self.assertEquals(self.ls.list_owned(), set())
1169 1169
    self.assertFalse(self.ls.check_owned(self.ls._names()))
1170
    self.assertEquals(self.ls.acquire(['one']), set(['one']))
1171
    self.assertEquals(self.ls.list_owned(), set(['one']))
1170
    self.assertEquals(self.ls.acquire(["one"]), set(["one"]))
1171
    self.assertEquals(self.ls.list_owned(), set(["one"]))
1172 1172
    self.ls.release()
1173 1173
    self.assertEquals(self.ls.list_owned(), set())
1174
    self.ls.acquire(['one', 'two', 'three'])
1175
    self.assertEquals(self.ls.list_owned(), set(['one', 'two', 'three']))
1174
    self.ls.acquire(["one", "two", "three"])
1175
    self.assertEquals(self.ls.list_owned(), set(["one", "two", "three"]))
1176 1176
    self.assertTrue(self.ls.check_owned(self.ls._names()))
1177 1177
    self.assertTrue(self.ls.check_owned(self.ls._names(), shared=0))
1178 1178
    self.assertFalse(self.ls.check_owned(self.ls._names(), shared=1))
1179
    self.ls.release('one')
1179
    self.ls.release("one")
1180 1180
    self.assertFalse(self.ls.check_owned(["one"]))
1181 1181
    self.assertTrue(self.ls.check_owned(["two", "three"]))
1182 1182
    self.assertTrue(self.ls.check_owned(["two", "three"], shared=0))
1183 1183
    self.assertFalse(self.ls.check_owned(["two", "three"], shared=1))
1184
    self.assertEquals(self.ls.list_owned(), set(['two', 'three']))
1185
    self.ls.release(['three'])
1186
    self.assertEquals(self.ls.list_owned(), set(['two']))
1184
    self.assertEquals(self.ls.list_owned(), set(["two", "three"]))
1185
    self.ls.release(["three"])
1186
    self.assertEquals(self.ls.list_owned(), set(["two"]))
1187 1187
    self.ls.release()
1188 1188
    self.assertEquals(self.ls.list_owned(), set())
1189
    self.assertEquals(self.ls.acquire(['one', 'three']), set(['one', 'three']))
1190
    self.assertEquals(self.ls.list_owned(), set(['one', 'three']))
1189
    self.assertEquals(self.ls.acquire(["one", "three"]), set(["one", "three"]))
1190
    self.assertEquals(self.ls.list_owned(), set(["one", "three"]))
1191 1191
    self.ls.release()
1192 1192
    self.assertEquals(self.ls.list_owned(), set())
1193 1193
    for name in self.ls._names():
1194 1194
      self.assertFalse(self.ls.check_owned(name))
1195 1195

  
1196 1196
  def testNoDoubleAcquire(self):
1197
    self.ls.acquire('one')
1198
    self.assertRaises(AssertionError, self.ls.acquire, 'one')
1199
    self.assertRaises(AssertionError, self.ls.acquire, ['two'])
1200
    self.assertRaises(AssertionError, self.ls.acquire, ['two', 'three'])
1197
    self.ls.acquire("one")
1198
    self.assertRaises(AssertionError, self.ls.acquire, "one")
1199
    self.assertRaises(AssertionError, self.ls.acquire, ["two"])
1200
    self.assertRaises(AssertionError, self.ls.acquire, ["two", "three"])
1201 1201
    self.ls.release()
1202
    self.ls.acquire(['one', 'three'])
1203
    self.ls.release('one')
1204
    self.assertRaises(AssertionError, self.ls.acquire, ['two'])
1205
    self.ls.release('three')
1202
    self.ls.acquire(["one", "three"])
1203
    self.ls.release("one")
1204
    self.assertRaises(AssertionError, self.ls.acquire, ["two"])
1205
    self.ls.release("three")
1206 1206

  
1207 1207
  def testNoWrongRelease(self):
1208 1208
    self.assertRaises(AssertionError, self.ls.release)
1209
    self.ls.acquire('one')
1210
    self.assertRaises(AssertionError, self.ls.release, 'two')
1209
    self.ls.acquire("one")
1210
    self.assertRaises(AssertionError, self.ls.release, "two")
1211 1211

  
1212 1212
  def testAddRemove(self):
1213
    self.ls.add('four')
1213
    self.ls.add("four")
1214 1214
    self.assertEquals(self.ls.list_owned(), set())
1215
    self.assert_('four' in self.ls._names())
1216
    self.ls.add(['five', 'six', 'seven'], acquired=1)
1217
    self.assert_('five' in self.ls._names())
1218
    self.assert_('six' in self.ls._names())
1219
    self.assert_('seven' in self.ls._names())
1220
    self.assertEquals(self.ls.list_owned(), set(['five', 'six', 'seven']))
1221
    self.assertEquals(self.ls.remove(['five', 'six']), ['five', 'six'])
1222
    self.assert_('five' not in self.ls._names())
1223
    self.assert_('six' not in self.ls._names())
1224
    self.assertEquals(self.ls.list_owned(), set(['seven']))
1225
    self.assertRaises(AssertionError, self.ls.add, 'eight', acquired=1)
1226
    self.ls.remove('seven')
1227
    self.assert_('seven' not in self.ls._names())
1215
    self.assert_("four" in self.ls._names())
1216
    self.ls.add(["five", "six", "seven"], acquired=1)
1217
    self.assert_("five" in self.ls._names())
1218
    self.assert_("six" in self.ls._names())
1219
    self.assert_("seven" in self.ls._names())
1220
    self.assertEquals(self.ls.list_owned(), set(["five", "six", "seven"]))
1221
    self.assertEquals(self.ls.remove(["five", "six"]), ["five", "six"])
1222
    self.assert_("five" not in self.ls._names())
1223
    self.assert_("six" not in self.ls._names())
1224
    self.assertEquals(self.ls.list_owned(), set(["seven"]))
1225
    self.assertRaises(AssertionError, self.ls.add, "eight", acquired=1)
1226
    self.ls.remove("seven")
1227
    self.assert_("seven" not in self.ls._names())
1228 1228
    self.assertEquals(self.ls.list_owned(), set([]))
1229 1229
    self.ls.acquire(None, shared=1)
1230
    self.assertRaises(AssertionError, self.ls.add, 'eight')
1230
    self.assertRaises(AssertionError, self.ls.add, "eight")
1231 1231
    self.ls.release()
1232 1232
    self.ls.acquire(None)
1233
    self.ls.add('eight', acquired=1)
1234
    self.assert_('eight' in self.ls._names())
1235
    self.assert_('eight' in self.ls.list_owned())
1236
    self.ls.add('nine')
1237
    self.assert_('nine' in self.ls._names())
1238
    self.assert_('nine' not in self.ls.list_owned())
1233
    self.ls.add("eight", acquired=1)
1234
    self.assert_("eight" in self.ls._names())
1235
    self.assert_("eight" in self.ls.list_owned())
1236
    self.ls.add("nine")
1237
    self.assert_("nine" in self.ls._names())
1238
    self.assert_("nine" not in self.ls.list_owned())
1239 1239
    self.ls.release()
1240
    self.ls.remove(['two'])
1241
    self.assert_('two' not in self.ls._names())
1242
    self.ls.acquire('three')
1243
    self.assertEquals(self.ls.remove(['three']), ['three'])
1244
    self.assert_('three' not in self.ls._names())
1245
    self.assertEquals(self.ls.remove('three'), [])
1246
    self.assertEquals(self.ls.remove(['one', 'three', 'six']), ['one'])
1247
    self.assert_('one' not in self.ls._names())
1240
    self.ls.remove(["two"])
1241
    self.assert_("two" not in self.ls._names())
1242
    self.ls.acquire("three")
1243
    self.assertEquals(self.ls.remove(["three"]), ["three"])
1244
    self.assert_("three" not in self.ls._names())
1245
    self.assertEquals(self.ls.remove("three"), [])
1246
    self.assertEquals(self.ls.remove(["one", "three", "six"]), ["one"])
1247
    self.assert_("one" not in self.ls._names())
1248 1248

  
1249 1249
  def testRemoveNonBlocking(self):
1250
    self.ls.acquire('one')
1251
    self.assertEquals(self.ls.remove('one'), ['one'])
1252
    self.ls.acquire(['two', 'three'])
1253
    self.assertEquals(self.ls.remove(['two', 'three']),
1254
                      ['two', 'three'])
1250
    self.ls.acquire("one")
1251
    self.assertEquals(self.ls.remove("one"), ["one"])
1252
    self.ls.acquire(["two", "three"])
1253
    self.assertEquals(self.ls.remove(["two", "three"]),
1254
                      ["two", "three"])
1255 1255

  
1256 1256
  def testNoDoubleAdd(self):
1257
    self.assertRaises(errors.LockError, self.ls.add, 'two')
1258
    self.ls.add('four')
1259
    self.assertRaises(errors.LockError, self.ls.add, 'four')
1257
    self.assertRaises(errors.LockError, self.ls.add, "two")
1258
    self.ls.add("four")
1259
    self.assertRaises(errors.LockError, self.ls.add, "four")
1260 1260

  
1261 1261
  def testNoWrongRemoves(self):
1262
    self.ls.acquire(['one', 'three'], shared=1)
1263
    # Cannot remove 'two' while holding something which is not a superset
1264
    self.assertRaises(AssertionError, self.ls.remove, 'two')
1265
    # Cannot remove 'three' as we are sharing it
1266
    self.assertRaises(AssertionError, self.ls.remove, 'three')
1262
    self.ls.acquire(["one", "three"], shared=1)
1263
    # Cannot remove "two" while holding something which is not a superset
1264
    self.assertRaises(AssertionError, self.ls.remove, "two")
1265
    # Cannot remove "three" as we are sharing it
1266
    self.assertRaises(AssertionError, self.ls.remove, "three")
1267 1267

  
1268 1268
  def testAcquireSetLock(self):
1269 1269
    # acquire the set-lock exclusively
1270
    self.assertEquals(self.ls.acquire(None), set(['one', 'two', 'three']))
1271
    self.assertEquals(self.ls.list_owned(), set(['one', 'two', 'three']))
1270
    self.assertEquals(self.ls.acquire(None), set(["one", "two", "three"]))
1271
    self.assertEquals(self.ls.list_owned(), set(["one", "two", "three"]))
1272 1272
    self.assertEquals(self.ls.is_owned(), True)
1273
    self.assertEquals(self.ls._names(), set(['one', 'two', 'three']))
1273
    self.assertEquals(self.ls._names(), set(["one", "two", "three"]))
1274 1274
    # I can still add/remove elements...
1275
    self.assertEquals(self.ls.remove(['two', 'three']), ['two', 'three'])
1276
    self.assert_(self.ls.add('six'))
1275
    self.assertEquals(self.ls.remove(["two", "three"]), ["two", "three"])
1276
    self.assert_(self.ls.add("six"))
1277 1277
    self.ls.release()
1278 1278
    # share the set-lock
1279
    self.assertEquals(self.ls.acquire(None, shared=1), set(['one', 'six']))
1279
    self.assertEquals(self.ls.acquire(None, shared=1), set(["one", "six"]))
1280 1280
    # adding new elements is not possible
1281
    self.assertRaises(AssertionError, self.ls.add, 'five')
1281
    self.assertRaises(AssertionError, self.ls.add, "five")
1282 1282
    self.ls.release()
1283 1283

  
1284 1284
  def testAcquireWithRepetitions(self):
1285
    self.assertEquals(self.ls.acquire(['two', 'two', 'three'], shared=1),
1286
                      set(['two', 'two', 'three']))
1287
    self.ls.release(['two', 'two'])
1288
    self.assertEquals(self.ls.list_owned(), set(['three']))
1285
    self.assertEquals(self.ls.acquire(["two", "two", "three"], shared=1),
1286
                      set(["two", "two", "three"]))
1287
    self.ls.release(["two", "two"])
1288
    self.assertEquals(self.ls.list_owned(), set(["three"]))
1289 1289

  
1290 1290
  def testEmptyAcquire(self):
1291 1291
    # Acquire an empty list of locks...
1292 1292
    self.assertEquals(self.ls.acquire([]), set())
1293 1293
    self.assertEquals(self.ls.list_owned(), set())
1294 1294
    # New locks can still be addded
1295
    self.assert_(self.ls.add('six'))
1295
    self.assert_(self.ls.add("six"))
1296 1296
    # "re-acquiring" is not an issue, since we had really acquired nothing
1297 1297
    self.assertEquals(self.ls.acquire([], shared=1), set())
1298 1298
    self.assertEquals(self.ls.list_owned(), set())
......
1302 1302
  def _doLockSet(self, names, shared):
1303 1303
    try:
1304 1304
      self.ls.acquire(names, shared=shared)
1305
      self.done.put('DONE')
1305
      self.done.put("DONE")
1306 1306
      self.ls.release()
1307 1307
    except errors.LockError:
1308
      self.done.put('ERR')
1308
      self.done.put("ERR")
1309 1309

  
1310 1310
  def _doAddSet(self, names):
1311 1311
    try:
1312 1312
      self.ls.add(names, acquired=1)
1313
      self.done.put('DONE')
1313
      self.done.put("DONE")
1314 1314
      self.ls.release()
1315 1315
    except errors.LockError:
1316
      self.done.put('ERR')
1316
      self.done.put("ERR")
1317 1317

  
1318 1318
  def _doRemoveSet(self, names):
1319 1319
    self.done.put(self.ls.remove(names))
1320 1320

  
1321 1321
  @_Repeat
1322 1322
  def testConcurrentSharedAcquire(self):
1323
    self.ls.acquire(['one', 'two'], shared=1)
1324
    self._addThread(target=self._doLockSet, args=(['one', 'two'], 1))
1323
    self.ls.acquire(["one", "two"], shared=1)
1324
    self._addThread(target=self._doLockSet, args=(["one", "two"], 1))
1325 1325
    self._waitThreads()
1326
    self.assertEqual(self.done.get_nowait(), 'DONE')
1327
    self._addThread(target=self._doLockSet, args=(['one', 'two', 'three'], 1))
1326
    self.assertEqual(self.done.get_nowait(), "DONE")
1327
    self._addThread(target=self._doLockSet, args=(["one", "two", "three"], 1))
1328 1328
    self._waitThreads()
1329
    self.assertEqual(self.done.get_nowait(), 'DONE')
1330
    self._addThread(target=self._doLockSet, args=('three', 1))
1329
    self.assertEqual(self.done.get_nowait(), "DONE")
1330
    self._addThread(target=self._doLockSet, args=("three", 1))
1331 1331
    self._waitThreads()
1332
    self.assertEqual(self.done.get_nowait(), 'DONE')
1333
    self._addThread(target=self._doLockSet, args=(['one', 'two'], 0))
1334
    self._addThread(target=self._doLockSet, args=(['two', 'three'], 0))
1332
    self.assertEqual(self.done.get_nowait(), "DONE")
1333
    self._addThread(target=self._doLockSet, args=(["one", "two"], 0))
1334
    self._addThread(target=self._doLockSet, args=(["two", "three"], 0))
1335 1335
    self.assertRaises(Queue.Empty, self.done.get_nowait)
1336 1336
    self.ls.release()
1337 1337
    self._waitThreads()
1338
    self.assertEqual(self.done.get_nowait(), 'DONE')
1339
    self.assertEqual(self.done.get_nowait(), 'DONE')
1338
    self.assertEqual(self.done.get_nowait(), "DONE")
1339
    self.assertEqual(self.done.get_nowait(), "DONE")
1340 1340

  
1341 1341
  @_Repeat
1342 1342
  def testConcurrentExclusiveAcquire(self):
1343
    self.ls.acquire(['one', 'two'])
1344
    self._addThread(target=self._doLockSet, args=('three', 1))
1343
    self.ls.acquire(["one", "two"])
1344
    self._addThread(target=self._doLockSet, args=("three", 1))
1345 1345
    self._waitThreads()
1346
    self.assertEqual(self.done.get_nowait(), 'DONE')
1347
    self._addThread(target=self._doLockSet, args=('three', 0))
1346
    self.assertEqual(self.done.get_nowait(), "DONE")
1347
    self._addThread(target=self._doLockSet, args=("three", 0))
1348 1348
    self._waitThreads()
1349
    self.assertEqual(self.done.get_nowait(), 'DONE')
1349
    self.assertEqual(self.done.get_nowait(), "DONE")
1350 1350
    self.assertRaises(Queue.Empty, self.done.get_nowait)
1351
    self._addThread(target=self._doLockSet, args=(['one', 'two'], 0))
1352
    self._addThread(target=self._doLockSet, args=(['one', 'two'], 1))
1353
    self._addThread(target=self._doLockSet, args=('one', 0))
1354
    self._addThread(target=self._doLockSet, args=('one', 1))
1355
    self._addThread(target=self._doLockSet, args=(['two', 'three'], 0))
1356
    self._addThread(target=self._doLockSet, args=(['two', 'three'], 1))
1351
    self._addThread(target=self._doLockSet, args=(["one", "two"], 0))
1352
    self._addThread(target=self._doLockSet, args=(["one", "two"], 1))
1353
    self._addThread(target=self._doLockSet, args=("one", 0))
1354
    self._addThread(target=self._doLockSet, args=("one", 1))
1355
    self._addThread(target=self._doLockSet, args=(["two", "three"], 0))
1356
    self._addThread(target=self._doLockSet, args=(["two", "three"], 1))
1357 1357
    self.assertRaises(Queue.Empty, self.done.get_nowait)
1358 1358
    self.ls.release()
1359 1359
    self._waitThreads()
1360 1360
    for _ in range(6):
1361
      self.failUnlessEqual(self.done.get_nowait(), 'DONE')
1361
      self.failUnlessEqual(self.done.get_nowait(), "DONE")
1362 1362

  
1363 1363
  @_Repeat
1364 1364
  def testSimpleAcquireTimeoutExpiring(self):
......
1412 1412
  @_Repeat
1413 1413
  def testDelayedAndExpiringLockAcquire(self):
1414 1414
    self._setUpLS()
1415
    self.ls.add(['five', 'six', 'seven', 'eight', 'nine'])
1415
    self.ls.add(["five", "six", "seven", "eight", "nine"])
1416 1416

  
1417 1417
    for expire in (False, True):
1418 1418
      names = sorted(self.ls._names())
......
1483 1483

  
1484 1484
  @_Repeat
1485 1485
  def testConcurrentRemove(self):
1486
    self.ls.add('four')
1487
    self.ls.acquire(['one', 'two', 'four'])
1488
    self._addThread(target=self._doLockSet, args=(['one', 'four'], 0))
1489
    self._addThread(target=self._doLockSet, args=(['one', 'four'], 1))
1490
    self._addThread(target=self._doLockSet, args=(['one', 'two'], 0))
1491
    self._addThread(target=self._doLockSet, args=(['one', 'two'], 1))
1486
    self.ls.add("four")
1487
    self.ls.acquire(["one", "two", "four"])
1488
    self._addThread(target=self._doLockSet, args=(["one", "four"], 0))
1489
    self._addThread(target=self._doLockSet, args=(["one", "four"], 1))
1490
    self._addThread(target=self._doLockSet, args=(["one", "two"], 0))
1491
    self._addThread(target=self._doLockSet, args=(["one", "two"], 1))
1492 1492
    self.assertRaises(Queue.Empty, self.done.get_nowait)
1493
    self.ls.remove('one')
1493
    self.ls.remove("one")
1494 1494
    self.ls.release()
1495 1495
    self._waitThreads()
1496 1496
    for i in range(4):
1497
      self.failUnlessEqual(self.done.get_nowait(), 'ERR')
1498
    self.ls.add(['five', 'six'], acquired=1)
1499
    self._addThread(target=self._doLockSet, args=(['three', 'six'], 1))
1500
    self._addThread(target=self._doLockSet, args=(['three', 'six'], 0))
1501
    self._addThread(target=self._doLockSet, args=(['four', 'six'], 1))
1502
    self._addThread(target=self._doLockSet, args=(['four', 'six'], 0))
1503
    self.ls.remove('five')
1497
      self.failUnlessEqual(self.done.get_nowait(), "ERR")
1498
    self.ls.add(["five", "six"], acquired=1)
1499
    self._addThread(target=self._doLockSet, args=(["three", "six"], 1))
1500
    self._addThread(target=self._doLockSet, args=(["three", "six"], 0))
1501
    self._addThread(target=self._doLockSet, args=(["four", "six"], 1))
1502
    self._addThread(target=self._doLockSet, args=(["four", "six"], 0))
1503
    self.ls.remove("five")
1504 1504
    self.ls.release()
1505 1505
    self._waitThreads()
1506 1506
    for i in range(4):
1507
      self.failUnlessEqual(self.done.get_nowait(), 'DONE')
1508
    self.ls.acquire(['three', 'four'])
1509
    self._addThread(target=self._doRemoveSet, args=(['four', 'six'], ))
1507
      self.failUnlessEqual(self.done.get_nowait(), "DONE")
1508
    self.ls.acquire(["three", "four"])
1509
    self._addThread(target=self._doRemoveSet, args=(["four", "six"], ))
1510 1510
    self.assertRaises(Queue.Empty, self.done.get_nowait)
1511
    self.ls.remove('four')
1511
    self.ls.remove("four")
1512 1512
    self._waitThreads()
1513
    self.assertEqual(self.done.get_nowait(), ['six'])
1514
    self._addThread(target=self._doRemoveSet, args=(['two']))
1513
    self.assertEqual(self.done.get_nowait(), ["six"])
1514
    self._addThread(target=self._doRemoveSet, args=(["two"]))
1515 1515
    self._waitThreads()
1516
    self.assertEqual(self.done.get_nowait(), ['two'])
1516
    self.assertEqual(self.done.get_nowait(), ["two"])
1517 1517
    self.ls.release()
1518 1518
    # reset lockset
1519 1519
    self._setUpLS()
......
1525 1525
    # ...another thread can share it too
1526 1526
    self._addThread(target=self._doLockSet, args=(None, 1))
1527 1527
    self._waitThreads()
1528
    self.assertEqual(self.done.get_nowait(), 'DONE')
1528
    self.assertEqual(self.done.get_nowait(), "DONE")
1529 1529
    # ...or just share some elements
1530
    self._addThread(target=self._doLockSet, args=(['one', 'three'], 1))
1530
    self._addThread(target=self._doLockSet, args=(["one", "three"], 1))
1531 1531
    self._waitThreads()
1532
    self.assertEqual(self.done.get_nowait(), 'DONE')
1532
    self.assertEqual(self.done.get_nowait(), "DONE")
1533 1533
    # ...but not add new ones or remove any
1534
    t = self._addThread(target=self._doAddSet, args=(['nine']))
1535
    self._addThread(target=self._doRemoveSet, args=(['two'], ))
1534
    t = self._addThread(target=self._doAddSet, args=(["nine"]))
1535
    self._addThread(target=self._doRemoveSet, args=(["two"], ))
1536 1536
    self.assertRaises(Queue.Empty, self.done.get_nowait)
1537 1537
    # this just releases the set-lock
1538 1538
    self.ls.release([])
1539 1539
    t.join(60)
1540
    self.assertEqual(self.done.get_nowait(), 'DONE')
1540
    self.assertEqual(self.done.get_nowait(), "DONE")
1541 1541
    # release the lock on the actual elements so remove() can proceed too
1542 1542
    self.ls.release()
1543 1543
    self._waitThreads()
1544
    self.failUnlessEqual(self.done.get_nowait(), ['two'])
1544
    self.failUnlessEqual(self.done.get_nowait(), ["two"])
1545 1545
    # reset lockset
1546 1546
    self._setUpLS()
1547 1547

  
......
1552 1552
    # ...no one can do anything else
1553 1553
    self._addThread(target=self._doLockSet, args=(None, 1))
1554 1554
    self._addThread(target=self._doLockSet, args=(None, 0))
1555
    self._addThread(target=self._doLockSet, args=(['three'], 0))
1556
    self._addThread(target=self._doLockSet, args=(['two'], 1))
1557
    self._addThread(target=self._doAddSet, args=(['nine']))
1555
    self._addThread(target=self._doLockSet, args=(["three"], 0))
1556
    self._addThread(target=self._doLockSet, args=(["two"], 1))
1557
    self._addThread(target=self._doAddSet, args=(["nine"]))
1558 1558
    self.assertRaises(Queue.Empty, self.done.get_nowait)
1559 1559
    self.ls.release()
1560 1560
    self._waitThreads()
1561 1561
    for _ in range(5):
1562
      self.assertEqual(self.done.get(True, 1), 'DONE')
1562
      self.assertEqual(self.done.get(True, 1), "DONE")
1563 1563
    # cleanup
1564 1564
    self._setUpLS()
1565 1565

  
1566 1566
  @_Repeat
1567 1567
  def testConcurrentSetLockAdd(self):
1568
    self.ls.acquire('one')
1568
    self.ls.acquire("one")
1569 1569
    # Another thread wants the whole SetLock
1570 1570
    self._addThread(target=self._doLockSet, args=(None, 0))
1571 1571
    self._addThread(target=self._doLockSet, args=(None, 1))
1572 1572
    self.assertRaises(Queue.Empty, self.done.get_nowait)
1573
    self.assertRaises(AssertionError, self.ls.add, 'four')
1573
    self.assertRaises(AssertionError, self.ls.add, "four")
1574 1574
    self.ls.release()
1575 1575
    self._waitThreads()
1576
    self.assertEqual(self.done.get_nowait(), 'DONE')
1577
    self.assertEqual(self.done.get_nowait(), 'DONE')
1576
    self.assertEqual(self.done.get_nowait(), "DONE")
1577
    self.assertEqual(self.done.get_nowait(), "DONE")
1578 1578
    self.ls.acquire(None)
1579 1579
    self._addThread(target=self._doLockSet, args=(None, 0))
1580 1580
    self._addThread(target=self._doLockSet, args=(None, 1))
1581 1581
    self.assertRaises(Queue.Empty, self.done.get_nowait)
1582
    self.ls.add('four')
1583
    self.ls.add('five', acquired=1)
1584
    self.ls.add('six', acquired=1, shared=1)
1582
    self.ls.add("four")
1583
    self.ls.add("five", acquired=1)
1584
    self.ls.add("six", acquired=1, shared=1)
1585 1585
    self.assertEquals(self.ls.list_owned(),
1586
      set(['one', 'two', 'three', 'five', 'six']))
1586
      set(["one", "two", "three", "five", "six"]))
1587 1587
    self.assertEquals(self.ls.is_owned(), True)
1588 1588
    self.assertEquals(self.ls._names(),
1589
      set(['one', 'two', 'three', 'four', 'five', 'six']))
1589
      set(["one", "two", "three", "four", "five", "six"]))
1590 1590
    self.ls.release()
1591 1591
    self._waitThreads()
1592
    self.assertEqual(self.done.get_nowait(), 'DONE')
1593
    self.assertEqual(self.done.get_nowait(), 'DONE')
1592
    self.assertEqual(self.done.get_nowait(), "DONE")
1593
    self.assertEqual(self.done.get_nowait(), "DONE")
1594 1594
    self._setUpLS()
1595 1595

  
1596 1596
  @_Repeat
1597 1597
  def testEmptyLockSet(self):
1598 1598
    # get the set-lock
1599
    self.assertEqual(self.ls.acquire(None), set(['one', 'two', 'three']))
1599
    self.assertEqual(self.ls.acquire(None), set(["one", "two", "three"]))
1600 1600
    # now empty it...
1601
    self.ls.remove(['one', 'two', 'three'])
1601
    self.ls.remove(["one", "two", "three"])
1602 1602
    # and adds/locks by another thread still wait
1603
    self._addThread(target=self._doAddSet, args=(['nine']))
1603
    self._addThread(target=self._doAddSet, args=(["nine"]))
1604 1604
    self._addThread(target=self._doLockSet, args=(None, 1))
1605 1605
    self._addThread(target=self._doLockSet, args=(None, 0))
1606 1606
    self.assertRaises(Queue.Empty, self.done.get_nowait)
1607 1607
    self.ls.release()
1608 1608
    self._waitThreads()
1609 1609
    for _ in range(3):
1610
      self.assertEqual(self.done.get_nowait(), 'DONE')
1610
      self.assertEqual(self.done.get_nowait(), "DONE")
1611 1611
    # empty it again...
1612
    self.assertEqual(self.ls.remove(['nine']), ['nine'])
1612
    self.assertEqual(self.ls.remove(["nine"]), ["nine"])
1613 1613
    # now share it...
1614 1614
    self.assertEqual(self.ls.acquire(None, shared=1), set())
1615 1615
    # other sharers can go, adds still wait
1616 1616
    self._addThread(target=self._doLockSet, args=(None, 1))
1617 1617
    self._waitThreads()
1618
    self.assertEqual(self.done.get_nowait(), 'DONE')
1619
    self._addThread(target=self._doAddSet, args=(['nine']))
1618
    self.assertEqual(self.done.get_nowait(), "DONE")
1619
    self._addThread(target=self._doAddSet, args=(["nine"]))
1620 1620
    self.assertRaises(Queue.Empty, self.done.get_nowait)
1621 1621
    self.ls.release()
1622 1622
    self._waitThreads()
1623
    self.assertEqual(self.done.get_nowait(), 'DONE')
1623
    self.assertEqual(self.done.get_nowait(), "DONE")
1624 1624
    self._setUpLS()
1625 1625

  
1626 1626
  def testAcquireWithNamesDowngrade(self):
......
1771 1771

  
1772 1772

  
1773 1773
class TestGanetiLockManager(_ThreadedTestCase):
1774

  
1775 1774
  def setUp(self):
1776 1775
    _ThreadedTestCase.setUp(self)
1777
    self.nodes=['n1', 'n2']
1778
    self.nodegroups=['g1', 'g2']
1779
    self.instances=['i1', 'i2', 'i3']
1780
    self.networks=['net1', 'net2', 'net3']
1776
    self.nodes = ["n1", "n2"]
1777
    self.nodegroups = ["g1", "g2"]
1778
    self.instances = ["i1", "i2", "i3"]
1779
    self.networks = ["net1", "net2", "net3"]
1781 1780
    self.GL = locking.GanetiLockManager(self.nodes, self.nodegroups,
1782 1781
                                        self.instances, self.networks)
1783 1782

  
......
1797 1796
    self.assertRaises(AssertionError, locking.GanetiLockManager, [], [], [], [])
1798 1797

  
1799 1798
  def testLockNames(self):
1800
    self.assertEqual(self.GL._names(locking.LEVEL_CLUSTER), set(['BGL']))
1799
    self.assertEqual(self.GL._names(locking.LEVEL_CLUSTER), set(["BGL"]))
1801 1800
    self.assertEqual(self.GL._names(locking.LEVEL_NODE), set(self.nodes))
1802 1801
    self.assertEqual(self.GL._names(locking.LEVEL_NODEGROUP),
1803 1802
                     set(self.nodegroups))
......
1809 1808
  def testInitAndResources(self):
1810 1809
    locking.GanetiLockManager._instance = None
1811 1810
    self.GL = locking.GanetiLockManager([], [], [], [])
1812
    self.assertEqual(self.GL._names(locking.LEVEL_CLUSTER), set(['BGL']))
1811
    self.assertEqual(self.GL._names(locking.LEVEL_CLUSTER), set(["BGL"]))
1813 1812
    self.assertEqual(self.GL._names(locking.LEVEL_NODE), set())
1814 1813
    self.assertEqual(self.GL._names(locking.LEVEL_NODEGROUP), set())
1815 1814
    self.assertEqual(self.GL._names(locking.LEVEL_INSTANCE), set())
......
1817 1816

  
1818 1817
    locking.GanetiLockManager._instance = None
1819 1818
    self.GL = locking.GanetiLockManager(self.nodes, self.nodegroups, [], [])
1820
    self.assertEqual(self.GL._names(locking.LEVEL_CLUSTER), set(['BGL']))
1819
    self.assertEqual(self.GL._names(locking.LEVEL_CLUSTER), set(["BGL"]))
1821 1820
    self.assertEqual(self.GL._names(locking.LEVEL_NODE), set(self.nodes))
1822 1821
    self.assertEqual(self.GL._names(locking.LEVEL_NODEGROUP),
1823 1822
                                    set(self.nodegroups))
......
1826 1825

  
1827 1826
    locking.GanetiLockManager._instance = None
1828 1827
    self.GL = locking.GanetiLockManager([], [], self.instances, [])
1829
    self.assertEqual(self.GL._names(locking.LEVEL_CLUSTER), set(['BGL']))
1828
    self.assertEqual(self.GL._names(locking.LEVEL_CLUSTER), set(["BGL"]))
1830 1829
    self.assertEqual(self.GL._names(locking.LEVEL_NODE), set())
1831 1830
    self.assertEqual(self.GL._names(locking.LEVEL_NODEGROUP), set())
1832 1831
    self.assertEqual(self.GL._names(locking.LEVEL_INSTANCE),
......
1834 1833

  
1835 1834
    locking.GanetiLockManager._instance = None
1836 1835
    self.GL = locking.GanetiLockManager([], [], [], self.networks)
1837
    self.assertEqual(self.GL._names(locking.LEVEL_CLUSTER), set(['BGL']))
1836
    self.assertEqual(self.GL._names(locking.LEVEL_CLUSTER), set(["BGL"]))
1838 1837
    self.assertEqual(self.GL._names(locking.LEVEL_NODE), set())
1839 1838
    self.assertEqual(self.GL._names(locking.LEVEL_NODEGROUP), set())
1840 1839
    self.assertEqual(self.GL._names(locking.LEVEL_INSTANCE), set())
......
1842 1841
                     set(self.networks))
1843 1842

  
1844 1843
  def testAcquireRelease(self):
1845
    self.GL.acquire(locking.LEVEL_CLUSTER, ['BGL'], shared=1)
1846
    self.assertEquals(self.GL.list_owned(locking.LEVEL_CLUSTER), set(['BGL']))
1847
    self.GL.acquire(locking.LEVEL_INSTANCE, ['i1'])
1848
    self.GL.acquire(locking.LEVEL_NODEGROUP, ['g2'])
1849
    self.GL.acquire(locking.LEVEL_NODE, ['n1', 'n2'], shared=1)
1844
    self.GL.acquire(locking.LEVEL_CLUSTER, ["BGL"], shared=1)
1845
    self.assertEquals(self.GL.list_owned(locking.LEVEL_CLUSTER), set(["BGL"]))
1846
    self.GL.acquire(locking.LEVEL_INSTANCE, ["i1"])
1847
    self.GL.acquire(locking.LEVEL_NODEGROUP, ["g2"])
1848
    self.GL.acquire(locking.LEVEL_NODE, ["n1", "n2"], shared=1)
1850 1849
    self.assertTrue(self.GL.check_owned(locking.LEVEL_NODE, ["n1", "n2"],
1851 1850
                                        shared=1))
1852 1851
    self.assertFalse(self.GL.check_owned(locking.LEVEL_INSTANCE, ["i1", "i3"]))
1853
    self.GL.release(locking.LEVEL_NODE, ['n2'])
1854
    self.assertEquals(self.GL.list_owned(locking.LEVEL_NODE), set(['n1']))
1855
    self.assertEquals(self.GL.list_owned(locking.LEVEL_NODEGROUP), set(['g2']))
1856
    self.assertEquals(self.GL.list_owned(locking.LEVEL_INSTANCE), set(['i1']))
1852
    self.GL.release(locking.LEVEL_NODE, ["n2"])
1853
    self.assertEquals(self.GL.list_owned(locking.LEVEL_NODE), set(["n1"]))
1854
    self.assertEquals(self.GL.list_owned(locking.LEVEL_NODEGROUP), set(["g2"]))
1855
    self.assertEquals(self.GL.list_owned(locking.LEVEL_INSTANCE), set(["i1"]))
1857 1856
    self.GL.release(locking.LEVEL_NODE)
1858 1857
    self.assertEquals(self.GL.list_owned(locking.LEVEL_NODE), set())
1859
    self.assertEquals(self.GL.list_owned(locking.LEVEL_NODEGROUP), set(['g2']))
1860
    self.assertEquals(self.GL.list_owned(locking.LEVEL_INSTANCE), set(['i1']))
1858
    self.assertEquals(self.GL.list_owned(locking.LEVEL_NODEGROUP), set(["g2"]))
1859
    self.assertEquals(self.GL.list_owned(locking.LEVEL_INSTANCE), set(["i1"]))
1861 1860
    self.GL.release(locking.LEVEL_NODEGROUP)
1862 1861
    self.GL.release(locking.LEVEL_INSTANCE)
1863 1862
    self.assertRaises(errors.LockError, self.GL.acquire,
1864
                      locking.LEVEL_INSTANCE, ['i5'])
1865
    self.GL.acquire(locking.LEVEL_INSTANCE, ['i3'], shared=1)
1866
    self.assertEquals(self.GL.list_owned(locking.LEVEL_INSTANCE), set(['i3']))
1863
                      locking.LEVEL_INSTANCE, ["i5"])
1864
    self.GL.acquire(locking.LEVEL_INSTANCE, ["i3"], shared=1)
1865
    self.assertEquals(self.GL.list_owned(locking.LEVEL_INSTANCE), set(["i3"]))
1867 1866

  
1868 1867
  def testAcquireWholeSets(self):
1869
    self.GL.acquire(locking.LEVEL_CLUSTER, ['BGL'], shared=1)
1868
    self.GL.acquire(locking.LEVEL_CLUSTER, ["BGL"], shared=1)
1870 1869
    self.assertEquals(self.GL.acquire(locking.LEVEL_INSTANCE, None),
1871 1870
                      set(self.instances))
1872 1871
    self.assertEquals(self.GL.list_owned(locking.LEVEL_INSTANCE),
......
1885 1884
    self.GL.release(locking.LEVEL_CLUSTER)
1886 1885

  
1887 1886
  def testAcquireWholeAndPartial(self):
1888
    self.GL.acquire(locking.LEVEL_CLUSTER, ['BGL'], shared=1)
1887
    self.GL.acquire(locking.LEVEL_CLUSTER, ["BGL"], shared=1)
1889 1888
    self.assertEquals(self.GL.acquire(locking.LEVEL_INSTANCE, None),
1890 1889
                      set(self.instances))
1891 1890
    self.assertEquals(self.GL.list_owned(locking.LEVEL_INSTANCE),
1892 1891
                      set(self.instances))
1893
    self.assertEquals(self.GL.acquire(locking.LEVEL_NODE, ['n2'], shared=1),
1894
                      set(['n2']))
1892
    self.assertEquals(self.GL.acquire(locking.LEVEL_NODE, ["n2"], shared=1),
1893
                      set(["n2"]))
1895 1894
    self.assertEquals(self.GL.list_owned(locking.LEVEL_NODE),
1896
                      set(['n2']))
1895
                      set(["n2"]))
1897 1896
    self.GL.release(locking.LEVEL_NODE)
1898 1897
    self.GL.release(locking.LEVEL_INSTANCE)
1899 1898
    self.GL.release(locking.LEVEL_CLUSTER)
1900 1899

  
1901 1900
  def testBGLDependency(self):
1902 1901
    self.assertRaises(AssertionError, self.GL.acquire,
1903
                      locking.LEVEL_NODE, ['n1', 'n2'])
1902
                      locking.LEVEL_NODE, ["n1", "n2"])
1904 1903
    self.assertRaises(AssertionError, self.GL.acquire,
1905
                      locking.LEVEL_INSTANCE, ['i3'])
1904
                      locking.LEVEL_INSTANCE, ["i3"])
1906 1905
    self.assertRaises(AssertionError, self.GL.acquire,
1907
                      locking.LEVEL_NODEGROUP, ['g1'])
1908
    self.GL.acquire(locking.LEVEL_CLUSTER, ['BGL'], shared=1)
1909
    self.GL.acquire(locking.LEVEL_NODE, ['n1'])
1906
                      locking.LEVEL_NODEGROUP, ["g1"])
1907
    self.GL.acquire(locking.LEVEL_CLUSTER, ["BGL"], shared=1)
1908
    self.GL.acquire(locking.LEVEL_NODE, ["n1"])
1910 1909
    self.assertRaises(AssertionError, self.GL.release,
1911
                      locking.LEVEL_CLUSTER, ['BGL'])
1910
                      locking.LEVEL_CLUSTER, ["BGL"])
1912 1911
    self.assertRaises(AssertionError, self.GL.release,
1913 1912
                      locking.LEVEL_CLUSTER)
1914 1913
    self.GL.release(locking.LEVEL_NODE)
1915
    self.GL.acquire(locking.LEVEL_INSTANCE, ['i1', 'i2'])
1914
    self.GL.acquire(locking.LEVEL_INSTANCE, ["i1", "i2"])
1916 1915
    self.assertRaises(AssertionError, self.GL.release,
1917
                      locking.LEVEL_CLUSTER, ['BGL'])
1916
                      locking.LEVEL_CLUSTER, ["BGL"])
1918 1917
    self.assertRaises(AssertionError, self.GL.release,
1919 1918
                      locking.LEVEL_CLUSTER)
1920 1919
    self.GL.release(locking.LEVEL_INSTANCE)
1921 1920
    self.GL.acquire(locking.LEVEL_NODEGROUP, None)
1922
    self.GL.release(locking.LEVEL_NODEGROUP, ['g1'])
1921
    self.GL.release(locking.LEVEL_NODEGROUP, ["g1"])
1923 1922
    self.assertRaises(AssertionError, self.GL.release,
1924
                      locking.LEVEL_CLUSTER, ['BGL'])
1923
                      locking.LEVEL_CLUSTER, ["BGL"])
1925 1924
    self.assertRaises(AssertionError, self.GL.release,
1926 1925
                      locking.LEVEL_CLUSTER)
1927 1926
    self.GL.release(locking.LEVEL_NODEGROUP)
1928 1927
    self.GL.release(locking.LEVEL_CLUSTER)
1929 1928

  
1930 1929
  def testWrongOrder(self):
1931
    self.GL.acquire(locking.LEVEL_CLUSTER, ['BGL'], shared=1)
1932
    self.GL.acquire(locking.LEVEL_NODE, ['n2'])
1930
    self.GL.acquire(locking.LEVEL_CLUSTER, ["BGL"], shared=1)
1931
    self.GL.acquire(locking.LEVEL_NODE, ["n2"])
1933 1932
    self.assertRaises(AssertionError, self.GL.acquire,
1934
                      locking.LEVEL_NODE, ['n1'])
1933
                      locking.LEVEL_NODE, ["n1"])
1935 1934
    self.assertRaises(AssertionError, self.GL.acquire,
1936
                      locking.LEVEL_NODEGROUP, ['g1'])
1935
                      locking.LEVEL_NODEGROUP, ["g1"])
1937 1936
    self.assertRaises(AssertionError, self.GL.acquire,
1938
                      locking.LEVEL_INSTANCE, ['i2'])
1937
                      locking.LEVEL_INSTANCE, ["i2"])
1939 1938

  
1940 1939
  def testModifiableLevels(self):
1941 1940
    self.assertRaises(AssertionError, self.GL.add, locking.LEVEL_CLUSTER,
1942
                      ['BGL2'])
1943
    self.GL.acquire(locking.LEVEL_CLUSTER, ['BGL'])
1944
    self.GL.add(locking.LEVEL_INSTANCE, ['i4'])
1945
    self.GL.remove(locking.LEVEL_INSTANCE, ['i3'])
1946
    self.GL.remove(locking.LEVEL_INSTANCE, ['i1'])
1947
    self.assertEqual(self.GL._names(locking.LEVEL_INSTANCE), set(['i2', 'i4']))
1948
    self.GL.add(locking.LEVEL_NODE, ['n3'])
1949
    self.GL.remove(locking.LEVEL_NODE, ['n1'])
1950
    self.assertEqual(self.GL._names(locking.LEVEL_NODE), set(['n2', 'n3']))
1951
    self.GL.add(locking.LEVEL_NODEGROUP, ['g3'])
1952
    self.GL.remove(locking.LEVEL_NODEGROUP, ['g2'])
1953
    self.GL.remove(locking.LEVEL_NODEGROUP, ['g1'])
1954
    self.assertEqual(self.GL._names(locking.LEVEL_NODEGROUP), set(['g3']))
1941
                      ["BGL2"])
1942
    self.GL.acquire(locking.LEVEL_CLUSTER, ["BGL"])
1943
    self.GL.add(locking.LEVEL_INSTANCE, ["i4"])
1944
    self.GL.remove(locking.LEVEL_INSTANCE, ["i3"])
1945
    self.GL.remove(locking.LEVEL_INSTANCE, ["i1"])
1946
    self.assertEqual(self.GL._names(locking.LEVEL_INSTANCE), set(["i2", "i4"]))
1947
    self.GL.add(locking.LEVEL_NODE, ["n3"])
1948
    self.GL.remove(locking.LEVEL_NODE, ["n1"])
1949
    self.assertEqual(self.GL._names(locking.LEVEL_NODE), set(["n2", "n3"]))
1950
    self.GL.add(locking.LEVEL_NODEGROUP, ["g3"])
1951
    self.GL.remove(locking.LEVEL_NODEGROUP, ["g2"])
1952
    self.GL.remove(locking.LEVEL_NODEGROUP, ["g1"])
1953
    self.assertEqual(self.GL._names(locking.LEVEL_NODEGROUP), set(["g3"]))
1955 1954
    self.assertRaises(AssertionError, self.GL.remove, locking.LEVEL_CLUSTER,
1956
                      ['BGL2'])
1955
                      ["BGL2"])
1957 1956

  
1958 1957
  # Helper function to run as a thread that shared the BGL and then acquires
1959 1958
  # some locks at another level.
1960 1959
  def _doLock(self, level, names, shared):
1961 1960
    try:
1962
      self.GL.acquire(locking.LEVEL_CLUSTER, ['BGL'], shared=1)
1961
      self.GL.acquire(locking.LEVEL_CLUSTER, ["BGL"], shared=1)
1963 1962
      self.GL.acquire(level, names, shared=shared)
1964
      self.done.put('DONE')
1963
      self.done.put("DONE")
1965 1964
      self.GL.release(level)
1966 1965
      self.GL.release(locking.LEVEL_CLUSTER)
1967 1966
    except errors.LockError:
1968
      self.done.put('ERR')
1967
      self.done.put("ERR")
1969 1968

  
1970 1969
  @_Repeat
1971 1970
  def testConcurrency(self):
1972
    self.GL.acquire(locking.LEVEL_CLUSTER, ['BGL'], shared=1)
1971
    self.GL.acquire(locking.LEVEL_CLUSTER, ["BGL"], shared=1)
1973 1972
    self._addThread(target=self._doLock,
1974
                    args=(locking.LEVEL_INSTANCE, 'i1', 1))
1973
                    args=(locking.LEVEL_INSTANCE, "i1", 1))
1975 1974
    self._waitThreads()
1976
    self.assertEqual(self.done.get_nowait(), 'DONE')
1977
    self.GL.acquire(locking.LEVEL_INSTANCE, ['i3'])
1975
    self.assertEqual(self.done.get_nowait(), "DONE")
1976
    self.GL.acquire(locking.LEVEL_INSTANCE, ["i3"])
1978 1977
    self._addThread(target=self._doLock,
1979
                    args=(locking.LEVEL_INSTANCE, 'i1', 1))
1978
                    args=(locking.LEVEL_INSTANCE, "i1", 1))
1980 1979
    self._waitThreads()
1981
    self.assertEqual(self.done.get_nowait(), 'DONE')
1980
    self.assertEqual(self.done.get_nowait(), "DONE")
1982 1981
    self._addThread(target=self._doLock,
1983
                    args=(locking.LEVEL_INSTANCE, 'i3', 1))
1982
                    args=(locking.LEVEL_INSTANCE, "i3", 1))
1984 1983
    self.assertRaises(Queue.Empty, self.done.get_nowait)
1985 1984
    self.GL.release(locking.LEVEL_INSTANCE)
1986 1985
    self._waitThreads()
1987
    self.assertEqual(self.done.get_nowait(), 'DONE')
1988
    self.GL.acquire(locking.LEVEL_INSTANCE, ['i2'], shared=1)
1986
    self.assertEqual(self.done.get_nowait(), "DONE")
1987
    self.GL.acquire(locking.LEVEL_INSTANCE, ["i2"], shared=1)
1989 1988
    self._addThread(target=self._doLock,
1990
                    args=(locking.LEVEL_INSTANCE, 'i2', 1))
1989
                    args=(locking.LEVEL_INSTANCE, "i2", 1))
1991 1990
    self._waitThreads()
1992
    self.assertEqual(self.done.get_nowait(), 'DONE')
1991
    self.assertEqual(self.done.get_nowait(), "DONE")
1993 1992
    self._addThread(target=self._doLock,
1994
                    args=(locking.LEVEL_INSTANCE, 'i2', 0))
1993
                    args=(locking.LEVEL_INSTANCE, "i2", 0))
1995 1994
    self.assertRaises(Queue.Empty, self.done.get_nowait)
1996 1995
    self.GL.release(locking.LEVEL_INSTANCE)
1997 1996
    self._waitThreads()
1998
    self.assertEqual(self.done.get(True, 1), 'DONE')
1999
    self.GL.release(locking.LEVEL_CLUSTER, ['BGL'])
1997
    self.assertEqual(self.done.get(True, 1), "DONE")
1998
    self.GL.release(locking.LEVEL_CLUSTER, ["BGL"])
2000 1999

  
2001 2000

  
2002 2001
class TestLockMonitor(_ThreadedTestCase):
b/test/ganeti.objects_unittest.py
32 32

  
33 33

  
34 34
class SimpleObject(objects.ConfigObject):
35
  __slots__ = ['a', 'b']
35
  __slots__ = ["a", "b"]
36 36

  
37 37

  
38 38
class TestDictState(unittest.TestCase):
39 39
  """Simple dict tansformation tests"""
40 40

  
41 41
  def testSimpleObjectToDict(self):
42
    o1 = SimpleObject(a='1')
43
    self.assertEquals(o1.ToDict(), {'a': '1'})
44
    self.assertEquals(o1.__getstate__(), {'a': '1'})
42
    o1 = SimpleObject(a="1")
43
    self.assertEquals(o1.ToDict(), {"a": "1"})
44
    self.assertEquals(o1.__getstate__(), {"a": "1"})
45 45
    self.assertEquals(o1.__getstate__(), o1.ToDict())
46 46
    o1.a = 2
47 47
    o1.b = 5
48
    self.assertEquals(o1.ToDict(), {'a': 2, 'b': 5})
48
    self.assertEquals(o1.ToDict(), {"a": 2, "b": 5})
49 49
    o2 = SimpleObject.FromDict(o1.ToDict())
50
    self.assertEquals(o1.ToDict(), {'a': 2, 'b': 5})
50
    self.assertEquals(o1.ToDict(), {"a": 2, "b": 5})
51 51

  
52 52

  
53 53
class TestClusterObject(unittest.TestCase):
b/test/ganeti.ovf_unittest.py
220 220
  "version": "0",
221 221
}
222 222
EXP_GANETI_DICT = {
223
  'tags': None,
224
  'auto_balance': 'False',
225
  'hypervisor': {
226
     'root-path': '/dev/sda',
227
     'name': 'xen-pvm',
228
     'kernel_args': 'ro'
223
  "tags": None,
224
  "auto_balance": "False",
225
  "hypervisor": {
226
     "root-path": "/dev/sda",
227
     "name": "xen-pvm",
228
     "kernel_args": "ro"
229 229
   },
230
  'version': '0',
231
  'disk_template': None,
232
  'os': {'name': 'lenny-image'}
230
  "version": "0",
231
  "disk_template": None,
232
  "os": {"name": "lenny-image"}
233 233
}
234 234
EXP_NAME ="xen-dev-i1"
235 235
EXP_VCPUS = 1
b/test/ganeti.rapi.resources_unittest.py
53 53
    self._TestFailingUri("/instances")
54 54
    self._TestUri("/version", (rlib2.R_version, [], {}))
55 55

  
56
    self._TestUri('/2/instances/www.test.com',
56
    self._TestUri("/2/instances/www.test.com",
57 57
                  (rlib2.R_2_instances_name,
58
                   ['www.test.com'],
58
                   ["www.test.com"],
59 59
                   {}))
60 60

  
61
    self._TestUri('/2/instances/www.test.com/tags?f=5&f=6&alt=html',
61
    self._TestUri("/2/instances/www.test.com/tags?f=5&f=6&alt=html",
62 62
                  (rlib2.R_2_instances_name_tags,
63
                   ['www.test.com'],
64
                   {'alt': ['html'],
65
                    'f': ['5', '6'],
63
                   ["www.test.com"],
64
                   {"alt": ["html"],
65
                    "f": ["5", "6"],
66 66
                   }))
67 67

  
68 68
    self._TestFailingUri("/tag")
b/test/ganeti.serializer_unittest.py
71 71
  def _TestSigned(self, dump_fn, load_fn):
72 72
    for data in self._TESTDATA:
73 73
      self.assertEqualValues(load_fn(dump_fn(data, "mykey"), "mykey"),
74
                             (data, ''))
74
                             (data, ""))
75 75
      self.assertEqualValues(load_fn(dump_fn(data, "myprivatekey",
76 76
                                             salt="mysalt"),
77 77
                                     "myprivatekey"),
b/test/ganeti.utils.io_unittest.py
470 470

  
471 471
  def setUp(self):
472 472
    """Create a temp dir and file for each case"""
473
    self.tmpdir = tempfile.mkdtemp('', 'ganeti-unittest-')
474
    fd, self.tmpfile = tempfile.mkstemp('', '', self.tmpdir)
473
    self.tmpdir = tempfile.mkdtemp("", "ganeti-unittest-")
474
    fd, self.tmpfile = tempfile.mkstemp("", "", self.tmpdir)
475 475
    os.close(fd)
476 476

  
477 477
  def tearDown(self):
......
772 772
    self.f_dpn = lambda name: os.path.join(self.dir, "%s.pid" % name)
773 773

  
774 774
  def testPidFileFunctions(self):
775
    pid_file = self.f_dpn('test')
776
    fd = utils.WritePidFile(self.f_dpn('test'))
775
    pid_file = self.f_dpn("test")
776
    fd = utils.WritePidFile(self.f_dpn("test"))
777 777
    self.failUnless(os.path.exists(pid_file),
778 778
                    "PID file should have been created")
779 779
    read_pid = utils.ReadPidFile(pid_file)
780 780
    self.failUnlessEqual(read_pid, os.getpid())
781 781
    self.failUnless(utils.IsProcessAlive(read_pid))
782 782
    self.failUnlessRaises(errors.PidFileLockError, utils.WritePidFile,
783
                          self.f_dpn('test'))
783
                          self.f_dpn("test"))
784 784
    os.close(fd)
785 785
    utils.RemoveFile(self.f_dpn("test"))
786 786
    self.failIf(os.path.exists(pid_file),
......
793 793
    self.failUnlessEqual(utils.ReadPidFile(pid_file), 0,
794 794
                         "ReadPidFile should return 0 for invalid pid file")
795 795
    # but now, even with the file existing, we should be able to lock it
796
    fd = utils.WritePidFile(self.f_dpn('test'))
796
    fd = utils.WritePidFile(self.f_dpn("test"))
797 797
    os.close(fd)
798 798
    utils.RemoveFile(self.f_dpn("test"))
799 799
    self.failIf(os.path.exists(pid_file),
800 800
                "PID file should not exist anymore")
801 801

  
802 802
  def testKill(self):
803
    pid_file = self.f_dpn('child')
803
    pid_file = self.f_dpn("child")
804 804
    r_fd, w_fd = os.pipe()
805 805
    new_pid = os.fork()
806 806
    if new_pid == 0: #child
807
      utils.WritePidFile(self.f_dpn('child'))
808
      os.write(w_fd, 'a')
807
      utils.WritePidFile(self.f_dpn("child"))
808
      os.write(w_fd, "a")
809 809
      signal.pause()
810 810
      os._exit(0)
811 811
      return
......
829 829

  
830 830
    utils.KillProcess(new_pid, waitpid=True)
831 831
    self.failIf(utils.IsProcessAlive(new_pid))
832
    utils.RemoveFile(self.f_dpn('child'))
832
    utils.RemoveFile(self.f_dpn("child"))
833 833
    self.failUnlessRaises(errors.ProgrammerError, utils.KillProcess, 0)
834 834

  
835 835
  def testExceptionType(self):
......
844 844
class TestSshKeys(testutils.GanetiTestCase):
845 845
  """Test case for the AddAuthorizedKey function"""
846 846

  
847
  KEY_A = 'ssh-dss AAAAB3NzaC1w5256closdj32mZaQU root@key-a'
847
  KEY_A = "ssh-dss AAAAB3NzaC1w5256closdj32mZaQU root@key-a"
848 848
  KEY_B = ('command="/usr/bin/fooserver -t --verbose",from="198.51.100.4" '
849
           'ssh-dss AAAAB3NzaC1w520smc01ms0jfJs22 root@key-b')
849
           "ssh-dss AAAAB3NzaC1w520smc01ms0jfJs22 root@key-b")
850 850

  
851 851
  def setUp(self):
852 852
    testutils.GanetiTestCase.setUp(self)
853 853
    self.tmpname = self._CreateTempFile()
854
    handle = open(self.tmpname, 'w')
854
    handle = open(self.tmpname, "w")
855 855
    try:
856 856
      handle.write("%s\n" % TestSshKeys.KEY_A)
857 857
      handle.write("%s\n" % TestSshKeys.KEY_B)
......
860 860

  
861 861
  def testAddingNewKey(self):
862 862
    utils.AddAuthorizedKey(self.tmpname,
863
                           'ssh-dss AAAAB3NzaC1kc3MAAACB root@test')
863
                           "ssh-dss AAAAB3NzaC1kc3MAAACB root@test")
864 864

  
865 865
    self.assertFileContent(self.tmpname,
866 866
      "ssh-dss AAAAB3NzaC1w5256closdj32mZaQU root@key-a\n"
......
870 870

  
871 871
  def testAddingAlmostButNotCompletelyTheSameKey(self):
872 872
    utils.AddAuthorizedKey(self.tmpname,
873
        'ssh-dss AAAAB3NzaC1w5256closdj32mZaQU root@test')
873
        "ssh-dss AAAAB3NzaC1w5256closdj32mZaQU root@test")
874 874

  
875 875
    # Only significant fields are compared, therefore the key won't be
876 876
    # updated/added
......
893 893

  
894 894
  def testRemovingExistingKeyWithSomeMoreSpaces(self):
895 895
    utils.RemoveAuthorizedKey(self.tmpname,
896
        'ssh-dss  AAAAB3NzaC1w5256closdj32mZaQU   root@key-a')
896
        "ssh-dss  AAAAB3NzaC1w5256closdj32mZaQU   root@key-a")
897 897

  
898 898
    self.assertFileContent(self.tmpname,
899 899
      'command="/usr/bin/fooserver -t --verbose",from="198.51.100.4"'
......
901 901

  
902 902
  def testRemovingNonExistingKey(self):
903 903
    utils.RemoveAuthorizedKey(self.tmpname,
904
        'ssh-dss  AAAAB3Nsdfj230xxjxJjsjwjsjdjU   root@test')
904
        "ssh-dss  AAAAB3Nsdfj230xxjxJjsjwjsjdjU   root@test")
905 905

  
906 906
    self.assertFileContent(self.tmpname,
907 907
      "ssh-dss AAAAB3NzaC1w5256closdj32mZaQU root@key-a\n"
b/test/ganeti.utils.text_unittest.py
261 261
  """Test case for shell quoting functions"""
262 262

  
263 263
  def testShellQuote(self):
264
    self.assertEqual(utils.ShellQuote('abc'), "abc")
264
    self.assertEqual(utils.ShellQuote("abc"), "abc")
265 265
    self.assertEqual(utils.ShellQuote('ab"c'), "'ab\"c'")
266 266
    self.assertEqual(utils.ShellQuote("a'bc"), "'a'\\''bc'")
267 267
    self.assertEqual(utils.ShellQuote("a b c"), "'a b c'")
268 268
    self.assertEqual(utils.ShellQuote("a b\\ c"), "'a b\\ c'")
269 269

  
270 270
  def testShellQuoteArgs(self):
271
    self.assertEqual(utils.ShellQuoteArgs(['a', 'b', 'c']), "a b c")
271
    self.assertEqual(utils.ShellQuoteArgs(["a", "b", "c"]), "a b c")
272 272
    self.assertEqual(utils.ShellQuoteArgs(['a', 'b"', 'c']), "a 'b\"' c")
273 273
    self.assertEqual(utils.ShellQuoteArgs(['a', 'b\'', 'c']), "a 'b'\\\''' c")
274 274

  
b/test/ganeti.utils_unittest.py
180 180

  
181 181
  def testSimpleDict(self):
182 182
    self.assertEqual(self._fdt({}), {})
183
    self.assertEqual(self._fdt({'a': 1}), {'a': 1})
184
    self.assertEqual(self._fdt({'a': '1'}), {'a': 1})
185
    self.assertEqual(self._fdt({'a': 1, 'b': 1}), {'a':1, 'b': True})
186
    self.assertEqual(self._fdt({'b': 1, 'c': 'foo'}), {'b': True, 'c': 'foo'})
187
    self.assertEqual(self._fdt({'b': 1, 'c': False}), {'b': True, 'c': ''})
188
    self.assertEqual(self._fdt({'b': 'false'}), {'b': False})
189
    self.assertEqual(self._fdt({'b': 'False'}), {'b': False})
190
    self.assertEqual(self._fdt({'b': False}), {'b': False})
191
    self.assertEqual(self._fdt({'b': 'true'}), {'b': True})
192
    self.assertEqual(self._fdt({'b': 'True'}), {'b': True})
193
    self.assertEqual(self._fdt({'d': '4'}), {'d': 4})
194
    self.assertEqual(self._fdt({'d': '4M'}), {'d': 4})
183
    self.assertEqual(self._fdt({"a": 1}), {"a": 1})
184
    self.assertEqual(self._fdt({"a": "1"}), {"a": 1})
185
    self.assertEqual(self._fdt({"a": 1, "b": 1}), {"a":1, "b": True})
186
    self.assertEqual(self._fdt({"b": 1, "c": "foo"}), {"b": True, "c": "foo"})
187
    self.assertEqual(self._fdt({"b": 1, "c": False}), {"b": True, "c": ""})
188
    self.assertEqual(self._fdt({"b": "false"}), {"b": False})
189
    self.assertEqual(self._fdt({"b": "False"}), {"b": False})
190
    self.assertEqual(self._fdt({"b": False}), {"b": False})
191
    self.assertEqual(self._fdt({"b": "true"}), {"b": True})
192
    self.assertEqual(self._fdt({"b": "True"}), {"b": True})
193
    self.assertEqual(self._fdt({"d": "4"}), {"d": 4})
194
    self.assertEqual(self._fdt({"d": "4M"}), {"d": 4})
195 195
    self.assertEqual(self._fdt({"e": None, }), {"e": None, })
196 196
    self.assertEqual(self._fdt({"e": "Hello World", }), {"e": "Hello World", })
197
    self.assertEqual(self._fdt({"e": False, }), {"e": '', })
197
    self.assertEqual(self._fdt({"e": False, }), {"e": "", })
198 198
    self.assertEqual(self._fdt({"b": "hello", }, ["hello"]), {"b": "hello"})
199 199

  
200 200
  def testErrors(self):
201
    self.assertRaises(errors.TypeEnforcementError, self._fdt, {'a': 'astring'})
201
    self.assertRaises(errors.TypeEnforcementError, self._fdt, {"a": "astring"})
202 202
    self.assertRaises(errors.TypeEnforcementError, self._fdt, {"b": "hello"})
203
    self.assertRaises(errors.TypeEnforcementError, self._fdt, {'c': True})
204
    self.assertRaises(errors.TypeEnforcementError, self._fdt, {'d': 'astring'})
205
    self.assertRaises(errors.TypeEnforcementError, self._fdt, {'d': '4 L'})
203
    self.assertRaises(errors.TypeEnforcementError, self._fdt, {"c": True})
204
    self.assertRaises(errors.TypeEnforcementError, self._fdt, {"d": "astring"})
205
    self.assertRaises(errors.TypeEnforcementError, self._fdt, {"d": "4 L"})
206 206
    self.assertRaises(errors.TypeEnforcementError, self._fdt, {"e": object(), })
207 207
    self.assertRaises(errors.TypeEnforcementError, self._fdt, {"e": [], })
208 208
    self.assertRaises(errors.TypeEnforcementError, self._fdt, {"x": None, })

Also available in: Unified diff