def test_should_return_204_if_load_surveys_returns_empty(
mock_load: MagicMock, sut: LoadSurveysController
):
mock_load.return_value = []
http_response = sut.handle(HttpRequest())
assert http_response.status_code == 204
assert not http_response.body
def test_return_204_on_success(sut: AddSurveyController):
http_request = HttpRequest(body=dict(
question="any_question",
answers=[dict(image="any_image", answer="any_answer")],
))
respose = sut.handle(http_request)
assert respose.status_code == 204
assert not respose.body
def test_should_401_if_invalid_credentials_are_provided(
mock_auth: MagicMock, sut: LoginController
):
mock_auth.return_value = None
request = HttpRequest(body=dict(email="*****@*****.**", password="******"))
response = sut.handle(request)
assert response.status_code == 401
assert response.body["message"] == "Unauthorized"
def test_should_call_add_survey_correct_values(mock_add: MagicMock,
sut: AddSurveyController):
http_request = HttpRequest(body=dict(
question="any_question",
answers=[dict(image="any_image", answer="any_answer")],
))
sut.handle(http_request)
mock_add.assert_called_with(AddSurveyModel(**http_request.body))
def test_should_calls_load_survey_by_id_with_values(
mock_load_by_id: MagicMock, sut: SaveSurveyResultController):
sut.handle(
HttpRequest(
params=dict(survey_id="any_id"),
body=dict(answer="any_answer"),
account_id="any_account_id",
))
mock_load_by_id.assert_called_with("any_id")
def test_should_500_if_authentication__raise_exception(
mock_auth: MagicMock, mock_get_collection: MagicMock, sut: LoginController
):
mock_auth.side_effect = Exception("Error on matrix")
mock_get_collection.return_value = mongomock.MongoClient().db.collection
request = HttpRequest(body=dict(email="*****@*****.**", password="******"))
response = sut.handle(request)
assert response.status_code == 500
assert response.body["message"] == "Internal server error"
def test_should_return_500_if_load_account_by_id_raise_exception(
mock_load: MagicMock, mock_get_collection: MagicMock,
sut: AuthMiddleware):
mock_load.side_effect = Exception("Error on matrix")
mock_get_collection.return_value = mongomock.MongoClient().db.collection
http_response = sut.handle(
HttpRequest(headers={"x-access-token": "any_token"}, body=None))
assert http_response.status_code == 500
assert http_response.body["message"] == "Internal server error"
def test_should_return_401_if_load_account_by_id_raise_jwt_exception(
mock_load: MagicMock, mock_get_collection: MagicMock,
sut: AuthMiddleware):
mock_load.side_effect = InvalidTokenError()
mock_get_collection.return_value = mongomock.MongoClient().db.collection
http_response = sut.handle(
HttpRequest(headers={"x-access-token": "any_token"}, body=None))
assert http_response.status_code == 401
assert http_response.body["message"] == "Unauthorized"
def test_should_403_if_an_invalid_answer_is_provided(
sut: SaveSurveyResultController):
http_response = sut.handle(
HttpRequest(
params=dict(survey_id="any_id"),
body=dict(answer="invalid_answer"),
account_id="any_account_id",
))
assert http_response.status_code == 403
assert http_response.body["message"] == "Invalid param: answer"
def test_return_400_if_validation_fails(mock_validate: MagicMock,
sut: AddSurveyController):
mock_validate.return_value = Exception("Error on matrix")
http_request = HttpRequest(body=dict(
question="any_question",
answers=[dict(image="any_image", answer="any_answer")],
))
respose = sut.handle(http_request)
assert respose.status_code == 400
assert respose.body == {"message": "Error on matrix"}
def test_should_403_if_load_survey_by_id_returns_none(
mock_load_by_id: MagicMock, sut: SaveSurveyResultController):
mock_load_by_id.return_value = None
http_response = sut.handle(
HttpRequest(
params=dict(survey_id="any_id"),
body=dict(answer="any_answer"),
account_id="any_account_id",
))
assert http_response.status_code == 403
assert http_response.body["message"] == "Invalid param: survey_id"
async def adpter_middleware(request: Request, call_next,
middleware: Middleware):
headers = request.headers
http_response = middleware.handle(HttpRequest(headers=headers))
if http_response.status_code == 200:
request.state.account_id = http_response.body
response = await call_next(request)
return response
else:
return JSONResponse(status_code=http_response.status_code,
content=http_response.body)
def test_should_call_validation_correct_value(mock_validate: MagicMock,
sut: SignUpController):
request = HttpRequest(
body={
"name": "John Doe",
"email": "*****@*****.**",
"password": "******",
"password_confirmation": "test",
})
sut.handle(request)
mock_validate.assert_called_with(request.body)
def test_should_204_if_data_is_valid(sut: SignUpController):
request = HttpRequest(
body={
"name": "John Doe",
"email": "*****@*****.**",
"password": "******",
"password_confirmation": "test",
})
response = sut.handle(request)
assert response.status_code == 204
def test_should_500_if_add_survey_raise_exception(
mock_add: MagicMock, mock_get_collection: MagicMock,
sut: AddSurveyController):
mock_add.side_effect = Exception("Error on matrix")
mock_get_collection.return_value = mongomock.MongoClient().db.collection
http_request = HttpRequest(body=dict(
question="any_question",
answers=[dict(image="any_image", answer="any_answer")],
))
response = sut.handle(http_request)
assert response.status_code == 500
assert response.body["message"] == "Internal server error"
def test_should_200_on_success(sut: LoadSurveyResultController):
http_response = sut.handle(HttpRequest(params=dict(survey_id="any_id")))
assert http_response.status_code == 200
assert http_response.body == dict(
survey_id="any_id",
question="any_question",
answers=[
dict(answer="any_answer", count=1, percent=40, image="any_image"),
dict(answer="other_answer", count=2, percent=60,
image="any_image"),
],
date=datetime.utcnow(),
)
def test_should_400_if_validation_returns_error(mock_validate: MagicMock,
sut: SignUpController):
mock_validate.return_value = MissingParamError("any_field")
request = HttpRequest(
body={
"name": "John Doe",
"email": "*****@*****.**",
"password": "******",
"password_confirmation": "test",
})
response = sut.handle(request)
assert response.status_code == 400
assert response.body == dict(message="Missing param: any_field")
def test_should_500_if_add_account_raise_exception(
mock_add: MagicMock, mock_get_collection: MagicMock,
sut: SignUpController):
mock_add.side_effect = Exception("Error on matrix")
mock_get_collection.return_value = mongomock.MongoClient().db.collection
request = HttpRequest(
body={
"name": "John Doe",
"email": "*****@*****.**",
"password": "******",
"password_confirmation": "test",
})
response = sut.handle(request)
assert response.status_code == 500
assert response.body["message"] == "Internal server error"
def test_should_500_if_load_survey_by_id_raise_exception(
mock_load_by_id: MagicMock,
mock_get_collection: MagicMock,
sut: SaveSurveyResultController,
):
mock_load_by_id.side_effect = Exception("Error on matrix")
mock_get_collection.return_value = mongomock.MongoClient().db.collection
http_response = sut.handle(
HttpRequest(
params=dict(survey_id="any_id"),
body=dict(answer="any_answer"),
account_id="any_account_id",
))
assert http_response.status_code == 500
assert http_response.body["message"] == "Internal server error"
def test_should_200_on_success(sut: SaveSurveyResultController, ):
http_response = sut.handle(
HttpRequest(
params=dict(survey_id="any_survey_id"),
body=dict(answer="any_answer"),
account_id="any_account_id",
))
assert http_response.status_code == 200
assert http_response.body == dict(
survey_id="any_survey_id",
question="any_question",
answers=[
dict(answer="any_answer", count=1, percent=100, image="any_image")
],
date=datetime.utcnow(),
)
def test_should_calls_save_survey_result_with_values(
mock_save: MagicMock,
mock_get_collection: MagicMock,
sut: SaveSurveyResultController,
):
mock_get_collection.return_value = mongomock.MongoClient().db.collection
sut.handle(
HttpRequest(
params=dict(survey_id="any_id"),
body=dict(answer="any_answer"),
account_id="any_account_id",
))
mock_save.assert_called_with(
SaveSurveyResultModel(survey_id="any_id",
account_id="any_account_id",
answer="any_answer"))
async def adpter_route(request: Request, response: Response,
controller: Controller):
body = await request.body()
headers = request.headers
params = request.path_params
account_id = getattr(request.state, "account_id", None)
http_response = controller.handle(
HttpRequest(
headers=headers,
params=params,
account_id=account_id,
body=json.loads(body or "{}"),
))
response.status_code = http_response.status_code
if http_response.status_code == 204:
return Response(status_code=204)
return http_response.body
def test_should_return_200_on_success(sut: LoadSurveysController):
http_response = sut.handle(HttpRequest())
expected = [
dict(
id="any_id",
question="any_question",
answers=[dict(image="any_image", answer="any_answer")],
date=datetime.utcnow(),
),
dict(
id="other_id",
question="other_question",
answers=[dict(image="other_image", answer="other_answer")],
date=datetime.utcnow(),
),
]
assert http_response.status_code == 200
assert http_response.body == expected
def test_should_call_add_account_correct_values(mock_add: MagicMock,
sut: SignUpController):
mock_add.return_value = AccountModel(
id="valid_id",
name="valid_name",
email="*****@*****.**",
hashed_password="******",
)
request = HttpRequest(
body={
"name": "John Doe",
"email": "*****@*****.**",
"password": "******",
"password_confirmation": "test",
})
sut.handle(request)
expected = AddAccountModel(
name="John Doe",
email="*****@*****.**",
password="******",
)
mock_add.assert_called_with(expected)
def test_should_500_if_load_survey_result_raise_exception(
mock_load: MagicMock, sut: LoadSurveyResultController):
mock_load.side_effect = Exception("Error on matrix")
http_response = sut.handle(HttpRequest(params=dict(survey_id="any_id")))
assert http_response.status_code == 500
assert http_response.body["message"] == "Internal server error"
def test_should_return_200_if_load_account_by_id_returns_an_account(
sut: AuthMiddleware, ):
http_response = sut.handle(
HttpRequest(headers={"x-access-token": "any_token"}, body=None))
assert http_response.status_code == 200
assert http_response.body
def test_should_return_403_if_load_account_by_id_returns_none(
mock_load: MagicMock, sut: AuthMiddleware):
mock_load.return_value = None
http_response = sut.handle(
HttpRequest(headers={"x-access-token": "any_token"}, body=None))
assert http_response.status_code == 403
def test_should_calls_load_account_by_id_correct_values(
mock_load: MagicMock, sut: AuthMiddleware):
sut.handle(HttpRequest(headers={"x-access-token": "any_token"}, body=None))
mock_load.assert_called_with(access_token="any_token", role=None)
def test_should_return_403_if_no_access_token_exists_in_headers(
sut: AuthMiddleware):
http_response = sut.handle(HttpRequest(headers=None, body=None))
assert http_response.status_code == 403
assert http_response.body["message"] == "Access danied"
def test_should_call_load_survey_result_with_correct_value(
mock_load: MagicMock, sut: LoadSurveyResultController):
mock_load.side_effect = Exception("Error on matrix")
sut.handle(HttpRequest(params=dict(survey_id="any_id")))
mock_load.assert_called_with("any_id")
