tests.TestWallhavenApiV1.test_search_sorting() - Code Metrics - Goblenus/WallhavenApi - Measure and Improve Code Quality continuously with Scrutinizer

tests.TestWallhavenApiV1.test_search_sorting() A
last analyzed 2020-02-29 18:37 UTC

↳ Parent: tests

Complexity

Conditions

Size

Total Lines	4
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	4
nop	1
dl	0
loc	4
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


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", 
                                            requestslimit_timeout=(15, 5))
    
    def test_search(self):
        search_data = self.wallhaven_api.search()

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

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

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

    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)

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

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

    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)

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

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

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

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

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

    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)

    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)

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

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

    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)

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

    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

    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)

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

    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

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

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

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

Goblenus / WallhavenApi

GitHub Access Token became invalid

tests.TestWallhavenApiV1.test_search_sorting() A last analyzed 2020-02-29 18:37 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

tests.TestWallhavenApiV1.test_search_sorting() A
last analyzed 2020-02-29 18:37 UTC