def test_inequality(self):
"""
Test object inequality between two objects
"""
p1 = TimeWindow('test',
begin='00:00:00',
end='11:11:11',
weekdays='6',
parent=None,
interval=0.1)
p2 = TimeWindow('test',
begin='11:11:11',
end='12:22:22',
weekdays=None,
parent=None,
interval=5.0)
self.assertNotEquals(p1, p2)
def test_process_met_end(self):
"""
Test _process_met method when setting 'end' parameter
"""
m = mox.Mox()
midnight = '00:00:00'
one = '01:00:00'
p1 = TimeWindow('test',
begin=None,
end=one,
weekdays=None,
parent=None,
interval=0.1)
p2 = TimeWindow('test',
begin=None,
end=midnight,
weekdays=None,
parent=None,
interval=0.1)
mid_time = datetime.datetime.strptime(midnight, '%H:%M:%S').time()
one_time = datetime.datetime.strptime(one, '%H:%M:%S').time()
m.StubOutWithMock(p1, '_get_comparison')
p1._get_comparison(p1.end).AndReturn(mid_time) # pretend it's midnight
m.StubOutWithMock(p2, '_get_comparison')
p2._get_comparison(p2.end).AndReturn(one_time) # pretend it's one
m.ReplayAll()
p1._process_met()
p2._process_met()
# should be 'met' if end is one and it is midnight
self.assertEqual(p1.met, True)
# should not be 'met' if end is midnight and it is one
self.assertEqual(p2.met, False)
m.VerifyAll()
m.UnsetStubs()
def test_process_met_attributes_all_none(self):
"""
Test that when all parameters are None 'met' is False
"""
p = TimeWindow('test',
begin=None,
end=None,
weekdays=None,
parent=None,
interval=0.1)
p._process_met()
self.assertEqual(p.met, False)
def test_process_met_weekdays(self):
"""
Test _process_met method when setting weekdays parameter
"""
m = mox.Mox()
m_to_fri = '0-4'
p1 = TimeWindow('test',
begin=None,
end=None,
weekdays=m_to_fri,
parent=None,
interval=0.1)
p2 = TimeWindow('test',
begin=None,
end=None,
weekdays=m_to_fri,
parent=None,
interval=0.1)
m.StubOutWithMock(p1, 'weekday')
p1.weekday().AndReturn(1) # pretend it's Tuesday
m.StubOutWithMock(p2, 'weekday')
p2.weekday().AndReturn(6) # pretend it's Sunday
m.ReplayAll()
p1._process_met()
p2._process_met()
# should be 'met' if weekdays = mon-fri and it is Tuesday
self.assertEqual(p1.met, True)
# should not be 'met' if weekdays = mon-fri and it is Sunday
self.assertEqual(p2.met, False)
m.VerifyAll()
m.UnsetStubs()
def create(self, xmlpart, callback=None, parent=None):
"""
:type xmlpart: xml.etree.ElementTree.Element
:type callback: types.FunctionType or None
:type parent: str or None
"""
if xmlpart is None:
# A dummy predicate will be returned if there are no predicates
# met is true b/c we don't want to block on no predicates
return create_dummy(comp=self._component_name,
parent=self._action,
met=True)
if isinstance(xmlpart, str):
root = ElementTree.fromstring(xmlpart)
else:
root = xmlpart
if parent is None:
parent = self._action
ptype = verify_attribute(root, 'type').lower()
operational = bool(
verify_attribute(root, 'operational', none_allowed=True))
if ptype == 'simple':
return self._ensure_new(SimplePredicate(self._component_name,
operational=operational,
parent=parent),
callback=callback)
elif ptype == PredicateType.ZOOKEEPERNODEEXISTS:
return self._ensure_new(ZookeeperNodeExists(
self._component_name,
self.zkclient,
verify_attribute(root, 'path'),
operational=operational,
parent=parent),
callback=callback)
elif ptype == PredicateType.ZOOKEEPERHASCHILDREN:
return self._ensure_new(ZookeeperHasChildren(
self._component_name,
self.zkclient,
verify_attribute(root, 'path'),
ephemeral_only=verify_attribute(root,
'ephemeral_only',
none_allowed=True,
default=True),
operational=operational,
parent=parent),
callback=callback)
elif ptype == PredicateType.ZOOKEEPERHASGRANDCHILDREN:
return self._ensure_new(ZookeeperHasGrandChildren(
self._component_name,
self.zkclient,
verify_attribute(root, 'path'),
ephemeral_only=verify_attribute(root,
'ephemeral_only',
none_allowed=True,
default=True),
operational=operational,
parent=parent),
callback=callback)
elif ptype == PredicateType.ZOOKEEPERGLOB:
return self._ensure_new(ZookeeperGlob(
self._component_name,
self.zkclient,
verify_attribute(root, 'path'),
ephemeral_only=verify_attribute(root,
'ephemeral_only',
none_allowed=True,
default=True),
operational=operational,
parent=parent),
callback=callback)
elif ptype == PredicateType.ZOOKEEPERGOODUNTILTIME:
return self._ensure_new(ZookeeperGoodUntilTime(
self._component_name,
self.zkclient,
verify_attribute(root, 'path'),
operational=operational,
parent=parent),
callback=callback)
elif ptype == PredicateType.PROCESS:
return self._ensure_new(PredicateProcess(self._component_name,
self._proc_client,
verify_attribute(
root,
'interval',
cast=float),
operational=operational,
parent=parent),
callback=callback)
elif ptype == PredicateType.API:
return self._ensure_new(APIPredicate(
self._component_name,
verify_attribute(root, 'url'),
verb=verify_attribute(root,
'verb',
none_allowed=True,
default='GET'),
expected_code=verify_attribute(root,
'expected_code',
none_allowed=True,
cast=int,
default=200),
interval=verify_attribute(root, 'interval', cast=float),
operational=operational,
parent=parent),
callback=callback)
elif ptype == PredicateType.HEALTH:
return self._ensure_new(PredicateHealth(
self._component_name,
verify_attribute(root, 'command'),
verify_attribute(root, 'interval', cast=float),
self._system,
operational=operational,
parent=parent),
callback=callback)
elif ptype == PredicateType.HOLIDAY:
return self._ensure_new(PredicateHoliday(self._component_name,
self.zkclient,
path=self._holiday_path,
operational=operational,
parent=parent),
callback=callback)
elif ptype == PredicateType.WEEKEND:
return self._ensure_new(PredicateWeekend(self._component_name,
operational=operational,
parent=parent),
callback=callback)
elif ptype == PredicateType.TIMEWINDOW:
return self._ensure_new(TimeWindow(
self._component_name,
begin=verify_attribute(root, 'begin', none_allowed=True),
end=verify_attribute(root, 'end', none_allowed=True),
weekdays=verify_attribute(root, 'weekdays', none_allowed=True),
operational=operational,
parent=parent),
callback=callback)
# below, use recursion to get nested predicates
elif ptype == PredicateType.NOT:
for element in root.findall('Predicate'):
dep = self.create(element, callback=callback)
return self._ensure_new(
PredicateNot(self._component_name,
dep,
parent=self._parent_name(parent, 'not')))
elif ptype == PredicateType.AND:
deps = list()
for element in root.findall('Predicate'):
deps.append(
self.create(element,
callback=callback,
parent=self._parent_name(parent, 'and')))
return self._ensure_new(
PredicateAnd(self._component_name, deps, parent=parent))
elif ptype == PredicateType.OR:
deps = list()
for element in root.findall('Predicate'):
deps.append(
self.create(element,
callback=callback,
parent=self._parent_name(parent, 'or')))
return self._ensure_new(
PredicateOr(self._component_name, deps, parent=parent))
else:
self._log.error(
'Unknown predicate type "{0}". Ignoring'.format(ptype))
# create dummy if it is an unknown predicate type.
# met is set to true b/c we don't want to block on error
return create_dummy(comp=self._component_name,
parent=self._action,
met=True)
