def test_cp(self): settings = {'min_cp': 5000, 'max_cp': 9000} raid_filter = Filters.RaidFilter('cp_filter', settings) for i in [5000, 8000, 9000]: event = Events.RaidEvent(generate_raid({'cp': i})) self.assertTrue(raid_filter.check_event(event)) for i in [4999, 9001, 999999]: event = Events.RaidEvent(generate_raid({'cp': i})) self.assertFalse(raid_filter.check_event(event))
def test_costume(self): # Create filter that forces settings settings = {"costume_ids": [1, 2]} mon_filter = Filters.MonFilter('costume_filter', settings) # Test events that should pass for c in [1, 2]: event = Events.MonEvent(generate_monster({"costume": c})) self.assertTrue(mon_filter.check_event(event)) # Test events that should fail for c in [3, 4]: event = Events.MonEvent(generate_monster({"costume": c})) self.assertFalse(mon_filter.check_event(event))
def test_gym_name_excludes(self): # Create the filters settings = {"gym_name_excludes": ["fail"]} egg_filter = Filters.EggFilter('filter1', settings) # Generate events that should pass for r in ["pass1", "2pass", "3pass3"]: event = Events.EggEvent(generate_egg({"name": r})) self.assertTrue(egg_filter.check_event(event)) # Generate events that should fail for r in ["fail1", "failpass", "passfail"]: event = Events.EggEvent(generate_egg({"name": r})) self.assertFalse(egg_filter.check_event(event))
def test_park(self): # Create the filters settings = {"park_contains": ["pass"]} egg_filter = Filters.EggFilter('filter1', settings) # Test events that should pass for n in ["pass1", "2pass", "3pass3"]: event = Events.EggEvent(generate_egg({"park": n})) self.assertTrue(egg_filter.check_event(event)) # Test events that should fail for n in ["fail1", "failpas", "pasfail"]: event = Events.EggEvent(generate_egg({"park": n})) self.assertFalse(egg_filter.check_event(event))
def gen_event(self, values): """ Generate a generic quest, overriding with an specific values. """ settings = { "pokestop_id": 0, "name": "Stop Name", "url": "http://placehold.it/500x500", "latitude": 37.7876146, "longitude": -122.390624, "timestamp": 1506897031, "quest_reward_type": "Pokemon", "quest_reward_type_raw": 7, "quest_target": 0, "quest_type": "Catch 10 Dragonites", "quest_type_raw": 0, "item_type": "Pokemon", "item_amount": 1, "item_id": 0, "pokemon_id": 123, "pokemon_form": 0, "pokemon_costume": 0, "quest_task": "Catch 10 Dragonites", "quest_condition": "[]", "quest_template": "" } settings.update(values) return Events.QuestEvent(settings)
def gen_event(self, values): """ Generate a generic monster, overriding with an specific values. """ settings = { "encounter_id": "0", "spawnpoint_id": "0", "pokemon_id": 1, "pokemon_level": 1, "player_level": 40, "latitude": 37.7876146, "longitude": -122.390624, "disappear_time": 1506897031, "last_modified_time": 1475033386661, "time_until_hidden_ms": 5000, "seconds_until_despawn": 1754, "spawn_start": 2153, "spawn_end": 3264, "verified": False, "cp_multiplier": 0.7317000031471252, "form": None, "cp": None, "individual_attack": None, "individual_defense": None, "individual_stamina": None, "move_1": None, "move_2": None, "height": None, "weight": None, "gender": None } settings.update(values) return Events.MonEvent(settings)
def test_sponsored(self): # Create the filters filter1 = Filters.RaidFilter('filter1', {"sponsored": False}) filter2 = Filters.RaidFilter('filter2', {"sponsored": True}) # Generate events not_sponsored = Events.EggEvent(generate_egg({"sponsor": 0})) sponsored = Events.EggEvent(generate_egg({"sponsor": 4})) # Test passing events self.assertTrue(filter1.check_event(not_sponsored)) self.assertTrue(filter2.check_event(sponsored)) # Test failing events self.assertFalse(filter2.check_event(not_sponsored)) self.assertFalse(filter1.check_event(sponsored))
def manage_webhook_data(_queue): warning_limit = datetime.utcnow() while True: # Check queue length periodically if (datetime.utcnow() - warning_limit) > timedelta(seconds=30): warning_limit = datetime.utcnow() size = _queue.qsize() if size > 2000: log.warning( "Queue length at %s! This may be causing a" "significant delay in notifications.", size) # Distribute events to the other managers data = _queue.get(block=True) obj = Events.event_factory(data) if obj is None: # TODO: Improve Event error checking continue for name, mgr in managers.iteritems(): if isinstance(obj, list): for event in obj: mgr.update(event) log.debug("Distributed event %s to %s managers.", event.id, len(managers)) else: mgr.update(obj) if not isinstance(obj, list): log.debug("Distributed event %s to %s managers.", obj.id, len(managers))
def test_time_left(self): # Create the filters settings = {'min_time_left': 1000, 'max_time_left': 8000} egg_filter = Filters.EggFilter('time_filter', settings) # Test events that should pass for s in [2000, 4000, 6000]: d = (datetime.now() + timedelta(seconds=s)) t = time.mktime(d.timetuple()) event = Events.EggEvent(generate_egg({"start": t})) self.assertTrue(egg_filter.check_event(event)) # Test events that should fail for s in [200, 999, 8001]: d = (datetime.now() + timedelta(seconds=s)) t = time.mktime(d.timetuple()) event = Events.EggEvent(generate_egg({"start": t})) self.assertFalse(egg_filter.check_event(event))
def test_custom_dts(self): # Create the filters settings = {"custom_dts": {"key1": "pass1"}} raid_filter = Filters.RaidFilter('filter1', settings) # Generate events that should pass pass1 = Events.RaidEvent(generate_raid({})) # Test passing events for e in [pass1]: self.assertTrue(raid_filter.check_event(e))
def test_missing_info(self): settings = {'is_missing_info': False, 'max_dist': 500} stop_filter = Filters.StopFilter('missing_info_filter', settings) stop_event = Events.StopEvent(generate_stop({})) self.assertFalse(stop_filter.check_event(stop_event)) for i in [0, 500]: stop_event.distance = i self.assertTrue(stop_filter.check_event(stop_event)) stop_event.distance = 'Unknown' self.assertFalse(stop_filter.check_event(stop_event))
def test_current_team(self): # Create the filters settings = {"current_teams": [1, "2", "Instinct"]} egg_filter = Filters.EggFilter('filter1', settings) # Generate events that should pass pass1 = Events.EggEvent(generate_egg({"team": 1})) pass2 = Events.EggEvent(generate_egg({"team": 2})) pass3 = Events.EggEvent(generate_egg({"team": 3})) # Test passing events for e in [pass1, pass2, pass3]: self.assertTrue(egg_filter.check_event(e)) # Generate events that should fail fail1 = Events.EggEvent(generate_egg({"team": 0})) # Test failing events for e in [fail1]: self.assertFalse(egg_filter.check_event(e))
def test_missing_info1(self): # Create the filters settings = {"max_dist": "inf", "is_missing_info": True} egg_filter = Filters.EggFilter('filter1', settings) # Generate events that should pass pass1 = Events.EggEvent(generate_egg({"dist": "Unknown"})) # Test passing events for e in [pass1]: self.assertTrue(egg_filter.check_event(e))
def test_rarity_id(self): # Create the filters settings = {"rarity": ["common", "Very Rare"]} mon_filter = Filters.MonFilter('filter1', settings) # Generate events that should pass pass1 = Events.MonEvent(generate_monster({"rarity": 0})) pass2 = Events.MonEvent(generate_monster({"rarity": 3})) # Test passing events for e in [pass1, pass2]: self.assertTrue(mon_filter.check_event(e)) # Generate events that should fail fail1 = Events.MonEvent(generate_monster({"rarity": 1})) fail2 = Events.MonEvent(generate_monster({"rarity": 2})) fail3 = Events.MonEvent(generate_monster({"rarity": 4})) # Test failing events for e in [fail1, fail2, fail3]: self.assertFalse(mon_filter.check_event(e))
def test_egg_lvl(self): # Create the filters settings = {"min_egg_lvl": 2, "max_egg_lvl": 4} egg_filter = Filters.EggFilter('filter1', settings) # Generate events that should pass pass1 = Events.EggEvent(generate_egg({"level": 2})) pass2 = Events.EggEvent(generate_egg({"level": 3})) pass3 = Events.EggEvent(generate_egg({"level": 4})) # Test passing events for e in [pass1, pass2, pass3]: self.assertTrue(egg_filter.check_event(e)) # Generate events that should fail fail1 = Events.EggEvent(generate_egg({"level": 1})) fail2 = Events.EggEvent(generate_egg({"level": 5})) # Test failing events for e in [fail1, fail2]: self.assertFalse(egg_filter.check_event(e))
def gen_event(self, values): weather_settings = { "s2_cell_id": 0, "latitude": 37.7876146, "longitude": -122.390624, "gameplay_weather": 1, "severity": 0, "world_time": 1 } weather_settings.update(values) return Events.WeatherEvent(weather_settings)
def test_missing_info2(self): # Create the filters settings = {"max_dist": "inf", "is_missing_info": False} egg_filter = Filters.EggFilter('filter1', settings) # Generate events that should pass pass1 = Events.EggEvent(generate_egg({})) pass1.distance = 1000 # Test passing events for e in [pass1]: self.assertTrue(egg_filter.check_event(e))
def test_egg_distance(self): # Create the filters settings = {"max_dist": "2000", "min_dist": "400"} egg_filter = Filters.EggFilter('filter1', settings) # Generate events that should pass pass1 = Events.EggEvent(generate_egg({})) pass1.distance = 1000 pass2 = Events.EggEvent(generate_egg({})) pass2.distance = 800 pass3 = Events.EggEvent(generate_egg({})) pass3.distance = 600 # Test passing events for e in [pass1]: self.assertTrue(egg_filter.check_event(e)) # Generate events that should fail fail1 = Events.EggEvent(generate_egg({})) fail1.distance = 3000 fail2 = Events.EggEvent(generate_egg({})) fail2.distance = 300 fail3 = Events.EggEvent(generate_egg({})) fail3.distance = 0 # Test failing events for e in [fail1, fail2, fail3]: self.assertFalse(egg_filter.check_event(e))
def test_distance(self): stop_event = Events.StopEvent(generate_stop({})) settings = {'min_dist': 5, 'max_dist': 2000} stop_filter = Filters.StopFilter('distance_filter', settings) for i in [5, 2000, 1000]: stop_event.distance = i self.assertTrue(stop_filter.check_event(stop_event)) settings2 = {'min_dist': 100, 'max_dist': 5000} stop_filter2 = Filters.StopFilter('distance_filter_2', settings2) for i in [99, 5001, 9999]: stop_event.distance = i self.assertFalse(stop_filter2.check_event(stop_event))
def test_distance(self): mon_event = Events.MonEvent(generate_monster({})) settings = {'min_dist': '5', 'max_dist': '2000'} mon_filter = Filters.MonFilter('distance_filter', settings) for i in [1000, 5, 2000]: mon_event.distance = i self.assertTrue(mon_filter.check_event(mon_event)) settings2 = {'min_dist': '5', 'max_dist': 500} mon_filter2 = Filters.MonFilter('distance_filter_2', settings2) for i in [4, 501, 9999]: mon_event.distance = i self.assertFalse(mon_filter2.check_event(mon_event))
def gen_event(self, values): """ Generate a generic stop, overriding with an specific values. """ settings = { "pokestop_id": 0, "enabled": "True", "latitude": 37.7876146, "longitude": -122.390624, "last_modified_time": 1572241600, "lure_expiration": 1572241600, "active_fort_modifier": 0 } settings.update(values) return Events.StopEvent(settings)
def manage_webhook_data(queue): while True: qsize = queue.qsize() if qsize > 5000: log.warning("Queue length is at %s... this may be causing " + "a significant delay in notifications.", qsize) data = queue.get(block=True) obj = Events.event_factory(data) if obj is not None: for name, mgr in managers.iteritems(): mgr.update(obj) log.debug("Distributing event {} to manager {}.".format( obj.id, name)) log.debug("Finished distributing event: {}".format(obj.id))
def gen_event(self, values): """ Generate a generic invasion, overriding with an specific values. """ settings = { "pokestop_id": 0, "enabled": "True", "latitude": 37.7876146, "longitude": -122.390624, "last_modified_time": 1572241600, "incident_expiration": 1572241600, "grunt_type": 6 } settings.update(values) return Events.GruntEvent(settings)
def gen_event(self, values): """ Generate a generic egg, overriding with an specific values. """ settings = { "gym_id": "OWNmOTFmMmM0YTY3NGQwYjg0Y2I1N2JlZjU4OWRkMTYuMTY=", "url": "???", "name": "unknown", "description": "???", "start": 1499244052, "end": 1499246052, "level": 5, "latitude": 37.7876146, "longitude": -122.390624, "sponsor": None, "park": None } settings.update(values) return Events.EggEvent(settings)
def manage_webhook_data(_queue): warning_limit = datetime.utcnow() while True: # Check queue length periodically if (datetime.utcnow() - warning_limit) > timedelta(seconds=30): warning_limit = datetime.utcnow() size = _queue.qsize() if size > 2000: log.warning("Queue length at %s! This may be causing a" "significant delay in notifications.", size) # Distribute events to the other managers data = _queue.get(block=True) obj = Events.event_factory(data) if obj is None: # TODO: Improve Event error checking continue for name, mgr in managers.iteritems(): mgr.update(obj) log.debug("Distributed event %s to %s managers.", obj.id, len(managers))
def gen_event(self, values): """ Generate a generic raid, overriding with an specific values. """ settings = { "gym_id": "OWNmOTFmMmM0YTY3NGQwYjg0Y2I1N2JlZjU4OWRkMTYuMTY=", "url": "???", "name": "Unknown", "description": "???", "pokemon_id": 150, "cp": 12345, "move_1": 123, "move_2": 123, "start": 1499244052, "end": 1499246052, "level": 5, "latitude": 37.7876146, "longitude": -122.390624, "sponsor": None, "park": None, "is_ex_raid_eligible": None } settings.update(values) return Events.RaidEvent(settings)
def test_monster_id(self): # Create the filters settings = {"monsters": [1, "2", "Venusaur"]} mon_filter = Filters.MonFilter('filter1', settings) # Generate events that should pass pass1 = Events.MonEvent(generate_monster({"pokemon_id": 1})) pass2 = Events.MonEvent(generate_monster({"pokemon_id": 2})) pass3 = Events.MonEvent(generate_monster({"pokemon_id": 3})) # Test passing events for e in [pass1, pass2, pass3]: self.assertTrue(mon_filter.check_event(e)) # Generate events that should fail fail1 = Events.MonEvent(generate_monster({"pokemon_id": 5})) fail2 = Events.MonEvent(generate_monster({"pokemon_id": 102})) fail3 = Events.MonEvent(generate_monster({"pokemon_id": 30})) # Test failing events for e in [fail1, fail2, fail3]: self.assertFalse(mon_filter.check_event(e))
def test_monsters_exclude(self): # Create the filters settings = {"monsters_exclude": [4, "5", "Charizard"]} mon_filter = Filters.MonFilter('filter1', settings) # Generate events that should pass pass1 = Events.MonEvent(generate_monster({"pokemon_id": 1})) pass2 = Events.MonEvent(generate_monster({"pokemon_id": 2})) pass3 = Events.MonEvent(generate_monster({"pokemon_id": 3})) # Test passing events for e in [pass1, pass2, pass3]: self.assertTrue(mon_filter.check_event(e)) # Generate events that should fail fail1 = Events.MonEvent(generate_monster({"pokemon_id": 4})) fail2 = Events.MonEvent(generate_monster({"pokemon_id": 5})) fail3 = Events.MonEvent(generate_monster({"pokemon_id": 6})) # Test failing events for e in [fail1, fail2, fail3]: self.assertFalse(mon_filter.check_event(e))
def test_charge_move(self): # Create the filters settings = {"charge_moves": [283, "14", "Solar Beam"]} raid_filter = Filters.RaidFilter('filter1', settings) # Generate events that should pass pass1 = Events.RaidEvent(generate_raid({"move_2": 283})) pass2 = Events.RaidEvent(generate_raid({"move_2": 14})) pass3 = Events.RaidEvent(generate_raid({"move_2": 116})) # Test passing events for e in [pass1, pass2, pass3]: self.assertTrue(raid_filter.check_event(e)) # Generate events that should fail fail1 = Events.RaidEvent(generate_raid({"move_2": 200})) fail2 = Events.RaidEvent(generate_raid({"move_2": 201})) fail3 = Events.RaidEvent(generate_raid({"move_2": 202})) # Test failing events for e in [fail1, fail2, fail3]: self.assertFalse(raid_filter.check_event(e))
def test_lvl(self): # Create the filters settings = {"min_lvl": 5, "max_lvl": 10} mon_filter = Filters.MonFilter('filter1', settings) # Generate events that should pass pass1 = Events.MonEvent(generate_monster({"pokemon_level": 5})) pass2 = Events.MonEvent(generate_monster({"pokemon_level": 7})) pass3 = Events.MonEvent(generate_monster({"pokemon_level": 10})) # Test passing events for e in [pass1, pass2, pass3]: self.assertTrue(mon_filter.check_event(e)) # Generate events that should fail fail1 = Events.MonEvent(generate_monster({"pokemon_id": 4})) fail2 = Events.MonEvent(generate_monster({"pokemon_id": 11})) fail3 = Events.MonEvent(generate_monster({"pokemon_id": 100})) # Test failing events for e in [fail1, fail2, fail3]: self.assertFalse(mon_filter.check_event(e))
def test_quick_move(self): # Create the filters settings = {"quick_moves": [225, "88", "Present"]} raid_filter = Filters.RaidFilter('filter1', settings) # Generate events that should pass pass1 = Events.RaidEvent(generate_raid({"move_1": 225})) pass2 = Events.RaidEvent(generate_raid({"move_1": 88})) pass3 = Events.RaidEvent(generate_raid({"move_1": 291})) # Test passing events for e in [pass1, pass2, pass3]: self.assertTrue(raid_filter.check_event(e)) # Generate events that should fail fail1 = Events.RaidEvent(generate_raid({"move_1": 200})) fail2 = Events.RaidEvent(generate_raid({"move_1": 201})) fail3 = Events.RaidEvent(generate_raid({"move_1": 202})) # Test failing events for e in [fail1, fail2, fail3]: self.assertFalse(raid_filter.check_event(e))