Melhora identação exercícios e seus testes

Fix #13

web_dev_challenges/01_essencial/01_hello_world/test_hello_world.py

@@ -3,22 +3,22 @@
 import pytest
 
 def test_not_none():
-  assert hello_world() is not None, "Esperado valor diferente de 'None'"
+    assert hello_world() is not None, "Esperado valor diferente de 'None'"
 
 def test_type():
-  assert type(hello_world()) == str and len(hello_world()) == 9, "Esperado string com 9 caracteres"
+    assert type(hello_world()) == str and len(hello_world()) == 9, "Esperado string com 9 caracteres"
 
 def test_parameters():
-  assert len(inspect.getfullargspec(hello_world).args) == 0, "Assinatura da função não poderá receber nenhum parâmetro"
+    assert len(inspect.getfullargspec(hello_world).args) == 0, "Assinatura da função não poderá receber nenhum parâmetro"
 
 def test_options_hello_world():
-  possible_anwsers = [
-                      "Olá Mundo",
-                      "Olá mundo",
-                      "Ola Mundo",
-                      "olá mundo",
-                      "ola mundo",
-                      "OLÁ MUNDO",
-                      "OLA MUNDO",
-                     ]
-  assert hello_world() in possible_anwsers , f"Esperado {possible_anwsers}"
+    possible_anwsers = [
+                        "Olá Mundo",
+                        "Olá mundo",
+                        "Ola Mundo",
+                        "olá mundo",
+                        "ola mundo",
+                        "OLÁ MUNDO",
+                        "OLA MUNDO",
+                        ]
+    assert hello_world() in possible_anwsers , f"Esperado {possible_anwsers}"

web_dev_challenges/01_essencial/02_github/my_github.py

@@ -1,3 +1,3 @@
 def my_github_nickname_is():
-  # TODO: Retorne seu usuário github.
-  pass
+    # TODO: Retorne seu usuário github.
+    pass

web_dev_challenges/01_essencial/02_github/test_github.py

@@ -3,16 +3,16 @@
 import requests
 
 def test_not_none():
-  assert my_github_nickname_is() is not None, "Esperado valor diferente de 'None'"
+    assert my_github_nickname_is() is not None, "Esperado valor diferente de 'None'"
 
 def test_type():
-  assert type(my_github_nickname_is()) == str and len(my_github_nickname_is()) > 3, "Esperado string com mais de 3 caracteres"
+    assert type(my_github_nickname_is()) == str and len(my_github_nickname_is()) > 3, "Esperado string com mais de 3 caracteres"
 
 def test_parameters():
-  assert len(inspect.getfullargspec(my_github_nickname_is).args) == 0, "Assinatura da função não poderá receber nenhum parâmetro"
+    assert len(inspect.getfullargspec(my_github_nickname_is).args) == 0, "Assinatura da função não poderá receber nenhum parâmetro"
 
 def test_valid_account_my_github_nickname_is():
-  user = my_github_nickname_is()
-  github_user_api_url = 'https://api.github.com/users'
-  response = requests.get(f'{github_user_api_url}/{user}')
-  assert response.status_code == 200 and response.json()['login'] == user, "Esperado usuário github válido"
+    user = my_github_nickname_is()
+    github_user_api_url = 'https://api.github.com/users'
+    response = requests.get(f'{github_user_api_url}/{user}')
+    assert response.status_code == 200 and response.json()['login'] == user, "Esperado usuário github válido"

web_dev_challenges/01_essencial/03_operadores/operators.py

@@ -1,28 +1,28 @@
 def add(first_number, second_number):
-  # TODO: retorne a soma dos parâmetros first_number e second_number
-  pass
+    # TODO: retorne a soma dos parâmetros first_number e second_number
+    pass
 
 def sub(first_number, second_number):
-  # TODO: retorne a subtração dos parâmetros first_number e second_number
-  pass
+    # TODO: retorne a subtração dos parâmetros first_number e second_number
+    pass
 
 def mult(first_number, second_number):
