Пример #1
0
 def test_cost_attribute_is_None(self):
     """testing if the cost attribute will be 0.0 if it is set to None
     """
     g = Good(**self.kwargs)
     self.assertNotEqual(g.cost, 0)
     g.cost = None
     self.assertEqual(g.cost, 0)
Пример #2
0
 def test_msrp_attribute_is_None(self):
     """testing if the msrp attribute will be 0.0 if it is set to None
     """
     g = Good(**self.kwargs)
     self.assertNotEqual(g.msrp, 0)
     g.msrp = None
     self.assertEqual(g.msrp, 0)
Пример #3
0
 def test_unit_attribute_is_working_properly(self):
     """testing if the unit attribute value can be changed properly
     """
     test_value = 'this is my unit'
     g = Good(**self.kwargs)
     self.assertNotEqual(g.unit, test_value)
     g.unit = test_value
     self.assertEqual(g.unit, test_value)
Пример #4
0
 def test_unit_attribute_is_set_to_None(self):
     """testing if the unit attribute will be an empty string if it is set
     to None
     """
     g = Good(**self.kwargs)
     self.assertNotEqual(g.unit, '')
     g.unit = None
     self.assertEqual(g.unit, '')
Пример #5
0
 def test_msrp_attribute_is_zero(self):
     """testing if it is totally ok to test the msrp attribute to 0
     """
     g = Good(**self.kwargs)
     self.assertNotEqual(g.msrp, 0.0)
     g.msrp = 0.0
     self.assertEqual(
         g.msrp,
         0.0
     )
Пример #6
0
    def test_unit_attribute_is_not_a_string(self):
        """testing if a TypeError will be raised if the unit attribute is set
        to a value which is not a string
        """
        g = Good(**self.kwargs)
        with self.assertRaises(TypeError) as cm:
            g.unit = 2342

        self.assertEqual(str(cm.exception),
                         'Good.unit should be a string, not int')
Пример #7
0
    def test_msrp_attribute_is_negative(self):
        """testing if ValueError will be raised if the msrp attribute is set to
        a negative number
        """
        g = Good(**self.kwargs)
        with self.assertRaises(ValueError) as cm:
            g.msrp = -10

        self.assertEqual(str(cm.exception),
                         'Good.msrp should be a non-negative number')
Пример #8
0
    def test_msrp_attribute_is_not_a_number(self):
        """testing if a TypeError will be raised if the msrp attribute is set
        to something other than a number
        """
        g = Good(**self.kwargs)
        with self.assertRaises(TypeError) as cm:
            g.msrp = 'not a number'

        self.assertEqual(str(cm.exception),
                         'Good.msrp should be a non-negative number, not str')
Пример #9
0
 def test_cost_attribute_is_zero(self):
     """testing if it is totally ok to test the cost attribute to 0
     """
     g = Good(**self.kwargs)
     self.assertNotEqual(g.cost, 0.0)
     g.cost = 0.0
     self.assertEqual(
         g.cost,
         0.0
     )
Пример #10
0
    def test_client_attribute_is_set_to_a_value_other_than_a_client(self):
        """testing if a TypeError will be raised when the client attribute is
        set to a value other than a Client instance
        """
        g = Good(**self.kwargs)
        with pytest.raises(TypeError) as cm:
            g.client = 'not a client'

        assert str(cm.value) == \
            'Good.client attribute should be a stalker.models.client.Client ' \
            'instance, not str'
Пример #11
0
    def test_goods_attribute_is_working_properly(self):
        """testing if the goods attribute is working properly
        """
        client1 = Client(**self.kwargs)
        from stalker.models.budget import Good
        good1 = Good(name='Test Good 1')
        good2 = Good(name='Test Good 2')
        good3 = Good(name='Test Good 3')
        client1.goods = [good1, good2, good3]

        assert client1.goods == [good1, good2, good3]
Пример #12
0
    def test_cost_attribute_is_not_a_number(self):
        """testing if a TypeError will be raised if the cost attribute is set
        to something other than a number
        """
        g = Good(**self.kwargs)
        with self.assertRaises(TypeError) as cm:
            g.cost = 'not a number'

        self.assertEqual(
            str(cm.exception),
            'Good.cost should be a non-negative number, not str'
        )
Пример #13
0
    def test_unit_attribute_is_not_a_string(self):
        """testing if a TypeError will be raised if the unit attribute is set
        to a value which is not a string
        """
        g = Good(**self.kwargs)
        with self.assertRaises(TypeError) as cm:
            g.unit = 2342

        self.assertEqual(
            str(cm.exception),
            'Good.unit should be a str, not int'
        )
Пример #14
0
    def test_msrp_attribute_is_negative(self):
        """testing if ValueError will be raised if the msrp attribute is set to
        a negative number
        """
        g = Good(**self.kwargs)
        with self.assertRaises(ValueError) as cm:
            g.msrp = -10

        self.assertEqual(
            str(cm.exception),
            'Good.msrp should be a non-negative number'
        )
Пример #15
0
 def test_msrp_attribute_is_working_properly(self):
     """testing if the msrp attribute value can be properly changed
     """
     test_value = 145
     g = Good(**self.kwargs)
     self.assertNotEqual(
         g.msrp,
         test_value
     )
     g.msrp = test_value
     self.assertEqual(
         g.msrp,
         test_value
     )
Пример #16
0
 def test_msrp_argument_is_skipped(self):
     """testing if the msrp attribute value will be 0.0 if the msrp argument
     is skipped
     """
     self.kwargs.pop('msrp')
     g = Good(**self.kwargs)
     assert g.msrp == 0
Пример #17
0
 def test_unit_argument_is_None(self):
     """testing if the unit attribute will be an empty string if the unit
     argument is None
     """
     self.kwargs['unit'] = None
     g = Good(**self.kwargs)
     assert g.unit == ''
