From c5db6daa837b747a4c5c93d37a01f3ef4b5db68e Mon Sep 17 00:00:00 2001 From: lauvwbk Date: Mon, 8 May 2023 15:19:31 +0200 Subject: [PATCH] pytest station model --- aircox/tests/models/test_station.py | 211 ++++++++++++++++++++++++++++ 1 file changed, 211 insertions(+) create mode 100644 aircox/tests/models/test_station.py diff --git a/aircox/tests/models/test_station.py b/aircox/tests/models/test_station.py new file mode 100644 index 0000000..70534c9 --- /dev/null +++ b/aircox/tests/models/test_station.py @@ -0,0 +1,211 @@ +import pytest + +from model_bakery import baker + +from aircox.models import Station, Port + +from aircox.tests.conftest import stations + +from aircox.conf import settings + +#(j'ai utilisé Baker directement ici à plusieurs reprises car la fixture 'stations' du fichier conftest génère des champs aléatoires avec lesquelles j'avais du mal à réaliser les tests.) + + +@pytest.mark.django_db +class TestStationQuerySet: + + # test the default method: the method consists in recovering a single default station in different cases. The definition of the station by this method is a univocal choice (not possible to have several stations by default in the db). + # Each case assumes that several stations are already in the database according to different parameters. + def test_default_case1(self): + """ case 1 : + - no default station in db + - no station defined in method """ + + #fake db + baker.make(Station, _quantity=3, default=False) + + #method test + default_station = Station.objects.default() + + # check: we have recovered one single default station as the method indicates. + assert default_station is not None + assert default_station == Station.objects.first() + + def test_default_case2(self): + """ case 2 : + - one default station in db + - no station defined in method """ + + # fake db + baker.make(Station, _quantity=2, default=False) + default_station = baker.make(Station, default=True) + + # method test + specific_station = Station.objects.default() + + # check: default station is the one defined in the fake db + assert specific_station == default_station + + def test_default_case3(self): + """ case 3 : + - one default station in db + - one station define in method """ + + # fake db + baker.make(Station, _quantity=2, default=False) + default_station = baker.make(Station, default=True) + + # method test + specific_station = Station.objects.default(station=default_station.pk) + + # check: default station is the one defined in the method + assert specific_station == default_station + + + # test the active method: return all the active station's instance + def test_active(self): + baker.make(Station, _quantity=2, active=False) + active_station = baker.make(Station, active=True) + + # test + filtered_active_station = Station.objects.active() + + # check: active station is returned. + assert active_station in filtered_active_station + + + + +@pytest.mark.django_db +class TestStation: + + # test the streams method: create an array based on a text by separating each element by the break line character(\n). + def test_stream_field_filled(self): + #case 1 : text data with break lines is entered in the audio_streams field + streams_urls = "http://radiocampus.be/stream1.mp3\nhttp://radiocampus.be/stream2.mp3" + station = baker.make(Station, audio_streams=streams_urls) + assert station.streams == ["http://radiocampus.be/stream1.mp3", "http://radiocampus.be/stream2.mp3"] + + def test_stream_field_empty(self): + #case 2 : no data in the audio_streams field + station = baker.make(Station, audio_streams=None) + assert station.streams == [] + + # test the __str__ method = retrieve 'name' field of the station. + def test__str__(self, stations): + for station in stations: + assert station.name == station.__str__() + + # test save method : save the station data in a folder. + def test_save_without_path(self): + #case 1 : not directory path defined. + station = baker.make(Station, path=None, slug="a-slug-with-dash") + station.save() + assert station.path == settings.CONTROLLERS_WORKING_DIR + '\\a_slug_with_dash' + + def test_save_default_station_while_anotherone_is_default(self): + #case 2 : save a new station while another one is already set default. + station1 = baker.make(Station, default=True) + station2 = baker.make(Station, default=False) + + # need to switch station2 default value to true before to try save method. + station2.default = True + station2.save() + + # need to refresh fake db from baker in order to make the test. + station1.refresh_from_db() + station2.refresh_from_db() + + # check if the station we choose to be default is the only one + assert Station.objects.filter(default=True).count() == 1 + assert station1.default is False + assert station2.default is True + +@pytest.mark.django_db +class TestPortQuerySet: + # test active methode : retrieve active ports. + # issues with the preset incompatibility between port and direction. I need to control which type and direction for each fake model instance in order to run pytest without failing randomly. + def test_active(self): + port1 = baker.make(Port, active=True, type=Port.TYPE_ICECAST, direction=Port.DIRECTION_OUTPUT) + port2 = baker.make(Port, active=False, type=Port.TYPE_ICECAST, direction=Port.DIRECTION_OUTPUT) + + active_ports = Port.objects.active() + assert port1 in active_ports + assert port2 not in active_ports + + inactive_ports = Port.objects.active(value=False) + assert port1 not in inactive_ports + assert port2 in inactive_ports + + # test output method : retrieve output ports. + def test_output(self): + port1 = baker.make(Port, type=Port.TYPE_ICECAST, direction=Port.DIRECTION_OUTPUT) + port2 = baker.make(Port, type=Port.TYPE_HTTP, direction=Port.DIRECTION_INPUT) + + output_ports = Port.objects.output() + assert port1 in output_ports + assert port2 not in output_ports + + # test input method : retrieve input ports. + def test_input(self): + port1 = baker.make(Port, type=Port.TYPE_ICECAST, direction=Port.DIRECTION_OUTPUT) + port2 = baker.make(Port, type=Port.TYPE_HTTP, direction=Port.DIRECTION_INPUT) + + input_ports = Port.objects.input() + assert port1 not in input_ports + assert port2 in input_ports + +@pytest.mark.django_db +class TestPort: + # test __str__ method = return the "type", "direction" and "port id" data of a given "Port" model in one sentence. + def test__str__(self): + port = baker.make(Port, type=Port.TYPE_ICECAST, direction=Port.DIRECTION_OUTPUT) + assert port.__str__() == 'output: icecast #1' + + # test is_valid_type method = return a Boolean value according to the compatibility criteria between the type and the port of a given port's instance. Compatibilyt criteria are defined in the method. + def test_is_valid_type_and_type_is_input(self): + # case 1 : input direction. return 'true' if the type is compatible + porthttp = baker.make(Port, type=Port.TYPE_HTTP, direction=Port.DIRECTION_INPUT) + porthttps = baker.make(Port, type=Port.TYPE_HTTPS, direction=Port.DIRECTION_INPUT) + + assert porthttp.is_valid_type() == True + assert porthttps.is_valid_type() == True + + + def test_is_valid_type_and_type_is_not_input(self): + # case 2 : is not input direction return 'true' if the type is compatible + porticecast = baker.make(Port, type=Port.TYPE_ICECAST, direction=Port.DIRECTION_OUTPUT) + portfile = baker.make(Port, type=Port.TYPE_FILE, direction=Port.DIRECTION_OUTPUT) + + assert porticecast.is_valid_type() == True + assert portfile.is_valid_type() == True + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +