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))