-  # TODO: retorne a multiplicação dos parâmetros first_number e second_number
-  pass
+    # TODO: retorne a multiplicação dos parâmetros first_number e second_number
+    pass
 
 def div(first_number, second_number):
-  # TODO: retorne a divisão dos parâmetros first_number e second_number
-  pass
+    # TODO: retorne a divisão dos parâmetros first_number e second_number
+    pass
 
 def expo(first_number, second_number):
-  # TODO: retorne a exponenciação dos parâmetros first_number e second_number
-  pass
+    # TODO: retorne a exponenciação dos parâmetros first_number e second_number
+    pass
 
 def remai(first_number, second_number):
-  # TODO: retorne o resto da divisão dos parâmetros first_number e second_number
-  pass
+    # TODO: retorne o resto da divisão dos parâmetros first_number e second_number
+    pass
 
 def quoti_remai(first_number, second_number):
-  # TODO: retorne o quociente e o resto da divisão, nesta exata ordem, dos parâmetros first_number e second_number
-  # Hint: Utilize a vírgula para separar os dois valores retornados na função
-  pass
+    # TODO: retorne o quociente e o resto da divisão, nesta exata ordem, dos parâmetros first_number e second_number
+    # Hint: Utilize a vírgula para separar os dois valores retornados na função
+    pass

web_dev_challenges/01_essencial/03_operadores/test_operators.py

@@ -11,32 +11,32 @@
 import pytest
 
 def test_not_none():
-  assert add(1, 1) is not None, "Esperado valor diferente de 'None'"
-  assert sub(1, 1) is not None, "Esperado valor diferente de 'None'"
-  assert mult(1, 1) is not None, "Esperado valor diferente de 'None'"
-  assert div(1, 1) is not None, "Esperado valor diferente de 'None'"
-  assert expo(1, 1) is not None, "Esperado valor diferente de 'None'"
-  assert remai(1, 1) is not None, "Esperado valor diferente de 'None'"
-  assert quoti_remai(1, 1) is not None, "Esperado valor diferente de 'None'"
+    assert add(1, 1) is not None, "Esperado valor diferente de 'None'"
+    assert sub(1, 1) is not None, "Esperado valor diferente de 'None'"
+    assert mult(1, 1) is not None, "Esperado valor diferente de 'None'"
+    assert div(1, 1) is not None, "Esperado valor diferente de 'None'"
+    assert expo(1, 1) is not None, "Esperado valor diferente de 'None'"
+    assert remai(1, 1) is not None, "Esperado valor diferente de 'None'"
+    assert quoti_remai(1, 1) is not None, "Esperado valor diferente de 'None'"
 
 def test_type():
-  assert type(add(1, 1)) == int or type(add(1, 1)) == float, "Esperado valor numérico (int ou float)"
-  assert type(sub(1, 1)) == int or type(sub(1, 1)) == float, "Esperado valor numérico (int ou float)"
-  assert type(mult(1, 1)) == int or type(mult(1, 1)) == float, "Esperado valor numérico (int ou float)"
-  assert type(div(1, 1)) == int or type(div(1, 1)) == float, "Esperado valor numérico (int ou float)"
-  assert type(expo(1, 1)) == int or type(expo(1, 1)) == float, "Esperado valor numérico (int ou float)"
-  assert type(remai(1, 1)) == int or type(remai(1, 1)) == float, "Esperado valor numérico (int ou float)"
-  assert type(quoti_remai(1, 1)[0]) == int or type(quoti_remai(1, 1)[0]) == float, "Esperado valor numérico (int ou float)"
-  assert type(quoti_remai(1, 1)[1]) == int or type(quoti_remai(1, 1)[1]) == float, "Esperado valor numérico (int ou float)"
+    assert type(add(1, 1)) == int or type(add(1, 1)) == float, "Esperado valor numérico (int ou float)"
+    assert type(sub(1, 1)) == int or type(sub(1, 1)) == float, "Esperado valor numérico (int ou float)"
+    assert type(mult(1, 1)) == int or type(mult(1, 1)) == float, "Esperado valor numérico (int ou float)"
+    assert type(div(1, 1)) == int or type(div(1, 1)) == float, "Esperado valor numérico (int ou float)"
+    assert type(expo(1, 1)) == int or type(expo(1, 1)) == float, "Esperado valor numérico (int ou float)"
+    assert type(remai(1, 1)) == int or type(remai(1, 1)) == float, "Esperado valor numérico (int ou float)"
+    assert type(quoti_remai(1, 1)[0]) == int or type(quoti_remai(1, 1)[0]) == float, "Esperado valor numérico (int ou float)"
+    assert type(quoti_remai(1, 1)[1]) == int or type(quoti_remai(1, 1)[1]) == float, "Esperado valor numérico (int ou float)"
 
 def test_parameters():
