Refactoring

Author: ikostan

kyu_5/alphabet_wars_nuclear_strike/test_alphabet_war.py

@@ -96,7 +96,7 @@ def test_alphabet_war(self, battlefield, expected):
             '<h3>Test Description:</h3>'
             "<p>Test a function that accepts battlefield string and "
             "returns letters that survived the nuclear strike.</p>")
-
+        # pylint: enable-msg=R0801
         result: str = alphabet_war(battlefield)
         with allure.step(f"Enter test string ({battlefield}) "
                          f"and verify the output ({result}) "

kyu_5/count_ip_addresses/test_ips_between.py

@@ -71,7 +71,6 @@ def test_ips_between(self, start, end, expected):
             "of strings. The last address will always be greater "
             "than the first one.</p>")
         # pylint: enable-msg=R0801
-
         result = ips_between(start, end)
         with allure.step(f"Enter test data (start: {start}, "
                          f"end: {end}) and verify "

kyu_5/diophantine_equation/test_solution.py

@@ -50,9 +50,10 @@ def test_solution_basic(self, num, expected):
         (9001, [[4501, 2250]]),
         (9004, [[2252, 1125]]),
         (9008, [[1128, 562]]),
-        (9009, [[4505, 2252], [1503, 750], [647, 320], [505, 248],
-                [415, 202], [353, 170], [225, 102], [153, 60],
-                [135, 48], [103, 20], [97, 10], [95, 2]])])
+        (9009, [[4505, 2252], [1503, 750], [647, 320],
+                [505, 248], [415, 202], [353, 170],
+                [225, 102], [153, 60], [135, 48],
+                [103, 20], [97, 10], [95, 2]])])
     def test_solution_medium(self, num, expected):
         """
         Testing using medium test data.
@@ -62,14 +63,20 @@ def test_solution_medium(self, num, expected):
         self.assertEqual(num, expected)
 
     @parameterized.expand([
-        (900000, [[112502, 56249], [56254, 28123], [37506, 18747],
-                  [22510, 11245], [18762, 9369], [12518, 6241],
-                  [11270, 5615], [7530, 3735], [6286, 3107], [4550, 2225],
-                  [3810, 1845], [2590, 1205], [2350, 1075], [1650, 675],
-                  [1430, 535], [1150, 325], [1050, 225], [950, 25]]),
+        (900000, [[112502, 56249], [56254, 28123],
+                  [37506, 18747], [22510, 11245],
+                  [18762, 9369], [12518, 6241],
+                  [11270, 5615], [7530, 3735],
+                  [6286, 3107], [4550, 2225],
+                  [3810, 1845], [2590, 1205],
+                  [2350, 1075], [1650, 675],
+                  [1430, 535], [1150, 325],
+                  [1050, 225], [950, 25]]),
         (90004, [[22502, 11250]]),
-        (90005, [[45003, 22501], [9003, 4499], [981, 467], [309, 37]]),
-        (90009, [[45005, 22502], [15003, 7500], [5005, 2498],
+        (90005, [[45003, 22501], [9003, 4499],
+                 [981, 467], [309, 37]]),
+        (90009, [[45005, 22502], [15003, 7500],
+                 [5005, 2498],
                  [653, 290], [397, 130], [315, 48]])])
     def test_solution_big(self, num, expected):
         """

kyu_5/directions_reduction/test_directions_reduction.py

@@ -46,8 +46,7 @@ class DirectionsReductionTestCase(unittest.TestCase):
           'WEST', 'NORTH', 'WEST', 'SOUTH', 'SOUTH']),
         (['WEST', 'NORTH', 'EAST', 'EAST', 'EAST', 'EAST', 'WEST', 'WEST',
           'WEST', 'WEST', 'NORTH', 'NORTH', 'SOUTH', 'EAST'],
-         ['WEST', 'NORTH', 'NORTH', 'EAST'])
-    ])
+         ['WEST', 'NORTH', 'NORTH', 'EAST'])])
     def test_directions_reduction(self, test_array, expected):
         """
         dir_reduc function test suite.
@@ -78,7 +77,6 @@ def test_directions_reduction(self, test_array, expected):
             "strings and returns an array of strings with the needless "
             "directions removed (W<->E or S<->N side by side).</p>")
         # pylint: enable-msg=R0801
-
         result = dir_reduc(test_array)
         with allure.step(f"Enter test data ({test_array}) "
                          f"and verify the output ({result}) "

kyu_5/extract_the_domain_name_from_url/test_domain_name.py

@@ -10,6 +10,7 @@
 # DECLARATIVE PROGRAMMING ADVANCED LANGUAGE FEATURES
 
 import unittest
+from parameterized import parameterized
 import allure
 from utils.log_func import print_log
 from kyu_5.extract_the_domain_name_from_url.extract_domain_from_url \
@@ -37,7 +38,12 @@
 class DomainNameTestCase(unittest.TestCase):
     """Testing domain_name function."""
 
-    def test_domain_name(self):
+    @parameterized.expand([
+        ("http://google.com", "google"),
+        ("http://google.co.jp", "google"),
+        ("www.xakep.ru", "xakep"),
+        ("https://youtube.com", "youtube")])
+    def test_domain_name(self, url, expected):
         """
         domain_name function testing.
 
