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)