-  assert len(inspect.getfullargspec(add).args) == 2, "Assinatura da função deverá receber dois parâmetros"
-  assert len(inspect.getfullargspec(sub).args) == 2, "Assinatura da função deverá receber dois parâmetros"
-  assert len(inspect.getfullargspec(mult).args) == 2, "Assinatura da função deverá receber dodois parâmetros"
-  assert len(inspect.getfullargspec(div).args) == 2, "Assinatura da função deverá receber dois parâmetros"
-  assert len(inspect.getfullargspec(expo).args) == 2, "Assinatura da função deverá receber dois parâmetros"
-  assert len(inspect.getfullargspec(remai).args) == 2, "Assinatura da função deverá receber dois parâmetros"
-  assert len(inspect.getfullargspec(quoti_remai).args) == 2, "Assinatura da função deverá receber dodois parâmetros"
+    assert len(inspect.getfullargspec(add).args) == 2, "Assinatura da função deverá receber dois parâmetros"
+    assert len(inspect.getfullargspec(sub).args) == 2, "Assinatura da função deverá receber dois parâmetros"
+    assert len(inspect.getfullargspec(mult).args) == 2, "Assinatura da função deverá receber dodois parâmetros"
+    assert len(inspect.getfullargspec(div).args) == 2, "Assinatura da função deverá receber dois parâmetros"
+    assert len(inspect.getfullargspec(expo).args) == 2, "Assinatura da função deverá receber dois parâmetros"
+    assert len(inspect.getfullargspec(remai).args) == 2, "Assinatura da função deverá receber dois parâmetros"
+    assert len(inspect.getfullargspec(quoti_remai).args) == 2, "Assinatura da função deverá receber dodois parâmetros"
 
 @pytest.mark.parametrize("first_number, second_number, expected_result", [
     (1, 1, 2),
@@ -45,7 +45,7 @@ def test_parameters():
     (10, 16, 26),
 ])
 def test_add(first_number, second_number, expected_result):
-  assert add(first_number, second_number) == expected_result, f"{first_number} + {second_number} = {expected_result}"
+    assert add(first_number, second_number) == expected_result, f"{first_number} + {second_number} = {expected_result}"
 
 @pytest.mark.parametrize("first_number, second_number, expected_result", [
     (1, 1, 0),
@@ -54,7 +54,7 @@ def test_add(first_number, second_number, expected_result):
     (10, 16, -6),
 ])
 def test_sub(first_number, second_number, expected_result):
-  assert sub(first_number, second_number) == expected_result, f"{first_number} - {second_number} = {expected_result}"
+    assert sub(first_number, second_number) == expected_result, f"{first_number} - {second_number} = {expected_result}"
 
 @pytest.mark.parametrize("first_number, second_number, expected_result", [
     (1, 1, 1),
@@ -63,7 +63,7 @@ def test_sub(first_number, second_number, expected_result):
     (10, 16, 160),
 ])
 def test_mult(first_number, second_number, expected_result):
