Example #1
0
    def test_get_properties_method():
        """
        Test get properties method in Family class

        """
        family = [
            Male(age=48),
            Female(age=45, pregnant='1'),
            Female(age=17),
            Male(age=13, sfo='1'),
            Female(age=5, kinder_garden='1')
        ]
        properties = {
            'inntekt': '1489000',
            'antall_biler': '2',
            'select_year': '2021'
        }
        for i, member in enumerate(family):
            for key, value in member.__dict__.items():
                if "_id" not in key:
                    properties.update({key[1:] + str(i): value})

        fam = Family(family, income=1489000, cars=2, select_year=2021)

        assert fam.sifo_properties() == properties
Example #2
0
    def test_that_family_get_set(self):
        """
        Test that Family object gets set if passed through constructor or setter

        """
        assert self.sifo.family == self.family

        new_family = Family(
            [Female(age=40),
             Female(age=13, sfo='1'),
             Male(age=10, sfo='1')])
        self.sifo.family = new_family
        assert self.sifo.family == new_family
Example #3
0
    def setup(cls):
        """
        Executed before every test

        """
        family_members = [
            Male(age=45),
            Female(age=40),
            Female(age=13, sfo='1'),
            Male(age=10, sfo='1')
        ]
        cls.family = Family(family_members, income=850000, cars=2)
        cls.sifo = Sifo(cls.family)
Example #4
0
    def setup(cls):
        """
        Executed before all tests

        """
        cls.family_members = [Male(age=39), Female(age=40)]
        cls.family = Family(cls.family_members)
Example #5
0
    def test_person_attending_kinder_garden_or_sfo(age):
        """
        Test that only person of age between 1-5 can attend kinder_garden and person between
        6-13 can attend sfo. ValueError thrown if not the case.

        """
        persons = [Male(), Female()]
        kinder_garden = age in range(1, 6)
        sfo = age in range(6, 14)
        for person in persons:
            if kinder_garden:
                person.alder = age
                person.barnehage = '1'
                assert person.alder == str(age)
                assert person.barnehage == '1'
            elif sfo:
                person.alder = age
                person.sfo = '1'
                assert person.alder == str(age)
                assert person.sfo == '1'
            else:
                with pt.raises(ValueError):
                    person.__class__(age, kinder_garden='1')
                with pt.raises(ValueError):
                    person.__class__(age, sfo='1')
Example #6
0
    def test_male_and_female_id_are_uuid4():
        """
        Test that Male and Female entity class ids are uuid4 compatible

        """
        for person in [Male(), Female()]:
            assert UUID(str(person.id_str))
Example #7
0
    def test_male_and_female_have_correct_gender():
        """
        Test that Male and Female objects have correct gender classification

        """
        persons = {'m': Male(), 'k': Female()}
        for gender, person in persons.items():
            assert person.kjonn == gender
Example #8
0
    def test_male_and_female_are_instances_and_subclasses_of_person_entity():
        """
        Test that all Male and Female instances are subclass and instance of
        Person and Entity classes

        """
        for person in [Male(), Female()]:
            for parents in [Person, Entity]:
                assert isinstance(person, parents)
                assert issubclass(person.__class__, parents)
Example #9
0
    def setup(cls):
        """
        Executed before every test

        """
        family_members = [Male(age=45), Female(age=40)]
        cls.family = Family(family_members,
                            income=850000,
                            cars=1,
                            select_year=2021)
        cls.sifo = Sifo(cls.family)
Example #10
0
    def test_arguments_gets_set_in_family_object_constructor(
            inntekt, antall_biler):
        """
        Test that valid arguments gets set into object through constructor

        """
        new_family = [Male(25), Female(24)]
        family = Family(new_family, inntekt, antall_biler, select_year=2021)

        assert family.familie_medlemmer == new_family
        assert family.inntekt == str(inntekt)
        assert family.antall_biler == str(antall_biler)
Example #11
0
    def test_add_family_members_method(self):
        """
        Test the add_family_members method in Family class

        """
        family = self.family
        children = [Male(age=12), Female(age=10)]
        family.add_family_members(children)
        assert len(family.family_members) == 4

        child = Male(age=5)
        family.add_family_members(child)
        assert len(family.family_members) == 5
Example #12
0
    def test_type_checking_person_input_arguments(invalid_age):
        """
        Test that TypeError is raised if invalid arg for age, kinder_garden or sfo is passed
        to person (Male or Female) object.

        """
        persons = [Male(), Female()]
        for person in persons:
            with pt.raises(TypeError):
                person.alder = invalid_age
            with pt.raises(TypeError):
                person.barnehage = invalid_age
            with pt.raises(TypeError):
                person.sfo = invalid_age
Example #13
0
    def test_arguments_gets_set_in_family_object(self, inntekt, antall_biler):
        """
        Test that valid arguments gets set into object

        """
        family = self.family
        new_family = [Male(25), Female(24)]

        family.family_members = new_family
        family.inntekt = inntekt
        family.antall_biler = antall_biler

        assert family.family_members == new_family
        assert family.inntekt == str(inntekt)
        assert family.antall_biler == str(antall_biler)
