async def update_password(gebruiker: GebruikerResponseModel, token: str):
if auth.check_if_token_in_cache(token):
gebruiker.gebruikersnaam = auth.get_user_by_token(token)
gebruiker.wachtwoord = auth.hash_wachtwoord(gebruiker.wachtwoord)
controller.update_wachtwoord(gebruiker)
else:
raise HTTPException(status_code=401,
detail="Uw token is ongeldig of verlopen")
class TestGebruikerJSONParser(TestCase):
return_object = GebruikerResponseModel()
return_object.id = 1
return_object.gebruikersnaam = "gebruikersnaam"
return_object.wachtwoord = "wachtwoord"
return_object.rol = 1
return_object.tijdelijk_wachtwoord = 0
return_object2 = GebruikerResponseModel()
return_object2.id = 2
return_object2.gebruikersnaam = "gebruikersnaam"
return_object2.wachtwoord = "wachtwoord"
return_object2.rol = 1
return_object2.tijdelijk_wachtwoord = 0
return_list = [return_object, return_object2]
"""test_get_gebruikers_returns_empty_list test of het aanroepen van get gebruikers een lege lijst teruggeeft"""
@mock.patch.object(GebruikerJSONParser, '_data_handler', return_value=[])
def test_get_gebruikers_returns_empty_list(self, mocked_handler):
parser = GebruikerJSONParser()
result = parser.get_gebruikers()
assert result == []
"""test_get_gebruikers_gets_list_of_gebruikers test of get gebruikers een lijst met gebruikers teruggeeft"""
@mock.patch.object(GebruikerJSONParser,
'_data_handler',
return_value=return_list)
def test_get_gebruikers_gets_list_of_gebruikers(self, mocked_handler):
parser = GebruikerJSONParser()
result = parser.get_gebruikers()
assert result[0].gebruikersnaam == self.return_object2.gebruikersnaam
"""test_get_gebruiker_returns_one_gebruiker test of get gebruikers een enkele gebruiker teruggeeft"""
@mock.patch.object(GebruikerJSONParser,
'_data_handler',
return_value=return_list)
def test_get_gebruiker_returns_one_gebruiker(self, mocked_handler):
parser = GebruikerJSONParser()
result = parser.get_gebruikers(1)
assert result.gebruikersnaam == self.return_object.gebruikersnaam
async def post_gebruiker(model: GebruikerResponseModel, token: str):
if auth.can_user_access(token) and auth.check_of_user_is_beheerder(token):
model.wachtwoord = auth.hash_wachtwoord(model.wachtwoord)
return controller.create_gebruiker(model)
raise HTTPException(
status_code=405,
detail="Om deze actie uit te voeren heeft u beheerdersrechten nodig")
def test_update_user_calls_handler(self, mock_get_gebruikers,
mock_handler):
gebruiker = GebruikerResponseModel()
gebruiker.id = 1
gebruiker.gebruikersnaam = "Gebruiker"
gebruiker.tijdelijk_wachtwoord = 1
gebruiker.rol = 1
gebruiker.wachtwoord = "changeme"
self.mapper.update_user(gebruiker)
mock_handler.assert_called_with(
"UPDATE gebruiker SET gebruikersnaam = %s, wachtwoord = %s, rol = %s, tijdelijk_wachtwoord = %s WHERE id = %s",
(gebruiker.gebruikersnaam, gebruiker.wachtwoord, gebruiker.rol,
gebruiker.tijdelijk_wachtwoord, gebruiker.id), False)
def test_add_user_calls_mapper(self, mock_get_gebruikers, mock_handler):
gebruiker = GebruikerResponseModel()
gebruiker.gebruikersnaam = "Gebruiker"
gebruiker.tijdelijk_wachtwoord = 1
gebruiker.rol = 1
gebruiker.wachtwoord = "changeme"
self.mapper.add_user(gebruiker)
mock_handler.assert_called_with(
"INSERT INTO gebruiker (gebruikersnaam, wachtwoord, rol, tijdelijk_wachtwoord) VALUES " \
"(%s, %s, %s, %s)",
(gebruiker.gebruikersnaam, gebruiker.wachtwoord, gebruiker.rol, gebruiker.tijdelijk_wachtwoord), False)
async def login(gebruiker: GebruikerResponseModel):
print(gebruiker.json() + "\n\n\n")
if auth.authenticate_user(gebruiker.gebruikersnaam, gebruiker.wachtwoord):
return auth.generate_token(gebruiker.gebruikersnaam)
class TestAuthenticationService(TestCase):
auth = AuthenticationService()
token_model = TokenModel(token='test', verloop=-1)
"""test_add_token_adds_token test of er een token toegevoegd kan worden aan de cache"""
def test_add_token_adds_token(self):
self.auth._add_token(self.token_model)
includes = self.auth.token_cache.__contains__(self.token_model)
self.auth._delete_token(self.token_model)
assert includes
"""test_delete_token_deletes_token test of het verwijderen van een token uit de cache werkt"""
def test_delete_token_deletes_token(self):
self.auth._add_token(self.token_model)
self.auth._delete_token(self.token_model)
includes = self.auth.token_cache.__contains__(self.token_model)
assert not includes
"""test_check_expirations_removes_token checkt of _check_expirations de verlopen tokens verwijdert """
def test_check_expirations_removes_token(self):
self.auth._check_expirations()
includes = self.auth.token_cache.__contains__(self.token_model)
assert not includes
"""test_check_expirations_calls_remove_token test of de methode de _delete_token methode aanroept"""
@mock.patch.object(AuthenticationService, '_delete_token', return_value=[])
def test_check_expirations_calls_remove_token(self, mock_delete_token):
self.auth._add_token(self.token_model)
self.auth._check_expirations()
mock_delete_token.assert_called_with(self.token_model)
"""test_check_wachtwoord_returns_false checkt of check_wachtwoord geen foutieve wachtwoorden doorlaat"""
def test_check_wachtwoord_returns_false(self):
foutieve_hash = self.auth.hash_wachtwoord('foutieve_hash')
assert not self.auth._check_wachtwoord('string', foutieve_hash)
"""test_check_wachtwoord_returns_true checkt of een juist wachtwoord door de hash komt"""
def test_check_wachtwoord_returns_true(self):
goede_hash = self.auth.hash_wachtwoord('string')
assert self.auth._check_wachtwoord('string', goede_hash)
"""test_generate_token_returns_token test of er een token wordt gegenereerd door generate_token"""
@mock.patch.object(GebruikerMapper,
'get_gebruikers',
return_value=[
GebruikerResponseModel(id=1,
gebruikersnaam='Daniel',
wachtwoord='wachtwoord',
rol=0,
tijdelijk_wachtwoord=0)
])
def test_generate_token_returns_token(self, mocked_gebruikers):
gebruikersnaam = 'Daniel'
token = self.auth.generate_token(gebruikersnaam)
assert self.auth.check_if_token_in_cache(token.token)
"""test_check_if_token_in_cache_returns_true checkt of de token gevonden kan worden in de cache"""
@mock.patch.object(GebruikerMapper,
'get_gebruikers',
return_value=[
GebruikerResponseModel(id=1,
gebruikersnaam='Daniel',
wachtwoord='wachtwoord',
rol=0,
tijdelijk_wachtwoord=0)
])
def test_check_if_token_in_cache_returns_true(self, mocked_gebruikers):
gebruikersnaam = "Daniel"
token = self.auth.generate_token(gebruikersnaam)
assert self.auth.check_if_token_in_cache(token.token)
"""test_check_if_token_in_cache_returns_false checkt of een onjuist token niet kan worden gevonden in de cache"""
@mock.patch.object(GebruikerMapper,
'get_gebruikers',
return_value=[
GebruikerResponseModel(id=1,
gebruikersnaam='Daniel',
wachtwoord='wachtwoord',
rol=0,
tijdelijk_wachtwoord=0)
])
def test_check_if_token_in_cache_returns_false(self, mocked_gebruiker):
gebruikersnaam = "Daniel"
self.auth.generate_token(gebruikersnaam)
token = self.auth.hash_wachtwoord('fake_token')
assert not self.auth.check_if_token_in_cache(token)
"""test_can_user_access_returns_true test of de gebruiker gevalideerd kan worden vanuit de cache"""
@mock.patch.object(GebruikerMapper,
'get_gebruikers',
return_value=[
GebruikerResponseModel(id=1,
gebruikersnaam='Daniel',
wachtwoord='wachtwoord',
rol=0,
tijdelijk_wachtwoord=0)
])
def test_can_user_access_returns_true(self, mocked_gebruikers):
token = self.auth.generate_token('Daniel')
assert self.auth.can_user_access(token.token)
"""test_can_user_access_throws_exception test of de functie een exception teruggeeft als de token niet bestaat"""
def test_can_user_access_throws_exception(self):
self.assertRaises(HTTPException, self.auth.can_user_access, 'no_token')
"""test_authticate_throws_exception_if_no_users test of de functie een exceptie geeft als er geen gebruikers in
de database staan """
@mock.patch.object(GebruikerController,
'get_gebruikers',
return_value=None)
def test_authticate_throws_exception_if_no_users(self, mocked_result):
gebruikersnaam = "Daniel"
wachtwoord = 'onjuist_wachtwoord'
self.assertRaises(HTTPException, self.auth.authenticate_user,
gebruikersnaam, wachtwoord)
"""test_check_if_authenticate_returns_true checkt of een gebruiker in kan loggen loggen met juiste gegevens"""
@mock.patch.object(
GebruikerController,
"get_gebruikers",
return_value=[
GebruikerResponseModel(
id=1,
gebruikersnaam='test',
wachtwoord=
'$2y$12$qjdhqWU1ORp.7GUnkqjT4.g0Nzh//GhvyM6afMsGAj9vt.Rh.zSQC',
rol=0,
tijdelijk_wachtwoord=0)
])
def test_check_if_authenticate_returns_true(self,
mocked_gebruiker_response):
gebruikersnaam = 'test'
wachtwoord = 'wachtwoord'
assert self.auth.authenticate_user(gebruikersnaam, wachtwoord)
"""test_check_if_user_has_token_returns_exception checkt of de functie een exception teruggeeft als het
wachtwoord onjuist is """
@mock.patch.object(
GebruikerController,
"get_gebruikers",
return_value=[
GebruikerResponseModel(
id=1,
gebruikersnaam='test',
wachtwoord=
'$2y$12$qjdhqWU1ORp.7GUnkqjT4.g0Nzh//GhvyM6afMsGAj9vt.Rh.zSQC',
rol=0,
tijdelijk_wachtwoord=0)
])
def test_check_if_user_has_token_returns_exception(
self, mocked_gebruiker_response):
gebruikersnaam = "test"
wachtwoord = 'onjuist_wachtwoord'
self.assertRaises(HTTPException, self.auth.authenticate_user,
gebruikersnaam, wachtwoord)
"""test_hash_wachtwoord_returns_hashed_wachtwoord test of er een wachtwoord gehasht kan worden"""
def test_hash_wachtwoord_returns_hashed_wachtwoord(self):
wachtwoord = 'test'
result = self.auth.hash_wachtwoord(wachtwoord)
assert self.auth._check_wachtwoord(wachtwoord, result)
@mock.patch.object(auth, 'get_user_by_token', return_value="naam")
@mock.patch.object(GebruikerController,
'check_is_beheerder',
return_value=True)
def test_check_of_user_is_beheerder_calls_check_is_beheerder(
self, mocked_check_of_user_is_beheerder, mocked_get_user_by_token):
self.auth.check_of_user_is_beheerder("token")
mocked_check_of_user_is_beheerder.assert_called_with("naam")
@mock.patch.object(auth, 'get_user_by_token', return_value="naam")
@mock.patch.object(GebruikerController,
'check_is_beheerder',
return_value=True)
def test_check_of_user_is_beheerder_calls_check_is_beheerder(
self, mocked_check_of_user_is_beheerder, mocked_get_user_by_token):
self.auth.check_of_user_is_beheerder("token")
mocked_get_user_by_token.assert_called_with("token")
@mock.patch.object(auth, 'get_user_by_token', return_value="naam")
@mock.patch.object(GebruikerController,
'check_is_beheerder',
return_value=True)
def test_check_of_user_is_beheerder_returns_True(
self, mocked_check_of_user_is_beheerder, mocked_get_user_by_token):
result = self.auth.check_of_user_is_beheerder("token")
assert result == True
@mock.patch.object(auth, 'get_user_by_token', return_value="naam")
@mock.patch.object(GebruikerController,
'check_is_beheerder',
return_value=False)
def test_check_of_user_is_beheerder_returns_False(
self, mocked_check_of_user_is_beheerder, mocked_get_user_by_token):
result = self.auth.check_of_user_is_beheerder("token")
assert result == False
def setUp(self):
self.sut = TestClient(app)
self.gebruiker = GebruikerResponseModel()
self.token = "1234-1234-1234-1234"
class TestGebruikerView(TestCase):
"""test_get_gebruikers test of get_gebruikers de correcte status code teruggeeft"""
def setUp(self):
self.sut = TestClient(app)
self.gebruiker = GebruikerResponseModel()
self.token = "1234-1234-1234-1234"
@mock.patch.object(GebruikerMapper, 'get_gebruikers', return_value=[])
@mock.patch.object(AuthenticationService,
'can_user_access',
return_value=True)
def test_get_gebruikers(self, mocked_auth, mocked_get_gebruikers):
response = self.sut.get("/?token=" + self.token)
assert response.status_code == 200
"""test_get_gebruikers_json test of get_gebruikers een json lijst teruggeeft"""
@mock.patch.object(AuthenticationService,
'can_user_access',
return_value=True)
@mock.patch.object(GebruikerMapper, 'get_gebruikers', return_value=[])
def test_get_gebruikers_json(self, mocked_get_gebruikers, mocked_auth):
response = self.sut.get("/?token=" + self.token)
assert response.json() == []
"""test_post_gebruiker test of post_gebruiker de correcte status code teruggeeft"""
@mock.patch.object(GebruikerMapper,
'add_user',
return_value=[
GebruikerResponseModel(id=1,
gebruikersnaam='Daniel',
wachtwoord='wachtwoord',
rol=0,
tijdelijk_wachtwoord=0)
])
@mock.patch.object(AuthenticationService,
'can_user_access',
return_value=True)
@mock.patch.object(AuthenticationService,
'check_of_user_is_beheerder',
return_value=True)
def test_post_gebruiker(self, mocked_auth, mocked_add_user,
mocked_check_of_user_is_beheerder):
response = self.sut.post("/?token=" + self.token,
json={
'id': 1,
'gebruikersnaam': 'nieuwe_gebruiker',
'wachtwoord': 'wachtwoord',
'rol': 0,
'tijdelijk_wachtwoord': 0
})
assert response.status_code == 201
"""test_post_gebruiker_json test of post_gebruiker een json lijst teruggeeft"""
@mock.patch.object(GebruikerMapper,
'add_user',
return_value=[
GebruikerResponseModel(id=1,
gebruikersnaam='Daniel',
wachtwoord='wachtwoord',
rol=0,
tijdelijk_wachtwoord=0)
])
@mock.patch.object(AuthenticationService,
'can_user_access',
return_value=True)
@mock.patch.object(AuthenticationService,
'check_of_user_is_beheerder',
return_value=True)
def test_post_gebruiker_json(self, mocked_auth, mocked_add_user,
mocked_check_of_user_is_beheerder):
response = self.sut.post("/?token=" + self.token, json={
"id": "1",
})
assert response.status_code == 201
"""test_update_gebruiker test of update_gebruiker de correcte status code teruggeeft"""
@mock.patch.object(GebruikerMapper,
'update_user',
return_value=[
GebruikerResponseModel(id=1,
gebruikersnaam='Daniel',
wachtwoord='wachtwoord',
rol=0,
tijdelijk_wachtwoord=0)
])
@mock.patch.object(AuthenticationService,
'can_user_access',
return_value=True)
@mock.patch.object(AuthenticationService,
'check_of_user_is_beheerder',
return_value=True)
def test_update_gebruiker(self, mocked_auth, mocked_update_user,
mocked_check_of_user_is_beheerder):
response = self.sut.put("/?token=" + self.token, json={
"id": "1",
})
assert response.status_code == 200
"""test_update_gebruiker tes of update_gebruiker een json lijst teruggeeft"""
@mock.patch.object(GebruikerMapper,
'update_user',
return_value=[
GebruikerResponseModel(id=1,
gebruikersnaam='Daniel',
wachtwoord='wachtwoord',
rol=0,
tijdelijk_wachtwoord=0)
])
@mock.patch.object(AuthenticationService,
'can_user_access',
return_value=True)
@mock.patch.object(AuthenticationService,
'check_of_user_is_beheerder',
return_value=True)
def test_update_gebruiker_json(self, mocked_auth, mocked_update_user,
mocked_check_of_user_is_beheerder):
response = self.sut.put("/?token=" + self.token, json={
"id": "1",
})
assert response.status_code == 200
"""test_delete_gebruiker test of delete_gebruiker de juiste status code teruggeeft"""
@mock.patch.object(DataMapper,
'_stored_procedure',
return_value="return_value")
@mock.patch.object(GebruikerMapper, 'delete_user', return_value=[])
@mock.patch.object(AuthenticationService,
'can_user_access',
return_value=True)
@mock.patch.object(AuthenticationService,
'check_of_user_is_beheerder',
return_value=True)
def test_delete_gebruiker(self, mocked_auth, mocked_gebruikers,
mocked_data_mapper,
mocked_check_of_user_is_beheerder):
response = self.sut.delete("/1/?token=" + self.token)
assert response.status_code == 200
"""test_delete_gebruiker_json test od delete_gebruiker een json lijst teruggeeft"""
@mock.patch.object(AuthenticationService,
'can_user_access',
return_value=True)
@mock.patch.object(AuthenticationService,
'check_of_user_is_beheerder',
return_value=True)
@mock.patch.object(GebruikerMapper, 'get_gebruikers', return_value=[])
@mock.patch.object(GebruikerMapper, 'delete_user', return_value=[])
def test_delete_gebruiker_json(self, mocked_delete, mocked_gebruikers,
mocked_auth,
mocked_check_of_user_is_beheerder):
response = self.sut.delete("/1/?token=" + self.token)
assert response.json() == []
"""Test of login() een status code 200 terug geeft"""
@mock.patch.object(
GebruikerMapper,
'get_gebruikers',
return_value=[
GebruikerResponseModel(
id=1,
gebruikersnaam='Daniel',
wachtwoord=
'$2y$12$qjdhqWU1ORp.7GUnkqjT4.g0Nzh//GhvyM6afMsGAj9vt.Rh.zSQC',
rol=0,
tijdelijk_wachtwoord=0)
])
@mock.patch.object(AuthenticationService,
'can_user_access',
return_value=True)
def test_login_geeft_een_200_status_code(self, mocked_auth,
mocked_get_gebruikers):
response = self.sut.post("/login",
json={
'id': 1,
'gebruikersnaam': 'Daniel',
'wachtwoord': 'wachtwoord',
'rol': 0,
'tijdelijk_wachtwoord': 0
})
assert response.status_code == 200
"""Test of login() de juiste token terug stuurt"""
@mock.patch.object(AuthenticationService,
'authenticate_user',
return_value=True)
@mock.patch.object(AuthenticationService,
'generate_token',
return_value='1234-1234-1234-1234')
@mock.patch.object(AuthenticationService,
'can_user_access',
return_value=True)
def test_login_geeft_een_token(self, mocked_access, mocked_token,
mocked_auth):
response = self.sut.post("/login",
json={
'id': 1,
'gebruikersnaam': 'Daniel',
'wachtwoord': 'wachtwoord',
'rol': 0,
'tijdelijk_wachtwoord': 0
})
print(response)
assert response.json() == self.token
"""Test of verify() de juiste boolean terug stuurt"""
@mock.patch.object(AuthenticationService,
'check_if_token_in_cache',
return_value=True)
def test_verify_retourneerd_true(self, mocked_auth):
response = self.sut.get("/verify?token=" + self.token)
assert response
"""Test of update_wachtwoord() check_if_token_in_cache() aanroept"""
@mock.patch.object(GebruikerController,
'update_wachtwoord',
return_value=None)
@mock.patch.object(AuthenticationService,
'hash_wachtwoord',
return_value="string")
@mock.patch.object(AuthenticationService,
'get_user_by_token',
return_value="string")
@mock.patch.object(AuthenticationService,
'check_if_token_in_cache',
return_value=True)
def test_update_wachtwoord_called_auth_check_if_token_in_cache(
self, mock_check_if_token_in_cache, mock_get_user_by_token,
mock_hash_password, mock_update_wachtwoord):
# Arrange
# Act
self.sut.put("/update_password?token=" + self.token,
self.gebruiker.json())
# Assert
mock_check_if_token_in_cache.assert_called()
"""Test of update_wachtwoord() get_user_by_token() aanroept"""
@mock.patch.object(GebruikerController,
'update_wachtwoord',
return_value=None)
@mock.patch.object(AuthenticationService,
'hash_wachtwoord',
return_value="string")
@mock.patch.object(AuthenticationService,
'get_user_by_token',
return_value="string")
@mock.patch.object(AuthenticationService,
'check_if_token_in_cache',
return_value=True)
def test_update_wachtwoord_called_auth_get_user_by_token(
self, mock_check_if_token_in_cache, mock_get_user_by_token,
mock_hash_password, mock_update_wachtwoord):
# Arrange
# Act
self.sut.put("/update_password?token=" + self.token,
self.gebruiker.json())
# Assert
mock_get_user_by_token.assert_called()
"""Test of update_wachtwoord() hash_wachtwoord aanroept"""
@mock.patch.object(GebruikerController,
'update_wachtwoord',
return_value=None)
@mock.patch.object(AuthenticationService,
'hash_wachtwoord',
return_value="string")
@mock.patch.object(AuthenticationService,
'get_user_by_token',
return_value="string")
@mock.patch.object(AuthenticationService,
'check_if_token_in_cache',
return_value=True)
def test_update_wachtwoord_called_auth_hash_password(
self, mock_check_if_token_in_cache, mock_get_user_by_token,
mock_hash_password, mock_update_wachtwoord):
# Arrange
# Act
self.sut.put("/update_password?token=" + self.token,
self.gebruiker.json())
# Assert
mock_hash_password.assert_called()
"""Test of update_wachtwoord() update_wachtwoord() aanroept"""
@mock.patch.object(GebruikerController,
'update_wachtwoord',
return_value=None)
@mock.patch.object(AuthenticationService,
'hash_wachtwoord',
return_value="string")
@mock.patch.object(AuthenticationService,
'get_user_by_token',
return_value="string")
@mock.patch.object(AuthenticationService,
'check_if_token_in_cache',
return_value=True)
def test_update_wachtwoord_called_controller_update_password(
self, mock_check_if_token_in_cache, mock_get_user_by_token,
mock_hash_password, mock_update_wachtwoord):
# Arrange
# Act
self.sut.put("/update_password?token=" + self.token,
self.gebruiker.json())
# Assert
mock_update_wachtwoord.assert_called()
@mock.patch.object(GebruikerController,
'update_wachtwoord',
return_value=None)
@mock.patch.object(AuthenticationService,
'hash_wachtwoord',
return_value="string")
@mock.patch.object(AuthenticationService,
'get_user_by_token',
return_value="string")
@mock.patch.object(AuthenticationService,
'check_if_token_in_cache',
return_value=False)
def test_update_wachtwoord_raises_HTTPException(
self, mock_check_if_token_in_cache, mock_get_user_by_token,
mock_hash_password, mock_update_wachtwoord):
# Arrange
# Act
try:
self.sut.put("/update_password?token=" + self.token,
self.gebruiker.json())
# Assert
except HTTPException as err:
assert err.detail == 'Uw token is ongeldig of verlopen'
@mock.patch.object(AuthenticationService,
'check_of_user_is_beheerder',
return_value=True)
def test_is_beheerder_calls_correct_method(
self, mock_check_of_user_is_beheerder):
self.sut.get('/is_beheerder?token=' + self.token)
mock_check_of_user_is_beheerder.assert_called_with(self.token)
@mock.patch.object(AuthenticationService,
'check_of_user_is_beheerder',
return_value=True)
@mock.patch.object(GebruikerController, 'get_rollen', return_value=[])
def test_get_rollen_calls_correct_methods_when_user_is_beheerder(
self, mock_get_rollen, mock_check_of_user_is_beheerder):
# Act
self.sut.get('/rollen?token=' + self.token)
# Assert
mock_get_rollen.assert_called()
mock_check_of_user_is_beheerder.assert_called()
@mock.patch.object(AuthenticationService,
'check_of_user_is_beheerder',
return_value=False)
@mock.patch.object(GebruikerController, 'get_rollen', return_value=[])
def test_get_rollen_thows_exception_when_not_beheerder(
self, mock_get_rollen, mock_check_of_user_is_beheerder):
# Act
try:
self.sut.get("/rollen?token=" + self.token)
# Assert
except HTTPException as err:
assert err.detail == 'U bent geen beheerder'
def get_gebruikers(self, id: int = None):
query = None
value = None
if id is None: # als er geen id is meegegeven
query = "SELECT * FROM gebruiker" # selecteren we alles uit de database
else:
query = "SELECT * FROM gebruiker WHERE id = %s" # anders geven we dat id mee
value = (id, )
result = self._data_handler(query, value, True)
gebruiker_lijst = []
for row in result: # voor iedere gebruiker die meegegeven wordt
gebruiker = GebruikerResponseModel(
) # maken we een nieuw model aan
if type(row) == GebruikerResponseModel:
gebruiker.id = row.id
gebruiker.gebruikersnaam = row.gebruikersnaam
gebruiker.wachtwoord = row.wachtwoord
gebruiker.rol = row.rol
gebruiker.tijdelijk_wachtwoord = row.tijdelijk_wachtwoord
if type(row) == tuple:
gebruiker.id = row[0]
gebruiker.gebruikersnaam = row[1]
gebruiker.wachtwoord = row[2]
gebruiker.rol = row[3]
gebruiker.tijdelijk_wachtwoord = row[4]
gebruiker_lijst.append(
gebruiker) # Voeg deze gebruiker toe aan de lijst
if id is not None:
return gebruiker_lijst[
0] # als er geen id is meegegeven, geven we het eerste (en enige) resultaat terug
else:
return gebruiker_lijst # anders geven we de hele lijst terug
def setUp(self):
self.gebruiker_controller = GebruikerController()
self.gebruiker_model = GebruikerResponseModel()
class TestGebruikerRepo(TestCase):
mapper = GebruikerMapper()
return_object = GebruikerResponseModel()
return_object.id = 1
return_object.gebruikersnaam = "gebruikersnaam"
return_object.wachtwoord = "wachtwoord"
return_object.rol = 1
return_object.tijdelijk_wachtwoord = 0
return_list = [return_object, return_object]
"""test_db_connection test of de db de connector aanroept"""
@mock.patch.object(mysql.connector, 'connect', return_value=[])
def test_db_connection(self, mock_connect):
self.mapper._db_connection()
mock_connect.assert_called()
"""test_get_gebruikers_returns_lijst test of 'get gebruikers' een lijst returnt"""
@mock.patch.object(GebruikerJSONParser,
'get_gebruikers',
return_value=return_object)
def test_get_gebruikers_returns_lijst(self, mock_parser):
result = self.mapper.get_gebruikers(1)
assert result.gebruikersnaam == self.return_object.gebruikersnaam
"""test_add_user_calls_mapper test of 'add_user' de mapper aanroept"""
@mock.patch.object(GebruikerMapper, '_data_handler', return_value=[])
@mock.patch.object(GebruikerMapper, 'get_gebruikers', return_value=[])
def test_add_user_calls_mapper(self, mock_get_gebruikers, mock_handler):
gebruiker = GebruikerResponseModel()
gebruiker.gebruikersnaam = "Gebruiker"
gebruiker.tijdelijk_wachtwoord = 1
gebruiker.rol = 1
gebruiker.wachtwoord = "changeme"
self.mapper.add_user(gebruiker)
mock_handler.assert_called_with(
"INSERT INTO gebruiker (gebruikersnaam, wachtwoord, rol, tijdelijk_wachtwoord) VALUES " \
"(%s, %s, %s, %s)",
(gebruiker.gebruikersnaam, gebruiker.wachtwoord, gebruiker.rol, gebruiker.tijdelijk_wachtwoord), False)
"""test_update_user_calls_handler test of de update functie de handler aanroept"""
@mock.patch.object(GebruikerMapper, '_data_handler', return_value=[])
@mock.patch.object(GebruikerMapper, 'get_gebruikers', return_value=[])
def test_update_user_calls_handler(self, mock_get_gebruikers,
mock_handler):
gebruiker = GebruikerResponseModel()
gebruiker.id = 1
gebruiker.gebruikersnaam = "Gebruiker"
gebruiker.tijdelijk_wachtwoord = 1
gebruiker.rol = 1
gebruiker.wachtwoord = "changeme"
self.mapper.update_user(gebruiker)
mock_handler.assert_called_with(
"UPDATE gebruiker SET gebruikersnaam = %s, wachtwoord = %s, rol = %s, tijdelijk_wachtwoord = %s WHERE id = %s",
(gebruiker.gebruikersnaam, gebruiker.wachtwoord, gebruiker.rol,
gebruiker.tijdelijk_wachtwoord, gebruiker.id), False)
"""test_delete_user_returns_list_of_users test of het verwijderen van een gebruiker een lijst met gebruikers
teruggeeft """
@mock.patch.object(GebruikerMapper, '_data_handler', return_value=[])
@mock.patch.object(GebruikerMapper,
'get_gebruikers',
return_value=return_list)
def test_delete_user_returns_list_of_users(self, get_mock, mock_handler):
result = self.mapper.delete_user(1)
assert result[0].gebruikersnaam == self.return_list[0].gebruikersnaam
@mock.patch.object(GebruikerMapper, '_data_handler', return_value=[])
@mock.patch.object(GebruikerMapper,
'get_gebruikers',
return_value=return_list)
def test_get_tijdelijk_wachtwoord_returns_int(self, get_mock,
mock_handler):
result = self.mapper.is_wachtwoord_tijdelijk(
self.return_object.gebruikersnaam)
assert result == self.return_list[0].tijdelijk_wachtwoord
@mock.patch.object(GebruikerMapper, '_data_handler', return_value=[])
def test_update_wachtwoord_calls__data_handler(self, mock__data_handler):
# Act
self.mapper.update_wachtwoord(self.return_object)
# Assert
mock__data_handler.assert_called()
@mock.patch.object(GebruikerMapper, '_data_handler', return_value=[(1, )])
def test_check_is_beheerder_calls__data_handler(self, mock__data_handler):
# Act
self.mapper.check_is_beheerder("test")
# Assert
mock__data_handler.assert_called()
@mock.patch.object(GebruikerMapper, '_data_handler', return_value=[(1, )])
def test_check_is_beheerder_returns_True(self, mock__data_handler):
# Act
result = self.mapper.check_is_beheerder("test")
# Assert
assert result == True
@mock.patch.object(GebruikerMapper, '_data_handler', return_value=[(0, )])
def test_check_is_beheerder_returns_False(self, mock__data_handler):
# Act
result = self.mapper.check_is_beheerder("test")
# Assert
assert result == False
@mock.patch.object(GebruikerMapper,
'_data_handler',
return_value=[(1, 'stuff')])
def test_get_rollen_returns_array_with_the_correct_length(
self, mock__data_handler):
# Arrange
expected_length = 1
# Act
result = self.mapper.get_rollen()
# Assert
mock__data_handler.assert_called()
assert len(result) == expected_length