-  assert mult(first_number, second_number) == expected_result, f"{first_number} x {second_number} = {expected_result}"
+    assert mult(first_number, second_number) == expected_result, f"{first_number} x {second_number} = {expected_result}"
 
 @pytest.mark.parametrize("first_number, second_number, expected_result", [
     (1, 1, 1),
@@ -72,7 +72,7 @@ def test_mult(first_number, second_number, expected_result):
     (10, 16, 0.625),
 ])
 def test_div(first_number, second_number, expected_result):
-  assert div(first_number, second_number) == expected_result, f"{first_number} / {second_number} = {expected_result}"
+    assert div(first_number, second_number) == expected_result, f"{first_number} / {second_number} = {expected_result}"
 
 @pytest.mark.parametrize("first_number, second_number, expected_result", [
     (1, 1, 1),
@@ -81,7 +81,7 @@ def test_div(first_number, second_number, expected_result):
     (10, 16, 10000000000000000),
 ])
 def test_expo(first_number, second_number, expected_result):
-  assert expo(first_number, second_number) == expected_result, f"{first_number} elevado a {second_number} = {expected_result}"
+    assert expo(first_number, second_number) == expected_result, f"{first_number} elevado a {second_number} = {expected_result}"
 
 @pytest.mark.parametrize("first_number, second_number, expected_result", [
     (1, 1, 0),
@@ -90,7 +90,7 @@ def test_expo(first_number, second_number, expected_result):
     (10, 16, 10),
 ])
 def test_remai(first_number, second_number, expected_result):
-  assert remai(first_number, second_number) == expected_result, f"Resto da divisão de {first_number} por {second_number} = {expected_result}"
+    assert remai(first_number, second_number) == expected_result, f"Resto da divisão de {first_number} por {second_number} = {expected_result}"
 
 @pytest.mark.parametrize("first_number, second_number, expected_result", [
     (3, 1, (3, 0)),
@@ -99,4 +99,4 @@ def test_remai(first_number, second_number, expected_result):
     (10, 16, (0, 10)),
 ])
 def test_quoti_remai(first_number, second_number, expected_result):
-  assert quoti_remai(first_number, second_number) == expected_result, f"O quociente da divisão de {first_number} por {second_number} é {expected_result[0]} e o resto é {expected_result[1]}"
+    assert quoti_remai(first_number, second_number) == expected_result, f"O quociente da divisão de {first_number} por {second_number} é {expected_result[0]} e o resto é {expected_result[1]}"

web_dev_challenges/01_essencial/04_areas/areas.py

@@ -1,13 +1,13 @@
 def circle_area(radius):
-  # TODO: Retorne a área de um círculo dado a medida de seu raio
-  # Auxílio: Utilize 3.14 como valor do Pi
-  pass
+    # TODO: Retorne a área de um círculo dado a medida de seu raio
+    # Auxílio: Utilize 3.14 como valor do Pi
+    pass
 
 
 def square_area(side):
-  # TODO: Retorne a área de um quadrado dado a medida de seu lado
-  pass
+    # TODO: Retorne a área de um quadrado dado a medida de seu lado
+    pass
 
 def rectangle_area(side, base):
-  # TODO: Retorne a área de um retângulo dado a medida de seu lado e de sua base
-  pass
+    # TODO: Retorne a área de um retângulo dado a medida de seu lado e de sua base
+    pass

web_dev_challenges/01_essencial/04_areas/test_areas.py

@@ -8,19 +8,19 @@
 import pytest
 
 def test_not_none():
-  assert circle_area(1) is not None, "Esperado valor diferente de 'None'"
-  assert square_area(1) is not None, "Esperado valor diferente de 'None'"
-  assert rectangle_area(1, 1) is not None, "Esperado valor diferente de 'None'"
+    assert circle_area(1) is not None, "Esperado valor diferente de 'None'"
+    assert square_area(1) is not None, "Esperado valor diferente de 'None'"
+    assert rectangle_area(1, 1) is not None, "Esperado valor diferente de 'None'"
 
 def test_type():
