test_simulation.py

"""
Tests for the Simulation class.
"""
import glob
import pytest
import os
import os.path

from biosim.island_manager import Island
from biosim.landscape_structure import HighLand, LowLand, Desert, Water
from biosim.simulation import BioSim
from biosim.animal_kingdom import Herbivore, Carnivore

__author__ = 'Mahrin Tasfe'
__email__ = 'mahrin.tasfe@nmbu.no'

SEED = 12345678  # random seed for tests


class TestBioSimSimulation:
    """
    Tests for Simulation class.
    """

    @pytest.fixture(autouse=True)
    def create_sim_with_no_pop_fixture(self):
        """ Creates an empty island with no population before  entering a test."""

        self.island_map_string = """\
        WWWWWWWWWWW
        WLHLLDDDDDW
        WLHLLDDDDDW
        WLHLLDDDDDW
        WLHLLDDDDDW
        WWWWWWWWWWW"""

        self.initial_pop = []
        self.seed = SEED
        self.sim_obj = BioSim(self.island_map_string, self.initial_pop, seed=self.seed,
                              vis_years=0)
        yield

    @pytest.fixture
    def reset_params_fixture(self):
        """
        Fixture resetting class parameters on both Herbivore & Carnivore. The fixture resets
        Herbivore & Carnivore class-level parameters before a test.
        """
        Herbivore.reset_params()
        Carnivore.reset_params()
        yield

    def test_sim_create(self):
        """
        Test that simulation can be created by just running setup.
        """
        assert self.sim_obj

    @pytest.mark.parametrize('animal_new_params', [('Herbivore', {'zeta': -3.2, 'xi': 1.8}),
                                                   ('Herbivore', {'zeta': 3.2, 'xi': -1.8}),
                                                   ('Herbivore', {'DeltaPhiMax': 100}),
                                                   ('Carnivore', {'DeltaPhiMax': 0}),
                                                   ('Dino', {'DeltaPhiMax': 10})])
    def test_set_animal_parameters_illegal(self, animal_new_params):
        """
        Test if ValueError is raised when illegal parameters for a species type is given.
        """
        species, new_params = animal_new_params
        with pytest.raises(ValueError):
            self.sim_obj.set_animal_parameters(species, new_params)

    @pytest.mark.parametrize('animal_class_type, animal_new_params',
                             [(Herbivore, ('Herbivore', {'zeta': 3.2, 'xi': 18})),
                              (Herbivore, ('Herbivore', {'zeta': 32, 'xi': 1.8})),
                              (Carnivore, ('Carnivore', {'DeltaPhiMax': 10}))])
    def test_set_animal_parameters(self, animal_class_type, animal_new_params):
        """
        Test if the set_params() is able to set the new given parameters properly.
        """
        species, new_params = animal_new_params
        self.sim_obj.set_animal_parameters(species, new_params)

        for parameter_name in new_params:
            assert animal_class_type.params[parameter_name] == new_params[parameter_name]

    @pytest.mark.parametrize('landscape_new_params', [('R', {'f_max': 700}), ('S', {'f_max': 700}),
                                                      ('T', {'f_max': 700})])
    def test_set_params_illegal(self, landscape_new_params):
        """
        Test if ValueError is raised when illegal parameters for a land type is given.
        """
        landscape, new_params = landscape_new_params
        with pytest.raises(ValueError):
            self.sim_obj.set_landscape_parameters(landscape, new_params)

    @pytest.mark.parametrize('landscape_class, landscape_new_params',
                             [(LowLand, ('L', {'f_max': 1000})), (HighLand, ('H', {'f_max': 100})),
                              (Desert, ('D', {'f_max': 1})), (Water, ('W', {'f_max': 50}))])
    def test_set_landscape_parameters(self, landscape_class, landscape_new_params):
        """
        Test if the set_params() is able to set the new given parameters properly.
        """
        landscape, new_params = landscape_new_params
        self.sim_obj.set_landscape_parameters(landscape, new_params)

        for parameter_name in new_params:
            assert landscape_class.params[parameter_name] == new_params[parameter_name]

    @pytest.mark.parametrize('population, result',
                             (([{'loc': (4, 4),
                                 'pop': [{'species': 'Carnivore', 'age': 5, 'weight': 20}
                                         for _ in range(20)]},
                                {'loc': (3, 3),
                                 'pop': [{'species': 'Herbivore', 'age': 5, 'weight': 20}
                                         for _ in range(5)]}],
                               {'Herbivore': 5, 'Carnivore': 20}),

                              ([{'loc': (5, 5),
                                 'pop': [{'species': 'Carnivore', 'age': 5, 'weight': 20}
                                         for _ in range(4)]},
                                {'loc': (2, 2),
                                 'pop': [{'species': 'Herbivore', 'age': 5, 'weight': 20}
                                         for _ in range(3)]}],
                               {'Herbivore': 3, 'Carnivore': 4})))
    def test_add_population(self, population, result):
        """
        Test if the add_population() works properly.
        """
        self.sim_obj.add_population(population)
        obtained_result = self.sim_obj.num_animals_per_species
        assert obtained_result == result

    def test_simulate_calls(self, mocker):
        """
        Test that Biosim class's simulate() method calls Island class's annual_cycle_on_island()
        method the correct number of times.
        """

        # mocker.spy wraps Island.annual_cycle_on_island() so that we can get a call count.
        mocker.spy(Island, 'annual_cycle_on_island')

        simulated_years = 20
        self.sim_obj.simulate(num_years=simulated_years)
        # noinspection PyUnresolvedReferences
        assert Island.annual_cycle_on_island.call_count == simulated_years

    def test_last_simulated_year_after_simulate(self):
        """
        Test that after calling the simulate() method for a fixed number of years,
        the 'year' named property which returns the last simulated year works properly.
        """
        last_simulated_year = 0
        simulated_year = 2
        for current_year in range(0, 10, simulated_year):
            self.sim_obj.simulate(num_years=simulated_year)
            last_simulated_year = last_simulated_year + simulated_year
            assert self.sim_obj.year == last_simulated_year

    @pytest.mark.parametrize('population, result',
                             (([{'loc': (4, 4),
                                 'pop': [{'species': 'Carnivore', 'age': 5, 'weight': 20}
                                         for _ in range(20)]},
                                {'loc': (3, 3),
                                 'pop': [{'species': 'Herbivore', 'age': 5, 'weight': 20}
                                         for _ in range(5)]}], 25),

                              ([{'loc': (5, 5),
                                 'pop': [{'species': 'Carnivore', 'age': 5, 'weight': 20}
                                         for _ in range(4)]},
                                {'loc': (2, 2),
                                 'pop': [{'species': 'Herbivore', 'age': 5, 'weight': 20}
                                         for _ in range(3)]}], 7)))
    def test_num_animals_class_property(self, population, result):
        """
        Test that the 'num_animals' named property which returns the total number of animals
        on the island works properly.
        """
        self.sim_obj.add_population(population)
        assert self.sim_obj.num_animals == result


