class TermAssert(unittest.TestCase):
def setUp(self):
key = "mock api key to satisfy type check in api._get_oauth()"
secret = "mock secret key to satisfy type check in api._get_oauth()"
self.api = API(key, secret, testing=True)
def test_str(self):
"""
Test _term_assert with term "goat"
"""
term = "goat"
self.api._term_assert(term, "term")
def test_str_non_ascii(self):
"""
Test _term_assert with term "¤"
"""
term = "¤"
self.api._term_assert(term, "term")
def test_str_multiple_words(self):
"""
Test _term_assert with term "goat horn"
"""
term = "goat horn"
self.api._term_assert(term, "term")
def test_str_empty(self):
"""
Test _term_assert with illegal term ""
"""
term = ""
with self.assertRaises(IllegalTerm):
self.api._term_assert(term, "term")
def setUp(self):
try:
key = os.environ["TNP_KEY"]
secret = os.environ["TNP_SECRET"]
except KeyError:
raise unittest.SkipTest(
"We skip tests sending actual requests if the key and secret are not set as environment variables."
)
self.api = API(key, secret)
self.limit = 2
self.common_attributes = {
"permalink", "id", "sponsor", "sponsor_id", "sponsor_campaign_link"
}
self.usage_attributes = {"limits", "usage"}
self.usage_time_attributes = {"daily", "hourly", "monthly"}
self.report_usage_attributes = {"licenses_consumed", "result"}
class UserCollectionsURLs(unittest.TestCase):
def setUp(self):
key = "mock api key to satisfy type check in api._get_oauth()"
secret = "mock secret key to satisfy type check in api._get_oauth()"
self.api = API(key, secret, testing=True)
def _test_get_user_collections(self, user_id):
"""
Helper function to call api's get_user_collections in such a way that we only get the URL
and don't actually make the request.
"""
return self.api.get_user_collections(user_id).url
def test_get_user_collections_legal(self):
"""
Test URL for get_user_collections with user_id 12
"""
expected = "http://api.thenounproject.com/user/12/collections"
user_id = 12
result = self._test_get_user_collections(user_id)
self.assertEqual(expected, result)
def test_get_user_collections_illegal_id(self):
"""
Test URL for get_user_collections with user_id None
"""
user_id = None
with self.assertRaises(IncorrectType):
self._test_get_user_collections(user_id)
class CollectionsURLs(unittest.TestCase):
def setUp(self):
key = "mock api key to satisfy type check in api._get_oauth()"
secret = "mock secret key to satisfy type check in api._get_oauth()"
self.api = API(key, secret, testing=True)
def _test_get_collections(self, limit=None, offset=None, page=None):
"""
Helper function to call api's get_collections in such a way that we only get the URL
and don't actually make the request.
"""
return self.api.get_collections(limit=limit, offset=offset, page=page).url
def test_get_collections(self):
"""
Test URL for get_collections
"""
expected = "http://api.thenounproject.com/collections"
result = self._test_get_collections()
self.assertEqual(expected, result)
def test_get_collections_limit_offset(self):
"""
Test URL for get_collections, with limit 12 and offset 3
"""
expected = "http://api.thenounproject.com/collections?limit=12&offset=3"
limit = 12
offset = 3
result = self._test_get_collections(limit=limit, offset=offset)
self.assertEqual(expected, result)
class IdAssert(unittest.TestCase):
def setUp(self):
key = "mock api key to satisfy type check in api._get_oauth()"
secret = "mock secret key to satisfy type check in api._get_oauth()"
self.api = API(key, secret, testing=True)
def test_id_12(self):
"""
Test _id_assert with id 12
"""
id = 12
self.api._id_assert(id, "id")
def test_id_neg_12(self):
"""
Test _id_assert with illegal id -12
"""
id = -12
with self.assertRaises(NonPositive):
self.api._id_assert(id, "id")
def test_id_0(self):
"""
Test _id_assert with illegal id 0
"""
id = 0
with self.assertRaises(NonPositive):
self.api._id_assert(id, "id")
class CollectionCustomURLs(unittest.TestCase):
def setUp(self):
key = "mock api key to satisfy type check in api._get_oauth()"
secret = "mock secret key to satisfy type check in api._get_oauth()"
self.api = API(key, secret, testing=True)
def _test_get_collection(self, identifier):
"""
Helper function to call api's get_collection in such a way that we only get the URL
and don't actually make the request.
"""
return self.api.get_collection(identifier).url
def test_get_collection_int(self):
"""
Test URL for get_collection with identifier 12
"""
identifier = 12
expected = "http://api.thenounproject.com/collection/12"
result = self._test_get_collection(identifier)
self.assertEqual(expected, result)
def test_get_collection_str(self):
"""
Test URL for get_collection with identifier "goat"
"""
identifier = "goat"
expected = "http://api.thenounproject.com/collection/goat"
result = self._test_get_collection(identifier)
self.assertEqual(expected, result)
def test_get_collection_none(self):
"""
Test URL for get_collection with illegal identifier None
"""
identifier = None
with self.assertRaises(IncorrectType):
self._test_get_collection(identifier)
def test_get_collection_bytes(self):
"""
Test URL for get_collection with identifier b"goat"
"""
identifier = b"goat"
with self.assertRaises(IncorrectType):
self._test_get_collection(identifier)
class GetUsageURLs(unittest.TestCase):
def setUp(self):
key = "mock api key to satisfy type check in api._get_oauth()"
secret = "mock secret key to satisfy type check in api._get_oauth()"
self.api = API(key, secret, testing=True)
def _test_get_usage(self):
"""
Helper function to call api's get_usage in such a way that we only get the URL
and don't actually make the request.
"""
return self.api.get_usage().url
def test_get_usage(self):
"""
Test URL for get_usage
"""
expected = "http://api.thenounproject.com/oauth/usage"
result = self._test_get_usage()
self.assertEqual(expected, result)
class SlugAssert(unittest.TestCase):
def setUp(self):
key = "mock api key to satisfy type check in api._get_oauth()"
secret = "mock secret key to satisfy type check in api._get_oauth()"
self.api = API(key, secret, testing=True)
def test_str(self):
"""
Test _slug_assert with slug "goat"
"""
slug = "goat"
self.api._slug_assert(slug, "slug")
def test_str_empty(self):
"""
Test _slug_assert with illegal slug ""
"""
slug = ""
with self.assertRaises(IllegalSlug):
self.api._slug_assert(slug, "slug")
def test_str_non_ascii(self):
"""
Test _slug_assert with illegal slug "¤"
"""
slug = "¤"
with self.assertRaises(IllegalSlug):
self.api._slug_assert(slug, "slug")
def test_str_multiple_words(self):
"""
Test _slug_assert with illegal slug "goat horn"
"""
slug = "goat horn"
with self.assertRaises(IllegalSlug):
self.api._slug_assert(slug, "slug")
class UserUploadsURLs(unittest.TestCase):
def setUp(self):
key = "mock api key to satisfy type check in api._get_oauth()"
secret = "mock secret key to satisfy type check in api._get_oauth()"
self.api = API(key, secret, testing=True)
def _test_get_user_uploads(self, username):
"""
Helper function to call api's get_user_uploads in such a way that we only get the URL
and don't actually make the request.
"""
return self.api.get_user_uploads(username).url
def test_get_user_uploads_legal(self):
"""
Test URL for get_user_uploads with username "goat"
"""
expected = "http://api.thenounproject.com/user/goat/uploads"
username = "******"
result = self._test_get_user_uploads(username)
self.assertEqual(expected, result)
def test_get_user_uploads_illegal_user_none(self):
"""
Test URL for get_user_uploads with username None
"""
username = None
with self.assertRaises(IncorrectType):
self._test_get_user_uploads(username)
def test_get_user_uploads_illegal_user_empty(self):
"""
Test URL for get_user_uploads with username ""
"""
username = ""
with self.assertRaises(IllegalTerm):
self._test_get_user_uploads(username)
def setUp(self):
key = "mock api key to satisfy type check in api._get_oauth()"
secret = "mock secret key to satisfy type check in api._get_oauth()"
self.api = API(key, secret, testing=True)
class IconsURLs(unittest.TestCase):
def setUp(self):
key = "mock api key to satisfy type check in api._get_oauth()"
secret = "mock secret key to satisfy type check in api._get_oauth()"
self.api = API(key, secret, testing=True)
def _test_get_icons_by_term(self,
term,
public_domain_only=False,
limit=None,
offset=None,
page=None):
"""
Helper function to call api's get_icons_by_term in such a way that we only get the URL
and don't actually make the request.
"""
return self.api.get_icons_by_term(term, public_domain_only, limit,
offset, page).url
def test_get_icons_by_term_legal_goat(self):
"""
Test URL for get_icons_by_term with term "goat"
"""
term = "goat"
expected = "http://api.thenounproject.com/icons/goat?limit_to_public_domain=0"
result = self._test_get_icons_by_term(term)
self.assertEqual(expected, result)
def test_get_icons_by_term_illegal_term_float(self):
"""
Test URL for get_icons_by_term with term 12.0
"""
term = 12.0
with self.assertRaises(IncorrectType):
self._test_get_icons_by_term(term)
def test_get_icons_by_term_illegal_term_none(self):
"""
Test URL for get_icons_by_term with term None
"""
term = None
with self.assertRaises(IncorrectType):
self._test_get_icons_by_term(term)
def test_get_icons_by_term_public_domain_true(self):
"""
Test URL for get_icons_by_term with term "goat", with public_domain_only as True
"""
term = "goat"
public_domain_only = True
expected = "http://api.thenounproject.com/icons/goat?limit_to_public_domain=1"
result = self._test_get_icons_by_term(
term, public_domain_only=public_domain_only)
self.assertEqual(expected, result)
def test_get_icons_by_term_public_domain_false(self):
"""
Test URL for get_icons_by_term with term "goat", with public_domain_only as False
"""
term = "goat"
public_domain_only = False
expected = "http://api.thenounproject.com/icons/goat?limit_to_public_domain=0"
result = self._test_get_icons_by_term(
term, public_domain_only=public_domain_only)
self.assertEqual(expected, result)
def test_get_icons_by_term_public_domain_int(self):
"""
Test URL for get_icons_by_term with term "goat", with public_domain_only as 12
Note that I'll allow any integer value, even zero and negative numbers.
"""
term = "goat"
public_domain_only = 12
expected = "http://api.thenounproject.com/icons/goat?limit_to_public_domain=12"
result = self._test_get_icons_by_term(
term, public_domain_only=public_domain_only)
self.assertEqual(expected, result)
def test_get_icons_by_term_public_domain_illegal(self):
"""
Test URL for get_icons_by_term with term "goat", with public_domain_only as "goat"
"""
term = "goat"
public_domain_only = "goat"
with self.assertRaises(IncorrectType):
self._test_get_icons_by_term(term,
public_domain_only=public_domain_only)
class ApiKeys(unittest.TestCase):
def setUp(self):
self.api = API(testing=True)
self.key = "mock api key to satisfy type check in api._get_oauth()"
self.secret = "mock secret key to satisfy type check in api._get_oauth()"
def test_no_api_key_no_secret(self):
"""
Attempt a request with no api key and no secret key
"""
with self.assertRaises(APIKeyNotSet):
self.api.get_usage()
def test_no_api_key(self):
"""
Attempt a request with no api key
"""
self.api.set_secret_key(self.secret)
with self.assertRaises(APIKeyNotSet):
self.api.get_usage()
def test_no_secret(self):
"""
Attempt a request with no secret key
"""
self.api.set_api_key(self.key)
with self.assertRaises(APIKeyNotSet):
self.api.get_usage()
def test_both(self):
"""
Attempt a request with both api and secret keys set
"""
self.api.set_secret_key(self.secret)
self.api.set_api_key(self.key)
self.api.get_usage()
class CollectionIconsCustomURLs(unittest.TestCase):
def setUp(self):
key = "mock api key to satisfy type check in api._get_oauth()"
secret = "mock secret key to satisfy type check in api._get_oauth()"
self.api = API(key, secret, testing=True)
def _test_get_collection_icons(self,
identifier,
limit=None,
offset=None,
page=None):
"""
Helper function to call api's get_collection_icons in such a way that we only get the URL
and don't actually make the request.
"""
return self.api.get_collection_icons(identifier,
limit=limit,
offset=offset,
page=page).url
def test_get_collection_icons_legal_int(self):
"""
Test URL for get_collection_icons with identifier 12
"""
identifier = 12
expected = "http://api.thenounproject.com/collection/12/icons"
result = self._test_get_collection_icons(identifier)
self.assertEqual(expected, result)
def test_get_collection_icons_legal_string(self):
"""
Test URL for get_collection_icons with identifier "goat"
"""
identifier = "goat"
expected = "http://api.thenounproject.com/collection/goat/icons"
result = self._test_get_collection_icons(identifier)
self.assertEqual(expected, result)
def test_get_collection_icons_limit_page(self):
"""
Test URL for get_collection_icons with identifier 12, with limit 12 and page 3
"""
identifier = 12
expected = "http://api.thenounproject.com/collection/12/icons?limit=12&page=3"
limit = 12
page = 3
result = self._test_get_collection_icons(identifier,
limit=limit,
page=page)
self.assertEqual(expected, result)
def test_get_collection_icons_offset(self):
"""
Test URL for get_collection_icons with identifier 12, with offset 12
"""
identifier = 12
expected = "http://api.thenounproject.com/collection/12/icons?offset=12"
offset = 12
result = self._test_get_collection_icons(identifier, offset=offset)
self.assertEqual(expected, result)
def test_get_collection_icons_illegal_identifier_none(self):
"""
Test URL for get_collection_icons with ilegal identifier None
"""
identifier = None
with self.assertRaises(IncorrectType):
self._test_get_collection_icons(identifier)
def test_get_collection_icons_illegal_identifier_float(self):
"""
Test URL for get_collection_icons with illegal identifier 12.0
"""
identifier = 12.0
with self.assertRaises(IncorrectType):
self._test_get_collection_icons(identifier)
def test_get_collection_icons_illegal_identifier_limit_page(self):
"""
Test URL for get_collection_icons with illegal identifier [12, 4, 5], with legal limit 12 and page 3
"""
identifier = [12, 4, 5]
limit = 12
page = 3
with self.assertRaises(IncorrectType):
self._test_get_collection_icons(identifier, limit=limit, page=page)
class CollectionIconsURLs(unittest.TestCase):
def setUp(self):
key = "mock api key to satisfy type check in api._get_oauth()"
secret = "mock secret key to satisfy type check in api._get_oauth()"
self.api = API(key, secret, testing=True)
def _test_get_collection_icons_by_id(self,
_id,
limit=None,
offset=None,
page=None):
"""
Helper function to call api's get_collection_icons_by_id in such a way that we only get the URL
and don't actually make the request.
"""
return self.api.get_collection_icons_by_id(_id,
limit=limit,
offset=offset,
page=page).url
def test_get_collection_icons_by_id_legal(self):
"""
Test URL for get_collection_icons with id 12
"""
_id = 12
expected = "http://api.thenounproject.com/collection/12/icons"
result = self._test_get_collection_icons_by_id(_id)
self.assertEqual(expected, result)
def test_get_collection_icons_by_id_limit_page(self):
"""
Test URL for get_collection_icons with id 12, with limit 12 and page 3
"""
_id = 12
expected = "http://api.thenounproject.com/collection/12/icons?limit=12&page=3"
limit = 12
page = 3
result = self._test_get_collection_icons_by_id(_id,
limit=limit,
page=page)
self.assertEqual(expected, result)
def test_get_collection_icons_by_id_offset(self):
"""
Test URL for get_collection_icons with id 12, with offset 12
"""
_id = 12
expected = "http://api.thenounproject.com/collection/12/icons?offset=12"
offset = 12
result = self._test_get_collection_icons_by_id(_id, offset=offset)
self.assertEqual(expected, result)
def test_get_collection_icons_by_id_illegal_identifier(self):
"""
Test URL for get_collection_icons with illegal id 12.0
"""
_id = 12.0
with self.assertRaises(IncorrectType):
self._test_get_collection_icons_by_id(_id)
def _test_get_collection_icons_by_slug(self,
slug,
limit=None,
offset=None,
page=None):
"""
Helper function to call api's get_collection_icons_by_slug in such a way that we only get the URL
and don't actually make the request.
"""
return self.api.get_collection_icons_by_slug(slug,
limit=limit,
offset=offset,
page=page).url
def test_get_collection_icons_by_slug_legal(self):
"""
Test URL for get_collection_icons with slug "goat"
"""
slug = "goat"
expected = "http://api.thenounproject.com/collection/goat/icons"
result = self._test_get_collection_icons_by_slug(slug)
self.assertEqual(expected, result)
def test_get_collection_icons_by_slug_limit_page(self):
"""
Test URL for get_collection_icons with slug "goat", with limit 12 and page 3
"""
slug = "goat"
expected = "http://api.thenounproject.com/collection/goat/icons?limit=12&page=3"
limit = 12
page = 3
result = self._test_get_collection_icons_by_slug(slug,
limit=limit,
page=page)
self.assertEqual(expected, result)
def test_get_collection_icons_by_slug_offset(self):
"""
Test URL for get_collection_icons with slug "goat", with offset 12
"""
slug = "goat"
expected = "http://api.thenounproject.com/collection/goat/icons?offset=12"
offset = 12
result = self._test_get_collection_icons_by_slug(slug, offset=offset)
self.assertEqual(expected, result)
def test_get_collection_icons_by_slug_illegal_identifier(self):
"""
Test URL for get_collection_icons with illegal slug 12
"""
slug = 12
with self.assertRaises(IncorrectType):
self._test_get_collection_icons_by_slug(slug)
class SlugAssert(unittest.TestCase):
def setUp(self):
key = "mock api key to satisfy type check in api._get_oauth()"
secret = "mock secret key to satisfy type check in api._get_oauth()"
self.api = API(key, secret, testing=True)
def _test_type(self, param, param_name, types):
"""
Helper method to call api's _type_assert
"""
self.api._type_assert(param, param_name, types)
def test_type_legal_none(self):
"""
Test to see that param as None with type(None) in types does not throw an exception
"""
goat = None
param_name = "goat"
types = (type(None), int, str)
self._test_type(goat, param_name, types)
def test_type_legal_str(self):
"""
Test to see that param as str with str in types does not throw an exception
"""
goat = "goat"
param_name = "goat"
types = (type(None), int, str)
self._test_type(goat, param_name, types)
def test_type_legal_int(self):
"""
Test to see that param as int with int in types does not throw an exception
"""
goat = 12
param_name = "goat"
types = int
self._test_type(goat, param_name, types)
def test_type_illegal_none(self):
"""
Test to see that param as None with type(None) not in types throws an exception
"""
goat = None
param_name = "goat"
types = (tuple, int, str)
with self.assertRaises(IncorrectType):
self._test_type(goat, param_name, types)
def test_type_illegal_float(self):
"""
Test to see that param as float with float not in types throws an exception
"""
goat = 12.0
param_name = "goat"
types = (int, str)
with self.assertRaises(IncorrectType):
self._test_type(goat, param_name, types)
def test_type_illegal_bytes(self):
"""
Test to see that param as bytes with bytes not in types throws an exception
"""
goat = b"goat"
param_name = "goat"
types = str
with self.assertRaises(IncorrectType):
self._test_type(goat, param_name, types)
class SlugAssert(unittest.TestCase):
def setUp(self):
key = "mock api key to satisfy type check in api._get_oauth()"
secret = "mock secret key to satisfy type check in api._get_oauth()"
self.api = API(key, secret, testing=True)
def _test_report_usage(self, icons, test=False):
"""
Helper method to call api's report_usage
"""
return self.api.report_usage(icons, test)
def _check_set(self, body, input_set):
"""
Helper method for comparing PreparedRequest body with a set of icon ids.
"""
json_data = json.loads(body.decode())
icons_str = json_data['icons']
icons_set = set(icons_str.split(","))
return icons_set == {str(item) for item in input_set}
def test_report_usage_int(self):
"""
Test URL and body for report_usage, with icons as 12
"""
icons = 12
expected_url = "http://api.thenounproject.com/notify/publish"
expected_body = b'{"icons": "12"}'
result = self._test_report_usage(icons)
self.assertEqual(result.url, expected_url)
self.assertEqual(result.body, expected_body)
def test_report_usage_str(self):
"""
Test URL and body for report_usage, with icons as "12"
"""
icons = "12"
expected_url = "http://api.thenounproject.com/notify/publish"
expected_body = b'{"icons": "12"}'
result = self._test_report_usage(icons)
self.assertEqual(result.url, expected_url)
self.assertEqual(result.body, expected_body)
def test_report_usage_set(self):
"""
Test URL and body for report_usage, with icons as {12, "4", 8, 12}
"""
icons = {12, "4", 8, 12}
expected_url = "http://api.thenounproject.com/notify/publish"
result = self._test_report_usage(icons)
self.assertEqual(result.url, expected_url)
self.assertTrue(self._check_set(result.body, icons))
def test_report_usage_list(self):
"""
Test URL and body for report_usage, with icons as ["4", 8, 12]
"""
icons = ["4", 8, 12]
expected_url = "http://api.thenounproject.com/notify/publish"
expected_body = b'{"icons": "4,8,12"}'
result = self._test_report_usage(icons)
self.assertEqual(result.url, expected_url)
self.assertEqual(result.body, expected_body)
def test_report_usage_none(self):
"""
Test URL and body for report_usage, with icons as None
"""
icons = None
with self.assertRaises(IncorrectType):
self._test_report_usage(icons)
def test_report_usage_float(self):
"""
Test URL and body for report_usage, with icons as 12.0
"""
icons = 12.0
with self.assertRaises(IncorrectType):
self._test_report_usage(icons)
def test_report_usage_int_test(self):
"""
Test URL and body for report_usage, with icons as "12", and test as True
"""
icons = "12"
expected_url = "http://api.thenounproject.com/notify/publish?test=1"
expected_body = b'{"icons": "12"}'
result = self._test_report_usage(icons, test=True)
self.assertEqual(result.url, expected_url)
self.assertEqual(result.body, expected_body)
def test_report_usage_set_test(self):
"""
Test URL and body for report_usage, with icons as {12, "4", 8, 12}, and test as True
"""
icons = {12, "4", 8, 12}
expected_url = "http://api.thenounproject.com/notify/publish?test=1"
result = self._test_report_usage(icons, test=True)
self.assertEqual(result.url, expected_url)
self.assertTrue(self._check_set(result.body, icons))
class CollectionURLs(unittest.TestCase):
def setUp(self):
key = "mock api key to satisfy type check in api._get_oauth()"
secret = "mock secret key to satisfy type check in api._get_oauth()"
self.api = API(key, secret, testing=True)
def _test_get_collection_by_id(self, _id):
"""
Helper function to call api's get_collection_by_id in such a way that we only get the URL
and don't actually make the request.
"""
return self.api.get_collection_by_id(_id).url
def test_get_collection_by_id_legal_12(self):
"""
Test URL for get_collection_by_id with id 12
"""
_id = 12
expected = "http://api.thenounproject.com/collection/12"
result = self._test_get_collection_by_id(_id)
self.assertEqual(expected, result)
def test_get_collection_by_id_illegal_id_float(self):
"""
Test URL for get_collection_by_id with id 12.0
"""
_id = 12.0
with self.assertRaises(IncorrectType):
self._test_get_collection_by_id(_id)
def test_get_collection_by_id_illegal_id_none(self):
"""
Test URL for get_collection_by_id with id None
"""
_id = None
with self.assertRaises(IncorrectType):
self._test_get_collection_by_id(_id)
def _test_get_collection_by_slug(self, slug):
"""
Helper function to call api's get_collection_by_slug in such a way that we only get the URL
and don't actually make the request.
"""
return self.api.get_collection_by_slug(slug).url
def test_get_collection_by_slug_legal_goat(self):
"""
Test URL for get_collection_by_slug with slug "goat"
"""
slug = "goat"
expected = "http://api.thenounproject.com/collection/goat"
result = self._test_get_collection_by_slug(slug)
self.assertEqual(expected, result)
def test_get_collection_by_slug_illegal_slug_float(self):
"""
Test URL for get_collection_by_slug with slug 12.0
"""
slug = 12.0
with self.assertRaises(IncorrectType):
self._test_get_collection_by_slug(slug)
def test_get_collection_by_slug_illegal_slug_none(self):
"""
Test URL for get_collection_by_slug with slug None
"""
slug = None
with self.assertRaises(IncorrectType):
self._test_get_collection_by_slug(slug)
class Endpoints(unittest.TestCase):
def setUp(self):
try:
key = os.environ["TNP_KEY"]
secret = os.environ["TNP_SECRET"]
except KeyError:
raise unittest.SkipTest(
"We skip tests sending actual requests if the key and secret are not set as environment variables."
)
self.api = API(key, secret)
self.limit = 2
self.common_attributes = {
"permalink", "id", "sponsor", "sponsor_id", "sponsor_campaign_link"
}
self.usage_attributes = {"limits", "usage"}
self.usage_time_attributes = {"daily", "hourly", "monthly"}
self.report_usage_attributes = {"licenses_consumed", "result"}
def tearDown(self):
self.api._close_session()
def test_collection_by_id(self):
"""
Check if the result has self.common_attributes as attributes.
"""
result = self.api.get_collection(12)
self.assertTrue(self.common_attributes <= set(result.json.keys()))
def test_collection_by_slug(self):
"""
Check if the result has self.common_attributes as attributes.
"""
result = self.api.get_collection("cue")
self.assertTrue(self.common_attributes <= set(result.json.keys()))
def test_collections(self):
"""
Check if the result has a list of objects with self.common_attributes as attributes.
"""
result = self.api.get_collections(limit=self.limit)
for collection in result:
self.assertTrue(
self.common_attributes <= set(collection.json.keys()))
def test_user_collections(self):
"""
Check if the result has a list of objects with self.common_attributes as attributes.
"""
result = self.api.get_user_collections(6)
for collection in result:
self.assertTrue(
self.common_attributes <= set(collection.json.keys()))
def test_user_collection(self):
result = self.api.get_user_collection(6, "truck")
self.assertTrue(self.common_attributes <= set(result.json.keys()))
def test_report_usage(self):
"""
Check if the result has self.report_usage_attributes as attributes.
"""
result = self.api.report_usage([3, 8, 12], test=True)
self.assertTrue(
self.report_usage_attributes <= set(result.json.keys()))
def test_collection_icons_by_id(self):
"""
Check if the result.collection has self.common_attributes as attributes.
Also ensure that the each icon under result has self.common_attributes as attributes.
Lastly check that result has generated_at as attribute.
"""
result = self.api.get_collection_icons(12, limit=self.limit)
self.assertTrue(hasattr(result, "generated_at"))
self.assertTrue(
self.common_attributes <= set(result.collection.keys()))
for icon in result:
self.assertTrue(self.common_attributes <= set(icon.json.keys()))
def test_collection_icons_by_slug(self):
"""
Check if the result.collection has self.common_attributes as attributes.
Also ensure that the each icon under result has self.common_attributes as attributes.
Lastly check that result has generated_at as attribute.
"""
result = self.api.get_collection_icons("cue", limit=self.limit)
self.assertTrue(hasattr(result, "generated_at"))
self.assertTrue(
self.common_attributes <= set(result.collection.keys()))
for icon in result:
self.assertTrue(self.common_attributes <= set(icon.json.keys()))
def test_icon_by_id(self):
"""
Check if the result has self.common_attributes as attributes.
Also ensure that the result.collection list has self.common_attributes as attributes for all of its elements.
"""
result = self.api.get_icon(12)
self.assertTrue(self.common_attributes <= set(result.json.keys()))
for collection in result.collections:
self.assertTrue(self.common_attributes <= set(
CollectionModel.parse(collection).json.keys()))
def test_icon_by_term(self):
"""
Check if the result has self.common_attributes as attributes.
Also ensure that the result.collection list has self.common_attributes as attributes for all of its elements.
"""
result = self.api.get_icon("baggage")
self.assertTrue(self.common_attributes <= set(result.json.keys()))
for collection in result.collections:
self.assertTrue(self.common_attributes <= set(
CollectionModel.parse(collection).json.keys()))
def test_recent_icons(self):
"""
Check if each icon under result has self.common_attributes as attributes.
Also ensure that result has generated_at as attribute.
"""
result = self.api.get_recent_icons(limit=self.limit)
self.assertTrue(hasattr(result, "generated_at"))
for icon in result:
self.assertTrue(self.common_attributes <= set(icon.json.keys()))
def test_icons_by_term(self):
"""
Check if each icon under result has self.common_attributes as attributes.
Also ensure that result has generated_at as attribute.
"""
result = self.api.get_icons_by_term("goat", limit=self.limit)
self.assertTrue(hasattr(result, "generated_at"))
for icon in result:
self.assertTrue(self.common_attributes <= set(icon.json.keys()))
def test_user_uploads(self):
"""
Check if each icon under result has self.common_attributes as attributes.
Also ensure that result has generated_at as attribute.
"""
result = self.api.get_user_uploads("dan", limit=self.limit)
self.assertTrue(hasattr(result, "generated_at"))
for icon in result:
self.assertTrue(self.common_attributes <= set(icon.json.keys()))
def test_usage(self):
"""
Check if the result has self.usage_attributes as attributes.
Also check if result.limits
"""
result = self.api.get_usage()
self.assertTrue(set(result.json.keys()) == self.usage_attributes)
self.assertTrue(
set(result.json.limits.keys()) == self.usage_time_attributes)
self.assertTrue(
set(result.json.usage.keys()) == self.usage_time_attributes)
def test_invalid_icon(self):
"""
Check if getting an icon with an invalid id produces the correct NotFound exception.
"""
invalid_id = int(1e15)
with self.assertRaises(NotFound):
self.api.get_icon(invalid_id)
class SlugAssert(unittest.TestCase):
def setUp(self):
key = "mock api key to satisfy type check in api._get_oauth()"
secret = "mock secret key to satisfy type check in api._get_oauth()"
self.api = API(key, secret, testing=True)
def _test_lop(self, limit=None, offset=None, page=None):
"""
Helper method to call api's _lop_assert
"""
self.api._lop_assert(limit, offset, page)
def test_lop_limit_none(self):
"""
Test to see that limit as None does not throw an exception
"""
limit = None
self._test_lop(limit=limit)
def test_lop_limit_int(self):
"""
Test to see that limit as 12 does not throw an exception
"""
limit = 12
self._test_lop(limit=limit)
def test_lop_limit_illegal(self):
"""
Test to see that limit as "goat" throws an exception
"""
limit = "goat"
with self.assertRaises(IncorrectType):
self._test_lop(limit=limit)
def test_lop_offset_none(self):
"""
Test to see that offset as None does not throw an exception
"""
offset = None
self._test_lop(offset=offset)
def test_lop_offset_int(self):
"""
Test to see that offset as 12 does not throw an exception
"""
offset = 12
self._test_lop(offset=offset)
def test_lop_offset_illegal(self):
"""
Test to see that offset as "goat" throws an exception
"""
offset = "goat"
with self.assertRaises(IncorrectType):
self._test_lop(offset=offset)
def test_lop_page_none(self):
"""
Test to see that page as None does not throw an exception
"""
page = None
self._test_lop(page=page)
def test_lop_page_int(self):
"""
Test to see that page as 12 does not throw an exception
"""
page = 12
self._test_lop(page=page)
def test_lop_page_illegal(self):
"""
Test to see that page as "goat" throws an exception
"""
page = "goat"
with self.assertRaises(IncorrectType):
self._test_lop(page=page)