def test_rsvps(self):
"""Test rsvps API call"""
http_requests = setup_http_server()
client = MeetupClient('aaaa', max_items=2)
# Call API
rsvps = client.rsvps('sqlpass-es', '1')
result = [rsvp for rsvp in rsvps]
self.assertEqual(len(result), 1)
expected = {
'fields': ['attendance_status'],
'key': ['aaaa'],
'page': ['2'],
'response': ['yes,no'],
'sign': ['true']
}
self.assertEqual(len(http_requests), 1)
req = http_requests[0]
self.assertEqual(req.method, 'GET')
self.assertRegex(req.path, '/sqlpass-es/events/1/rsvps')
self.assertDictEqual(req.querystring, expected)
def test_rate_limit_error(self):
"""Test if a rate limit error is raised when rate is exhausted"""
http_requests = setup_http_server(rate_limit=0, reset_rate_limit=1)
client = MeetupClient('aaaa', max_items=2)
# Call API
events = client.events('sqlpass-es')
with self.assertRaises(RateLimitError):
_ = [event for event in events]
expected = {
'fields': [
'event_hosts,featured,group_topics,plain_text_description,rsvpable,series'
],
'key': ['aaaa'],
'order': ['updated'],
'page': ['2'],
'scroll': ['since:1970-01-01T00:00:00.000Z'],
'sign': ['true'],
'status': ['cancelled,upcoming,past,proposed,suggested']
}
self.assertEqual(len(http_requests), 1)
req = http_requests[0]
self.assertEqual(req.method, 'GET')
self.assertRegex(req.path, '/sqlpass-es/events')
self.assertDictEqual(req.querystring, expected)
def test_init(self):
"""Test initialization"""
client = MeetupClient('aaaa', max_items=10)
self.assertEqual(client.api_token, 'aaaa')
self.assertEqual(client.max_items, 10)
self.assertFalse(client.sleep_for_rate)
self.assertEqual(client.min_rate_to_sleep, MIN_RATE_LIMIT)
self.assertTrue(client.ssl_verify)
client = MeetupClient('aaaa',
max_items=10,
sleep_for_rate=True,
min_rate_to_sleep=4,
ssl_verify=False)
self.assertEqual(client.api_token, 'aaaa')
self.assertEqual(client.max_items, 10)
self.assertTrue(client.sleep_for_rate)
self.assertEqual(client.min_rate_to_sleep, 4)
self.assertFalse(client.ssl_verify)
# Max rate limit is never overtaken
client = MeetupClient('aaaa',
max_items=10,
sleep_for_rate=True,
min_rate_to_sleep=100000000)
self.assertEqual(client.min_rate_to_sleep, client.MAX_RATE_LIMIT)
def test_comments(self):
"""Test comments API call"""
http_requests = setup_http_server()
client = MeetupClient('aaaa', max_items=2)
# Call API
comments = client.comments('sqlpass-es', '1')
result = [comment for comment in comments]
self.assertEqual(len(result), 1)
expected = {
'key': ['aaaa'],
'page': ['2'],
'sign': ['true']
}
self.assertEqual(len(http_requests), 1)
req = http_requests[0]
self.assertEqual(req.method, 'GET')
self.assertRegex(req.path, '/sqlpass-es/events/1/comments')
self.assertDictEqual(req.querystring, expected)
def test_events_oauth_token(self):
"""Test events API call with oauth token"""
http_requests = setup_http_server()
client = MeetupClient('aaaa', is_oauth_token=True, max_items=2)
from_date = datetime.datetime(2016, 1, 1)
# Call API
events = client.events('sqlpass-es', from_date=from_date)
result = [event for event in events]
self.assertEqual(len(result), 2)
expected = [{
'fields': [
'event_hosts,featured,group_topics,plain_text_description,rsvpable,series'
],
'access_token': ['aaaa'],
'order': ['updated'],
'page': ['2'],
'scroll': ['since:2016-01-01T00:00:00.000Z'],
'status': ['cancelled,upcoming,past,proposed,suggested']
}, {
'access_token': ['aaaa']
}]
self.assertEqual(len(http_requests), 2)
for x in range(0, len(http_requests)):
req = http_requests[x]
self.assertEqual(req.method, 'GET')
self.assertRegex(req.path, '/sqlpass-es/events')
self.assertDictEqual(req.querystring, expected[x])
def test_events_error(self):
"""Test whether HTTP errors different from 410 are thrown when fetching event pages"""
httpretty.register_uri(httpretty.GET,
MEETUP_EVENTS_URL,
body="",
status=401)
client = MeetupClient('aaaa', max_items=2)
events = client.events('sqlpass-es')
with self.assertRaises(requests.exceptions.HTTPError):
_ = [event for event in events]
def test_group_gone(self):
"""Test whether the group gone exception (HTTP 410) is properly handled"""
httpretty.register_uri(httpretty.GET,
MEETUP_EVENTS_URL,
body="",
status=410)
client = MeetupClient('aaaa', max_items=2)
events = client.events('sqlpass-es')
with self.assertRaises(RepositoryError):
_ = [event for event in events]
def test_too_many_requests(self):
"""Test if a Retry error is raised"""
httpretty.register_uri(httpretty.GET, MEETUP_EVENTS_URL, status=429)
client = MeetupClient('aaaa', max_items=2, sleep_time=0.1)
start = float(time.time())
expected = start + (sum(
[i * client.sleep_time for i in range(client.MAX_RETRIES)]))
events = client.events('sqlpass-es')
with self.assertRaises(requests.exceptions.RetryError):
_ = [event for event in events]
end = float(time.time())
self.assertGreater(end, expected)
def test_sleep_for_rate(self):
""" Test if the clients sleeps when the rate limit is reached"""
wait_to_reset = 1
http_requests = setup_http_server(rate_limit=0,
reset_rate_limit=wait_to_reset)
client = MeetupClient('aaaa',
max_items=2,
min_rate_to_sleep=2,
sleep_for_rate=True)
# Call API
before = float(time.time())
events = client.events('sqlpass-es')
results = [event for event in events]
after = float(time.time())
diff = after - before
self.assertGreaterEqual(diff, wait_to_reset)
self.assertEqual(len(results), 2)
expected = [{
'fields': [
'event_hosts,featured,group_topics,plain_text_description,rsvpable,series'
],
'order': ['updated'],
'page': ['2'],
'scroll': ['since:1970-01-01T00:00:00.000Z'],
'status': ['cancelled,upcoming,past,proposed,suggested']
}, {
'order': ['updated'],
'page': ['2'],
'scroll': ['since:1970-01-01T00:00:00.000Z']
}]
self.assertEqual(len(http_requests), 2)
for x in range(0, len(http_requests)):
req = http_requests[x]
self.assertEqual(req.method, 'GET')
self.assertRegex(req.path, '/sqlpass-es/events')
self.assertIn((MeetupClient.PKEY_OAUTH2, 'Bearer aaaa'),
req.headers._headers)
self.assertDictEqual(req.querystring, expected[x])
def test_init_oauth_token(self):
"""Test initialization with an oauth token"""
client = MeetupClient('aaaa', is_oauth_token=True, max_items=10)
self.assertEqual(client.api_key, 'aaaa')
self.assertEqual(client.max_items, 10)
self.assertFalse(client.sleep_for_rate)
self.assertEqual(client.min_rate_to_sleep, MIN_RATE_LIMIT)
self.assertTrue(client.is_oauth_token)
def test_init(self):
"""Test initialization"""
client = MeetupClient('aaaa', max_items=10)
self.assertEqual(client.api_key, 'aaaa')
self.assertEqual(client.max_items, 10)
self.assertEqual(client.sleep_for_rate, False)
self.assertEqual(client.min_rate_to_sleep, MIN_RATE_LIMIT)
client = MeetupClient('aaaa',
max_items=10,
sleep_for_rate=True,
min_rate_to_sleep=4)
self.assertEqual(client.api_key, 'aaaa')
self.assertEqual(client.max_items, 10)
self.assertEqual(client.sleep_for_rate, True)
self.assertEqual(client.min_rate_to_sleep, 4)
# Max rate limit is never overtaken
client = MeetupClient('aaaa',
max_items=10,
sleep_for_rate=True,
min_rate_to_sleep=100000000)
self.assertEqual(client.min_rate_to_sleep, MAX_RATE_LIMIT)
def test_sanitize_for_archive(self):
"""Test whether the sanitize method works properly"""
url = "http://example.com"
headers = "headers-information"
payload = {'page': 2,
'sign': ('true',),
'order': 'updated',
'scroll': 'since:2016-01-01T00:00:00.000Z',
'key': 'aaaa'}
s_url, s_headers, s_payload = MeetupClient.sanitize_for_archive(url, headers, copy.deepcopy(payload))
payload.pop('key')
payload.pop('sign')
self.assertEqual(url, s_url)
self.assertEqual(headers, s_headers)
self.assertEqual(payload, s_payload)
def test_sanitize_for_archive(self):
"""Test whether the sanitize method works properly"""
url = "http://example.com"
headers = {MeetupClient.PKEY_OAUTH2: 'Bear aaaa'}
payload = {
'page': 2,
'order': 'updated',
'scroll': 'since:2016-01-01T00:00:00.000Z'
}
s_url, s_headers, s_payload = MeetupClient.sanitize_for_archive(
url, copy.deepcopy(headers), payload)
headers.pop(MeetupClient.PKEY_OAUTH2)
self.assertEqual(url, s_url)
self.assertEqual(headers, s_headers)
self.assertEqual(payload, s_payload)
def test_init(self):
"""Test initialization"""
client = MeetupClient('aaaa', max_items=10)
self.assertEqual(client.api_key, 'aaaa')
self.assertEqual(client.max_items, 10)
