def test_route():
""" Testing route method in RegisterUserRouter """
register_pet_use_case = RegisterPetSpy(PetRepositorySpy(), UserRepositorySpy())
register_pet_router = RegisterPetController(register_pet_use_case)
attributes = {
"name": faker.word(),
"specie": "Dog",
"age": faker.random_number(),
"user_information": {
"user_id": faker.random_number(),
"user_name": faker.word(),
},
}
response = register_pet_router.route(HttpRequest(body=attributes))
# Testing input
assert register_pet_use_case.registry_param["name"] == attributes["name"]
assert register_pet_use_case.registry_param["specie"] == attributes["specie"]
assert register_pet_use_case.registry_param["age"] == attributes["age"]
assert (
register_pet_use_case.registry_param["user_information"]
== attributes["user_information"]
)
# Testing output
assert response.status_code == 200
assert "error" not in response.body
def test_registry():
"""Testing register pet funcionality"""
pet_repo = PetsRepositorySpy()
find_user = FindUserSpy(UserRepositorySpy())
register_pet = RegisterPet(pet_repo, find_user)
attributes = {
"name": faker.name(),
"specie": faker.name(),
"age": faker.random_number(digits=1),
"user_info": {
"user_name": faker.name(),
"user_id": faker.random_number(digits=5),
},
}
response = register_pet.register(
name=attributes["name"],
specie=attributes["specie"],
age=attributes["age"],
user_info=attributes["user_info"],
)
# Testing Inputs
assert pet_repo.insert_pets_params["name"] == attributes["name"]
assert pet_repo.insert_pets_params["specie"] == attributes["specie"]
assert pet_repo.insert_pets_params["age"] == attributes["age"]
print(response)
def test_registry_fail_attributes():
""" Testing registry fail method in RegisterPet by attributes """
pet_repo = PetRepositorySpy()
find_user = FindUserSpy(UserRepositorySpy())
registry_pet = RegisterPet(pet_repo, find_user)
attributes = {
"name": faker.name(),
"specie": faker.random_number(),
"age": faker.name(),
"user_information": {
"user_id": faker.random_number(digits=1),
"user_name": faker.name(),
},
}
response = registry_pet.registry(
name=attributes["name"],
specie=attributes["specie"],
age=attributes["age"],
user_information=attributes["user_information"],
)
# Testing Inputs
assert pet_repo.insert_pet_param == {}
# Testing Outputs
assert response["Success"] is False
assert response["Data"] is None
def test_select_by_id():
"""Test Method"""
user_repo = UserRepositorySpy()
find_user = FindUser(user_repo)
attributes = {"id": faker.random_number(digits=2)}
response = find_user.by_id(user_id=attributes["id"])
# Testing
assert response["Success"] is True
assert user_repo.select_user_params["user_id"] == attributes["id"]
def test_select_by_name():
"""Test Method"""
user_repo = UserRepositorySpy()
find_user = FindUser(user_repo)
attributes = {"name": faker.name()}
response = find_user.by_name(name=attributes["name"])
# Testing
assert response["Success"] is True
assert user_repo.select_user_params["name"] == attributes["name"]
def test_route_error_no_body():
""" Testing route method in RegisterUserRouter """
register_user_use_case = RegisterUserSpy(UserRepositorySpy())
register_user_router = RegisterUserRouter(register_user_use_case)
response = register_user_router.route(HttpRequest())
# Testing input
assert register_user_use_case.registry_param == {}
# Testing output
assert response.status_code == 400
assert "error" in response.body
def test_route_error_wrong_body():
""" Testing route method in RegisterUserRouter """
register_user_use_case = RegisterUserSpy(UserRepositorySpy())
register_user_router = RegisterUserRouter(register_user_use_case)
attributes = {"name": faker.word()}
response = register_user_router.route(HttpRequest(body=attributes))
# Testing input
assert register_user_use_case.registry_param == {}
# Testing output
assert response.status_code == 422
assert "error" in response.body
def test_by_id():
""" Testing by_id method in FindUser """
user_repo = UserRepositorySpy()
find_user = FindUser(user_repo)
attribute = {"id": faker.random_number(digits=2)}
response = find_user.by_id(user_id=attribute["id"])
# Testing Input
assert user_repo.select_user_params["user_id"] == attribute["id"]
# Testing Outputs
assert response["Success"] is True
assert response["Data"]
def test_fail_by_name():
""" Testing by_name fail method in FindUser """
user_repo = UserRepositorySpy()
find_user = FindUser(user_repo)
attribute = {"name": faker.random_number(digits=2)}
response = find_user.by_name(name=attribute["name"])
# Testing Input
assert user_repo.select_user_params == {}
# Testing Outputs
assert response["Success"] is False
assert response["Data"] is None
def test_fail_by_id():
""" Testing by_id fail method in FindUser """
user_repo = UserRepositorySpy()
find_user = FindUser(user_repo)
attribute = {"id": faker.word()}
response = find_user.by_id(user_id=attribute["id"])
# Testing Input
assert user_repo.select_user_params == {}
# Testing Outputs
assert response["Success"] is False
assert response["Data"] is None
def test_by_name():
""" Testing by_name method in FindUser """
user_repo = UserRepositorySpy()
find_user = FindUser(user_repo)
attribute = {"name": faker.word()}
response = find_user.by_name(name=attribute["name"])
# Testing Input
assert user_repo.select_user_params["name"] == attribute["name"]
# Testing Outputs
assert response["Success"] is True
assert response["Data"]
def test_route_by_name():
""" Testing route method in FindUserRouter """
find_user_use_case = FindUserSpy(UserRepositorySpy())
find_user_router = FindUserRouter(find_user_use_case)
attributes = {"user_name": faker.word()}
response = find_user_router.route(HttpRequest(query=attributes))
# Testing input
assert find_user_use_case.by_name_param["name"] == attributes["user_name"]
# Testing Output
assert response.status_code == 200
assert response.body
def test_route_by_id():
""" Testing route method in FindUserRouter """
find_user_use_case = FindUserSpy(UserRepositorySpy())
find_user_router = FindUserRouter(find_user_use_case)
attributes = {"user_id": faker.random_number(digits=2)}
response = find_user_router.route(HttpRequest(query=attributes))
# Testing input
assert find_user_use_case.by_id_param["user_id"] == attributes["user_id"]
# Testing output
assert response.status_code == 200
assert response.body
def test_route_error_wrong_query():
""" Testing route method in FindUserRouter """
find_user_use_case = FindUserSpy(UserRepositorySpy())
find_user_router = FindUserRouter(find_user_use_case)
response = find_user_router.route(HttpRequest(query={"something": faker.word()}))
# Testing input
assert find_user_use_case.by_id_param == {}
assert find_user_use_case.by_name_param == {}
assert find_user_use_case.by_id_and_user_param == {}
# Testing output
assert response.status_code == 422
assert "error" in response.body
def test_route_error_wrong_user_information():
""" Testing route method in RegisterUserRouter """
register_pet_use_case = RegisterPetSpy(PetRepositorySpy(), UserRepositorySpy())
register_pet_router = RegisterPetController(register_pet_use_case)
attributes = {"name": faker.word(), "specie": "Dog", "user_information": {}}
response = register_pet_router.route(HttpRequest(body=attributes))
# Testing input
assert register_pet_use_case.registry_param == {}
# Testing output
assert response.status_code == 422
assert "error" in response.body
def test_route():
""" Testing route method in RegisterUserRouter """
register_user_use_case = RegisterUserSpy(UserRepositorySpy())
register_user_router = RegisterUserRouter(register_user_use_case)
attributes = {"name": faker.word(), "password": faker.word()}
response = register_user_router.route(HttpRequest(body=attributes))
# Testing input
assert register_user_use_case.registry_param["name"] == attributes["name"]
assert register_user_use_case.registry_param["password"] == attributes["password"]
# Testing output
assert response.status_code == 201
assert "error" not in response.body
def test_handle_no_query_param():
""" Testing Handle method """
find_user_use_case = FindUserSpy(UserRepositorySpy())
find_user_controller = FindUserController(find_user_use_case)
http_request = HttpRequest()
response = find_user_controller.route(http_request)
# Testing Inputs
assert find_user_use_case.by_id_and_name_param == {}
assert find_user_use_case.by_id_param == {}
assert find_user_use_case.by_name_param == {}
# Testing Output
assert response.status_code == 400
assert "error" in response.body
def test_register():
"""Test Registry method"""
user_repo = UserRepositorySpy()
register_user = RegisterUser(user_repo)
attributes = {"name": faker.name(), "password": faker.name()}
response = register_user.register(name=attributes["name"],
password=attributes["password"])
# Testing Input
assert user_repo.insert_user_params["name"] == attributes["name"]
assert user_repo.insert_user_params["password"] == attributes["password"]
# Testing Output
assert response["Success"] is True
assert response["Data"]
def test_register_fail():
"""Test Registry method"""
user_repo = UserRepositorySpy()
register_user = RegisterUser(user_repo)
attributes = {
"name": faker.random_number(digits=2),
"password": faker.name()
}
response = register_user.register(name=attributes["name"],
password=attributes["password"])
print(response)
# Testing Input
assert user_repo.insert_user_params == {}
# Testing Output
assert response["Success"] is False
assert response["Data"] is None
def test_route_query_params_error():
""" Testing Route method """
find_user_use_case = FindUserSpy(UserRepositorySpy())
find_user_controller = FindUserController(find_user_use_case)
http_request = HttpRequest(query={
"id": faker.random_number(),
"name": faker.word()
})
response = find_user_controller.route(http_request)
# Testing Inputs
assert find_user_use_case.by_id_and_name_param == {}
assert find_user_use_case.by_id_param == {}
assert find_user_use_case.by_name_param == {}
# Testing Output
assert response.status_code == 422
assert "error" in response.body
def test_registry_fail():
""" Testing registry fail method in RegisterUser """
user_repo = UserRepositorySpy()
registry_user = RegisterUser(user_repo)
attributes = {
"name": faker.random_number(digits=3),
"password": faker.word(),
}
response = registry_user.registry(
name=attributes["name"], password=attributes["password"]
)
# Testing Inputs
assert user_repo.insert_user_params == {}
# Testing Outputs
assert response["Success"] is False
assert response["Data"] is None
def test_handle():
""" Testing Handle method """
find_user_use_case = FindUserSpy(UserRepositorySpy())
find_user_controller = FindUserController(find_user_use_case)
http_request = HttpRequest(query={
"user_id": faker.random_number(),
"user_name": faker.word()
})
response = find_user_controller.route(http_request)
# Testing Inputs
assert (find_user_use_case.by_id_and_name_param["user_id"] ==
http_request.query["user_id"])
assert (find_user_use_case.by_id_and_name_param["name"] ==
http_request.query["user_name"])
# Testing Output
assert response.status_code == 200
assert response.body
def test_registry():
""" Testing registry method in RegisterPet """
pet_repo = PetRepositorySpy()
find_user = FindUserSpy(UserRepositorySpy())
registry_pet = RegisterPet(pet_repo, find_user)
attributes = {
"name": faker.name(),
"specie": faker.name(),
"age": faker.random_number(digits=1),
"user_information": {
"user_id": faker.random_number(digits=1),
"user_name": faker.name(),
},
}
response = registry_pet.registry(
name=attributes["name"],
specie=attributes["specie"],
age=attributes["age"],
user_information=attributes["user_information"],
)
# Testing Inputs
assert pet_repo.insert_pet_param["name"] == attributes["name"]
assert pet_repo.insert_pet_param["specie"] == attributes["specie"]
assert pet_repo.insert_pet_param["age"] == attributes["age"]
assert (pet_repo.insert_pet_param["user_id"] ==
attributes["user_information"]["user_id"])
# Testing FindUser Inputs
assert (find_user.by_id_and_user_param["user_id"] ==
attributes["user_information"]["user_id"])
assert (find_user.by_id_and_user_param["name"] ==
attributes["user_information"]["user_name"])
# Testing Outputs
assert response["Success"] is True
assert response["Data"]