Пример #18
0
 def test_cost_argument_is_skipped(self):
     """testing if the cost attribute value will be 0.0 if the cost argument
     is skipped
     """
     self.kwargs.pop('cost')
     g = Good(**self.kwargs)
     assert g.cost == 0
Пример #19
0
 def test_unit_argument_is_skipped(self):
     """testing if the unit attribute will be an empty string if the unit
     argument is skipped
     """
     self.kwargs.pop('unit')
     g = Good(**self.kwargs)
     assert g.unit == ''
Пример #20
0
 def test_msrp_argument_is_None(self):
     """testing if the msrp attribute value will be 0.0 if the msrp argument
     is None
     """
     self.kwargs['msrp'] = None
     g = Good(**self.kwargs)
     assert g.msrp == 0
Пример #21
0
 def test_cost_argument_is_None(self):
     """testing if the cost attribute value will be 0.0 if the cost argument
     is None
     """
     self.kwargs['cost'] = None
     g = Good(**self.kwargs)
     assert g.cost == 0
Пример #22
0
 def test_client_argument_is_none(self):
     """testing if a Good can be created without a Client
     """
     self.kwargs['client'] = None
     g = Good(**self.kwargs)
     assert g is not None
     assert isinstance(g, Good)
Пример #23
0
 def test_client_argument_is_skipped(self):
     """testing if a Good can be created without a Client
     """
     self.kwargs.pop('client', None)
     g = Good(**self.kwargs)
     assert g is not None
     assert isinstance(g, Good)
Пример #24
0
 def test_cost_argument_is_working_properly(self):
     """testing if the cost argument value is properly passed to the cost
     attribute
     """
     test_value = 113
     self.kwargs['cost'] = test_value
     g = Good(**self.kwargs)
     assert g.cost == test_value
Пример #25
0
 def test_unit_argument_is_working_properly(self):
     """testing if the unit argument value is properly passed to the unit
     attribute
     """
     test_value = 'this is my unit'
     self.kwargs['unit'] = test_value
     g = Good(**self.kwargs)
     assert g.unit == test_value
Пример #26
0
 def test_client_argument_is_working_properly(self):
     """testing if the client argument is working properly
     """
     from stalker.models.client import Client
     client = Client(name='Test Client')
     self.kwargs['client'] = client
     g = Good(**self.kwargs)
     assert g.client == client
Пример #27
0
 def test_msrp_argument_is_working_properly(self):
     """testing if the msrp argument value is properly passed to the msrp
     attribute
     """
     test_value = 113
     self.kwargs['msrp'] = test_value
     g = Good(**self.kwargs)
     assert g.msrp == test_value
Пример #28
0
    def test_cost_argument_is_negative(self):
        """testing if a ValueError will be raised if the cost argument is a
        negative number
        """
        self.kwargs['cost'] = -10
        with pytest.raises(ValueError) as cm:
            g = Good(**self.kwargs)

        assert str(cm.value) == 'Good.cost should be a non-negative number'
Пример #29
0
    def test_cost_argument_is_negative(self):
        """testing if a ValueError will be raised if the cost argument is a
        negative number
        """
        self.kwargs['cost'] = -10
        with self.assertRaises(ValueError) as cm:
            g = Good(**self.kwargs)

        self.assertEqual(str(cm.exception),
                         'Good.cost should be a non-negative number')
Пример #30
0
    def test_cost_argument_is_not_a_number(self):
        """testing if a TypeError will be raised if cost argument is not a
        number
        """
        self.kwargs['cost'] = 'not a number'
        with pytest.raises(TypeError) as cm:
            g = Good(**self.kwargs)

        assert str(cm.value) == \
            'Good.cost should be a non-negative number, not str'
Пример #31
0
    def test_cost_argument_is_not_a_number(self):
        """testing if a TypeError will be raised if cost argument is not a
        number
        """
        self.kwargs['cost'] = 'not a number'
        with self.assertRaises(TypeError) as cm:
            g = Good(**self.kwargs)

        self.assertEqual(str(cm.exception),
                         'Good.cost should be a non-negative number, not str')
Пример #32
0
    def test_unit_argument_is_not_a_string(self):
        """testing if a TypeError will be raised if the unit argument is not a
        string
        """
        self.kwargs['unit'] = 12312
        with pytest.raises(TypeError) as cm:
            g = Good(**self.kwargs)

        assert str(cm.value) == \
            'Good.unit should be a string, not int'
Пример #33
0
    def test_unit_argument_is_not_a_string(self):
        """testing if a TypeError will be raised if the unit argument is not a
        string
        """
        self.kwargs['unit'] = 12312
        with self.assertRaises(TypeError) as cm:
            g = Good(**self.kwargs)

        self.assertEqual(str(cm.exception),
                         'Good.unit should be a str, not int')
Пример #34
0
    def test_client_argument_is_not_a_client_instance(self):
        """testing if a TypeError will be raised if the client argument is not
        a Client instance
        """
        self.kwargs['client'] = 'not a client'
        with pytest.raises(TypeError) as cm:
            Good(**self.kwargs)

        assert str(cm.value) == \
            'Good.client attribute should be a stalker.models.client.Client ' \
            'instance, not str'
Пример #35
0
 def test_cost_argument_is_zero(self):
     """testing if it is totally ok to set the cost to 0
     """
     self.kwargs['cost'] = 0
     g = Good(**self.kwargs)
     assert g.cost == 0.0
Пример #36
0
 def test_msrp_argument_is_zero(self):
     """testing if it is totally ok to set the msrp to 0
     """
     self.kwargs['msrp'] = 0
     g = Good(**self.kwargs)
     assert g.msrp == 0.0