@pytest.fixture
def reset_island_fixture():
    """
    The fixture resets the dictionary holding the island map before and after leaving a test.
    """
    Island.island_map = {}
    yield
    Island.island_map = {}


@pytest.mark.parametrize('ini_pop, result',
                         (([{'loc': (2, 2),
                             'pop': []}],
                           {'Herbivore': 0, 'Carnivore': 0}),


                          ([{'loc': (2, 2),
                             'pop': [{'species': 'Carnivore', 'age': 5, 'weight': 20}
                                     for _ in range(20)]},
                            {'loc': (3, 3),
                             'pop': [{'species': 'Herbivore', 'age': 5, 'weight': 20}
                                     for _ in range(5)]}],
                           {'Herbivore': 5, 'Carnivore': 20}),


                          ([{'loc': (2, 2),
                             'pop': [{'species': 'Carnivore', 'age': 5, 'weight': 20}
                                     for _ in range(4)]},
                            {'loc': (2, 2),
                             'pop': [{'species': 'Herbivore', 'age': 5, 'weight': 20}
                                     for _ in range(3)]}],
                           {'Herbivore': 3, 'Carnivore': 4})))
def test_initial_island_population(ini_pop, result, reset_island_fixture):
    """
    Test that simulation is set up with correct number of initial population.
    """
    island_map_string = """\
    WWWWWWWWWWW
    WLHLLDDDDDW
    WLHLLDDDDDW
    WWWWWWWWWWW"""

    sim_obj = BioSim(island_map_string, ini_pop=ini_pop, seed=SEED, vis_years=0)
    assert sim_obj.num_animals_per_species == result


@pytest.fixture
def fig_file_base():
    """Provides name for image base and delete image after test completion."""

    f_base = "figfileroot"
    yield f_base
    for f in glob.glob(f"{f_base}_0*.png"):
        os.remove(f)


def test_simulate_calls_vis_years(mocker, fig_file_base):
    """
    Test that BioSim class's simulate() method calls Island class's annual_cycle_on_island()
    method the correct number of times. This time with visualization on. Set up vis_years = 20.
    After every 20 years, images will be saved.
    """
    island_map_string = """\
    WWWWWWWWWWW
    WLHLLDDDDDW
    WLHLLDDDDDW
    WLHLLDDDDDW
    WLHLLDDDDDW
    WWWWWWWWWWW"""

    initial_pop = []
    sim_obj = BioSim(island_map_string, initial_pop, seed=SEED, vis_years=1,
                     img_base=fig_file_base, img_fmt='png', img_dir='.')

    # mocker.spy wraps Island.annual_cycle_on_island() so that we can get a call count.
    mocker.spy(Island, 'annual_cycle_on_island')

    simulated_years = 2
    sim_obj.simulate(num_years=simulated_years)

    # noinspection PyUnresolvedReferences
    assert Island.annual_cycle_on_island.call_count == simulated_years


def test_log_file_saved_with_directory_name_given():
    """Test that the log files are saved during simulation.
    This test only checks when the user has given a directory name for saving the log file.
    It does not test in case of absolute paths.
    It tests whether the created log file has been saved in inside the exact directory that
    user has given before the simulation started."""

    log_file_directory = 'log_test_results'

    for seed_val in range(4):
        sim = BioSim(island_map="WWWW\nWLHW\nWWWW",
                     ini_pop=[],
                     seed=seed_val,
                     log_file=log_file_directory, vis_years=0)
        sim.simulate(2)

        # This is the formet of log_file name I have used for writing the csv file using seed
        # Because user might be running code with several seed values.
        complete_log_name = "seed" + str(seed_val) + "_simulation_population_data.csv"
        complete_path_for_finding_log = '..//' + log_file_directory + '//' + complete_log_name

        # If log_file not found in the correct location assert
        assert os.path.isfile(complete_path_for_finding_log)

        # After completion of work removing/deleting the csv file.
        # For directory removal, it gives Permission Error.
        os.remove(complete_path_for_finding_log)