@@ -56,14 +62,7 @@ def test_domain_name(self):
             "<p>Assert that 'domain_name' function "
             "returns domain name from given URL string.</p>")
         # pylint: enable-msg=R0801
-        test_data: tuple = (
-            ("http://google.com", "google"),
-            ("http://google.co.jp", "google"),
-            ("www.xakep.ru", "xakep"),
-            ("https://youtube.com", "youtube"))
-
-        for url, expected in test_data:
-            with allure.step("Enter test string and verify the output"):
-                actual = domain_name(url)
-                print_log(url=url, expected=expected, actual=actual)
-                self.assertEqual(expected, actual)
+        with allure.step("Enter test string and verify the output"):
+            actual = domain_name(url)
+            print_log(url=url, expected=expected, actual=actual)
+            self.assertEqual(expected, actual)

kyu_5/find_the_safest_places_in_town/test_advice.py

@@ -70,8 +70,7 @@ def test_create_city_map(self, n, expected):
           (2, 30), (58, 40), (60, 36), (2, 67), (16, 58), (53, 13),
           (36, 38), (29, 54), (50, 15), (14, 28),
           (23, 30), (0, 64), (58, 57), (38, 2), (28, 40), (22, 6),
-          (12, 46), (50, 35), (56, 27)}, 10, set())
-    ])
+          (12, 46), (50, 35), (56, 27)}, 10, set())])
     def test_agents_cleanup(self, agents, n, expected):
         """
         Testing a function named agents_cleanup.

kyu_5/find_the_smallest/test_smallest.py

@@ -64,9 +64,8 @@ def test_smallest(self, n, expected):
             '<h3>Test Description:</h3>'
             "<p></p>")
         # pylint: enable-msg=R0801
-
-        with allure.step(f"Enter test data: {n} "
-                         f"and verify the output vs expected: {expected}."):
+        with allure.step(f"Enter test data: {n} \
+                         and verify the output vs expected: {expected}."):
             result = smallest(n)
             print_log(n=n, expected=expected, result=result)
             self.assertListEqual(expected, result)

kyu_5/first_non_repeating_character/test_first_non_repeating_letter.py

@@ -74,7 +74,7 @@ def test_first_non_repeating_letter(self, string, expected):
             '<h3>Test Description:</h3>'
             "<p></p>")
         # pylint: enable-msg=R0801
-        with allure.step(f"Enter test string: {string} "
-                         f"and verify the output: {expected}"):
+        with allure.step(f"Enter test string: {string} \
+                         and verify the output: {expected}"):
             print_log(string=string, expected=expected)
             self.assertEqual(expected, first_non_repeating_letter(string))

kyu_5/human_readable_time/test_make_readable.py

@@ -64,7 +64,7 @@ def test_make_readable(self, seconds, expected):
             '<h3>Test Description:</h3>'
             "<p></p>")
         # pylint: enable-msg=R0801
-        with allure.step(f"Enter test number: {seconds} "
-                         f"and verify the output: {expected}"):
+        with allure.step(f"Enter test number: {seconds} \
+                         and verify the output: {expected}"):
             print_log(seconds=seconds, expected=expected)
             self.assertEqual(expected, make_readable(seconds))

kyu_5/integers_recreation_one/test_list_squared.py

@@ -54,8 +54,7 @@ class ListSquaredTestCase(unittest.TestCase):
         (689, 5666, [[728, 722500], [1434, 2856100], [1673, 2856100],
                      [1880, 4884100], [4264, 24304900]]),
         (257, 4195, [[287, 84100], [728, 722500], [1434, 2856100],
-                     [1673, 2856100], [1880, 4884100]])
-    ])
+                     [1673, 2856100], [1880, 4884100]])])
     def test_flatten(self, m, n, expected):
         """
         Testing list_squared function.
@@ -74,7 +73,6 @@ def test_flatten(self, m, n, expected):
             "all integers between m and n whose sum of squared divisors "
             "is itself a square.</p>")
         # pylint: enable-msg=R0801
