142 lines
4.2 KiB
Python
142 lines
4.2 KiB
Python
from datetime import datetime
|
|
import unittest
|
|
from osclib.conf import Config
|
|
from osclib.obslock import OBSLock
|
|
|
|
from . import obs
|
|
|
|
class TestOBSLock(unittest.TestCase):
|
|
def setUp(self):
|
|
self.obs = obs.OBS()
|
|
Config(obs.APIURL, obs.PROJECT)
|
|
|
|
def obs_lock(self, reason='list'):
|
|
return OBSLock(obs.APIURL, obs.PROJECT, reason=reason)
|
|
|
|
def assertLockFail(self, lock):
|
|
with self.assertRaises(SystemExit):
|
|
with lock:
|
|
self.assertFalse(lock.locked)
|
|
|
|
def test_lock(self):
|
|
lock = self.obs_lock()
|
|
self.assertFalse(lock.locked)
|
|
|
|
with lock:
|
|
self.assertTrue(lock.locked)
|
|
|
|
user, reason, reason_sub, ts = lock._parse(lock._read())
|
|
self.assertIsNotNone(user)
|
|
self.assertEqual(reason, 'list')
|
|
self.assertIsNone(reason_sub)
|
|
self.assertIsInstance(ts, datetime)
|
|
|
|
self.assertFalse(lock.locked)
|
|
|
|
def test_locked_self(self, hold=False):
|
|
lock1 = self.obs_lock()
|
|
lock2 = self.obs_lock()
|
|
|
|
self.assertFalse(lock1.locked)
|
|
self.assertFalse(lock2.locked)
|
|
|
|
with lock1:
|
|
self.assertTrue(lock1.locked)
|
|
self.assertLockFail(lock2)
|
|
|
|
if not hold:
|
|
# A hold will remain locked.
|
|
self.assertFalse(lock1.locked)
|
|
self.assertFalse(lock2.locked)
|
|
|
|
def test_hold(self):
|
|
lock = self.obs_lock('lock')
|
|
self.assertFalse(lock.locked)
|
|
|
|
with lock:
|
|
self.assertTrue(lock.locked)
|
|
lock.hold('test')
|
|
|
|
self.assertTrue(lock.locked)
|
|
|
|
# Same constraints should apply since same user against hold.
|
|
self.test_locked_self(hold=True)
|
|
|
|
# Hold should remain after subcommands are executed.
|
|
user, reason, reason_sub, ts = lock._parse(lock._read())
|
|
self.assertIsNotNone(user)
|
|
self.assertEqual(reason, 'hold: test')
|
|
self.assertIsNone(reason_sub)
|
|
self.assertIsInstance(ts, datetime)
|
|
|
|
# Other users should not bypass hold.
|
|
lock_user2 = self.obs_lock()
|
|
lock_user2.user = 'other'
|
|
self.assertLockFail(lock_user2)
|
|
|
|
lock.release(force=True)
|
|
|
|
self.assertFalse(lock.locked)
|
|
|
|
def test_expire(self):
|
|
lock1 = self.obs_lock()
|
|
lock2 = self.obs_lock()
|
|
lock2.ttl = 0
|
|
lock2.user = 'user2'
|
|
|
|
self.assertFalse(lock1.locked)
|
|
self.assertFalse(lock2.locked)
|
|
|
|
with lock1:
|
|
self.assertTrue(lock1.locked)
|
|
with lock2:
|
|
self.assertTrue(lock2.locked)
|
|
user, _, _, _ = lock2._parse(lock2._read())
|
|
self.assertEqual(user, lock2.user)
|
|
|
|
def test_expire_hold(self):
|
|
lock1 = self.obs_lock('lock')
|
|
lock2 = self.obs_lock('override')
|
|
lock2.ttl = 0
|
|
lock2.user = 'user2'
|
|
|
|
self.assertFalse(lock1.locked)
|
|
self.assertFalse(lock2.locked)
|
|
|
|
with lock1:
|
|
self.assertTrue(lock1.locked)
|
|
lock1.hold('test')
|
|
with lock2:
|
|
self.assertTrue(lock2.locked)
|
|
user, reason, reason_sub, _ = lock2._parse(lock2._read())
|
|
self.assertEqual(user, lock2.user)
|
|
self.assertEqual(reason, 'override')
|
|
self.assertEqual(reason_sub, None, 'does not inherit hold')
|
|
|
|
def test_reserved_characters(self):
|
|
lock = self.obs_lock('some reason @ #night')
|
|
|
|
with lock:
|
|
_, reason, _, _ = lock._parse(lock._read())
|
|
self.assertEqual(reason, 'some reason at hashnight')
|
|
|
|
def test_needed(self):
|
|
lock1 = self.obs_lock()
|
|
lock2 = self.obs_lock('unlock')
|
|
lock2.user = 'user2'
|
|
lock2.needed = False
|
|
|
|
self.assertFalse(lock1.locked)
|
|
self.assertFalse(lock2.locked)
|
|
|
|
with lock1:
|
|
self.assertTrue(lock1.locked)
|
|
with lock2:
|
|
self.assertFalse(lock2.locked)
|
|
user, _, _, _ = lock2._parse(lock2._read())
|
|
self.assertEqual(user, lock1.user, 'lock1 remains')
|
|
|
|
lock2.release(force=True)
|
|
user, _, _, _ = lock2._parse(lock2._read())
|
|
self.assertEqual(user, None, 'unlocked')
|