Example #14
0
    def test_female_pregnancy(age):
        """
        Test that females can be pregnant only at ages between 19-50 years

        """
        female = Female()
        pregnancy = age in range(19, 51)
        if pregnancy:
            female.alder = age
            female.gravid = '1'
            assert female.alder == str(age)
            assert female.gravid == '1'
        else:
            with pt.raises(ValueError):
                female.__class__(age, pregnant='1')
Example #15
0
class TestFamily:
    """
    Test class for the entity Family()

    """
    @classmethod
    def setup(cls):
        """
        Executed before all tests

        """
        cls.family_members = [Male(age=39), Female(age=40)]
        cls.family = Family(cls.family_members)

    @classmethod
    def teardown(cls):
        """
        Executed after all tests

        """
        cls.family = None

    def test_family_object_is_instance_of_family(self):
        """
        Test that all family objects are instances of Family class

        """
        for parents in [Entity, ABC]:
            isinstance(self.family, parents)
            issubclass(self.family.__class__, parents)

    @pt.mark.parametrize('invalid_arg',
                         [True, 'test', 90210, 90210.0, ('test', 'test'), {}])
    def test_family_members_type_are_list(self, invalid_arg):
        """
        Test that Family object raises TypeError if family_members argument are invalid

        """
        with pt.raises(TypeError):
            self.family.family_members = invalid_arg

    def test_family_cannot_be_empty(self):
        """
        Test that family_members cannot be empty

        """
        with pt.raises(ValueError):
            self.family.family_members = []

    @pt.mark.parametrize('invalid_arg', [(), {}, []])
    def test_income_and_cars_type_error_for_invalid_arguments(
            self, invalid_arg):
        """
        TypeError raised when invalid income and cars argument types passed into Family class
        through constructor or setter

        """
        with pt.raises(TypeError):
            self.family.inntekt = invalid_arg
        with pt.raises(TypeError):
            self.family.antall_biler = invalid_arg

    @pt.mark.parametrize('negative_income',
                         [-1094400, -1094400.0, '-1094400', '-1094400.0'])
    @pt.mark.parametrize('negative_cars', [-1, '-1'])
    def test_income_and_cars_cannot_be_negative(self, negative_income,
                                                negative_cars):
        """
        Test that ValueError is raised if negative values for income and cars are passed into
        Family class through constructor or setter

        """
        with pt.raises(ValueError):
            self.family.inntekt = negative_income
        with pt.raises(ValueError):
            self.family.antall_biler = negative_cars

    @pt.mark.parametrize('inntekt', [594400, 594400, '594400', '594400'])
    @pt.mark.parametrize('antall_biler', [0, '0'])
    def test_arguments_gets_set_in_family_object(self, inntekt, antall_biler):
        """
        Test that valid arguments gets set into object

        """
        family = self.family
        new_family = [Male(25), Female(24)]

        family.family_members = new_family
        family.inntekt = inntekt
        family.antall_biler = antall_biler

        assert family.family_members == new_family
        assert family.inntekt == str(inntekt)
        assert family.antall_biler == str(antall_biler)

    @staticmethod
    @pt.mark.parametrize(
        'invalid_family',
        [Male(17), Female(17), [Male(17), Female(17)]])
    def test_family_cannot_exist_without_guardianship(invalid_family):
        """
        Test that Family object cannot exist without guardianship, i.e. must have atleast one
        person over 18 years.

        """
        with pt.raises(NotPossibleError):
            family = Family(invalid_family) if isinstance(
                invalid_family, list) else Family([invalid_family])
            print(family)

    def test_add_family_members_method(self):
        """
        Test the add_family_members method in Family class

        """
        family = self.family
        children = [Male(age=12), Female(age=10)]
        family.add_family_members(children)
        assert len(family.family_members) == 4

        child = Male(age=5)
        family.add_family_members(child)
        assert len(family.family_members) == 5

    @staticmethod
    def test_get_properties_method():
        """
        Test get properties method in Family class

        """
        family = [
            Male(age=48),
            Female(age=45, pregnant='1'),
            Female(age=17),
            Male(age=13, sfo='1'),
            Female(age=5, kinder_garden='1')
        ]
        properties = {'inntekt': '1489000', 'antall_biler': '2'}
        for i, member in enumerate(family):
            for key, value in member.__dict__.items():
                if "id" not in key:
                    properties.update({key[1:] + str(i): value})

        fam = Family(family, income=1489000, cars=2)
        assert fam.sifo_properties() == properties

    def test_that_id_not_in_sifo_properties(self):
        """
        Test that sifo_properties() does not include entity id's

        """
        prop = self.family.sifo_properties()
        assert 'id' not in prop.keys()

    def test_family_object_id_are_uuid4(self):
        """
        Test that all entity ids are uuid4 compatible

        """
        assert UUID(str(self.family.id_str))