-
         with allure.step("Enter test data and verify the output..."):
             actual_result = list_squared(m, n)
             print_log(m=m, n=n, expected=expected, actual_result=actual_result)

kyu_5/josephus_survivor/test_josephus_survivor.py

@@ -62,15 +62,14 @@ def test_josephus_survivor(self, test_data, expected):
             "correctly returns who is the \"survivor\", ie: the "
             "last element of a Josephus permutation.</p>")
         # pylint: enable-msg=R0801
-
         total = test_data[0]
         eliminated = test_data[1]
         result = josephus_survivor(total, eliminated)
-        with allure.step(f"Enter test data "
-                         f"(n: {total}, "
-                         f"k: {eliminated}) and verify "
-                         f"the output ({result}) "
-                         f"vs expected ({expected})"):
+        with allure.step(f"Enter test data \
+                         (n: {total}, \
+                         k: {eliminated}) and verify \
+                         the output ({result}) \
+                         vs expected ({expected})"):
 
             print_log(total=total,
                       eliminated=eliminated,

kyu_5/master_your_primes_sieve_with_memoization/test_primes.py

@@ -76,7 +76,7 @@ def test_is_primes(self, number, expected):
             '<h3>Test Description:</h3>'
             "<p></p>")
         # pylint: enable-msg=R0801
-        with allure.step(f"Enter test number: {number} "
-                         f"and verify the output: {expected}."):
+        with allure.step(f"Enter test number: {number} \
+                         and verify the output: {expected}."):
             print_log(number=number, expected=expected)
             self.assertEqual(expected, is_prime(number))

kyu_5/moving_zeros_to_the_end/test_move_zeros.py

@@ -67,7 +67,7 @@ def test_move_zeros(self, array, expected):
             '<h3>Test Description:</h3>'
             "<p></p>")
         # pylint: enable-msg=R0801
-        with allure.step(f"Enter test data: {array} "
-                         f"and verify the output: {expected}"):
+        with allure.step(f"Enter test data: {array} \
+                         and verify the output: {expected}"):
             print_log(array=array, expected=expected)
             self.assertEqual(expected, move_zeros(array))

kyu_5/not_very_secure/test_alphanumeric.py

@@ -60,7 +60,7 @@ def test_alphanumeric(self, password, expected):
             '/badges/large">'
             '<h3>Test Description:</h3>'
             "<p></p>")
-# pylint: enable-msg=R0801
+        # pylint: enable-msg=R0801
         with allure.step("Enter test string and verify the output"):
             print_log(password=password, expected=expected)
             self.assertEqual(expected, alphanumeric(password))

kyu_5/number_of_trailing_zeros_of_n/test_zeros.py

@@ -55,7 +55,7 @@ def test_zeros(self, number, expected, message):
             '<h3>Test Description:</h3>'
             "<p></p>")
         # pylint: enable-msg=R0801
-        with allure.step(f"Enter test number: {number} "
-                         f"and verify the result: {expected}"):
+        with allure.step(f"Enter test number: {number} \
+                         and verify the result: {expected}"):
             print_log(message=message, number=number, expected=expected)
             self.assertEqual(expected, zeros(number))

kyu_5/simple_pig_latin/test_pig_it.py

@@ -53,7 +53,7 @@ def test_pig_it(self, text, expected):
             '<h3>Test Description:</h3>'
             "<p></p>")
         # pylint: enable-msg=R0801
-        with allure.step(f"Enter test string: {text} "
-                         f"and verify the output: {expected}"):
+        with allure.step(f"Enter test string: {text} \
+                         and verify the output: {expected}"):
             print_log(expected=expected, text=text)
             self.assertEqual(expected, pig_it(text))

kyu_5/sports_league_table_ranking/test_compute_ranks.py

@@ -96,13 +96,11 @@ def test_compute_ranks(self, number, games, expected):
             "scored and those conceded)</li>"
             "<li>- Goals scored</li></ul>")
         # pylint: enable-msg=R0801
-
-        with allure.step(f"Enter a test data: {number, games}"
-                         f" and verify the result: {expected}"):
+        with allure.step(f"Enter a test data: {number, games}\
+                          and verify the result: {expected}"):
             actual_result: list = compute_ranks(number, games)
             print_log(number=number,
                       games=games,
                       expected=expected,
                       actual_result=actual_result)
-
             self.assertEqual(expected, actual_result)

kyu_5/string_incrementer/test_increment_string.py

@@ -67,8 +67,8 @@ def test_increment_string(self, string, expected):
             "should be appended to the new string."
             "</p>")
         # pylint: enable-msg=R0801
