tests.TestWallhavenApiV1.test_search_resolutions() - Code Metrics - Inspection of "feat,fix: New methods, search parameter, "download..." - Goblenus/WallhavenApi - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 226fe6...caa6b4 )

by Anton

created 2019-11-03 19:10 UTC

tests.TestWallhavenApiV1.test_search_resolutions() A

↳ Parent: tests

Complexity

Conditions

Size

Total Lines	6
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	6
nop	1
dl	0
loc	6
rs	10
c	0
b	0
f	0

import unittest
from wallhavenapi import WallhavenApiV1, Category, Purity, Sorting, Order, TopRange, Color, Type, RequestsLimitError
import os
import datetime
import time


def request_limit_decorator(test_method):
    def wrapper(self, *args, **kwargs):
        for _ in range(5):
            try:
                result = test_method(self, *args, **kwargs)
                break
            except RequestsLimitError:
                time.sleep(10)
                
        return result

    return wrapper


class TestWallhavenApiV1(unittest.TestCase):
    @classmethod
    def setUpClass(self):
        self.wallhaven_api = WallhavenApiV1(api_key=os.getenv('APIKEY', None), verify_connection=False, 
                                            base_url="http://wallhaven.cc/api/v1")
    
    def test_search(self):
        search_data = self.wallhaven_api.search()

        self.assertIn("data", search_data)
        self.assertIn("meta", search_data)

    @request_limit_decorator
    def test_search_categories(self):
        for category in list(Category):
            search_data = self.wallhaven_api.search(categories=category)

            for wallpaper_data in search_data["data"]:
                self.assertEqual(category.value, wallpaper_data["category"])

    @request_limit_decorator
    def test_search_purities(self):
        for purity in list(Purity):
            search_data = self.wallhaven_api.search(purities=purity)

            for wallpaper_data in search_data["data"]:
                self.assertEqual(purity.value, wallpaper_data["purity"])

    @request_limit_decorator
    def test_search_sorting(self):
        for sorting_method in list(Sorting):
            search_data = self.wallhaven_api.search(sorting=sorting_method)
            self.assertIn("data", search_data)

    def search_sorting_dated_added(self, order):
        def parse_datetime(datetime_string):
            # Format: 2018-10-31 01:23:10.000000
            return datetime.datetime.strptime(datetime_string, "%Y-%m-%d %H:%M:%S")
        
        search_data = self.wallhaven_api.search(sorting=Sorting.date_added, order=order)
        for i in range(len(search_data["data"]) - 1):
            datetime_1 = parse_datetime(search_data["data"][i]["created_at"])
            datetime_2 = parse_datetime(search_data["data"][i + 1]["created_at"])
            self.assertGreaterEqual(datetime_1, datetime_2) \
            if order == Order.desc else self.assertLessEqual(datetime_1, datetime_2)

    @request_limit_decorator
    def test_search_sorting_dated_added_asc(self):
        self.search_sorting_dated_added(Order.asc)

    @request_limit_decorator
    def test_search_sorting_dated_added_desc(self):
        self.search_sorting_dated_added(Order.desc)

    @request_limit_decorator
    def search_sorting_views(self, order):
        search_data = self.wallhaven_api.search(sorting=Sorting.views, order=order)
        for i in range(len(search_data["data"]) - 1):
            views_1 = int(search_data["data"][i]["views"])
            views_2 = int(search_data["data"][i + 1]["views"])
            self.assertGreaterEqual(views_1, views_2) \
            if order == Order.desc else self.assertLessEqual(views_1, views_2)

    @request_limit_decorator
    @unittest.skip("May content unsorted results. Need help")
    def test_search_sorting_views_asc(self):
        self.search_sorting_views(Order.asc)

    @request_limit_decorator
    @unittest.skip("May content unsorted results. Need help")
    def test_search_sorting_views_desc(self):
        self.search_sorting_views(Order.desc)

    def search_sorting_favorites(self, order):
        search_data = self.wallhaven_api.search(sorting=Sorting.favorites, order=order)
        for i in range(len(search_data["data"]) - 1):
            favorites_1 = int(search_data["data"][i]["favorites"])
            favorites_2 = int(search_data["data"][i + 1]["favorites"])
            self.assertGreaterEqual(favorites_1, favorites_2) \
            if order == Order.desc else self.assertLessEqual(favorites_1, favorites_2)

    @request_limit_decorator
    @unittest.skip("May content unsorted results. Need help")
    def test_search_sorting_favorites_asc(self):
        self.search_sorting_favorites(Order.asc)

    @request_limit_decorator
    @unittest.skip("May content unsorted results. Need help")
    def test_search_sorting_favorites_desc(self):
        self.search_sorting_favorites(Order.desc)

    @request_limit_decorator
    @unittest.skip("May content unsorted results. Need help")
    def test_search_top_range(self):
        for top_range in list(TopRange):
            search_data = self.wallhaven_api.search(top_range=top_range, sorting=Sorting.toplist)
            self.assertIn("data", search_data)

            if str(top_range.value[-1]).endswith("d"):
                timedelta = datetime.timedelta(days=int(top_range.value[:-1]))
            elif str(top_range.value[-1]).endswith("w"):
                timedelta = datetime.timedelta(days=(int(top_range.value[:-1]) * 7))
            elif str(top_range.value[-1]).endswith("M"):
                timedelta = datetime.timedelta(days=(int(top_range.value[:-1]) * 30))
            else:
                timedelta = datetime.timedelta(days=(int(top_range.value[:-1]) * 365))

            for wallpaper in search_data["data"]:
                created_at = datetime.datetime.strptime(wallpaper["created_at"], "%Y-%m-%d %H:%M:%S")

                self.assertGreaterEqual(created_at, datetime.datetime.now() - timedelta)
    
    @request_limit_decorator
    def test_search_atleast(self):
        search_data = self.wallhaven_api.search(atleast=(1920, 1080))
        for wallpaper in search_data["data"]:
            self.assertGreaterEqual(int(wallpaper["dimension_x"]), 1920)
            self.assertGreaterEqual(int(wallpaper["dimension_y"]), 1080)

    @request_limit_decorator
    def test_search_resolutions(self):
        search_data = self.wallhaven_api.search(resolutions=(1920, 1080))
        for wallpaper in search_data["data"]:
            self.assertEqual(int(wallpaper["dimension_x"]), 1920)
            self.assertEqual(int(wallpaper["dimension_y"]), 1080)

    @request_limit_decorator
    def test_search_ratios(self):
        search_data = self.wallhaven_api.search(ratios=(16, 10))
        for wallpaper in search_data["data"]:
            self.assertEqual(float(wallpaper["ratio"]), 1.6)

    @request_limit_decorator
    def test_search_colors(self):
        for color in list(Color):
            search_data = self.wallhaven_api.search(colors=color)
            for wallpaper in search_data["data"]:
                self.assertIn("colors", wallpaper)
                self.assertIn("#{}".format(color.value), wallpaper["colors"])

    @request_limit_decorator
    def test_search_page(self):
        search_data = self.wallhaven_api.search()

        self.assertIn("last_page", search_data["meta"])

        if int(search_data["meta"]["last_page"]) > 1:
            search_data = self.wallhaven_api.search(page=2)

            self.assertIn("data", search_data)
            self.assertIn("meta", search_data)
            self.assertIn("current_page", search_data["meta"])
            self.assertEqual(2, int(search_data["meta"]["current_page"]))

    @request_limit_decorator
    def test_wallpaper(self):
        search_data = self.wallhaven_api.search()

        if not len(search_data["data"]):
            return

        for wallpaper_temp in search_data["data"]:
            self.assertIn("id", wallpaper_temp)

        wallpaper = self.wallhaven_api.wallpaper(search_data["data"][0]["id"])
        self.assertIn("data", wallpaper)

    @request_limit_decorator
    def test_tag(self):
        search_data = self.wallhaven_api.search()

        for wallpaper_temp in search_data["data"]:
            self.assertIn("id", wallpaper_temp)
            wallpaper = self.wallhaven_api.wallpaper(wallpaper_temp["id"])
            self.assertIn("data", wallpaper)
            self.assertIn("tags", wallpaper["data"])

            if not len(wallpaper["data"]["tags"]):
                continue

            for tag_temp in wallpaper["data"]["tags"]:
                self.assertIn("id", tag_temp)
        
            tag = self.wallhaven_api.tag(wallpaper["data"]["tags"][0]['id'])
            
            self.assertIn("data", tag)
            
            break
    
    @request_limit_decorator
    def test_search_query_uploader(self):
        search_data = self.wallhaven_api.search()

        self.assertIn("data", search_data)

        if not len(search_data["data"]):
            return None

        wallpaper = self.wallhaven_api.wallpaper(search_data["data"][0]["id"])

        self.assertIn("data", wallpaper)
        self.assertIn("uploader", wallpaper["data"])
        self.assertIn("username", wallpaper["data"]["uploader"])
        
        search_data = self.wallhaven_api.search(q="@{}".format(wallpaper["data"]["uploader"]["username"]))

        self.assertIn("data", search_data)

        self.assertGreater(len(search_data["data"]), 0)

    @request_limit_decorator
    def test_search_query_id(self):
        search_data = self.wallhaven_api.search()

        for wallpaper_temp in search_data["data"]:
            self.assertIn("id", wallpaper_temp)
            wallpaper = self.wallhaven_api.wallpaper(wallpaper_temp["id"])
            self.assertIn("data", wallpaper)
            self.assertIn("tags", wallpaper["data"])

            if not len(wallpaper["data"]["tags"]):
                continue

            for tag_temp in wallpaper["data"]["tags"]:
                self.assertIn("id", tag_temp)

            search_data = self.wallhaven_api.search(q="id:{}".format(wallpaper["data"]["tags"][0]['id']))
            
            self.assertIn("data", search_data)
            self.assertGreater(len(search_data["data"]), 0)
            break

    @request_limit_decorator
    def test_search_query_like(self):
        search_data = self.wallhaven_api.search()

        if not len(search_data):
            return

        search_data = self.wallhaven_api.search(q="like:{}".format(search_data["data"][0]['id']))
            
        self.assertIn("data", search_data)
        self.assertIn("meta", search_data)

    @request_limit_decorator
    def test_search_query_type(self):
        for image_type in Type:
            search_data = self.wallhaven_api.search(q="type:{}".format(image_type.value))
            
            self.assertIn("data", search_data)
            self.assertIn("meta", search_data)

            for wallpaper in search_data["data"]:
                self.assertIn("file_type", wallpaper)
                if image_type in [Type.jpeg, Type.jpg]:
                    self.assertTrue(str(wallpaper["file_type"]).endswith(Type.jpeg.value) \
                                    or str(wallpaper["file_type"]).endswith(Type.jpg.value))
                else:
                    self.assertTrue(str(wallpaper["file_type"]).endswith(image_type.value))
    
    @request_limit_decorator
    def test_settings(self):
        result = self.wallhaven_api.settings()

        assert result is None if self.wallhaven_api.api_key is None else result is not None

    @request_limit_decorator
    def test_collections(self):
                                                # Just a random user, who has a collection with wallpapers
        result = self.wallhaven_api.collections("ThorRagnarok")

        assert "data" in result
        assert len(result["data"])
        assert "id" in result["data"][0]

        return result

    @request_limit_decorator
    def test_collection_wallpapers(self, page=None):
        collections = self.test_collections()

        collections_wallpapers = self.wallhaven_api.collection_wallpapers("ThorRagnarok", 
            collections["data"][0]["id"], page=page)

        assert "data" in collections_wallpapers
        assert "meta" in collections_wallpapers
        assert len(collections_wallpapers["data"])

    @request_limit_decorator
    def test_collection_wallpapers_page(self):
        self.test_collection_wallpapers(2)

    @request_limit_decorator
    def test_my_collections(self):
        result = self.wallhaven_api.my_collections()

        assert "data" in result