-  assert type(circle_area(1)) == float, "Esperado valor decimal (float)"
-  assert type(square_area(1)) == int or type(square_area(1)) == float, "Esperado valor numérico"
-  assert type(rectangle_area(1, 1)) == int or type(rectangle_area(1, 1)) == float, "Esperado valor numérico"
+    assert type(circle_area(1)) == float, "Esperado valor decimal (float)"
+    assert type(square_area(1)) == int or type(square_area(1)) == float, "Esperado valor numérico"
+    assert type(rectangle_area(1, 1)) == int or type(rectangle_area(1, 1)) == float, "Esperado valor numérico"
 
 def test_parameters():
-  assert len(inspect.getfullargspec(circle_area).args) == 1, "Assinatura da função deverá receber um parâmetros"
-  assert len(inspect.getfullargspec(square_area).args) == 1, "Assinatura da função deverá receber um parâmetros"
-  assert len(inspect.getfullargspec(rectangle_area).args) == 2, "Assinatura da função deverá receber dois parâmetros"
+    assert len(inspect.getfullargspec(circle_area).args) == 1, "Assinatura da função deverá receber um parâmetros"
+    assert len(inspect.getfullargspec(square_area).args) == 1, "Assinatura da função deverá receber um parâmetros"
+    assert len(inspect.getfullargspec(rectangle_area).args) == 2, "Assinatura da função deverá receber dois parâmetros"
 
 @pytest.mark.parametrize("radius, expected_result", [
     (1, 3.14),
@@ -29,7 +29,7 @@ def test_parameters():
     (16, 803.84),
 ])
 def test_circle_area(radius, expected_result):
-  assert circle_area(radius) == expected_result, f"A área de um círculo de raio {radius} é igual a {expected_result}"
+    assert circle_area(radius) == expected_result, f"A área de um círculo de raio {radius} é igual a {expected_result}"
 
 @pytest.mark.parametrize("side, expected_result", [
     (1, 1),
@@ -38,7 +38,7 @@ def test_circle_area(radius, expected_result):
     (9, 81),
 ])
 def test_square_area(side, expected_result):
-  assert square_area(side) == expected_result, f"A área de um quadrade de lado {side} é igual a {expected_result}"
+    assert square_area(side) == expected_result, f"A área de um quadrade de lado {side} é igual a {expected_result}"
 
 @pytest.mark.parametrize("side, base, expected_result", [
     (1, 2, 2),
@@ -47,4 +47,4 @@ def test_square_area(side, expected_result):
     (9, 5, 45),
 ])
 def test_rectangle_area(side, base, expected_result):
-  assert rectangle_area(side, base) == expected_result, f"A área de um retângulo de lado {side} e base {base} é igual a {expected_result}"
+    assert rectangle_area(side, base) == expected_result, f"A área de um retângulo de lado {side} e base {base} é igual a {expected_result}"

web_dev_challenges/01_essencial/05_strings/learn_strings.py

@@ -1,20 +1,20 @@
 def has_letter(letter, input_word):
-  # TODO: Retorne True ou False para a existência da letra (letter) no texto informado (string)
-  pass
+    # TODO: Retorne True ou False para a existência da letra (letter) no texto informado (string)
+    pass
 
 def uper_case(input_word):
-  # TODO: Retorne o valor to texto todo em letras maiúsculas
-  pass
+    # TODO: Retorne o valor to texto todo em letras maiúsculas
+    pass
 
 
 def lower_case(input_word):
-  # TODO: Retorne o valor to texto todo em letras minúsculas
-  pass
+    # TODO: Retorne o valor to texto todo em letras minúsculas
+    pass
 
 def capitalize(input_word):
-  # TODO: Retorne o valor to texto todo com a primeira letra maiúscula
-  pass
+    # TODO: Retorne o valor to texto todo com a primeira letra maiúscula
+    pass
 
 def reverse(input_word):
-  # TODO: Retorne o valor inverso de um texto
-  pass
+    # TODO: Retorne o valor inverso de um texto
+    pass