-        with allure.step(f"Enter test string: {string} "
-                         f"and verify the output: {expected}"):
+        with allure.step(f"Enter test string: {string} \
+                         and verify the output: {expected}"):
             result = increment_string(string)
             print_log(string=string, expected=expected, result=result)
             self.assertEqual(expected, result)

kyu_5/sum_of_pairs/test_sum_pairs.py

@@ -72,9 +72,8 @@ def test_sum_pairs(self, ints, s, expected, message):
             "from the left please) in order of appearance that add up "
             "to form the sum.</p>")
         # pylint: enable-msg=R0801
-
-        with allure.step(f"Enter a test list {ints}"
-                         f"and verify the output {expected}."):
+        with allure.step(f"Enter a test list {ints}\
+                         and verify the output {expected}."):
             result = sum_pairs(ints, s)
             print_log(ints=ints,
                       s=s,

kyu_5/the_hashtag_generator/test_generate_hashtag.py

@@ -78,7 +78,6 @@ def test_generate_hashtag(self, string, expected, message):
             "If the input or the result is an empty string it "
             "must return false."
             "</p>")
-
         with allure.step("Enter a test string and verify the output:"):
             actual_result = generate_hashtag(string)
             print_log(string=string,

kyu_5/tic_tac_toe_checker/test_checker.py

@@ -29,11 +29,16 @@ class IsSolvedTestCase(unittest.TestCase):
     """Testing is_solved function."""
 
     @parameterized.expand([
-        ([[0, 0, 1], [0, 1, 2], [2, 1, 0]], -1, 'not yet finished'),
-        ([[1, 1, 1], [0, 2, 2], [0, 0, 0]], 1, 'winning row'),
-        ([[2, 1, 2], [2, 1, 1], [1, 1, 2]], 1, 'winning column'),
-        ([[2, 1, 2], [2, 1, 1], [1, 2, 1]], 0, 'draw'),
-        ([[1, 2, 0], [0, 1, 2], [0, 0, 1]], 1, 'wining diagonal')])
+        ([[0, 0, 1], [0, 1, 2], [2, 1, 0]], -1,
+         'not yet finished'),
+        ([[1, 1, 1], [0, 2, 2], [0, 0, 0]], 1,
+         'winning row'),
+        ([[2, 1, 2], [2, 1, 1], [1, 1, 2]], 1,
+         'winning column'),
+        ([[2, 1, 2], [2, 1, 1], [1, 2, 1]], 0,
+         'draw'),
+        ([[1, 2, 0], [0, 1, 2], [0, 0, 1]], 1,
+         'wining diagonal')])
     def test_is_solved(self, board, expected, message):
         """
         Testing is_solved function with various test data.
@@ -61,9 +66,8 @@ def test_is_solved(self, board, expected, message):
             "<p>The function should return whether the board's "
             "current state is solved.</p>")
         # pylint: enable-msg=R0801
-
-        with allure.step(f"Enter Tic-Tac-Toe board {board}"
-                         f" and verify the output {expected}."):
+        with allure.step(f"Enter Tic-Tac-Toe board {board}\
+                          and verify the output {expected}."):
             result: int = is_solved(board)
             print_log(expected=expected, result=result, message=message)
             self.assertEqual(expected, result, msg=message)

kyu_5/valid_parentheses/test_valid_parentheses.py

@@ -60,7 +60,7 @@ def test_valid_parentheses(self, test_input, expected):
             '<h3>Test Description:</h3>'
             "<p></p>")
         # pylint: enable-msg=R0801
-        with allure.step(f"Enter test string: {test_input}"
-                         f"and verify the expected output: {expected}."):
+        with allure.step(f"Enter test string: {test_input}\
+                         and verify the expected output: {expected}."):
             print_log(test_input=test_input, expected=expected)
             self.assertEqual(expected, valid_parentheses(test_input))

kyu_5/where_my_anagrams_at/test_anagrams.py

@@ -36,8 +36,7 @@ class AnagramsTestCase(unittest.TestCase):
          ['aabb', 'bbaa']),
         ('racer',
          ['crazer', 'carer', 'racar', 'caers', 'racer'],
-         ['carer', 'racer'])
-    ])
+         ['carer', 'racer'])])
     def test_anagrams(self, string, array, expected):
         """
         Testing anagrams function with various test data.
@@ -57,7 +56,7 @@ def test_anagrams(self, string, array, expected):
             '<h3>Test Description:</h3>'
             "<p></p>")
         # pylint: enable=R0801
-        with allure.step(f"Enter test data: {string, array}"
-                         f" and verify the expected output: {expected}"):
+        with allure.step(f"Enter test data: {string, array}\
+                          and verify the expected output: {expected}"):
             print_log(string=string, array=array, expected=expected)
             self.assertListEqual(expected, anagrams(string, array))