if __name__ == '__main__':
    unittest.main()

1			import unittest
2			from wallhavenapi import WallhavenApiV1, Category, Purity, Sorting, Order, TopRange, Color, Type, RequestsLimitError
3			import os
4			import datetime
5			import time
6
7
8			def request_limit_decorator(test_method):
9			def wrapper(self, args, *kwargs):
10			for _ in range(5):
11			try:
12			result = test_method(self, args, *kwargs)
13			break
14			except RequestsLimitError:
15			time.sleep(10)
16
17			return result
			0 ignored issues – show introduced 2019-11-03 19:13 UTC by Report Bug Copy Issue Report The variable `result` does not seem to be defined in case the `for` loop on line `10` is not entered. Are you sure this can never be the case? Loading history...
18			return wrapper
19
20
21			class TestWallhavenApiV1(unittest.TestCase):
22			@classmethod
23			def setUpClass(self):
24			self.wallhaven_api = WallhavenApiV1(api_key=os.getenv('APIKEY', None), verify_connection=False,
25			base_url="http://wallhaven.cc/api/v1")
26
27			def test_search(self):
28			search_data = self.wallhaven_api.search()
29
30			self.assertIn("data", search_data)
31			self.assertIn("meta", search_data)
32
33			@request_limit_decorator
34			def test_search_categories(self):
35			for category in list(Category):
36			search_data = self.wallhaven_api.search(categories=category)
37
38			for wallpaper_data in search_data["data"]:
39			self.assertEqual(category.value, wallpaper_data["category"])
40
41			@request_limit_decorator
42			def test_search_purities(self):
43			for purity in list(Purity):
44			search_data = self.wallhaven_api.search(purities=purity)
45
46			for wallpaper_data in search_data["data"]:
47			self.assertEqual(purity.value, wallpaper_data["purity"])
48
49			@request_limit_decorator
50			def test_search_sorting(self):
51			for sorting_method in list(Sorting):
52			search_data = self.wallhaven_api.search(sorting=sorting_method)
53			self.assertIn("data", search_data)
54
55			def search_sorting_dated_added(self, order):
56			def parse_datetime(datetime_string):
57			# Format: 2018-10-31 01:23:10.000000
58			return datetime.datetime.strptime(datetime_string, "%Y-%m-%d %H:%M:%S")
59
60			search_data = self.wallhaven_api.search(sorting=Sorting.date_added, order=order)
61			for i in range(len(search_data["data"]) - 1):
62			datetime_1 = parse_datetime(search_data["data"][i]["created_at"])
63			datetime_2 = parse_datetime(search_data["data"][i + 1]["created_at"])
64			self.assertGreaterEqual(datetime_1, datetime_2) \
65			if order == Order.desc else self.assertLessEqual(datetime_1, datetime_2)
66
67			@request_limit_decorator
68			def test_search_sorting_dated_added_asc(self):
69			self.search_sorting_dated_added(Order.asc)
70
71			@request_limit_decorator
72			def test_search_sorting_dated_added_desc(self):
73			self.search_sorting_dated_added(Order.desc)
74
75			@request_limit_decorator
76			def search_sorting_views(self, order):
77			search_data = self.wallhaven_api.search(sorting=Sorting.views, order=order)
78			for i in range(len(search_data["data"]) - 1):
79			views_1 = int(search_data["data"][i]["views"])
80			views_2 = int(search_data["data"][i + 1]["views"])
81			self.assertGreaterEqual(views_1, views_2) \
82			if order == Order.desc else self.assertLessEqual(views_1, views_2)
83
84			@request_limit_decorator
85			@unittest.skip("May content unsorted results. Need help")
86			def test_search_sorting_views_asc(self):
87			self.search_sorting_views(Order.asc)
88
89			@request_limit_decorator
90			@unittest.skip("May content unsorted results. Need help")
91			def test_search_sorting_views_desc(self):
92			self.search_sorting_views(Order.desc)
93
94			def search_sorting_favorites(self, order):
95			search_data = self.wallhaven_api.search(sorting=Sorting.favorites, order=order)
96			for i in range(len(search_data["data"]) - 1):
97			favorites_1 = int(search_data["data"][i]["favorites"])
98			favorites_2 = int(search_data["data"][i + 1]["favorites"])
99			self.assertGreaterEqual(favorites_1, favorites_2) \
100			if order == Order.desc else self.assertLessEqual(favorites_1, favorites_2)
101
102			@request_limit_decorator
103			@unittest.skip("May content unsorted results. Need help")
104			def test_search_sorting_favorites_asc(self):
105			self.search_sorting_favorites(Order.asc)
106
107			@request_limit_decorator
108			@unittest.skip("May content unsorted results. Need help")
109			def test_search_sorting_favorites_desc(self):
110			self.search_sorting_favorites(Order.desc)
111
112			@request_limit_decorator
113			@unittest.skip("May content unsorted results. Need help")
114			def test_search_top_range(self):
115			for top_range in list(TopRange):
116			search_data = self.wallhaven_api.search(top_range=top_range, sorting=Sorting.toplist)
117			self.assertIn("data", search_data)
118
119			if str(top_range.value[-1]).endswith("d"):
120			timedelta = datetime.timedelta(days=int(top_range.value[:-1]))
121			elif str(top_range.value[-1]).endswith("w"):
122			timedelta = datetime.timedelta(days=(int(top_range.value[:-1]) * 7))
123			elif str(top_range.value[-1]).endswith("M"):
124			timedelta = datetime.timedelta(days=(int(top_range.value[:-1]) * 30))
125			else:
126			timedelta = datetime.timedelta(days=(int(top_range.value[:-1]) * 365))
127
128			for wallpaper in search_data["data"]:
129			created_at = datetime.datetime.strptime(wallpaper["created_at"], "%Y-%m-%d %H:%M:%S")
130
131			self.assertGreaterEqual(created_at, datetime.datetime.now() - timedelta)
132
133			@request_limit_decorator
134			def test_search_atleast(self):
135			search_data = self.wallhaven_api.search(atleast=(1920, 1080))
136			for wallpaper in search_data["data"]:
137			self.assertGreaterEqual(int(wallpaper["dimension_x"]), 1920)
138			self.assertGreaterEqual(int(wallpaper["dimension_y"]), 1080)
139
140			@request_limit_decorator
141			def test_search_resolutions(self):
142			search_data = self.wallhaven_api.search(resolutions=(1920, 1080))
143			for wallpaper in search_data["data"]:
144			self.assertEqual(int(wallpaper["dimension_x"]), 1920)
145			self.assertEqual(int(wallpaper["dimension_y"]), 1080)
146
147			@request_limit_decorator
148			def test_search_ratios(self):
149			search_data = self.wallhaven_api.search(ratios=(16, 10))
150			for wallpaper in search_data["data"]:
151			self.assertEqual(float(wallpaper["ratio"]), 1.6)
152
153			@request_limit_decorator
154			def test_search_colors(self):
155			for color in list(Color):
156			search_data = self.wallhaven_api.search(colors=color)
157			for wallpaper in search_data["data"]:
158			self.assertIn("colors", wallpaper)
159			self.assertIn("#{}".format(color.value), wallpaper["colors"])
160
161			@request_limit_decorator
162			def test_search_page(self):
163			search_data = self.wallhaven_api.search()
164
165			self.assertIn("last_page", search_data["meta"])
166
167			if int(search_data["meta"]["last_page"]) > 1:
168			search_data = self.wallhaven_api.search(page=2)
169
170			self.assertIn("data", search_data)
171			self.assertIn("meta", search_data)
172			self.assertIn("current_page", search_data["meta"])
173			self.assertEqual(2, int(search_data["meta"]["current_page"]))
174
175			@request_limit_decorator
176			def test_wallpaper(self):
177			search_data = self.wallhaven_api.search()
178
179			if not len(search_data["data"]):
180			return
181
182			for wallpaper_temp in search_data["data"]:
183			self.assertIn("id", wallpaper_temp)
184
185			wallpaper = self.wallhaven_api.wallpaper(search_data["data"][0]["id"])
186			self.assertIn("data", wallpaper)
187
188			@request_limit_decorator
189			def test_tag(self):
190			search_data = self.wallhaven_api.search()
191
192			for wallpaper_temp in search_data["data"]:
193			self.assertIn("id", wallpaper_temp)
194			wallpaper = self.wallhaven_api.wallpaper(wallpaper_temp["id"])
195			self.assertIn("data", wallpaper)
196			self.assertIn("tags", wallpaper["data"])
197
198			if not len(wallpaper["data"]["tags"]):
199			continue
200
201			for tag_temp in wallpaper["data"]["tags"]:
202			self.assertIn("id", tag_temp)
203
204			tag = self.wallhaven_api.tag(wallpaper["data"]["tags"][0]['id'])
205
206			self.assertIn("data", tag)
207
208			break
209
210			@request_limit_decorator
211			def test_search_query_uploader(self):
212			search_data = self.wallhaven_api.search()
213
214			self.assertIn("data", search_data)
215
216			if not len(search_data["data"]):
217			return None
218
219			wallpaper = self.wallhaven_api.wallpaper(search_data["data"][0]["id"])
220
221			self.assertIn("data", wallpaper)
222			self.assertIn("uploader", wallpaper["data"])
223			self.assertIn("username", wallpaper["data"]["uploader"])
224
225			search_data = self.wallhaven_api.search(q="@{}".format(wallpaper["data"]["uploader"]["username"]))
226
227			self.assertIn("data", search_data)
228
229			self.assertGreater(len(search_data["data"]), 0)
230
231			@request_limit_decorator
232			def test_search_query_id(self):
233			search_data = self.wallhaven_api.search()
234
235			for wallpaper_temp in search_data["data"]:
236			self.assertIn("id", wallpaper_temp)
237			wallpaper = self.wallhaven_api.wallpaper(wallpaper_temp["id"])
238			self.assertIn("data", wallpaper)
239			self.assertIn("tags", wallpaper["data"])
240
241			if not len(wallpaper["data"]["tags"]):
242			continue
243
244			for tag_temp in wallpaper["data"]["tags"]:
245			self.assertIn("id", tag_temp)
246
247			search_data = self.wallhaven_api.search(q="id:{}".format(wallpaper["data"]["tags"][0]['id']))
248
249			self.assertIn("data", search_data)
250			self.assertGreater(len(search_data["data"]), 0)
251			break
252
253			@request_limit_decorator
254			def test_search_query_like(self):
255			search_data = self.wallhaven_api.search()
256
257			if not len(search_data):
258			return
259
260			search_data = self.wallhaven_api.search(q="like:{}".format(search_data["data"][0]['id']))
261
262			self.assertIn("data", search_data)
263			self.assertIn("meta", search_data)
264
265			@request_limit_decorator
266			def test_search_query_type(self):
267			for image_type in Type:
268			search_data = self.wallhaven_api.search(q="type:{}".format(image_type.value))
269
270			self.assertIn("data", search_data)
271			self.assertIn("meta", search_data)
272
273			for wallpaper in search_data["data"]:
274			self.assertIn("file_type", wallpaper)
275			if image_type in [Type.jpeg, Type.jpg]:
276			self.assertTrue(str(wallpaper["file_type"]).endswith(Type.jpeg.value) \
277			or str(wallpaper["file_type"]).endswith(Type.jpg.value))
278			else:
279			self.assertTrue(str(wallpaper["file_type"]).endswith(image_type.value))
280
281			@request_limit_decorator
282			def test_settings(self):
283			result = self.wallhaven_api.settings()
284
285			assert result is None if self.wallhaven_api.api_key is None else result is not None
286
287			@request_limit_decorator
288			def test_collections(self):
289			# Just a random user, who has a collection with wallpapers
290			result = self.wallhaven_api.collections("ThorRagnarok")
291
292			assert "data" in result
293			assert len(result["data"])
294			assert "id" in result["data"][0]
295
296			return result
297
298			@request_limit_decorator
299			def test_collection_wallpapers(self, page=None):
300			collections = self.test_collections()
301
302			collections_wallpapers = self.wallhaven_api.collection_wallpapers("ThorRagnarok",
303			collections["data"][0]["id"], page=page)
304
305			assert "data" in collections_wallpapers
306			assert "meta" in collections_wallpapers
307			assert len(collections_wallpapers["data"])
308
309			@request_limit_decorator
310			def test_collection_wallpapers_page(self):
311			self.test_collection_wallpapers(2)
312
313			@request_limit_decorator
314			def test_my_collections(self):
315			result = self.wallhaven_api.my_collections()
316
317			assert "data" in result
318
319
320			if __name__ == '__main__':
321			unittest.main()

Goblenus / WallhavenApi

GitHub Access Token became invalid

Push — master ( 226fe6...caa6b4 )

tests.TestWallhavenApiV1.test_search_resolutions() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like