diff --git a/aircox/tests/conftest.py b/aircox/tests/conftest.py index bb93cca..4cbd7b1 100644 --- a/aircox/tests/conftest.py +++ b/aircox/tests/conftest.py @@ -12,6 +12,26 @@ def stations(): return baker.make(models.Station, _quantity=2) +@pytest.fixture +def stations_without_default(): + return baker.make(models.Station, _quantity=3, default=False) + + +@pytest.fixture +def station_default(): + return baker.make(models.Station, default=True) + + +@pytest.fixture +def stations_inactive(): + return baker.make(models.Station, _quantity=3, active=False) + + +@pytest.fixture +def station_active(): + return baker.make(models.Station, active=True) + + @pytest.fixture def programs(stations): items = list( diff --git a/aircox/tests/models/test_station.py b/aircox/tests/models/test_station.py index 952df10..eee4ec6 100644 --- a/aircox/tests/models/test_station.py +++ b/aircox/tests/models/test_station.py @@ -4,208 +4,229 @@ 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: +class TestStationQuerySet: + # default method : not possible to have several stations by default. + # default method : return a selected instance of station but do not save it. + def test_default_without_default_station(self, stations_without_default): + returned_station = Station.objects.default() - # 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 """ + assert returned_station is not None + assert returned_station == Station.objects.first() + + def test_default_with_pkargs_and_without_default_station( + self, stations_without_default + ): + station = stations_without_default[1] + returned_station = Station.objects.default( + station=station.pk + ) + + assert station == returned_station + + def test_default_with_default_station( + self, station_default, stations_without_default + ): + returned_default_station = Station.objects.default() + + assert returned_default_station == station_default + + def test_default_with_pkargs_and_default_station( + self, station_default, stations_without_default + ): + returned_default_station = Station.objects.default( + station=station_default.pk + ) + + assert returned_default_station == station_default - #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 + def test_active(self, station_active, stations_inactive): filtered_active_station = Station.objects.active() - # check: active station is returned - assert active_station in filtered_active_station + assert station_active 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 + def test_stream_field_filled(self, stations): 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 + assert station.streams == [ + "http://radiocampus.be/stream1.mp3", + "http://radiocampus.be/stream2.mp3", + ] + + def test_stream_field_empty(self, stations): 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. + def test_save_without_path(self, stations): 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() + assert ( + station.path + == settings.CONTROLLERS_WORKING_DIR + "\\a_slug_with_dash" + ) - # need to refresh fake db from baker in order to make the test. - station1.refresh_from_db() - station2.refresh_from_db() + def test_save_default_station_while_anotherone_is_default( + self, station_default, stations_without_default + ): + old_default_station = station_default + new_default_station = stations_without_default[1] + new_default_station.default = True + new_default_station.save() + old_default_station.refresh_from_db() + new_default_station.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 + assert old_default_station.default is False + assert new_default_station.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) - + # issues with the preset incompatibility between port and direction. + # I need to control which type and direction for each fake model + # Otherwhise pytest fail randomly. + def test_active_value_true(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 - + + def test_active_value_false(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, + ) + 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) + 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) + 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. + port = baker.make( + Port, type=Port.TYPE_ICECAST, direction=Port.DIRECTION_OUTPUT + ) + assert port.__str__() == "output: icecast #1" + 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) + 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) + 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 + def test_save_with_valid_type_icecast_output(self): + port = baker.make( + Port, type=Port.TYPE_ICECAST, direction=Port.DIRECTION_OUTPUT + ) + port.save() + saved_port = Port.objects.get(id=port.id) + assert saved_port is not None + def test_save_with_valid_type_file_output(self): + port = baker.make( + Port, type=Port.TYPE_FILE, direction=Port.DIRECTION_OUTPUT + ) + port.save() + saved_port = Port.objects.get(id=port.id) + assert saved_port is not None + def test_save_with_valid_type_http_input(self): + port = baker.make( + Port, type=Port.TYPE_HTTP, direction=Port.DIRECTION_INPUT + ) + port.save() + saved_port = Port.objects.get(id=port.id) + assert saved_port is not None + def test_save_with_valid_type_https_input(self): + port = baker.make( + Port, type=Port.TYPE_HTTPS, direction=Port.DIRECTION_INPUT + ) + port.save() + saved_port = Port.objects.get(id=port.id) + assert saved_port is not None - - - - - - - - - - - - - - - - - - - - - + def test_save_without_valid_type(self): + with pytest.raises(ValueError): + baker.make( + Port, type=Port.TYPE_HTTP, direction=Port.DIRECTION_OUTPUT + )