def test_get(httpserver: HTTPServer):
api_client: MeetupApiClient = MeetupApiClient()
with pytest.raises(HttpNotFoundError):
api_client.get(meetup_groups["not-exist"]["urlname"])
with pytest.raises(HttpNotAccessibleError):
api_client.get(meetup_groups["gone"]["urlname"])
json: dict = api_client.get(meetup_groups["sandbox"]["urlname"])
assert isinstance(json, dict)
assert json["id"] == meetup_groups["sandbox"]["meetup_id"]
# test for HttpNoXRateLimitHeader execption
for _ in range(4):
httpserver.expect_oneshot_request(
"/HttpNoXRateLimitHeader").respond_with_data("OK")
api_client.base_url = httpserver.url_for("/HttpNoXRateLimitHeader")
with pytest.raises(HttpNoXRateLimitHeader):
api_client.get(url_path="", reset_time=2)
# test for HttpNoSuccess execption
for _ in range(4):
httpserver.expect_oneshot_request("/HttpNoSuccess")
api_client.base_url = httpserver.url_for("")
with pytest.raises(HttpNoSuccess):
api_client.get(url_path="/", reset_time=2)
def test_group_page_last_event():
# test when there is no event
sandbox_group: GroupPage = GroupPageFactory()
assert sandbox_group.last_event() is None
# test when there is a new event
sandbox_event_1: EventPage = EventPage1Factory()
assert sandbox_group.last_event().meetup_id == sandbox_event_1.meetup_id
sandbox_event_2: EventPage = EventPage2Factory()
EventPage3Factory()
assert sandbox_group.last_event().meetup_id == sandbox_event_2.meetup_id
# delete all events
for event in sandbox_group.events():
event.delete()
# get 20 events from the sandbox group
api_client: MeetupApiClient = MeetupApiClient()
event_page_entries = 20
api_client.update_group_events(group=sandbox_group,
max_entries=event_page_entries)
event_page_counter: int = 1
for _ in sandbox_group.events():
last_event: EventPage = sandbox_group.last_event()
last_event_time: datetime = last_event.time
last_event.delete()
assert last_event_time is not None
if sandbox_group.last_event():
event_page_counter = event_page_counter + 1
assert last_event_time > sandbox_group.last_event().time
assert event_page_counter == event_page_entries
def handle(self, *args, **options):
api_client: MeetupApiClient = MeetupApiClient()
group: GroupPage = api_client.get_group("Meetup-API-Testing")
groups: [GroupPage] = GroupPage.objects.all()
event_counter: int = 0
for group in groups:
group_events: [EventPage] = api_client.update_all_group_events(group=group)
event_counter = event_counter + len(group_events)
print(
"{} groups was updated & {} events added".format(len(groups), event_counter)
)
def test_home_page_child_pages():
# get home page
api_client: MeetupApiClient = MeetupApiClient()
home_page: HomePage = api_client.get_home_page()
# test when there no child page
assert len(home_page.child_pages) == 0
# test with 1 child page
ImprintPageFactory()
assert len(home_page.child_pages) == 1
# test with 1 child page
PrivacyPageFactory()
assert len(home_page.child_pages) == 2
def test_get_group(httpserver: HTTPServer):
api_client: MeetupApiClient = MeetupApiClient()
sandbox_group: GroupPage = api_client.get_group(
meetup_groups["sandbox"]["urlname"])
assert isinstance(sandbox_group, GroupPage)
assert sandbox_group.meetup_id == meetup_groups["sandbox"]["meetup_id"]
# test with gone group
none_group: GroupPage = api_client.get_group(
meetup_groups["gone"]["urlname"])
assert none_group is None
# test without existing group in database
none_group: GroupPage = api_client.get_group(
meetup_groups["not-exist"]["urlname"])
assert none_group is None
# test with existing group in database
NotExistGroupPageFactory()
none_group: GroupPage = api_client.get_group(
meetup_groups["not-exist"]["urlname"])
assert none_group is None
not_exist_groups = GroupPage.objects.filter(
urlname=meetup_groups["not-exist"]["urlname"])
assert not_exist_groups.exists() is False
sandbox_group: GroupPage = GroupPageFactory()
# test for HttpNoXRateLimitHeader execption
httpserver.expect_oneshot_request("/{}".format(
sandbox_group.urlname)).respond_with_data("OK")
api_client.base_url = httpserver.url_for("/")
none_group = api_client.get_group(sandbox_group.urlname)
assert none_group is None
sandbox_group_datbase = GroupPage.objects.filter(
urlname=sandbox_group.urlname)
assert sandbox_group_datbase.exists() is True
# test for HttpNoSuccess execption
httpserver.expect_oneshot_request("/HttpNoSuccess").respond_with_data("OK")
api_client.base_url = httpserver.url_for("/HttpNoSuccess")
none_group = api_client.get_group(sandbox_group.urlname)
assert none_group is None
sandbox_group_datbase = GroupPage.objects.filter(
urlname=sandbox_group.urlname)
assert sandbox_group_datbase.exists() is True
def test_update_group_events(httpserver: HTTPServer):
api_client: MeetupApiClient = MeetupApiClient()
sandbox_group: GroupPage = api_client.get_group(
group_urlname=meetup_groups["sandbox"]["urlname"])
event_1: [EventPage] = api_client.update_group_events(group=sandbox_group,
max_entries=1)
event_2: [EventPage] = api_client.update_group_events(group=sandbox_group,
max_entries=3)
event_3: [EventPage] = api_client.update_group_events(group=sandbox_group,
max_entries=2)
assert isinstance(event_1[0], EventPage)
assert len(event_1) == 1
assert isinstance(event_2[0], EventPage)
assert len(event_2) == 3
assert event_1[0] != event_2[0]
assert len(event_3) == 1
assert event_1[0] != event_3[0]
not_exist_group: GroupPage = NotExistGroupPageFactory()
none_group_events: [
EventPage
] = api_client.update_group_events(group=not_exist_group)
assert len(none_group_events) == 0
# delete all events from sandbox group
sandbox_group_events: [EventPage] = sandbox_group.events()
for event in sandbox_group_events:
event.delete()
# test for HttpNoXRateLimitHeader execption
httpserver.expect_oneshot_request("{}/events?status=past&page=1".format(
sandbox_group.urlname)).respond_with_data("OK")
api_client.base_url = httpserver.url_for("/")
event_4: [EventPage] = api_client.update_group_events(group=sandbox_group,
max_entries=1)
assert len(event_4) == 0
# test for HttpNoSuccess execption
httpserver.expect_oneshot_request("/HttpNoSuccess").respond_with_data("OK")
api_client.base_url = httpserver.url_for("/HttpNoSuccess")
event_5: [EventPage] = api_client.update_group_events(group=sandbox_group,
max_entries=1)
assert len(event_5) == 0
def test_update_all_group_events():
# set api_client & sandbox group
api_client: MeetupApiClient = MeetupApiClient()
sandbox_group: GroupPage = GroupPageFactory()
# delte all events from group
for event in sandbox_group.events():
event.delete()
# update sandbox group
events: [EventPage
] = api_client.update_all_group_events(group=sandbox_group)
assert isinstance(events[0], EventPage)
assert len(events) > 1
# check if all events was added to the database
events: [EventPage
] = api_client.update_all_group_events(group=sandbox_group)
assert len(events) == 0
# update non exist group
not_exist_group: GroupPage = NotExistGroupPageFactory()
none_group_events: [
EventPage
] = api_client.update_all_group_events(group=not_exist_group)
assert len(none_group_events) == 0
# delte last event
sandbox_group.last_event().delete()
# update sandbox group with max_entries_per_page of 300
events: [EventPage
] = api_client.update_all_group_events(group=sandbox_group,
max_entries_per_page=300)
assert isinstance(events[0], EventPage)
# delte last event
sandbox_group.last_event().delete()
# update sandbox group with max_entries_per_page of -10
events: [EventPage
] = api_client.update_all_group_events(group=sandbox_group,
max_entries_per_page=-10)
assert isinstance(events[0], EventPage)
def handle(self, *args, **options):
api_client: MeetupApiClient = MeetupApiClient()
if not options["json_path"]:
options["json_path"] = "/app/meetup_groups"
mettup_groups_files: [] = glob.glob("{}/*.json".format(
options["json_path"]))
group_counter: int = 0
group_not_exists_counter: int = 0
event_counter: int = 0
for mettup_groups_file in mettup_groups_files:
with open(mettup_groups_file) as json_file:
data = json.load(json_file)
for group_data in data:
group: GroupPage = api_client.get_group(
data[group_data]["urlname"])
# break if group not exists
if not group:
group_not_exists_counter = group_not_exists_counter + 1
break
group_counter = group_counter + 1
group_events: [
EventPage
] = api_client.update_all_group_events(group=group)
event_counter = event_counter + len(group_events)
print("Group {} was updatet with {} events".format(
group.name, len(group_events)))
print(
"{} groups was updatet with {} new events & {} do not exists anymore"
.format(group_counter, event_counter, group_not_exists_counter))
def handle(self, *args, **options):
api_client: MeetupApiClient = MeetupApiClient()
if options["sandbox"]:
options["group_urlname"] = "Meetup-API-Testing"
if not options["group_urlname"]:
raise CommandError(
"No group_urlname was given, add a group by --group_urlname GroupUrl or use the sandbox group by --sandbox"
)
group: GroupPage = api_client.get_group(options["group_urlname"])
if not group:
raise CommandError("Group with urlname {} does not exists".format(
options["group_urlname"]))
group_events: [EventPage
] = api_client.update_all_group_events(group=group)
print("{} has been {} events added!".format(group.name,
len(group_events)))
def test_get_group_from_response():
api_client: MeetupApiClient = MeetupApiClient()
timezone.activate(pytz.timezone("UTC"))
# set group page response
group_1_response: dict = get_group_response(
meetup_id=54654, urlname="group_1", content=False
)
group_2_response: dict = get_group_response(
meetup_id=54655, urlname="group_2", content=True
)
group_3_response: dict = get_group_response(
meetup_id=54656, urlname="group_3", content=True
)
del group_3_response["fee_options"]["currencies"]["default"]
del group_3_response["nomination_acceptable"]
# get photo model
group_1: GroupPage = get_group_from_response(
response=group_1_response, home_page=api_client.get_home_page()
)
group_2: GroupPage = get_group_from_response(
response=group_2_response, home_page=api_client.get_home_page()
)
group_3: GroupPage = get_group_from_response(
response=group_3_response, home_page=api_client.get_home_page()
)
# assert group_1
assert isinstance(group_1, GroupPage)
assert group_1.title == group_1_response["name"]
assert group_1.slug == str(group_1_response["id"])
assert group_1.meetup_id == group_1_response["id"]
assert group_1.urlname == group_1_response["urlname"]
assert group_1.created == timezone.make_aware(
datetime.fromtimestamp(group_1_response["created"] / 1000)
)
assert group_1.description == group_1_response["description"]
assert "{0:.8f}".format(group_1.lat) == "{0:.8f}".format(group_1_response["lat"])
assert "{0:.8f}".format(group_1.lon) == "{0:.8f}".format(group_1_response["lon"])
assert group_1.link == group_1_response["link"]
assert group_1.members == group_1_response["members"]
assert group_1.name == group_1_response["name"]
assert group_2.nomination_acceptable is True
assert group_1.status == group_1_response["status"]
assert group_1.timezone == group_1_response["timezone"]
assert group_1.visibility == group_1_response["visibility"]
assert group_1.short_link is None
assert group_1.welcome_message is None
assert group_1.city is None
assert group_1.city_link is None
assert group_1.untranslated_city is None
assert group_1.country is None
assert group_1.localized_country_name is None
assert group_1.localized_location is None
assert group_1.state is None
assert group_1.join_mode is None
assert group_1.fee_options_currencies_code is None
assert group_1.fee_options_currencies_default is None
assert group_1.fee_options_type is None
assert group_1.member_limit is None
assert group_1.organizer is None
assert group_1.who is None
assert group_1.group_photo is None
assert group_1.key_photo is None
assert group_1.category is None
assert len(group_1.topics.all()) == 0
assert group_1.meta_category is None
# assert group_2
assert isinstance(group_2, GroupPage)
assert group_2.title == group_2_response["name"]
assert group_2.slug == str(group_2_response["id"])
assert group_2.meetup_id == group_2_response["id"]
assert group_2.urlname == group_2_response["urlname"]
assert group_2.created == timezone.make_aware(
datetime.fromtimestamp(group_2_response["created"] / 1000)
)
assert group_2.description == group_2_response["description"]
assert "{0:.8f}".format(group_2.lat) == "{0:.8f}".format(group_2_response["lat"])
assert "{0:.8f}".format(group_2.lon) == "{0:.8f}".format(group_2_response["lon"])
assert group_2.link == group_2_response["link"]
assert group_2.members == group_2_response["members"]
assert group_2.name == group_2_response["name"]
assert group_2.nomination_acceptable == group_2_response["nomination_acceptable"]
assert group_2.status == group_2_response["status"]
assert group_2.timezone == group_2_response["timezone"]
assert group_2.visibility == group_2_response["visibility"]
assert group_2.short_link == group_2_response["short_link"]
assert group_2.welcome_message == group_2_response["welcome_message"]
assert group_2.city == group_2_response["city"]
assert group_2.city_link == group_2_response["city_link"]
assert group_2.untranslated_city == group_2_response["untranslated_city"]
assert group_2.country == group_2_response["country"]
assert group_2.localized_country_name == group_2_response["localized_country_name"]
assert group_2.localized_location == group_2_response["localized_location"]
assert group_2.state == group_2_response["state"]
assert group_2.join_mode == group_2_response["join_mode"]
assert (
group_2.fee_options_currencies_code
== group_2_response["fee_options"]["currencies"]["code"]
)
assert (
group_2.fee_options_currencies_default
== group_2_response["fee_options"]["currencies"]["default"]
)
assert group_2.fee_options_type == group_2_response["fee_options"]["type"]
assert group_2.member_limit == group_2_response["member_limit"]
assert isinstance(group_2.organizer, Member)
assert group_2.who == group_2_response["who"]
assert isinstance(group_2.group_photo, Photo)
assert isinstance(group_2.key_photo, Photo)
assert isinstance(group_2.category, Category)
assert len(group_2.topics.all()) == 1
assert isinstance(group_2.topics.all()[0], Topic)
assert isinstance(group_2.meta_category, MetaCategory)
# assert group_3
assert (
group_3.fee_options_currencies_code
== group_3_response["fee_options"]["currencies"]["code"]
)
assert group_3.fee_options_currencies_default is False
assert group_3.fee_options_type == group_3_response["fee_options"]["type"]
assert group_3.nomination_acceptable is False
def test_get_home_page():
api_client: MeetupApiClient = MeetupApiClient()
home_page: HomePage = api_client.get_home_page()
assert isinstance(home_page, HomePage)
assert home_page.title == "Home"