class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassa = Kassapaate()

    def test_luotu_kassa_oikein(self):
        self.assertEqual(round(self.kassa.kassassa_rahaa / 100, 2), 1000)
        self.assertEqual(self.kassa.edulliset + self.kassa.maukkaat, 0)

    def test_kateisosto_toimii_edullinen(self):
        self.kassa.syo_edullisesti_kateisella(250)
        self.kassa.syo_edullisesti_kateisella(230)
        self.assertEqual(round(self.kassa.kassassa_rahaa / 100, 2), 1002.4)
        self.assertEqual(self.kassa.edulliset, 1)
        self.assertEqual(self.kassa.syo_edullisesti_kateisella(250), 10)
        self.assertEqual(self.kassa.syo_edullisesti_kateisella(230), 230)

    def test_kateisosto_toimii_maukas(self):
        self.kassa.syo_maukkaasti_kateisella(410)
        self.kassa.syo_maukkaasti_kateisella(230)
        self.assertEqual(round(self.kassa.kassassa_rahaa / 100, 2), 1004.0)
        self.assertEqual(self.kassa.maukkaat, 1)
        self.assertEqual(self.kassa.syo_maukkaasti_kateisella(500), 100)
        self.assertEqual(self.kassa.syo_maukkaasti_kateisella(230), 230)

    def test_korttiosto_toimii_edullinen(self):
        kortti = Maksukortti(440)
        self.kassa.syo_edullisesti_kortilla(kortti)
        self.assertEqual(self.kassa.edulliset, 1)
        self.assertEqual(kortti.saldo, 200)
        kortti = Maksukortti(400)
        self.assertTrue(self.kassa.syo_edullisesti_kortilla(kortti))
        self.assertEqual(round(self.kassa.kassassa_rahaa / 100, 2), 1000)
        kortti = Maksukortti(200)
        self.kassa.syo_edullisesti_kortilla(kortti)
        self.assertEqual(kortti.saldo, 200)
        self.assertEqual(self.kassa.edulliset, 2)
        self.assertFalse(self.kassa.syo_edullisesti_kortilla(kortti))

    def test_korttiosto_toimii_maukas(self):
        kortti = Maksukortti(440)
        self.kassa.syo_maukkaasti_kortilla(kortti)
        self.assertEqual(self.kassa.maukkaat, 1)
        self.assertEqual(kortti.saldo, 40)
        kortti = Maksukortti(400)
        self.assertTrue(self.kassa.syo_maukkaasti_kortilla(kortti))
        self.assertEqual(round(self.kassa.kassassa_rahaa / 100, 2), 1000)
        kortti = Maksukortti(200)
        self.kassa.syo_maukkaasti_kortilla(kortti)
        self.assertEqual(kortti.saldo, 200)
        self.assertEqual(self.kassa.maukkaat, 2)
        self.assertFalse(self.kassa.syo_maukkaasti_kortilla(kortti))

    def test_lataaminen_toimii_kassalla(self):
        kortti = Maksukortti(100)
        self.kassa.lataa_rahaa_kortille(kortti, 100)
        self.assertEqual(kortti.saldo, 200)
        self.assertEqual(round(self.kassa.kassassa_rahaa / 100, 2), 1001.0)
        self.assertIsNone(self.kassa.lataa_rahaa_kortille(kortti, -100))
Example #2
0
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassapaate = Kassapaate()
        self.maksukortti = Maksukortti(0)

    def test_kassan_alkusaldot(self):
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
        self.assertEqual(self.kassapaate.edulliset, 0)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_kateisosto(self):
        self.kassapaate.syo_edullisesti_kateisella(240)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100240)
        self.assertEqual(self.kassapaate.edulliset, 1)
        self.kassapaate.syo_maukkaasti_kateisella(400)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100640)
        self.assertEqual(self.kassapaate.maukkaat, 1)
        self.kassapaate.syo_edullisesti_kateisella(200)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100640)
        self.assertEqual(self.kassapaate.edulliset, 1)
        self.kassapaate.syo_maukkaasti_kateisella(300)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100640)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_kortti_osto_saldo_riittaa_syodaan_edullisesti(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, 1000)
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(str(self.maksukortti), "saldo: 7.6")
        self.assertEqual(self.kassapaate.edulliset, 1)
        return True

    def test_kortti_osto_saldo_riittaa_syodaan_maukkaasti(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, 1000)
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(str(self.maksukortti), "saldo: 6.0")
        self.assertEqual(self.kassapaate.maukkaat, 1)
        return True

    def test_kassassa_oleva_saldo_ei_muutu_korttiostossa(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_kortti_osta_saldo_ei_riita(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(str(self.maksukortti), "saldo: 0.0")
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(str(self.maksukortti), "saldo: 0.0")
        self.assertEqual(self.kassapaate.edulliset, 0)
        self.assertEqual(self.kassapaate.maukkaat, 0)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
        return False

    def test_lataa_rahaa_kortille(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, 1000)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 101000)
        self.assertEqual(str(self.maksukortti), "saldo: 10.0")
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassapaate = Kassapaate()

    def test_alkutiedot_oikein(self):
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
        self.assertEqual(self.kassapaate.edulliset, 0)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_kateisostot_toimii(self):
        takaisin = self.kassapaate.syo_edullisesti_kateisella(400)
        self.assertEqual(takaisin, 160)
        takaisin = self.kassapaate.syo_edullisesti_kateisella(100)
        self.assertEqual(takaisin, 100)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100240)
        self.assertEqual(self.kassapaate.edulliset, 1)

        takaisin = self.kassapaate.syo_maukkaasti_kateisella(560)
        self.assertEqual(takaisin, 160)
        takaisin = self.kassapaate.syo_maukkaasti_kateisella(100)
        self.assertEqual(takaisin, 100)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100640)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_korttiostot_toimii(self):
        kortti = Maksukortti(700)

        tosi = self.kassapaate.syo_maukkaasti_kortilla(kortti)
        self.assertEqual(tosi, True)
        tosi = self.kassapaate.syo_edullisesti_kortilla(kortti)
        self.assertEqual(tosi, True)

        epatosi = self.kassapaate.syo_maukkaasti_kortilla(kortti)
        self.assertEqual(epatosi, False)
        epatosi = self.kassapaate.syo_edullisesti_kortilla(kortti)
        self.assertEqual(epatosi, False)

        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
        self.assertEqual(self.kassapaate.edulliset, 1)
        self.assertEqual(self.kassapaate.maukkaat, 1)
        self.assertEqual(str(kortti), "saldo: 0.6")

    def test_rahan_lataus_toimii(self):
        kortti = Maksukortti(100)

        self.kassapaate.lataa_rahaa_kortille(kortti, -20)
        self.kassapaate.lataa_rahaa_kortille(kortti, 100)
        self.assertEqual(str(kortti), "saldo: 2.0")
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100100)
Example #4
0
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassapaate = Kassapaate()
        self.maksukortti = Maksukortti(0)

    def test_maarat_alussa_oikein(self):
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
        self.assertEqual(self.kassapaate.edulliset, 0)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_kateisosto_toimii(self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(250), 10)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100240)
        self.assertEqual(self.kassapaate.edulliset, 1)
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(230), 230)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100240)
        self.assertEqual(self.kassapaate.edulliset, 1)
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(410), 10)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100640)
        self.assertEqual(self.kassapaate.maukkaat, 1)
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(390), 390)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100640)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_korttiosto_toimii(self):
        self.maksukortti.lataa_rahaa(250)
        self.assertEqual(self.maksukortti.saldo, 250)
        self.assertEqual(
            self.kassapaate.syo_edullisesti_kortilla(self.maksukortti), True)
        self.assertEqual(self.kassapaate.edulliset, 1)
        self.assertEqual(self.maksukortti.saldo, 10)
        self.assertEqual(
            self.kassapaate.syo_edullisesti_kortilla(self.maksukortti), False)
        self.assertEqual(self.kassapaate.edulliset, 1)
        self.assertEqual(self.maksukortti.saldo, 10)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, 500)
        self.assertEqual(self.maksukortti.saldo, 510)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100500)
        self.assertEqual(
            self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti), True)
        self.assertEqual(self.kassapaate.maukkaat, 1)
        self.assertEqual(self.maksukortti.saldo, 110)
        self.assertEqual(
            self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti), False)
        self.assertEqual(self.kassapaate.maukkaat, 1)
        self.assertEqual(self.maksukortti.saldo, 110)
        self.assertEqual(
            self.kassapaate.lataa_rahaa_kortille(self.maksukortti, -50), None)
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassapaate = Kassapaate()
        self.maksukortti = Maksukortti(640)

    def test_kassapaatteen_arvot_alussa_oikein(self):
        self.assertEqual((self.kassapaate.kassassa_rahaa, self.kassapaate.edulliset, self.kassapaate.maukkaat), (100000, 0, 0))

    def test_kateisosto_toimii_edullisissa_kun_maksu_on_riittava(self):
        vaihtoraha = self.kassapaate.syo_edullisesti_kateisella(241)
        self.assertEqual((self.kassapaate.kassassa_rahaa, vaihtoraha, self.kassapaate.edulliset), (100240, 1, 1))

    def test_kateisosto_toimii_maukkaissa_kun_maksu_on_riittava(self):
        vaihtoraha = self.kassapaate.syo_maukkaasti_kateisella(401)
        self.assertEqual((self.kassapaate.kassassa_rahaa, vaihtoraha, self.kassapaate.maukkaat), (100400, 1, 1))

    def test_kateisosto_toimii_edullisissa_kun_maksu_ei_ole_riittava(self):
        vaihtoraha = self.kassapaate.syo_edullisesti_kateisella(239)
        self.assertEqual((self.kassapaate.kassassa_rahaa, vaihtoraha, self.kassapaate.edulliset), (100000, 239, 0))

    def test_kateisosto_toimii_maukkaissa_kun_maksu_ei_ole_riittava(self):
        vaihtoraha = self.kassapaate.syo_maukkaasti_kateisella(399)
        self.assertEqual((self.kassapaate.kassassa_rahaa, vaihtoraha, self.kassapaate.maukkaat), (100000, 399, 0))

    def test_korttiosto_toimii_jos_rahaa_on_tarpeeksi(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual((self.kassapaate.kassassa_rahaa, self.kassapaate.edulliset, self.kassapaate.maukkaat, str(self.maksukortti)), (100000, 1, 1, "saldo: 0.0"))

    def test_korttiosto_toimii_jos_rahaa_ei_ole_tarpeeksi(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual((self.kassapaate.kassassa_rahaa, self.kassapaate.edulliset, self.kassapaate.maukkaat, str(self.maksukortti)), (100000, 1, 1, "saldo: 0.0"))

    def test_rahan_lataaminen_kortille_toimii_kun_summa_yli_0(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, 100)
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, -1)
        self.assertEqual((str(self.maksukortti), self.kassapaate.kassassa_rahaa), ("saldo: 7.4", 100100))
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassapaate = Kassapaate()
        self.maksukortti = Maksukortti(1000)

    def test_luodaan_uusi_kassapaate(self):
        self.assertNotEqual(self.kassapaate.kassassa_rahaa, 10000)

    def test_kateisosto_edullisesti_toimii(self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(600), 360)

    def test_kateisosto_maukkaasti_toimii(self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(600), 200)
    
    def test_kateisosto_maukkaasti_eitoimi(self):
        Kassapaate.syo_maukkaasti_kateisella(self, 99)
    
    def test_kateisosto_edullisesti_eitoimi(self):
        Kassapaate.syo_edullisesti_kateisella(self, 1)
    
    def test_korttiosto_maukkaasti_toimii(self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti), True)

    def test_korttiosto_maukkaasti_eitoimi(self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti), True)
        self.assertEqual(self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti), True)
        self.assertEqual(self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti), False)

    def test_korttiosto_edullisesti_toimii(self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kortilla(self.maksukortti), True)

    def test_korttiosto_edullisesti_eitoimi(self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kortilla(self.maksukortti), True)
        self.assertEqual(self.kassapaate.syo_edullisesti_kortilla(self.maksukortti), True)
        self.assertEqual(self.kassapaate.syo_edullisesti_kortilla(self.maksukortti), True)
        self.assertEqual(self.kassapaate.syo_edullisesti_kortilla(self.maksukortti), True)
        self.assertEqual(self.kassapaate.syo_edullisesti_kortilla(self.maksukortti), False)

    def test_lataa_negatiivinen(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, -10)
        self.assertEqual(str(self.maksukortti), "saldo: 10.0")

    def test_lataa_positiivinen(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, 10)
        self.assertEqual(str(self.maksukortti), "saldo: 10.1")
Example #7
0
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassa = Kassapaate()
        self.kortti = Maksukortti(1000)

    def test_alustuksessa_kassan_rahamaara_on_oikea(self):
        self.assertEqual(str(self.kassa.kassassa_rahaa), "100000")

    def test_alustuksessa_myytyjen_edullisten_maara_on_oikea(self):
        self.assertEqual(str(self.kassa.edulliset), "0")

    def test_alustuksessa_myytyjen_maukkaiden_maara_on_oikea(self):
        self.assertEqual(str(self.kassa.maukkaat), "0")

    def test_jos_maksu_kateisella_riittava_rahamaara_kasvaa_edullisen_hinnan_verran(
            self):
        self.kassa.syo_edullisesti_kateisella(240)
        self.assertEqual(str(self.kassa.kassassa_rahaa), "100240")

    def test_jos_maksu_kateisella_riittava_rahamaara_kasvaa_maukkaan_hinnan_verran(
            self):
        self.kassa.syo_maukkaasti_kateisella(400)
        self.assertEqual(str(self.kassa.kassassa_rahaa), "100400")

    def test_jos_maksu_kateisella_riittava_vaihtoraha_oikein_edullisella(self):
        self.assertEqual(str(self.kassa.syo_edullisesti_kateisella(250)), "10")

    def test_jos_maksu_kateisella_riittava_vaihtoraha_oikein_maukkaalla(self):
        self.assertEqual(str(self.kassa.syo_maukkaasti_kateisella(450)), "50")

    def test_jos_maksu_kateisella_riittava_ostettujen_edullisten_lounaiden_maara_kasvaa(
            self):
        self.kassa.syo_edullisesti_kateisella(240)
        self.assertEqual(str(self.kassa.edulliset), "1")

    def test_jos_maksu_kateisella_riittava_maukkaiden_lounaiden_maara_kasvaa(
            self):
        self.kassa.syo_maukkaasti_kateisella(400)
        self.assertEqual(str(self.kassa.maukkaat), "1")

    def test_jos_maksu_kateisella_ei_riittava_ostettujen_edullisten_lounaiden_maara_ei_kasvaa(
            self):
        self.kassa.syo_edullisesti_kateisella(200)
        self.assertEqual(str(self.kassa.edulliset), "0")

    def test_jos_maksu_kateisella_ei_riittava_ostettujen_maukkaiden_lounaiden_maara_ei_kasva(
            self):
        self.kassa.syo_maukkaasti_kateisella(200)
        self.assertEqual(str(self.kassa.edulliset), "0")

    def test_jos_maksu_kateisella_ei_riittava_rahat_palautetaan_edullisista(
            self):
        self.assertEqual(str(self.kassa.syo_edullisesti_kateisella(200)),
                         "200")

    def test_jos_maksu_ei_riittava_rahat_palautetaan_maukkaista(self):
        self.assertEqual(str(self.kassa.syo_maukkaasti_kateisella(350)), "350")

    def test_jos_maksu_kortilla_riittava_edulliseen_lounaaseen_palautetaan_True(
            self):
        self.assertEqual(str(self.kassa.syo_edullisesti_kortilla(self.kortti)),
                         "True")

    def test_jos_maksu_kortilla_riittava_maukkaseen_lounaaseen_palautetaan_True(
            self):
        self.assertEqual(str(self.kassa.syo_maukkaasti_kortilla(self.kortti)),
                         "True")

    def test_jos_maksu_kortilla_ei_riittava_edulliseen_lounaaseen_palautetaan_False(
            self):
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.kassa.syo_edullisesti_kortilla(self.kortti)
        self.kassa.syo_edullisesti_kortilla(self.kortti)
        self.assertEqual(str(self.kassa.syo_edullisesti_kortilla(self.kortti)),
                         "False")

    def test_jos_maksu_kortilla_ei_riittava_maukkaaseen_lounaaseen_palautetaan_False(
            self):
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.assertEqual(str(self.kassa.syo_maukkaasti_kortilla(self.kortti)),
                         "False")

    def test_jos_maksu_kortilla_riittava_kortilta_veloitetaan_edullisen_hinta(
            self):
        self.kassa.syo_edullisesti_kortilla(self.kortti)
        self.assertEqual(str(self.kortti.saldo), "760")

    def test_jos_maksu_kortilla_riittava_kortilta_veloitetaan_maukkaan_hinta(
            self):
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.assertEqual(str(self.kortti.saldo), "600")

    def test_jos_maksu_kortilla_riittava_edulliseen_kassa_ei_kasva(self):
        self.kassa.syo_edullisesti_kortilla(self.kortti)
        self.assertEqual(str(self.kassa.kassassa_rahaa), "100000")

    def test_jos_maksu_kortilla_riittava_maukkaaseen_kassa_ei_kasva(self):
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.assertEqual(str(self.kassa.kassassa_rahaa), "100000")

    def test_jos_maksu_kortilla_riittava_edullisten_maara_kasvaa(self):
        self.kassa.syo_edullisesti_kortilla(self.kortti)
        self.assertEqual(str(self.kassa.edulliset), "1")

    def test_jos_maksu_kortilla_riittava_maukkaiden_maara_kasvaa(self):
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.assertEqual(str(self.kassa.maukkaat), "1")

    def test_jos_maksu_kortilla_ei_riittava_edulliseen_edullisten_maara_muuttumaton(
            self):
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.kassa.syo_edullisesti_kortilla(self.kortti)
        self.assertEqual(str(self.kassa.edulliset), "0")

    def test_jos_maksu_kortilla_ei_riittava_maukkaaseen_lounaaseen_maukkaiden_maara_muuttumaton(
            self):
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.assertEqual(str(self.kassa.maukkaat), "2")

    def test_ladattaessa_rahaa_kortille_kortin_saldo_kasvaa(self):
        self.kassa.lataa_rahaa_kortille(self.kortti, 200)
        self.assertEqual(str(self.kortti.saldo), "1200"),

    def test_ladattaessa_rahaa_kortille_kassan_rahamaara_kasvaa(self):
        self.kassa.lataa_rahaa_kortille(self.kortti, 200)
        self.assertEqual(str(self.kassa.kassassa_rahaa), "100200")

    def test_ladattaessa_negatiivinen_summa_kortille_kortin_saldo_ei_muutu(
            self):
        self.kassa.lataa_rahaa_kortille(self.kortti, -200)
        self.assertEqual(str(self.kortti.saldo), "1000")
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassapaate = Kassapaate()
        self.maksukortti = Maksukortti(440)

    def test_kassapaatteen_rahamaara_on_oikein(self):
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_myytyjen_lounaiden_maara_oikein(self):
        self.assertEqual(self.kassapaate.edulliset + self.kassapaate.maukkaat,
                         0)

    def test_rahamaara_kasvaa_edullisen_hinnalla(self):
        self.kassapaate.syo_edullisesti_kateisella(240)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100240)

    def test_rahamaara_kasvaa_maukkaan_hinnalla(self):
        self.kassapaate.syo_maukkaasti_kateisella(400)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100400)

    def test_edullisten_maara_kasvaa(self):
        self.kassapaate.syo_edullisesti_kateisella(240)
        self.kassapaate.syo_edullisesti_kateisella(240)
        self.assertEqual(self.kassapaate.edulliset, 2)

    def test_maukkaiden_maara_kasvaa(self):
        self.kassapaate.syo_maukkaasti_kateisella(400)
        self.kassapaate.syo_maukkaasti_kateisella(400)
        self.assertEqual(self.kassapaate.maukkaat, 2)

    def test_vaihtorahan_maara_on_oikea_edullisesti(self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(250), 10)

    def test_vaihtorahan_maara_on_oikea_maukkaasti(self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(410), 10)

    def test_riittamaton_maksu_palautetaan_kokonaan_edullisesti(self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(200), 200)

    def test_riittamaton_maksu_palautetaan_kokonaan_maukkaasti(self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(200), 200)

    def test_riittamaton_maksu_ei_muuta_edullisia(self):
        self.kassapaate.syo_edullisesti_kateisella(240)
        self.kassapaate.syo_edullisesti_kateisella(200)
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_riittamaton_maksu_ei_muuta_maukkaita(self):
        self.kassapaate.syo_maukkaasti_kateisella(400)
        self.kassapaate.syo_maukkaasti_kateisella(200)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_saldo_kortilla_muuttuu_oikein_edullisesti(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.maksukortti.saldo, 200)

    def test_saldo_kortilla_muuttuu_oikein_maukkaasti(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.maksukortti.saldo, 40)

    def test_onnistunut_korttiosto_palauttaa_true_edullisesti(self):
        self.assertEqual(
            self.kassapaate.syo_edullisesti_kortilla(self.maksukortti), True)

    def test_onnistunut_korttiosto_palauttaa_true_maukkaasti(self):
        self.assertEqual(
            self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti), True)

    def test_onnistunut_korttiosto_lisaa_edullisten_maaraa(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_onnistunut_korttiosto_lisaa_maukkaiden_maaraa(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_epaonnistunut_korttiosto_ei_muuta_saldoa_edullisesti(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.maksukortti.saldo, 200)

    def test_epaonnistunut_korttiosto_ei_muuta_saldoa_maukkaasti(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.maksukortti.saldo, 200)

    def test_epaonnistunut_korttiosto_palauttaa_false_edullisesti(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(
            self.kassapaate.syo_edullisesti_kortilla(self.maksukortti), False)

    def test_epaonnistunut_korttiosto_palauttaa_false_maukkaasti(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(
            self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti), False)

    def test_epaonnistunut_korttiosto_ei_lisaa_edullisten_maaraa(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_epaonnistunut_korttiosto_ei_lisaa_maukkaiden_maaraa(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_rahaa_ladatessa_kassan_rahamaara_kasvaa(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, 1000)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 101000)

    def test_rahaa_ladatessa_kortin_rahamaara_kasvaa(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, 60)
        self.assertEqual(self.maksukortti.saldo, 500)

    def test_rahaa_ladatessa_negatiivinen_summa_ei_muuta_kassan_rahamaaraa(
            self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, -1)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_rahaa_ladatessa_negatiivinen_summa_ei_muuta_kortin_saldoa(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, -1)
        self.assertEqual(self.maksukortti.saldo, 440)
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassa = Kassapaate()
        self.kortti = Maksukortti(1000)

    def test_raha_alussa(self):
        self.assertEqual(self.kassa.kassassa_rahaa, 100000)

    def test_edullisia_alussa(self):
        self.assertEqual(self.kassa.edulliset, 0)

    def test_maukkaita_alussa(self):
        self.assertEqual(self.kassa.maukkaat, 0)

    def test_tarpeeksi_rahaa_kateinen_maukas1(self):
        self.kassa.syo_maukkaasti_kateisella(500)
        self.assertEqual(self.kassa.kassassa_rahaa, 100400)
        self.assertEqual(self.kassa.syo_maukkaasti_kateisella(500), 100)

    def test_tarpeeksi_rahaa_kateinen_maukas2(self):
        self.kassa.syo_maukkaasti_kateisella(500)
        self.assertEqual(self.kassa.maukkaat, 1)

    def test_tarpeeksi_rahaa_kateinen_edullinen1(self):
        self.kassa.syo_edullisesti_kateisella(300)
        self.assertEqual(self.kassa.kassassa_rahaa, 100240)
        self.assertEqual(self.kassa.syo_edullisesti_kateisella(300), 60)

    def test_tarpeeksi_rahaa_kateinen_edullinen2(self):
        self.kassa.syo_edullisesti_kateisella(300)
        self.assertEqual(self.kassa.edulliset, 1)

    def test_vahan_rahaa_kateinen_edullinen(self):
        self.kassa.syo_edullisesti_kateisella(100)
        self.assertEqual(self.kassa.kassassa_rahaa, 100000)
        self.assertEqual(self.kassa.edulliset, 0)
        self.assertEqual(self.kassa.syo_edullisesti_kateisella(100), 100)

    def test_vahan_rahaa_kateinen_maukas(self):
        self.kassa.syo_maukkaasti_kateisella(100)
        self.assertEqual(self.kassa.kassassa_rahaa, 100000)
        self.assertEqual(self.kassa.maukkaat, 0)
        self.assertEqual(self.kassa.syo_maukkaasti_kateisella(100), 100)

    def test_tarpeeksi_rahaa_kortti_edullinen1(self):
        self.kassa.syo_edullisesti_kortilla(self.kortti)
        self.assertEqual(str(self.kortti), "saldo: 7.6")
        self.assertEqual(self.kassa.syo_edullisesti_kortilla(self.kortti),
                         True)

    def test_tarpeeksi_rahaa_kortti_edullinen2(self):
        self.kassa.syo_edullisesti_kortilla(self.kortti)
        self.assertEqual(self.kassa.edulliset, 1)

    def test_tarpeeksi_rahaa_kortti_maukas(self):
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.assertEqual(str(self.kortti), "saldo: 6.0")
        self.assertEqual(self.kassa.syo_maukkaasti_kortilla(self.kortti), True)

    def test_tarpeeksi_rahaa_kortti_maukas(self):
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.assertEqual(self.kassa.maukkaat, 1)

    def test_vahan_rahaa_kortti_edullinen1(self):
        self.kassa.syo_edullisesti_kortilla(self.kortti)
        self.kassa.syo_edullisesti_kortilla(self.kortti)
        self.kassa.syo_edullisesti_kortilla(self.kortti)
        self.kassa.syo_edullisesti_kortilla(self.kortti)
        self.kassa.syo_edullisesti_kortilla(self.kortti)
        self.assertEqual(str(self.kortti), "saldo: 0.4")
        self.assertEqual(self.kassa.edulliset, 4)
        self.assertEqual(self.kassa.syo_edullisesti_kortilla(self.kortti),
                         False)

    def test_vahan_rahaa_kortti_edullinen2(self):
        self.kassa.syo_edullisesti_kortilla(self.kortti)
        self.assertEqual(self.kassa.kassassa_rahaa, 100000)

    def test_vahan_rahaa_kortti_maukas1(self):
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.assertEqual(str(self.kortti), "saldo: 2.0")
        self.assertEqual(self.kassa.maukkaat, 2)
        self.assertEqual(self.kassa.syo_maukkaasti_kortilla(self.kortti),
                         False)

    def test_vahan_rahaa_kortti_maukas2(self):
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.assertEqual(self.kassa.kassassa_rahaa, 100000)

    def test_kassan_saldo_muuttuu_kortin_kanssa(self):
        self.kassa.lataa_rahaa_kortille(self.kortti, 1000)
        self.assertEqual(str(self.kortti), "saldo: 20.0")
        self.assertEqual(self.kassa.kassassa_rahaa, 101000)

    def test_kassan_saldo_muuttuu_kortin_kanssa_negatiivinen(self):
        self.kassa.lataa_rahaa_kortille(self.kortti, -1000)
        self.assertEqual(str(self.kortti), "saldo: 10.0")
        self.assertEqual(self.kassa.kassassa_rahaa, 100000)
Example #10
0
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassapaate = Kassapaate()

    def test_luodun_kassapaatteen_rahamaara_ja_myytyjen_lounaiden_maara_on_oikea(
            self):
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
        self.assertEqual(self.kassapaate.edulliset, 0)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_kateisosto_toimii_maukkaiden_lounaiden_osalta(self):
        palautus = self.kassapaate.syo_maukkaasti_kateisella(450)
        self.assertEqual(palautus, 50)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100400)
        self.assertEqual(self.kassapaate.maukkaat, 1)
        palautus2 = self.kassapaate.syo_maukkaasti_kateisella(100)
        self.assertEqual(palautus2, 100)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100400)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_kateisosto_toimii_edullisten_lounaiden_osalta(self):
        palautus = self.kassapaate.syo_edullisesti_kateisella(250)
        self.assertEqual(palautus, 10)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100240)
        self.assertEqual(self.kassapaate.edulliset, 1)
        palautus2 = self.kassapaate.syo_edullisesti_kateisella(100)
        self.assertEqual(palautus2, 100)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100240)
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_korttiosto_toimii__edullisten_lounaiden_osalta(self):
        maksukortti = Maksukortti(50000)
        korttiosto = self.kassapaate.syo_edullisesti_kortilla(maksukortti)
        self.assertEqual(korttiosto, True)
        self.assertEqual(maksukortti.saldo, 50000 - 240)
        self.assertEqual(self.kassapaate.edulliset, 1)
        maksukortti2 = Maksukortti(100)
        korttiosto2 = self.kassapaate.syo_edullisesti_kortilla(maksukortti2)
        self.assertEqual(korttiosto2, False)
        self.assertEqual(maksukortti2.saldo, 100)
        self.assertEqual(self.kassapaate.edulliset, 1)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_korttiosto_toimii__maukkaiden_lounaiden_osalta(self):
        maksukortti = Maksukortti(50000)
        korttiosto = self.kassapaate.syo_maukkaasti_kortilla(maksukortti)
        self.assertEqual(korttiosto, True)
        self.assertEqual(maksukortti.saldo, 50000 - 400)
        self.assertEqual(self.kassapaate.maukkaat, 1)
        maksukortti2 = Maksukortti(100)
        korttiosto2 = self.kassapaate.syo_maukkaasti_kortilla(maksukortti2)
        self.assertEqual(korttiosto2, False)
        self.assertEqual(maksukortti2.saldo, 100)
        self.assertEqual(self.kassapaate.maukkaat, 1)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_kortille_rahaa_ladattaessa(self):
        maksukortti = Maksukortti(50000)
        self.kassapaate.lataa_rahaa_kortille(maksukortti, 10000)
        self.assertEqual(maksukortti.saldo, 60000)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000 + 10000)
        palautus = self.kassapaate.lataa_rahaa_kortille(maksukortti, -10000)
        self.assertEqual(palautus, None)
Example #11
0
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassapaate = Kassapaate()
        self.kortti1 = Maksukortti(1000)
        self.kortti2 = Maksukortti(100)

    def test_kassapaate_oikein_alussa(self):
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
        self.assertEqual(self.kassapaate.edulliset, 0)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_maukkaan_kateisosto_toimii(self):
        hinta = 400
        kassa_alussa = self.kassapaate.kassassa_rahaa
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(1000),
                         1000 - hinta)
        self.assertEqual(self.kassapaate.maukkaat, 1)
        self.assertEqual(self.kassapaate.kassassa_rahaa - kassa_alussa, hinta)
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(100), 100)
        self.assertEqual(self.kassapaate.maukkaat, 1)
        self.assertEqual(self.kassapaate.kassassa_rahaa, kassa_alussa + hinta)

    def test_edullisen_kateisosto_toimii(self):
        hinta = 240
        kassa_alussa = self.kassapaate.kassassa_rahaa
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(1000),
                         1000 - hinta)
        self.assertEqual(self.kassapaate.edulliset, 1)
        self.assertEqual(self.kassapaate.kassassa_rahaa - kassa_alussa, hinta)
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(100), 100)
        self.assertEqual(self.kassapaate.edulliset, 1)
        self.assertEqual(self.kassapaate.kassassa_rahaa, kassa_alussa + hinta)

    def test_maukkaan_korttiosto_toimii(self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kortilla(self.kortti1),
                         True)
        self.assertEqual(self.kortti1.saldo, 600)
        self.assertEqual(self.kassapaate.maukkaat, 1)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
        self.assertEqual(self.kassapaate.syo_maukkaasti_kortilla(self.kortti2),
                         False)
        self.assertEqual(self.kortti2.saldo, 100)
        self.assertEqual(self.kassapaate.maukkaat, 1)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_edullisen_korttiosto_toimii(self):
        self.assertEqual(
            self.kassapaate.syo_edullisesti_kortilla(self.kortti1), True)
        self.assertEqual(self.kortti1.saldo, 760)
        self.assertEqual(self.kassapaate.edulliset, 1)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
        self.assertEqual(
            self.kassapaate.syo_edullisesti_kortilla(self.kortti2), False)
        self.assertEqual(self.kortti2.saldo, 100)
        self.assertEqual(self.kassapaate.edulliset, 1)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_saldon_lataus_toimii(self):
        self.kassapaate.lataa_rahaa_kortille(self.kortti2, 400)
        self.assertEqual(self.kortti2.saldo, 500)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100400)
Example #12
0
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassapaate = Kassapaate()

    #kateis testit

    def test_luotu_kassapaate_on_olemassa(self):
        self.assertNotEqual(self.kassapaate, None)

    def test_luotu_kassapaate_on_oikeanlainen(self):
        myydyt = self.kassapaate.maukkaat + self.kassapaate.edulliset
        self.assertEqual((self.kassapaate.kassassa_rahaa, myydyt), (100000, 0))

    def test_rahamaara_kasvaa_oikein_ostettaessa_edullinen_kateisella(self):
        self.kassapaate.syo_edullisesti_kateisella(500)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100240)

    def test_rahamaara_kasvaa_oikein_ostettaessa_maukas_kateisella(self):
        self.kassapaate.syo_maukkaasti_kateisella(500)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100400)

    def test_vaihtorahan_suuruus_on_oikea_ostettessa_edullinen_kateisella(
            self):
        takaisin = self.kassapaate.syo_edullisesti_kateisella(500)
        self.assertEqual(takaisin, 260)

    def test_vaihtorahan_suuruus_on_oikea_ostettessa_maukas_kateisella(self):
        takaisin = self.kassapaate.syo_maukkaasti_kateisella(500)
        self.assertEqual(takaisin, 100)

    def test_edullisten_maara_kasvaa_ostettaessa_kateisella(self):
        self.kassapaate.syo_maukkaasti_kateisella(600)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_maukkaiden_maara_kasvaa_ostettaessa_kateisella(self):
        self.kassapaate.syo_maukkaasti_kateisella(600)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_kassan_rahamaara_ei_kasva_jos_maksu_on_liian_pieni_edullinen(
            self):
        self.kassapaate.syo_edullisesti_kateisella(10)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_kassan_rahamaara_ei_kasva_jos_maksu_on_liian_pieni_maukas(self):
        self.kassapaate.syo_maukkaasti_kateisella(10)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_edullisten_maara_ei_kasva_jos_maksu_on_liian_pieni(self):
        self.kassapaate.syo_edullisesti_kateisella(180)
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_maukkaiden_maara_ei_kasva_jos_maksu_on_liian_pieni(self):
        self.kassapaate.syo_maukkaasti_kateisella(180)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    #kortti testit

    def test_edullinen_maksu_kortilla_palauttaa_true(self):
        kortti = Maksukortti(1000)
        tila = self.kassapaate.syo_edullisesti_kortilla(kortti)
        self.assertEqual(tila, True)

    def test_maukas_maksu_kortilla_palauttaa_true(self):
        kortti = Maksukortti(1000)
        tila = self.kassapaate.syo_maukkaasti_kortilla(kortti)
        self.assertEqual(tila, True)

    def test_kortilta_veloitetaan_rahaa_kun_saldo_riittaa_edullinen(self):
        kortti = Maksukortti(1000)
        self.kassapaate.syo_edullisesti_kortilla(kortti)
        self.assertEqual(str(kortti), "saldo: 7.6")

    def test_kortilta_veloitetaan_rahaa_kun_saldo_riittaa_maukas(self):
        kortti = Maksukortti(1000)
        self.kassapaate.syo_maukkaasti_kortilla(kortti)
        self.assertEqual(str(kortti), "saldo: 6.0")

    def test_edullinen_maksu_kortilla_palauttaa_false_kun_raha_ei_riita(self):
        kortti = Maksukortti(1)
        tila = self.kassapaate.syo_edullisesti_kortilla(kortti)
        self.assertEqual(tila, False)

    def test_maukas_maksu_kortilla_palauttaa_false_kun_raha_ei_riita(self):
        kortti = Maksukortti(1)
        tila = self.kassapaate.syo_maukkaasti_kortilla(kortti)
        self.assertEqual(tila, False)

    def test_kortilta_ei_veloiteta_rahaa_kun_saldo_ei_riita_edullinen(self):
        kortti = Maksukortti(1)
        self.kassapaate.syo_edullisesti_kortilla(kortti)
        self.assertEqual(str(kortti), "saldo: 0.01")

    def test_kortilta_ei_veloiteta_rahaa_kun_saldo_ei_riita_riittaa_maukas(
            self):
        kortti = Maksukortti(1)
        self.kassapaate.syo_maukkaasti_kortilla(kortti)
        self.assertEqual(str(kortti), "saldo: 0.01")

    def test_myytyjen_maara_kasvaa_kun_edullinen_ostetaan(self):
        kortti = Maksukortti(1000)
        self.kassapaate.syo_edullisesti_kortilla(kortti)
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_myytyjen_maara_kasvaa_kun_maukas_ostetaan(self):
        kortti = Maksukortti(1000)
        self.kassapaate.syo_maukkaasti_kortilla(kortti)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_myytyjen_maara_ei_kasva_kun_saldo_ei_riita_edulliset(self):
        kortti = Maksukortti(1)
        self.kassapaate.syo_edullisesti_kortilla(kortti)
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_myytyjen_maara_ei_kasva_kun_saldo_ei_riita_maukkaat(self):
        kortti = Maksukortti(1)
        self.kassapaate.syo_maukkaasti_kortilla(kortti)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_tila_kortilta_veloitettu_raha_ei_siirry_kassaan_edulliset(self):
        kortti = Maksukortti(1000)
        self.kassapaate.syo_edullisesti_kortilla(kortti)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_tila_kortilta_veloitettu_raha_ei_siirry_kassaan_maukkaat(self):
        kortti = Maksukortti(1000)
        self.kassapaate.syo_maukkaasti_kortilla(kortti)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_tila_kortilta_veloittamaton_raha_ei_siirry_kassaan_edulliset(
            self):
        kortti = Maksukortti(1)
        self.kassapaate.syo_edullisesti_kortilla(kortti)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_tila_kortilta_veloittamaton_raha_ei_siirry_kassaan_maukkaat(self):
        kortti = Maksukortti(1)
        self.kassapaate.syo_maukkaasti_kortilla(kortti)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_kortille_laataaminen_nostaa_kassan_rahamaaraa(self):
        kortti = Maksukortti(1000)
        self.kassapaate.lataa_rahaa_kortille(kortti, 500)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100500)

    def test_kortille_laataaminen_nostaa_kortin_saldoa(self):
        kortti = Maksukortti(1000)
        self.kassapaate.lataa_rahaa_kortille(kortti, 500)
        self.assertEqual(kortti.saldo, 1500)

    def test_kortille_ei_voi_ladata_kortille_negatiivista_rahaa(self):
        kortti = Maksukortti(1000)
        self.kassapaate.lataa_rahaa_kortille(kortti, -500)
        self.assertEqual(kortti.saldo, 1000)
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassapaate = Kassapaate()
        self.maksukortti = Maksukortti(1000)
        self.koyhakortti = Maksukortti(200)

    def test_luodun_kassapaatteen_raha_oikein(self):
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_luodun_kassapaatten_myynnit_oikein(self):
        self.assertEqual(self.kassapaate.edulliset, 0)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_kateismaksu_edullinen_riittava_summa_vaihtoraha_oikein(self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(500), 260)
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(240), 0)

    def test_kateismaksu_maukas_riittava_summa_vaihtoraha_oikein(self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(500), 100)
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(400), 0)

    def test_kateismaksu_edullinen_riittava_summa_myynnit_kasvaa(self):
        self.kassapaate.syo_edullisesti_kateisella(500)
        self.assertEqual(self.kassapaate.edulliset, 1)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_kateismaksu_maukas_riittava_summa_myynnit_kasvaa(self):
        self.kassapaate.syo_maukkaasti_kateisella(500)
        self.assertEqual(self.kassapaate.maukkaat, 1)
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_kateismaksu_edullinen_riittamaton_summa_vaihtoraha_oikein(self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(200), 200)

    def test_kateismaksu_maukas_riittamaton_summa_vaihtoraha_oikein(self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(300), 300)

    def test_kateismaksu_edullinen_riittamaton_summa_myynnit_ei_kasva(self):
        self.kassapaate.syo_edullisesti_kateisella(200)
        self.assertEqual(self.kassapaate.edulliset, 0)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_kateismaksu_maukas_riittamaton_summa_myynnit_ei_kasva(self):
        self.kassapaate.syo_maukkaasti_kateisella(300)
        self.assertEqual(self.kassapaate.edulliset, 0)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_korttimaksu_edullinen_riittava_summa_veloitus_onnistuu(self):
        self.assertTrue(
            self.kassapaate.syo_edullisesti_kortilla(self.maksukortti))
        self.assertEqual(self.maksukortti.saldo, 760)

    def test_korttimaksu_maukas_riittava_summa_veloitus_onnistuu(self):
        self.assertTrue(
            self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti))
        self.assertEqual(self.maksukortti.saldo, 600)

    def test_korttimaksu_edullinen_riittava_summa_myynnit_kasvaa(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.edulliset, 1)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_korttimaksu_maukas_riittava_summa_myynnit_kasvaa(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.maukkaat, 1)
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_korttimaksu_edullinen_riittamaton_summa_veloitus_ei_onnistu(self):
        self.assertFalse(
            self.kassapaate.syo_edullisesti_kortilla(self.koyhakortti))
        self.assertEqual(self.maksukortti.saldo, 1000)

    def test_korttimaksu_maukas_riittamaton_summa_veloitus_ei_onnistu(self):
        self.assertFalse(
            self.kassapaate.syo_maukkaasti_kortilla(self.koyhakortti))
        self.assertEqual(self.maksukortti.saldo, 1000)

    def test_korttimaksu_edullinen_riittamaton_summa_myynnit_ei_kasva(self):
        self.kassapaate.syo_edullisesti_kortilla(self.koyhakortti)
        self.assertEqual(self.kassapaate.edulliset, 0)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_korttimaksu_maukas_riittamaton_summa_myynnit_ei_kasva(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.koyhakortti)
        self.assertEqual(self.kassapaate.edulliset, 0)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_korttimaksu_edullinen_ei_muuta_kassaa(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_korttimaksu_maukas_ei_muuta_kassaa(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_rahan_lataaminen_kasvattaa_kortin_saldoa(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, 1000)
        self.assertEqual(self.maksukortti.saldo, 2000)

    def test_rahan_lataaminen_kasvattaa_kassan_rahoja(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, 1000)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 101000)

    def test_negatiivisen_summan_lataaminen_kortille_ei_kasvata_saldoa(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, -1000)
        self.assertEqual(self.maksukortti.saldo, 1000)

    def test_negatiivisen_summan_lataaminen_ei_kasvata_kassan_rahoja(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, -1000)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
Example #14
0
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassapaate = Kassapaate()

    def test_tiedot_oikein_alussa(self):
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
        self.assertEqual(self.kassapaate.maukkaat, 0)
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_syo_edullisesti_toimii_kun_maksu_on_riittava(self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(500), 260)
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_syo_maukkaasti_toimii_kun_maksu_on_riittava(self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(500), 100)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_syo_edullisesti_toimii_oikein_kun_maksu_ei_ole_riittava(self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(10), 10)
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_syo_maukkaasti_toimii_oikein_kun_maksu_ei_ole_riittava(self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(20), 20)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_syo_edullisesti_toimii_oikein_jos_kortilla_on_tarpeeksi_rahaa(
            self):
        kortti = Maksukortti(1000)
        self.assertTrue(self.kassapaate.syo_edullisesti_kortilla(kortti))
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_myytyjen_lounaiden_maara_kasvaa_jos_maksu_on_riittava(self):
        self.kassapaate.syo_maukkaasti_kateisella(500)
        self.kassapaate.syo_edullisesti_kateisella(500)
        self.assertEqual(self.kassapaate.maukkaat, 1)
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_syo_maukkaasti_toimii_oikein_jos_kortilla_on_tarpeeksi_rahaa(
            self):
        kortti = Maksukortti(1000)
        self.assertTrue(self.kassapaate.syo_maukkaasti_kortilla(kortti))
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_syo_edullisesti_toimii_oikein_jos_kortilla_ei_ole_tarpeeksi_rahaa(
            self):
        kortti = Maksukortti(1)
        self.assertFalse(self.kassapaate.syo_edullisesti_kortilla(kortti))
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_syo_maukkaasti_toimii_oikein_jos_kortilla_ei_ole_tarpeeksi_rahaa(
            self):
        kortti = Maksukortti(1)
        self.assertFalse(self.kassapaate.syo_maukkaasti_kortilla(kortti))
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_kortille_lataaminen_toimii(self):
        kortti = Maksukortti(1)
        self.kassapaate.lataa_rahaa_kortille(kortti, 2000)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 102000)
        self.assertEqual(kortti.saldo, 2001)

    def test_kortille_ei_voi_lataa_negatiivinen_maara(self):
        kortti = Maksukortti(1)
        self.kassapaate.lataa_rahaa_kortille(kortti, -20)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
        self.assertEqual(kortti.saldo, 1)
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassapaate = Kassapaate()
        self.maksukortti = Maksukortti(500)
        self.koyhakortti = Maksukortti(200)

    def test_kassapaate(self):
        self.assertEqual(str(self.kassapaate.kassassa_rahaa), "100000")
        self.assertEqual(str(self.kassapaate.edulliset), "0")
        self.assertEqual(str(self.kassapaate.maukkaat), "0")

    def test_käteisosto_edullisesti(self):
        self.kassapaate.syo_edullisesti_kateisella(240)
        self.assertEqual(str(self.kassapaate.kassassa_rahaa), "100240")
        self.assertEqual(str(self.kassapaate.syo_edullisesti_kateisella(450)), "210")
    
    def test_käteisosto_maukkaasti(self):
        self.kassapaate.syo_maukkaasti_kateisella(450) 
        self.assertEqual(str(self.kassapaate.kassassa_rahaa), "100400")
        self.assertEqual(str(self.kassapaate.syo_maukkaasti_kateisella(450)), "50")

    def test_myydy_maukkaat(self):
        self.kassapaate.syo_maukkaasti_kateisella(450)
        self.assertEqual(str(self.kassapaate.maukkaat), "1") 
    def test_myydy_edulliset(self):  
        self.kassapaate.syo_edullisesti_kateisella(240)
        self.assertEqual(str(self.kassapaate.edulliset), "1")
    def test_myydy_lounaat_ei_rahaa(self):
        self.kassapaate.syo_maukkaasti_kateisella(300)
        self.kassapaate.syo_edullisesti_kateisella(200)
        self.assertEqual(str(self.kassapaate.maukkaat), "0")
        self.assertEqual(str(self.kassapaate.edulliset), "0")
    
    def test_käteisosto_ei_rahaa(self): 
        self.kassapaate.syo_maukkaasti_kateisella(300)
        self.kassapaate.syo_edullisesti_kateisella(200)
        self.assertEqual(str(self.kassapaate.kassassa_rahaa), "100000")
        self.assertEqual(str(self.kassapaate.syo_maukkaasti_kateisella(300)), "300")
        self.assertEqual(str(self.kassapaate.syo_edullisesti_kateisella(200)), "200")

    def test_syo_edullisesti_kortilla(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(str(self.maksukortti), "saldo: 2.6")
        self.assertEqual(str(self.kassapaate.edulliset), "1")

    def test_syo_maukkaasti_kortilla(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(str(self.maksukortti), "saldo: 1.0")
        self.assertEqual(str(self.kassapaate.maukkaat), "1")

    def test_on_rahaa_kortilla(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(str(self.maksukortti), "saldo: 2.6")
        self.assertEqual(str(self.kassapaate.edulliset), "1")

    def test_ei_rahaa_kortilla(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.koyhakortti)
        self.assertEqual(str(self.koyhakortti), "saldo: 2.0")
        self.assertEqual(str(self.kassapaate.maukkaat), "0")

        self.kassapaate.syo_edullisesti_kortilla(self.koyhakortti)
        self.assertEqual(str(self.koyhakortti), "saldo: 2.0")
        self.assertEqual(str(self.kassapaate.edulliset), "0")

    def test_true_false(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.syo_edullisesti_kortilla(self.maksukortti), True)
        self.assertEqual(self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti), False)
    
    def test_kassa_ei_muutu(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(str(self.kassapaate.kassassa_rahaa), "100000")

    def test_lataa_rahaa_kortille(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, 100)
        self.assertEqual(str(self.kassapaate.kassassa_rahaa), "100100")
        self.assertEqual(str(self.maksukortti), "saldo: 6.0")
Example #16
0
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassapaate = Kassapaate()
        self.maksukortti = Maksukortti(1000)

    def test_alku_saldo(self):
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
    
    def test_myydyt_edulliset_aluksi(self):
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_myydyt_maukkaat_aluksi(self):
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_edullinen_kateinen_saldo(self):
        self.kassapaate.syo_edullisesti_kateisella(240)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100240)
    
    def test_maukkaasti_kateinen_saldo(self):
        self.kassapaate.syo_maukkaasti_kateisella(400)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100400)

    def test_edullinen_kateinen_vaihtoraha(self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(240), 0)

    def test_maukkaasti_kateinen_vaihtoraha(self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(400), 0)
    
    def test_edullinen_lounaiden_maara(self):
        self.kassapaate.syo_edullisesti_kateisella(240)
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_maukkaasti_lounaiden_maara(self):
        self.kassapaate.syo_maukkaasti_kateisella(400)
        self.assertEqual(self.kassapaate.maukkaat, 1)
    
    def test_edullinen_ei_riita(self):
        self.kassapaate.syo_edullisesti_kateisella(200)
        self.assertEqual(self.kassapaate.edulliset, 0)
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(200), 200)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
    
    def test_maukkaasti_ei_riita(self):
        self.kassapaate.syo_maukkaasti_kateisella(200)
        self.assertEqual(self.kassapaate.maukkaat, 0)
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(200), 200)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_edullinen_riittaa_kortilta(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.maksukortti.saldo, 760)
        self.assertEqual(self.kassapaate.syo_edullisesti_kortilla(self.maksukortti), True)
        self.assertEqual(self.kassapaate.edulliset, 2)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_maukkaasti_riittaa_kortilta(self):
        self.maksukortti = Maksukortti(10400)
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.maksukortti.saldo, 10000)
        self.assertEqual(self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti), True)
        self.assertEqual(self.kassapaate.maukkaat, 2)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_edullinen_ei_riita_kortilta(self):
        self.maksukortti = Maksukortti(100)
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.maksukortti.saldo, 100)
        self.assertEqual(self.kassapaate.syo_edullisesti_kortilla(self.maksukortti), False)
        self.assertEqual(self.kassapaate.edulliset, 0)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_maukkaasti_ei_riita_kortilta(self):
        self.maksukortti = Maksukortti(100)
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.maksukortti.saldo, 100)
        self.assertEqual(self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti), False)
        self.assertEqual(self.kassapaate.maukkaat, 0)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_lataa_rahaa(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, 100)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100100)
        self.assertEqual(self.maksukortti.saldo, 1100)
    
    def test_lataa_rahaa_alle_0e(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, -100)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
        self.assertEqual(self.maksukortti.saldo, 1000)
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassapaate = Kassapaate()
        self.maksukortti = Maksukortti(1000)

#Testataan, että kassapäätteen alustus ok

    def test_luotu_kassapaate_alustaa_rahan_oikein(self):
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_luotu_kassapaate_alustaa_maukkaat_oikein(self):
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_luotu_kassapaate_alustaa_edulliset_oikein(self):
        self.assertEqual(self.kassapaate.edulliset, 0)

#Testataan, että käteisosto toimii sekä edullisten että maukkaiden lounaiden osalta

    def test_jos_maksu_riittaa_vaihtoraha_ok_maukas(self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(500), 100)

    def test_jos_maksu_riittaa_kassan_saldo_ok_maukas(self):
        self.kassapaate.syo_maukkaasti_kateisella(500)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100400)

    def test_jos_maksu_riittaa_vaihtoraha_ok_edullinen(self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(300), 60)

    def test_jos_maksu_riittaa_kassan_saldo_ok_edullinen(self):
        self.kassapaate.syo_edullisesti_kateisella(300)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100240)

    def test_jos_maksu_riittaa_myydyt_lounaat_kasvaa_maukas(self):
        self.kassapaate.syo_maukkaasti_kateisella(400)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_jos_maksu_riittaa_myydyt_lounaat_kasvaa_edullinen(self):
        self.kassapaate.syo_edullisesti_kateisella(240)
        self.assertEqual(self.kassapaate.edulliset, 1)

#Testataan tilanteita käteismaksussa, jossa maksu ei ole riittävä

    def test_jos_maksu_ei_riita_kassan_saldo_ei_muutu_maukas(self):
        self.kassapaate.syo_maukkaasti_kateisella(300)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_jos_maksu_ei_riita_vaihtoraha_palautetaan_kokonaan_maukas(self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(300), 300)

    def test_jos_maksu_ei_riita_kassan_saldo_ei_muutu_edullinen(self):
        self.kassapaate.syo_edullisesti_kateisella(200)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_jos_maksu_ei_riita_vaihtoraha_palautetaan_kokonaan_edullinen(
            self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(200), 200)

    def test_jos_maksu_ei_riita_myydyt_lounaat_ei_kasva_maukas(self):
        self.kassapaate.syo_maukkaasti_kateisella(300)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_jos_maksu_ei_riita_myydyt_lounaat_ei_kasva_edullinen(self):
        self.kassapaate.syo_edullisesti_kateisella(200)
        self.assertEqual(self.kassapaate.edulliset, 0)

#Testataan, että korttiostot toimii sekä edullisten että maukkaiden lounaiden osalta

    def test_jos_kortilla_tarpeeksi_rahaa_veloitetaan_summa_maukas(self):
        self.assertEqual(
            self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti), True)
        self.assertEqual(str(self.maksukortti), "saldo: 6.0")

    def test_jos_kortilla_tarpeeksi_rahaa_veloitetaan_summa_edullinen(self):
        self.assertEqual(
            self.kassapaate.syo_edullisesti_kortilla(self.maksukortti), True)
        self.assertEqual(str(self.maksukortti), "saldo: 7.6")

    def test_jos_kortilla_tarpeeksi_rahaa_myydyt_lounaat_kasvaa_maukas(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_jos_kortilla_tarpeeksi_rahaa_myydyt_lounaat_kasvaa_edullinen(
            self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.edulliset, 1)

#Testataan tilanteita korttimaksussa, jossa kortin saldo ei ole riittävä

    def test_jos_kortilla_ei_riita_rahat_kortin_saldo_pysyy_maukas(self):
        kortti = Maksukortti(200)
        self.assertEqual(self.kassapaate.syo_maukkaasti_kortilla(kortti),
                         False)
        self.assertEqual(str(kortti), "saldo: 2.0")

    def test_jos_kortilla_ei_riita_rahat_kortin_saldo_pysyy_edullinen(self):
        kortti = Maksukortti(200)
        self.assertEqual(self.kassapaate.syo_edullisesti_kortilla(kortti),
                         False)
        self.assertEqual(str(kortti), "saldo: 2.0")

    def test_jos_kortilla_ei_riita_rahat_myydyt_lounaat_ei_kasva_maukas(self):
        kortti = Maksukortti(200)
        self.kassapaate.syo_maukkaasti_kortilla(kortti)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_jos_kortilla_ei_riita_rahat_myydyt_lounaat_ei_kasva_edullinen(
            self):
        kortti = Maksukortti(200)
        self.kassapaate.syo_edullisesti_kortilla(kortti)
        self.assertEqual(self.kassapaate.edulliset, 0)

#Testataan, että kassassa oleva rahamäärä ei muutu kortilla ostaessa

    def test_jos_maksaa_kortilla_kassan_rahamaara_pysyy_samana_maukas(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_jos_maksaa_kortilla_kassan_rahamaara_pysyy_samana_edullinen(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

# Testataan, että kortille rahaa ladattaessa kortin saldo muuttuu ja kassassa oleva rahamäärä kasvaa ladatulla summalla

    def test_kortille_rahaa_ladattaessa_kortin_saldo_muuttuu(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, 500)
        self.assertEqual(str(self.maksukortti), "saldo: 15.0")

    def test_kortille_rahaa_ladattaessa_kassa_kasvaa(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, 500)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100500)


#Testataan , että kun ladataan kortille rahaa negatiivisella summalla niin kassan arvo ei muutu eikä kortin saldo

    def test_kortille_ladatattaessa_negatiivinen_summa_ei_muutoksia(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, -100)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
        self.assertEqual(str(self.maksukortti), "saldo: 10.0")
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassapaate = Kassapaate()
        self.maksukortti = Maksukortti(1000)

    def test_raha_oikein(self):
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_lounaat_oikein(self):
        self.assertEqual(self.kassapaate.edulliset, 0)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_syo_edullisesti_kateisella_rahat(self):
        self.kassapaate.syo_edullisesti_kateisella(300)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100240)

    def test_syo_edullisesti_kateisella_maara(self):
        self.kassapaate.syo_edullisesti_kateisella(300)
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_syo_edullisesti_kateisella_rahat_takaisin(self):
        rahat = str(self.kassapaate.syo_edullisesti_kateisella(500))
        self.assertEqual(rahat, '260')

    def test_syo_maukkaasti_kateisella_rahat(self):
        self.kassapaate.syo_maukkaasti_kateisella(500)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100400)

    def test_syo_maukkaasti_kateisella_rahat_takaisin(self):
        rahat = str(self.kassapaate.syo_maukkaasti_kateisella(500))
        self.assertEqual(rahat, '100')

    def test_syo_maukkaasti_kateisella_maara(self):
        self.kassapaate.syo_maukkaasti_kateisella(500)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_veloitetaan_kortilta_oikein_edullinen(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        if self.assertEqual(str(self.maksukortti), "saldo: 7.6"):
            return True

    def test_kortilta_edullinen_maara(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_veloitetaan_kortilta_oikein_maukas(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        if self.assertEqual(str(self.maksukortti), "saldo: 6.0"):
            return True

    def test_kortilta_maukas_maara(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_kortilla_ei_tarpeeksi_rahaa_edulliseen(self):
        self.maksukortti.ota_rahaa(900)
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.edulliset, 0)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
        if self.assertEqual(str(self.maksukortti), "saldo: 1.0"):
            return False

    def test_kortilla_ei_tarpeeksi_rahaa_maukkaaseen(self):
        self.maksukortti.ota_rahaa(900)
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.maukkaat, 0)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
        if self.assertEqual(str(self.maksukortti), "saldo: 1.0"):
            return False

    def test_rahamaara_ei_muutu_kun_ostetaan_kortilla(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_lataa_rahaa_kortille(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, 100)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100100)
        self.assertEqual(str(self.maksukortti), "saldo: 11.0")
Example #19
0
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassapaate = Kassapaate()

    def maksukortti(self, saldo=1000):
        return Maksukortti(saldo)

    def test_kassapaate_alustuu_oikein(self):
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
        self.assertEqual(self.kassapaate.edulliset, 0)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_edullinen_kateisosto_rahamaarat_oikein(self):
        paluuarvo = self.kassapaate.syo_edullisesti_kateisella(250)
        self.assertEqual(paluuarvo, 10)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100240)

    def test_edullinen_kateisosto_kasvattaa_myytyjen_maaraa(self):
        self.kassapaate.syo_edullisesti_kateisella(250)
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_edullinen_kateisosto_liian_vahan_rahaa(self):
        paluuarvo = self.kassapaate.syo_edullisesti_kateisella(239)
        self.assertEqual(paluuarvo, 239)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_maukas_kateisosto_rahamaarat_oikein(self):
        paluuarvo = self.kassapaate.syo_maukkaasti_kateisella(440)
        self.assertEqual(paluuarvo, 40)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100400)

    def test_maukas_kateisosto_kasvattaa_myytyjen_maaraa(self):
        self.kassapaate.syo_maukkaasti_kateisella(440)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_maukas_kateisosto_liian_vahan_rahaa(self):
        paluuarvo = self.kassapaate.syo_maukkaasti_kateisella(399)
        self.assertEqual(paluuarvo, 399)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_edullinen_korttiosto_riittavasti_rahaa(self):
        kortti = self.maksukortti()
        paluuarvo = self.kassapaate.syo_edullisesti_kortilla(kortti)
        self.assertEqual(paluuarvo, True)
        self.assertEqual(str(kortti), "saldo: 7.6")

    def test_edullinen_korttiosto_kasvattaa_myytyjen_maaraa(self):
        kortti = self.maksukortti()
        self.kassapaate.syo_edullisesti_kortilla(kortti)
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_edullinen_korttiosto_ei_riittavasti_rahaa(self):
        kortti = self.maksukortti(239)
        paluuarvo = self.kassapaate.syo_edullisesti_kortilla(kortti)
        self.assertEqual(paluuarvo, False)
        self.assertEqual(str(kortti), "saldo: 2.39")
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_edullinen_kortti_osto_ei_muuta_kassan_rahamaaraa(self):
        kortti = self.maksukortti()
        self.kassapaate.syo_edullisesti_kortilla(kortti)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_maukas_korttiosto_riittavasti_rahaa(self):
        kortti = self.maksukortti()
        paluuarvo = self.kassapaate.syo_maukkaasti_kortilla(kortti)
        self.assertEqual(paluuarvo, True)
        self.assertEqual(str(kortti), "saldo: 6.0")

    def test_maukas_korttiosto_kasvattaa_myytyjen_maaraa(self):
        kortti = self.maksukortti()
        self.kassapaate.syo_maukkaasti_kortilla(kortti)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_maukas_korttiosto_ei_riittavasti_rahaa(self):
        kortti = self.maksukortti(399)
        paluuarvo = self.kassapaate.syo_maukkaasti_kortilla(kortti)
        self.assertEqual(paluuarvo, False)
        self.assertEqual(str(kortti), "saldo: 3.99")
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_maukas_kortti_osto_ei_muuta_kassan_rahamaaraa(self):
        kortti = self.maksukortti()
        self.kassapaate.syo_maukkaasti_kortilla(kortti)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_kortin_lataus_positiivisella_toimii(self):
        kortti = self.maksukortti()
        self.kassapaate.lataa_rahaa_kortille(kortti, 550)
        self.assertEqual(str(kortti), "saldo: 15.5")
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100550)

    def test_kortin_lataus_negatiivisella_ei_toimi(self):
        kortti = self.maksukortti()
        # pankkiryöstö
        self.kassapaate.lataa_rahaa_kortille(kortti, -50000)
        self.assertEqual(str(kortti), "saldo: 10.0")
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
Example #20
0
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassapaate = Kassapaate()
        self.kortti = Maksukortti(10000)

    def test_luodussa_kassapaatteessa_rahaa_oikein(self):
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_luodussa_kassapaatteessa_edulliset_oikein(self):
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_luodussa_kassapaatteessa_maukkaat_oikein(self):
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_maukkaasti_kateisella_rahat_riittaa(self):
        vaihtorahat = self.kassapaate.syo_maukkaasti_kateisella(1000)

        self.assertEqual(self.kassapaate.kassassa_rahaa, 100400)
        self.assertEqual(vaihtorahat, 600)

    def test_maukkaasti_kateisella_rahat_ei_riita(self):
        vaihtorahat = self.kassapaate.syo_maukkaasti_kateisella(100)

        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
        self.assertEqual(self.kassapaate.maukkaat, 0)
        self.assertEqual(vaihtorahat, 100)

    def test_maukkaasti_kateisella_lounaiden_maara_kasvaa(self):
        self.kassapaate.syo_maukkaasti_kateisella(1000)

        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_edullisesti_kateisella_rahat_riittaa(self):
        vaihtorahat = self.kassapaate.syo_edullisesti_kateisella(1000)

        self.assertEqual(self.kassapaate.kassassa_rahaa, 100240)
        self.assertEqual(vaihtorahat, 760)

    def test_edullisesti_kateisella_rahat_ei_riita(self):
        vaihtorahat = self.kassapaate.syo_edullisesti_kateisella(100)

        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
        self.assertEqual(self.kassapaate.edulliset, 0)
        self.assertEqual(vaihtorahat, 100)

    def test_edullisesti_kateisella_lounaiden_maara_kasvaa(self):
        self.kassapaate.syo_edullisesti_kateisella(1000)

        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_maukkaasti_kortilla_rahat_riittaa(self):
        transaktio = self.kassapaate.syo_maukkaasti_kortilla(self.kortti)

        self.assertTrue(transaktio)
        self.assertEqual(self.kortti.saldo, 9600)
        self.assertEqual(self.kassapaate.maukkaat, 1)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_maukkaasti_kortilla_rahat_ei_riita(self):
        self.kortti.ota_rahaa(9900)
        transaktio = self.kassapaate.syo_maukkaasti_kortilla(self.kortti)

        self.assertEqual(self.kortti.saldo, 100)
        self.assertFalse(transaktio)
        self.assertEqual(self.kassapaate.maukkaat, 0)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_edullisesti_kortilla_rahat_riittaa(self):
        transaktio = self.kassapaate.syo_edullisesti_kortilla(self.kortti)

        self.assertTrue(transaktio)
        self.assertEqual(self.kortti.saldo, 9760)
        self.assertEqual(self.kassapaate.edulliset, 1)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_edullisesti_kortilla_rahat_ei_riita(self):
        self.kortti.ota_rahaa(9900)
        transaktio = self.kassapaate.syo_edullisesti_kortilla(self.kortti)

        self.assertFalse(transaktio)
        self.assertEqual(self.kortti.saldo, 100)
        self.assertEqual(self.kassapaate.edulliset, 0)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_kortin_lataus_kasvattaa_kassaa(self):
        self.kassapaate.lataa_rahaa_kortille(self.kortti, 666)

        self.assertEqual(self.kortti.saldo, 10666)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100666)

    def test_kortin_lataus_negatiivisella_ei_kasvata_kassaa(self):
        self.kassapaate.lataa_rahaa_kortille(self.kortti, -666)

        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
Example #21
0
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassapaate = Kassapaate()
        self.maksukortti = Maksukortti(1000)

    def test_luotu_kassapaate_olemassa(self):
        self.assertIsNotNone(self.kassapaate)

    def test_alussa_oikea_maara_rahaa(self):
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_alussa_ei_myytyja_lounaita_edull(self):
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_alussa_ei_myytyja_lounaita_maukk(self):
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_kateisosto_edull_kassa_oikein(self):
        self.kassapaate.syo_edullisesti_kateisella(250)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100240)

    def test_kateisosto_edull_kassa_ei_muutu(self):
        self.kassapaate.syo_edullisesti_kateisella(200)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_kateisosto_edull_vaihtorahat_oikein(self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(250), 10)

    def test_kateisosto_edull_rahat_ei_riita(self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(200), 200)

    def test_kateisosto_edull_lounaiden_maara_kasvaa(self):
        self.kassapaate.syo_edullisesti_kateisella(250)
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_kateisosto_edull_lounaiden_maara_ei_kasva(self):
        self.kassapaate.syo_edullisesti_kateisella(200)
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_kateisosto_maukk_kassa_oikein(self):
        self.kassapaate.syo_maukkaasti_kateisella(500)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100400)

    def test_kateisosto_maukk_kassa_ei_muutu(self):
        self.kassapaate.syo_maukkaasti_kateisella(200)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_kateisosto_maukk_vaihtorahat_oikein(self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(500), 100)

    def test_kateisosto_maukk_rahat_ei_riita(self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(200), 200)

    def test_kateisosto_maukk_lounaiden_maara_kasvaa(self):
        self.kassapaate.syo_maukkaasti_kateisella(500)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_kateisosto_maukk_lounaiden_maara_ei_kasva(self):
        self.kassapaate.syo_maukkaasti_kateisella(200)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_korttiosto_edull_kortin_saldo_pienenee(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.maksukortti.saldo, 760)

    def test_korttiosto_edull_kortin_saldo_ei_muutu(self):
        kortti = Maksukortti(100)
        self.kassapaate.syo_edullisesti_kortilla(kortti)
        self.assertEqual(kortti.saldo, 100)

    def test_korttiosto_edull_kassan_saldo_ei_muutu(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_korttiosto_edull_lounaiden_maara_kasvaa(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_korttiosto_edull_lounaiden_maara_ei_kasva(self):
        kortti = Maksukortti(100)
        self.kassapaate.syo_edullisesti_kortilla(kortti)
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_korttiosto_edull_rahat_riittaa_palauttaa_true(self):
        self.assertTrue(self.kassapaate.syo_edullisesti_kortilla(self.maksukortti))

    def test_korttiosto_edull_rahat_ei_riita_palauttaa_false(self):
        kortti = Maksukortti(100)
        self.assertFalse(self.kassapaate.syo_edullisesti_kortilla(kortti))

    def test_korttiosto_maukk_kortin_saldo_pienenee(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.maksukortti.saldo, 600)

    def test_korttiosto_maukk_kortin_saldo_ei_muutu(self):
        kortti = Maksukortti(100)
        self.kassapaate.syo_maukkaasti_kortilla(kortti)
        self.assertEqual(kortti.saldo, 100)

    def test_korttiosto_maukk_kassan_saldo_ei_muutu(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_korttiosto_maukk_lounaiden_maara_kasvaa(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_korttiosto_maukk_lounaiden_maara_ei_kasva(self):
        kortti = Maksukortti(100)
        self.kassapaate.syo_maukkaasti_kortilla(kortti)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_korttiosto_maukk_rahat_riittaa_palauttaa_true(self):
        self.assertTrue(self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti))

    def test_korttiosto_maukk_rahat_ei_riita_palauttaa_false(self):
        kortti = Maksukortti(100)
        self.assertFalse(self.kassapaate.syo_maukkaasti_kortilla(kortti))

    def test_rahan_lataus_kortille_kortin_saldo_muuttuu(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, 1000)
        self.assertEqual(self.maksukortti.saldo, 2000)

    def test_rahan_lataus_kortille_kassan_saldo_muuttuu(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, 1000)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 101000)

    def test_rahan_lataus_neg_summa_ei_onnistu(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, -1000)
        self.assertEqual(self.maksukortti.saldo, 1000)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassapaate = Kassapaate()
        self.card = Maksukortti(500)

# Luodun kassapäätteen rahamäärä ja myytyjen lounaiden määrä on oikea (rahaa 1000, lounaita myyty 0)

    def test_kassapaate_exists(self):
        self.assertNotEqual(self.kassapaate, None)

    def test_kassapaate_saldo_is_correct(self):
        self.assertEqual(int(self.kassapaate.kassassa_rahaa), int(100_000))

    def test_edullinen_purchased_is_zero(self):
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_maukas_purchased_is_zero(self):
        self.assertEqual(self.kassapaate.edulliset, 0)

# Käteisosto toimii sekä edullisten että maukkaiden lounaiden osalta
# Jos maksu riittävä:
# vaihtorahan suuruus on oikea

    def test_buy_edullinen_with_exact_change(self):
        change = self.kassapaate.syo_edullisesti_kateisella(240)
        self.assertEqual(change, 0)

    def test_buy_edullinen_with_change(self):
        change = self.kassapaate.syo_edullisesti_kateisella(340)
        self.assertEqual(change, 100)

    def test_buy_maukas_with_exact_change(self):
        change = self.kassapaate.syo_maukkaasti_kateisella(400)
        self.assertEqual(change, 0)

    def test_buy_maukas_with_change(self):
        change = self.kassapaate.syo_maukkaasti_kateisella(500)
        self.assertEqual(change, 100)

    # kassassa oleva rahamäärä kasvaa lounaan hinnalla
    def test_buying_edullinen_with_cash_increases_amount_of_money_in_kassassa_rahaa(
            self):
        self.kassapaate.syo_edullisesti_kateisella(500)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100240)

    def test_buying_maukas_with_cash_increases_amount_of_money_in_kassassa_rahaa(
            self):
        self.kassapaate.syo_maukkaasti_kateisella(500)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100400)

    # myytyjen lounaiden määrä kasvaa
    def test_edulliset_increases_after_cash_purchase(self):
        self.kassapaate.syo_edullisesti_kateisella(500)
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_maukkaat_increases_after_cash_purchase(self):
        self.kassapaate.syo_maukkaasti_kateisella(500)
        self.assertEqual(self.kassapaate.maukkaat, 1)

# Jos maksu ei ole riittävä:
# kassassa oleva rahamäärä ei muutu,

    def test_buy_edullinen_with_too_little_cash_does_not_alter_kassassa_rahaa(
            self):
        change = self.kassapaate.syo_edullisesti_kateisella(99)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100_000)

    def test_buy_maukas_with_too_little_cash_does_not_alter_kassassa_rahaa(
            self):
        change = self.kassapaate.syo_maukkaasti_kateisella(99)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100_000)

    # kaikki rahat palautetaan vaihtorahana
    def test_buy_edullinen_with_too_little_cash_returns_same_value_as_change(
            self):
        change = self.kassapaate.syo_edullisesti_kateisella(99)
        self.assertEqual(change, 99)

    def test_buy_maukas_with_too_little_cash_returns_same_value_as_change(
            self):
        change = self.kassapaate.syo_maukkaasti_kateisella(99)
        self.assertEqual(change, 99)

    # myytyjen lounaiden määrässä ei muutosta
    def test_buy_edullinen_with_too_little_cash_does_not_alter_amount_of_sold_edullinen(
            self):
        change = self.kassapaate.syo_edullisesti_kateisella(99)
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_buy_edullinen_with_too_little_cash_does_not_alter_amount_of_sold_edullinen(
            self):
        change = self.kassapaate.syo_maukkaasti_kateisella(99)
        self.assertEqual(self.kassapaate.maukkaat, 0)

# Korttiosto toimii sekä edullisten että maukkaiden lounaiden osalta
# Jos tarpeeksi rahaa kortilla
# veloita summa ja palauta True

    def test_buy_edullinen_decreases_money_from_card(self):
        self.kassapaate.syo_edullisesti_kortilla(self.card)
        self.assertEqual(str(self.card), "saldo: 2.6")

    def test_buy_maukas_decreases_money_from_card(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.card)
        self.assertEqual(str(self.card), "saldo: 1.0")

    def test_buy_edullinen_with_card_returns_true(self):
        return_value = self.kassapaate.syo_edullisesti_kortilla(self.card)
        self.assertEqual(return_value, True)

    def test_buy_maukas_with_card_returns_true(self):
        return_value = self.kassapaate.syo_maukkaasti_kortilla(self.card)
        self.assertEqual(return_value, True)

    # myydyt lounaat kasvavat yhdellä
    def test_edulliset_increases_after_card_purchase(self):
        self.kassapaate.syo_edullisesti_kortilla(self.card)
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_maukkaat_increases_after_card_purchase(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.card)
        self.assertEqual(self.kassapaate.maukkaat, 1)

# Jos ei tarpeeksi rahaa kortilla
# kortin rahamäärä ei muutu

    def test_buying_edullinen_does_not_alter_amount_of_money_on_card_if_not_enough_money(
            self):
        self.kassapaate.syo_maukkaasti_kortilla(self.card)
        self.kassapaate.syo_edullisesti_kortilla(self.card)
        self.assertEqual(str(self.card), "saldo: 1.0")

    def test_buying_maukas_does_not_alter_amount_of_money_on_card_if_not_enough_money(
            self):
        self.kassapaate.syo_maukkaasti_kortilla(self.card)
        self.kassapaate.syo_maukkaasti_kortilla(self.card)
        self.assertEqual(str(self.card), "saldo: 1.0")

    # palautetaan False
    def test_buy_edullinen_with_card_returns_false_if_not_enough_money(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.card)
        return_value = self.kassapaate.syo_edullisesti_kortilla(self.card)
        self.assertEqual(return_value, False)

    def test_buy_maukas_with_card_returns_false_if_not_enough_money(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.card)
        return_value = self.kassapaate.syo_maukkaasti_kortilla(self.card)
        self.assertEqual(return_value, False)

    # myytyjen lounaiden määrä ei muutu
    def test_buying_edullinen_with_card_does_not_increase_edulliset_if_not_enough_money(
            self):
        self.kassapaate.syo_maukkaasti_kortilla(self.card)
        self.kassapaate.syo_edullisesti_kortilla(self.card)
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_buying_maukas_with_card_does_not_increase_maukkaat_if_not_enough_money(
            self):
        self.kassapaate.syo_maukkaasti_kortilla(self.card)
        self.kassapaate.syo_maukkaasti_kortilla(self.card)
        self.assertEqual(self.kassapaate.maukkaat, 1)

# Kassassa oleva rahamäärä ei muutu kortilla ostettaessa

    def test_buying_edullinen_with_card_does_not_change_kassassa_rahaa(self):
        self.kassapaate.syo_edullisesti_kortilla(self.card)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100_000)

    def test_buying_maukas_with_card_does_not_change_kassassa_rahaa(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.card)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100_000)

# Kortille rahaa ladattaessa kortin saldo muuttuu ja

    def test_putting_money_on_card_alters_cards_amount_of_money(self):
        self.kassapaate.lataa_rahaa_kortille(self.card, 100)
        self.assertEqual(str(self.card), "saldo: 6.0")

# kassassa oleva rahamäärä kasvaa ladatulla summalla

    def test_putting_money_on_card_increases_kassassa_rahaa(self):
        self.kassapaate.lataa_rahaa_kortille(self.card, 100)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100_100)


#lataa negatiivista rahaa ei muuta rahamääriä

    def test_putting_negative_money_on_card_does_not_alter_cards_amount_of_money(
            self):
        self.kassapaate.lataa_rahaa_kortille(self.card, -100)
        self.assertEqual(str(self.card), "saldo: 5.0")

    def test_put_negative_money_on_card_does_not_increase_kassassa_rahaa(self):
        self.kassapaate.lataa_rahaa_kortille(self.card, -100)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100_000)
Example #23
0
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassapaate = Kassapaate()
        self.kortti = Maksukortti(450)

    def test_luodun_kassapaatteen_tiedot_oikein(self):
        alkukassa = self.kassapaate.kassassa_rahaa
        myytyja_edullisia = self.kassapaate.edulliset
        myytyja_maukkaita = self.kassapaate.maukkaat
        self.assertEqual((alkukassa, myytyja_edullisia, myytyja_maukkaita),
                         (100000, 0, 0))

    def test_kateisosto_velottaa_oikein_edullisilla(self):
        vaihtorahat = self.kassapaate.syo_edullisesti_kateisella(500)
        self.assertEqual((self.kassapaate.kassassa_rahaa, vaihtorahat),
                         (100240, 260))

    def test_kateisosto_veloittaa_oikein_maukkailla(self):
        vaihtorahat = self.kassapaate.syo_maukkaasti_kateisella(500)
        self.assertEqual((self.kassapaate.kassassa_rahaa, vaihtorahat),
                         (100400, 100))

    def test_kateisosto_kasvattaa_myytyjen_maaraa_edullisilla(self):
        self.kassapaate.syo_edullisesti_kateisella(500)
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_kateisosto_kasvattaa_myytyjen_maaraa_maukkailla(self):
        self.kassapaate.syo_maukkaasti_kateisella(500)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_rahamaara_ei_muutu_jos_kateismaksu_ei_ole_riittava_edullisilla(
            self):
        vaihtoraha = self.kassapaate.syo_edullisesti_kateisella(200)
        self.assertEqual((self.kassapaate.kassassa_rahaa, vaihtoraha),
                         (100000, 200))

    def test_rahamaara_ei_muutu_jos_kateismaksu_ei_ole_riittava_edullisilla(
            self):
        vaihtoraha = self.kassapaate.syo_maukkaasti_kateisella(200)
        self.assertEqual((self.kassapaate.kassassa_rahaa, vaihtoraha),
                         (100000, 200))

    def test_edullisten_maara_ei_muutu_jos_kateismaksu_ei_riittava(self):
        self.kassapaate.syo_edullisesti_kateisella(200)
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_maukkaiden_maara_ei_muutu_jos_kateismaksu_ei_riittava(self):
        self.kassapaate.syo_maukkaasti_kateisella(200)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_korttiosto_veloittaa_oikein_edullisilla_kun_rahaa_tarpeeksi(self):
        toteutuiko = self.kassapaate.syo_edullisesti_kortilla(self.kortti)
        self.assertEqual((self.kortti.saldo, toteutuiko), (210, True))

    def test_korttiosto_veloittaa_oikein_maukkailla_kun_rahaa_tarpeeksi(self):
        toteutuiko = self.kassapaate.syo_maukkaasti_kortilla(self.kortti)
        self.assertEqual((self.kortti.saldo, toteutuiko), (50, True))

    def test_korttiosto_ei_veloita_edullisilla_kun_rahaa_ei_ole_tarpeeksi(
            self):
        self.kassapaate.syo_edullisesti_kortilla(self.kortti)
        toteutuiko = self.kassapaate.syo_edullisesti_kortilla(self.kortti)
        self.assertEqual((self.kortti.saldo, toteutuiko), (210, False))

    def test_korttiosto_ei_veloita_maukkailla_kun_rahaa_ei_ole_tarpeeksi(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.kortti)
        toteutuiko = self.kassapaate.syo_maukkaasti_kortilla(self.kortti)
        self.assertEqual((self.kortti.saldo, toteutuiko), (50, False))

    def test_korttiosto_kasvattaa_edullisia_kun_rahaa_on_tarpeeksi(self):
        self.kassapaate.syo_edullisesti_kortilla(self.kortti)
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_korttiosto_kasvattaa_maukkaita_kun_rahaa_on_tarpeeksi(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.kortti)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_korttiosto_ei_kasvata_edullisia_kun_rahaa_ei_ole_tarpeeksi(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.kortti)
        self.kassapaate.syo_edullisesti_kortilla(self.kortti)
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_korttiosto_ei_kasvata_maukkaita_kun_rahaa_ei_ole_tarpeeksi(self):
        self.kassapaate.syo_edullisesti_kortilla(self.kortti)
        self.kassapaate.syo_maukkaasti_kortilla(self.kortti)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_korttilataus_positiivisella_summalla_kasvattaa_arvoa_kortilla(
            self):
        self.kassapaate.lataa_rahaa_kortille(self.kortti, 1000)
        self.assertEqual(self.kortti.saldo, 1450)

    def test_korttilataus_positiivisella_summalla_kasvattaa_rahaa_kassassa(
            self):
        self.kassapaate.lataa_rahaa_kortille(self.kortti, 1000)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 101000)

    def test_korttilataus_nollaa_pienemmilla_ei_muuta_kortin_arvoa(self):
        palautus = self.kassapaate.lataa_rahaa_kortille(self.kortti, -1000)
        self.assertEqual((self.kortti.saldo, palautus), (450, None))

    def test_korttilataus_nollaa_pienemmilla_ei_muuta_rahaa_kassassa(self):
        palautus = self.kassapaate.lataa_rahaa_kortille(self.kortti, -1000)
        self.assertEqual((self.kassapaate.kassassa_rahaa, palautus),
                         (100000, None))
Example #24
0
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassapaate = Kassapaate()
        self.maksukortti = Maksukortti(400)

    def test_kassapaatteen_rahamaara_oikein(self):
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_lounaita_myyty_oikein(self):
        self.assertEqual(self.kassapaate.edulliset + self.kassapaate.maukkaat,
                         0)

    def test_edullisen_kateisosto_toimii_myydyt_ok(self):
        self.kassapaate.syo_edullisesti_kateisella(300)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100240)

    def test_edullisen_kateisoston_vaihtoraha_ok(self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(300), 60)

    def test_edullisen_kateisosto_toimii_ei_tarpeeksi_rahaa(self):
        self.kassapaate.syo_edullisesti_kateisella(200)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_edullisen_kateisosto_toimii_ei_tarpeeksi_rahaa_vaihtorahat_ok(
            self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(200), 200)

    def test_edullisen_kateisosto_toimii_ei_tarpeeksi_rahaa_myydyt_ok(self):
        self.kassapaate.syo_edullisesti_kateisella(200)
        self.assertEqual(self.kassapaate.edulliset + self.kassapaate.maukkaat,
                         0)

    def test_maukkaan_kateisosto_toimii_myydyt_ok(self):
        self.kassapaate.syo_maukkaasti_kateisella(450)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100400)

    def test_maukkaan_kateisoston_vaihtoraha_ok(self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(400), 0)

    def test_maukkaan_kateisosto_toimii_ei_tarpeeksi_rahaa(self):
        self.kassapaate.syo_maukkaasti_kateisella(200)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_maukkaan_kateisosto_toimii_ei_tarpeeksi_rahaa_vaihtorahat_ok(
            self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(200), 200)

    def test_maukkaan_kateisosto_toimii_ei_tarpeeksi_rahaa_myydyt_ok(self):
        self.kassapaate.syo_maukkaasti_kateisella(200)
        self.assertEqual(self.kassapaate.edulliset + self.kassapaate.maukkaat,
                         0)

    def test_edullinen_korttiosto_toimii(self):
        self.assertEqual(
            self.kassapaate.syo_edullisesti_kortilla(self.maksukortti), True)

    def test_edullinen_korttiosto_toimii(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(str(self.maksukortti), "saldo: 1.6")

    def test_korttiosto_myydyt_ok(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.edulliset + self.kassapaate.maukkaat,
                         1)

    def test_korttiosto_ei_tarpeeksi_rahaa_myydyt_ok(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.edulliset + self.kassapaate.maukkaat,
                         1)

    def test_korttiosto_ei_tarpeeksi_rahaa(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(
            self.kassapaate.syo_edullisesti_kortilla(self.maksukortti), False)

    def test_korttiosto_ei_tarpeeksi_rahaa_kortti_ok(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(str(self.maksukortti), "saldo: 1.6")

    def test_kassan_rahamaara_korttiostossa_ok(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
##########

    def test_maukas_korttiosto_toimii(self):
        self.assertEqual(
            self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti), True)

    def test_maukas_korttiosto_toimii(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(str(self.maksukortti), "saldo: 0.0")

    def test_maukas_korttiosto_myydyt_ok(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.edulliset + self.kassapaate.maukkaat,
                         1)

    def test_maukas_korttiosto_ei_tarpeeksi_rahaa_myydyt_ok(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.edulliset + self.kassapaate.maukkaat,
                         1)

    def test_korttiosto_ei_tarpeeksi_rahaa(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(
            self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti), False)

    def test_maukas_korttiosto_ei_tarpeeksi_rahaa_kortti_ok(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(str(self.maksukortti), "saldo: 0.0")

    def test_kassan_rahamaara_maukkaassa_korttiostossa_ok(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
########

    def test_rahan_lataus_kortille_ok(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, 10)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100010)

    def test_rahan_lataus_kortille_ok(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, 10)
        self.assertEqual(self.maksukortti.saldo, 410)

    def test_rahan_lataus_kortille_negatiivinen_summa(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, -10)
        self.assertEqual(self.maksukortti.saldo, 400)
Example #25
0
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassapaate = Kassapaate()
        self.maksukortti = Maksukortti(500)

    def test_kassan_saldo_on_oikein(self):
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_lounaita_ei_viela_myyty(self):
        self.assertEqual(self.kassapaate.edulliset, 0)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_syo_edullisesti_kateisella_kasvattaa_saldoa(self):
        self.kassapaate.syo_edullisesti_kateisella(240)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100240)

    def test_syo_edullisesti_kateisella_palauttaa_vaihdon(self):
        maksu = self.kassapaate.syo_edullisesti_kateisella(300)
        self.assertEqual(maksu, 60)

    def test_syo_edullisesti_kateisella_kasvattaa_lounaita(self):
        self.kassapaate.syo_edullisesti_kateisella(240)
        self.kassapaate.syo_edullisesti_kateisella(300)
        self.assertEqual(self.kassapaate.edulliset, 2)

    def test_syo_edullisesti_kateinen_ei_riita_ja_saldo_ei_muutu(self):
        self.kassapaate.syo_edullisesti_kateisella(200)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_syo_edullisesti_kateinen_ei_riita_ja_rahat_palautetaan(self):
        maksu = self.kassapaate.syo_edullisesti_kateisella(200)
        self.assertEqual(maksu, 200)

    def test_syo_edullisesti_kateinen_ei_riita_ja_lounaat_eivat_kasva(self):
        self.kassapaate.syo_edullisesti_kateisella(200)
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_syo_maukkaasti_kateisella_kasvattaa_saldoa(self):
        self.kassapaate.syo_maukkaasti_kateisella(400)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100400)

    def test_syo_maukkaasti_kateisella_palauttaa_vaihdon(self):
        maksu = self.kassapaate.syo_maukkaasti_kateisella(500)
        self.assertEqual(maksu, 100)

    def test_syo_maukkaasti_kateisella_kasvattaa_lounaita(self):
        self.kassapaate.syo_maukkaasti_kateisella(400)
        self.kassapaate.syo_maukkaasti_kateisella(500)
        self.assertEqual(self.kassapaate.maukkaat, 2)

    def test_syo_maukkaasti_kateinen_ei_riita_ja_saldo_ei_muutu(self):
        self.kassapaate.syo_maukkaasti_kateisella(300)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_syo_maukkaasti_kateinen_ei_riita_ja_rahat_palautetaan(self):
        maksu = self.kassapaate.syo_maukkaasti_kateisella(300)
        self.assertEqual(maksu, 300)

    def test_syo_maukkaasti_kateinen_ei_riita_ja_lounaat_eivat_kasva(self):
        self.kassapaate.syo_maukkaasti_kateisella(300)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_syo_edullisesti_kortilla_kortin_saldo_oikein(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.maksukortti.saldo, 260)

    def test_syo_edullisesti_kortilla_palauttaa_true(self):
        tulos = self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertTrue(tulos)

    def test_syo_edullisesti_kortilla_kasvattaa_lounaita(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_syo_edullisesti_ei_rahaa_ei_muuta_kortin_saldoa(self):
        self.maksukortti.saldo = 200
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.maksukortti.saldo, 200)

    def test_syo_edullisesti_ei_rahaa_ei_kasvata_lounaita(self):
        self.maksukortti.saldo = 200
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_syo_edullisesti_ei_rahaa_palauttaa_false(self):
        self.maksukortti.saldo = 200
        tulos = self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertFalse(tulos)

    def test_syo_edullisesti_kortilla_ei_muuta_kassan_saldoa(self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_syo_maukkaasti_kortilla_kortin_saldo_oikein(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.maksukortti.saldo, 100)

    def test_syo_maukkaasti_kortilla_palauttaa_true(self):
        tulos = self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertTrue(tulos)

    def test_syo_maukkaasti_kortilla_kasvattaa_lounaita(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_syo_maukkaasti_ei_rahaa_ei_muuta_kortin_saldoa(self):
        self.maksukortti.saldo = 350
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.maksukortti.saldo, 350)

    def test_syo_maukkaasti_ei_rahaa_ei_kasvata_lounaita(self):
        self.maksukortti.saldo = 350
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_syo_maukkaasti_ei_rahaa_palauttaa_false(self):
        self.maksukortti.saldo = 350
        tulos = self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertFalse(tulos)

    def test_syo_maukkaasti_kortilla_ei_muuta_kassan_saldoa(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_rahan_lataus_kortin_saldo_muuttuu(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, 500)
        self.assertEqual(str(self.maksukortti), 'saldo: 10.0')

    def test_rahan_lataus_kassan_saldo_kasvaa(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, 500)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100500)

    def test_negatiivinen_summa_ei_kasvata_saldoa(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, -500)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassa = Kassapaate()
        self.kassassa_rahaa = 1000

    def test_saldo_oikein_luonnissa(self):
        self.assertEqual(self.kassassa_rahaa, 1000)

    def test_kateisosto_edullinen_kassa_kasvaa(self):
        self.kassa.syo_edullisesti_kateisella(500)
        self.assertEqual(self.kassa.kassassa_rahaa, 100240)

    def test_myydyt_lounaat_kasvaa_edullinen_kateinen(self):
        self.kassa.syo_edullisesti_kateisella(240)
        self.assertEqual(self.kassa.edulliset, 1)

    def test_kateisosto_maukas_kassa_kasvaa(self):
        self.kassa.syo_maukkaasti_kateisella(500)
        self.assertEqual(self.kassa.kassassa_rahaa, 100400)

    def test_kateisosto_edullinen_vaihtoraha(self):
        self.assertEqual(self.kassa.syo_edullisesti_kateisella(500), 260)

    def test_myydyt_lounaat_kasvaa_edullinen_kateinen(self):
        self.kassa.syo_edullisesti_kateisella(500)
        self.assertEqual(self.kassa.edulliset, 1)

    def test_edullinen_maksu_ei_riita_kateinen_summa(self):
        self.kassa.syo_edullisesti_kateisella(200)
        self.assertEqual(self.kassa.edulliset, 0)

    def test_edullinen_maksu_ei_riita_kateinen_kassanraha(self):
        self.kassa.syo_edullisesti_kateisella(200)
        self.assertEqual(self.kassa.kassassa_rahaa, 100000)

    def test_edullinen_maksu_ei_riita_kateinen_vaihtoraha(self):
        self.kassa.syo_edullisesti_kateisella(200)
        self.assertEqual(self.kassa.syo_edullisesti_kateisella(200), 200)

    def test_kateisosto_maukas_kassa_kasvaa(self):
        self.kassa.syo_maukkaasti_kateisella(500)
        self.assertEqual(self.kassa.kassassa_rahaa, 100400)

    def test_kateisosto_maukas_vaihtoraha(self):
        self.kassa.syo_maukkaasti_kateisella(500)
        self.assertEqual(self.kassa.syo_maukkaasti_kateisella(500), 100)

    def test_myydyt_lounaat_kasvaa_maukas_kateinen(self):
        self.kassa.syo_maukkaasti_kateisella(500)
        self.assertEqual(self.kassa.maukkaat, 1)

    def test_maukas_maksu_ei_riita_kateinen_summa(self):
        self.kassa.syo_maukkaasti_kateisella(200)
        self.assertEqual(self.kassa.maukkaat, 0)

    def test_maukas_maksu_ei_riita_kateinen_kassanraha(self):
        self.kassa.syo_maukkaasti_kateisella(200)
        self.assertEqual(self.kassa.kassassa_rahaa, 100000)

    def test_maukas_maksu_ei_riita_kateinen_vaihtoraha(self):
        self.kassa.syo_maukkaasti_kateisella(200)
        self.assertEqual(self.kassa.syo_maukkaasti_kateisella(200), 200)

    def test_korttiosto_edullinen_raha_riittaa(self):
        self.kortti = Maksukortti(1000)
        self.kassa.syo_edullisesti_kortilla(self.kortti)
        self.assertEqual(str(self.kortti), "saldo: 7.6")

    def test_korttiosto_edullinen_raha_riittaa_palautus(self):
        self.kortti = Maksukortti(1000)
        self.kassa.syo_edullisesti_kortilla(self.kortti)
        self.assertEqual(self.kassa.syo_edullisesti_kortilla(self.kortti),
                         True)

    def test_korttiosto_maukas_raha_riittaa_saldo(self):
        self.kortti = Maksukortti(1000)
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.assertEqual(str(self.kortti), "saldo: 6.0")

    def test_korttiosto_maukas_raha_riittaa_palautus(self):
        self.kortti = Maksukortti(1000)
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.assertEqual(self.kassa.syo_maukkaasti_kortilla(self.kortti), True)

    def test_korttiosto_edullinen_myydyt_kasvaa(self):
        self.kortti = Maksukortti(1000)
        self.kassa.syo_edullisesti_kortilla(self.kortti)
        self.assertEqual(self.kassa.edulliset, 1)

    def test_korttiosto_maukas_myydyt_kasvaa(self):
        self.kortti = Maksukortti(1000)
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.assertEqual(self.kassa.maukkaat, 1)

    def test_korttiosto_edullinen_rahatLoppu_KortinSaldo(self):
        self.kortti = Maksukortti(200)
        self.kassa.syo_edullisesti_kortilla(self.kortti)
        self.assertEqual(str(self.kortti), "saldo: 2.0")

    def test_korttiosto_maukas_rahatLoppu_KortinSaldo(self):
        self.kortti = Maksukortti(200)
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.assertEqual(str(self.kortti), "saldo: 2.0")

    def test_korttiosto_edullinen_rahatLoppu_myydyt(self):
        self.kortti = Maksukortti(200)
        self.kassa.syo_edullisesti_kortilla(self.kortti)
        self.assertEqual(self.kassa.edulliset, 0)

    def test_korttiosto_maukas_rahatLoppu_myydyt(self):
        self.kortti = Maksukortti(200)
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.assertEqual(self.kassa.maukkaat, 0)

    def test_korttiosto_edullinen_rahatLoppu_palautus(self):
        self.kortti = Maksukortti(200)
        self.kassa.syo_edullisesti_kortilla(self.kortti)
        self.assertEqual(self.kassa.syo_edullisesti_kortilla(self.kortti),
                         False)

    def test_korttiosto_maukas_rahatLoppu_palautus(self):
        self.kortti = Maksukortti(200)
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.assertEqual(self.kassa.syo_maukkaasti_kortilla(self.kortti),
                         False)

    def test_korttiosto_kassan_saldo(self):
        self.kortti = Maksukortti(500)
        self.kassa.syo_edullisesti_kortilla(self.kortti)
        self.assertEqual(self.kassa.kassassa_rahaa, 100000)

    def test_kortin_saldo_muuttuu(self):
        self.kortti = Maksukortti(500)
        self.kortti.lataa_rahaa(200)
        self.assertEqual(self.kortti.saldo, 700)

    def test_kassan_rahat_kasvaa(self):
        self.kortti = Maksukortti(500)
        self.kassa.lataa_rahaa_kortille(self.kortti, 200)
        self.assertEqual(self.kassa.kassassa_rahaa, 100200)

    def test_kassan_rahat_kasvaa_negatiivinen_lisays(self):
        self.kortti = Maksukortti(500)
        self.kassa.lataa_rahaa_kortille(self.kortti, -200)
        self.assertEqual(self.kassa.kassassa_rahaa, 100000)
Example #27
0
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassapaate = Kassapaate()
        self.riittavasti_maksukortti = Maksukortti(500)
        self.alle_maksukortti = Maksukortti(100)

    # kassapäätteen alustamisen testaus

    def test_kassapaate_alussa_rahaa_1000_euroa(self):
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
    
    def test_kassapaate_alussa_ei_yhtaan_myytya_maukasta_lounasta(self):
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_kassapaate_alussa_ei_yhtaan_myytya_edullista_lounasta(self):
        self.assertEqual(self.kassapaate.edulliset, 0)
    
    # käteismaksun testaaminen

    # edullisesti
    def test_kateismaksu_syo_edullisesti_onnistuessa_kassassa_rahaa_kasvaa(self):
        self.kassapaate.syo_edullisesti_kateisella(240)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100240)

    def test_kateismaksu_syo_edullisesti_ei_riittavasti_rahaa_kassassa_rahaa_ei_kasva(self):
        self.kassapaate.syo_edullisesti_kateisella(100)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_kateismaksu_syo_edullisesti_tasarahalla_palautetaan_nolla(self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(240), 0)

    def test_kateismaksu_syo_edullisesti_suuremmalla_summalla_palautetaan_vaihtoraha(self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(500), 260)

    def test_kateismaksu_syo_edullisesti_ei_riittavasti_rahaa_palautuu_maksu(self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(100), 100)

    def test_kateismaksu_syo_edullisesti_onnistuessa_myytyjen_maara_kasvaa(self):
        self.kassapaate.syo_edullisesti_kateisella(500)
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_kateismaksu_syo_edullisesti_epaonnistuessa_myytyjen_maara_ei_kasva(self):
        self.kassapaate.syo_edullisesti_kateisella(100)
        self.assertEqual(self.kassapaate.edulliset, 0)

    # maukkaasti
    def test_kateismaksu_syo_maukkaasti_onnistuessa_kassassa_rahaa_kasvaa(self):
        self.kassapaate.syo_maukkaasti_kateisella(400)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100400)

    def test_kateismaksu_syo_maukkaasti_ei_riittavasti_rahaa_kassassa_rahaa_ei_kasva(self):
        self.kassapaate.syo_maukkaasti_kateisella(100)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_kateismaksu_syo_maukkaasti_tasarahalla_palautetaan_nolla(self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(400), 0)

    def test_kateismaksu_syo_maukkaasti_suuremmalla_summalla_palautetaan_vaihtoraha(self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(500), 100)

    def test_kateismaksu_syo_maukkaasti_ei_riittavasti_rahaa_palautuu_maksu(self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(100), 100)

    def test_kateismaksu_syo_maukkaasti_onnistuessa_myytyjen_maara_kasvaa(self):
        self.kassapaate.syo_maukkaasti_kateisella(500)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_kateismaksu_syo_maukkaasti_epaonnistuessa_myytyjen_maara_ei_kasva(self):
        self.kassapaate.syo_maukkaasti_kateisella(100)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    # korttioston testaaminen

    # edullisesti
    def test_korttimaksu_syo_edullisesti_onnistuessa_palauttaa_true(self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kortilla(self.riittavasti_maksukortti), True)

    def test_korttimaksu_syo_edullisesti_onnistuessa_veloittaa_korttia(self):
        self.kassapaate.syo_edullisesti_kortilla(self.riittavasti_maksukortti)
        self.assertEqual(self.riittavasti_maksukortti.saldo, 260)

    def test_korttimaksu_syo_edullisesti_epaonnistuessa_palauttaa_false(self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kortilla(self.alle_maksukortti), False)

    def test_korttimaksu_syo_edullisesti_epaonnistuessa_ei_veloita_korttia(self):
        self.kassapaate.syo_edullisesti_kortilla(self.alle_maksukortti)
        self.assertEqual(self.alle_maksukortti.saldo, 100)
    
    def test_korttimaksu_syo_edullisesti_onnistuessa_myytyjen_maara_kasvaa(self):
        self.kassapaate.syo_edullisesti_kortilla(self.riittavasti_maksukortti)
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_korttimaksu_syo_edullisesti_epaonnistuessa_myytyjen_maara_ei_kasva(self):
        self.kassapaate.syo_edullisesti_kortilla(self.alle_maksukortti)
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_korttimaksu_syo_edullisesti_onnistuessa_ei_muuta_rahaa_kassassa(self):
        self.kassapaate.syo_edullisesti_kortilla(self.riittavasti_maksukortti)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_korttimaksu_syo_edullisesti_epaonnistuessa_ei_muuta_rahaa_kassassa(self):
        self.kassapaate.syo_edullisesti_kortilla(self.alle_maksukortti)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    # maukkaasti
    def test_korttimaksu_syo_maukkaasti_onnistuessa_palauttaa_true(self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kortilla(self.riittavasti_maksukortti), True)

    def test_korttimaksu_syo_maukkaasti_onnistuessa_veloittaa_korttia(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.riittavasti_maksukortti)
        self.assertEqual(self.riittavasti_maksukortti.saldo, 100)

    def test_korttimaksu_syo_maukkaasti_epaonnistuessa_palauttaa_false(self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kortilla(self.alle_maksukortti), False)

    def test_korttimaksu_syo_maukkaasti_epaonnistuessa_ei_veloita_korttia(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.alle_maksukortti)
        self.assertEqual(self.alle_maksukortti.saldo, 100)
    
    def test_korttimaksu_syo_maukkaasti_onnistuessa_myytyjen_maara_kasvaa(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.riittavasti_maksukortti)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_korttimaksu_syo_maukkaasti_epaonnistuessa_myytyjen_maara_ei_kasva(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.alle_maksukortti)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_korttimaksu_syo_maukkaasti_onnistuessa_ei_muuta_rahaa_kassassa(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.riittavasti_maksukortti)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_korttimaksu_syo_maukkaasti_epaonnistuessa_ei_muuta_rahaa_kassassa(self):
        self.kassapaate.syo_maukkaasti_kortilla(self.alle_maksukortti)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    # rahan lataaminen kortille

    def test_lataa_rahaa_kortille_siirtaa_kortille_rahaa(self):
        self.kassapaate.lataa_rahaa_kortille(self.riittavasti_maksukortti, 500)
        self.assertEqual(self.riittavasti_maksukortti.saldo, 1000)
    
    def test_lataa_rahaa_kortille_ei_siirra_negatiivista_summaa(self):
        self.kassapaate.lataa_rahaa_kortille(self.riittavasti_maksukortti, -500)
        self.assertEqual(self.riittavasti_maksukortti.saldo, 500)
    
    def test_lataa_rahaa_kortille_onnistuessa_kasvattaa_kassassa_rahaa(self):
        self.kassapaate.lataa_rahaa_kortille(self.riittavasti_maksukortti, 500)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100500)

    def test_lataa_rahaa_kortille_epaonnistuessa_ei_kasvata_rahaa_kassassa(self):
        self.kassapaate.lataa_rahaa_kortille(self.riittavasti_maksukortti, -500)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
Example #28
0
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassa = Kassapaate()
        self.kortti = Maksukortti(200)

    def test_kassassa_oikea_maara_rahaa(self):
        self.assertEqual(self.kassa.kassassa_rahaa, 100000)

    def test_kassassa_oikea_maara_myytyja_lounaita(self):
        myydyt = self.kassa.edulliset + self.kassa.maukkaat
        self.assertEqual(myydyt, 0)

    def test_osta_kateisella_edullinen_kasvu(self):
        self.kassa.syo_edullisesti_kateisella(250)
        self.assertEqual(self.kassa.kassassa_rahaa, 100240)

    def test_osta_kateisella_edullinen_vaihtoraha(self):
        self.assertEqual(self.kassa.syo_edullisesti_kateisella(250), 10)

    def test_osta_kateisella_edullinen_myydyt_lisaantyy(self):
        self.kassa.syo_edullisesti_kateisella(250)
        self.assertEqual(self.kassa.edulliset, 1)

    def test_osta_kateisella_edullinen_kasvu_ei_tarpeeksi_rahaa(self):
        self.kassa.syo_edullisesti_kateisella(200)
        self.assertEqual(self.kassa.kassassa_rahaa, 100000)

    def test_osta_kateisella_edullinen_vaihtoraha_ei_tarpeeksi_rahaa(self):
        self.assertEqual(self.kassa.syo_edullisesti_kateisella(200), 200)

    def test_osta_kateisella_edullinen_myydyt_lisaantyy_ei_tarpeeksi_rahaa(
            self):
        self.kassa.syo_edullisesti_kateisella(200)
        self.assertEqual(self.kassa.edulliset, 0)

    def test_osta_kateisella_maukas_kasvu(self):
        self.kassa.syo_maukkaasti_kateisella(450)
        self.assertEqual(self.kassa.kassassa_rahaa, 100400)

    def test_osta_kateisella_maukas_vaihtoraha(self):
        self.assertEqual(self.kassa.syo_maukkaasti_kateisella(450), 50)

    def test_osta_kateisella_maukas_myydyt_lisaantyy(self):
        self.kassa.syo_maukkaasti_kateisella(450)
        self.assertEqual(self.kassa.maukkaat, 1)

    def test_osta_kateisella_maukas_kasvu_ei_tarpeeksi_rahaa(self):
        self.kassa.syo_maukkaasti_kateisella(200)
        self.assertEqual(self.kassa.kassassa_rahaa, 100000)

    def test_osta_kateisella_maukas_vaihtoraha_ei_tarpeeksi_rahaa(self):
        self.assertEqual(self.kassa.syo_maukkaasti_kateisella(200), 200)

    def test_osta_kateisella_maukas_myydyt_lisaantyy_ei_tarpeeksi_rahaa(self):
        self.kassa.syo_maukkaasti_kateisella(200)
        self.assertEqual(self.kassa.maukkaat, 0)

    def test_osta_kortilla_edullisesti_tarpeeksi_rahaa(self):
        self.kortti.lataa_rahaa(200)
        self.assertEqual(self.kassa.syo_edullisesti_kortilla(self.kortti),
                         True)

    def test_osta_kortilla_edullisesti_tarpeeksi_rahaa_veloitus(self):
        self.kortti.lataa_rahaa(200)
        self.kassa.syo_edullisesti_kortilla(self.kortti)
        self.assertEqual(str(self.kortti), "saldo: 1.6")

    def test_osta_kortilla_edullisesti_tarpeeksi_rahaa_myydyt(self):
        self.kortti.lataa_rahaa(200)
        self.kassa.syo_edullisesti_kortilla(self.kortti)
        self.assertEqual(self.kassa.edulliset, 1)

    def test_osta_kortilla_edullisesti_ei_tarpeeksi_rahaa(self):
        self.assertEqual(self.kassa.syo_edullisesti_kortilla(self.kortti),
                         False)

    def test_osta_kortilla_edullisesti_ei_tarpeeksi_rahaa_veloitus(self):
        self.kassa.syo_edullisesti_kortilla(self.kortti)
        self.assertEqual(str(self.kortti), "saldo: 2.0")

    def test_osta_kortilla_edullisesti_ei_tarpeeksi_rahaa_myydyt(self):
        self.kassa.syo_edullisesti_kortilla(self.kortti)
        self.assertEqual(self.kassa.edulliset, 0)

    def test_osta_kortilla_maukkaasti_tarpeeksi_rahaa(self):
        self.kortti.lataa_rahaa(200)
        self.assertEqual(self.kassa.syo_maukkaasti_kortilla(self.kortti), True)

    def test_osta_kortilla_maukkaasti_tarpeeksi_rahaa_veloitus(self):
        self.kortti.lataa_rahaa(200)
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.assertEqual(str(self.kortti), "saldo: 0.0")

    def test_osta_kortilla_maukkaasti_tarpeeksi_rahaa_myydyt(self):
        self.kortti.lataa_rahaa(200)
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.assertEqual(self.kassa.maukkaat, 1)

    def test_osta_kortilla_maukkaasti_ei_tarpeeksi_rahaa(self):
        self.assertEqual(self.kassa.syo_maukkaasti_kortilla(self.kortti),
                         False)

    def test_osta_kortilla_maukkaasti_ei_tarpeeksi_rahaa_veloitus(self):
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.assertEqual(str(self.kortti), "saldo: 2.0")

    def test_osta_kortilla_maukkaasti_ei_tarpeeksi_rahaa_myydyt(self):
        self.kassa.syo_maukkaasti_kortilla(self.kortti)
        self.assertEqual(self.kassa.maukkaat, 0)

    def test_rahaa_ladatessa_kassaan_tulee_rahaa(self):
        self.kassa.lataa_rahaa_kortille(self.kortti, 210)
        self.assertEqual(self.kassa.kassassa_rahaa, 1210)

    def test_rahaa_ladatessa_kassaan_tulee_rahaa(self):
        self.kassa.lataa_rahaa_kortille(self.kortti, 210)
        self.assertEqual(str(self.kortti), "saldo: 4.1")

    def test_rahaa_ladataan_negatiivinen_maara(self):
        self.kassa.lataa_rahaa_kortille(self.kortti, -210)
        self.assertEqual(str(self.kortti), "saldo: 2.0")
Example #29
0
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassapaate = Kassapaate()
        self.maksukortti = Maksukortti(1000)

    #kassapääte luotu oikein:
    def test_luodun_kassapaatteen_rahamaara_oikein(self):
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_luodun_kassapaatteen_myydyt_edulliset_lounaat_oikein(self):
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_luodun_kassapaatteen_myydyt_maukkaat_lounaat_oikein(self):
        self.assertEqual(self.kassapaate.maukkaat, 0)

    #Käteisosto toimii edullisten lounaiden osalta:
    def test_vaihtoraha_oikein_kun_edullisen_lounaan_kateisosto_onnistuu(self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(250), 10)

    def test_kassan_rahamaara_kasvaa_oikein_kun_ostetaan_kateisella_edullinen_lounas(
            self):
        self.kassapaate.syo_edullisesti_kateisella(250)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100240)

    def test_myytyjen_edullisten_lounaiden_maara_oikein_kun_kateisosto_onnistuu(
            self):
        self.kassapaate.syo_edullisesti_kateisella(250)
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_kassan_rahamaara_oikein_kun_edullisen_lounaan_maksu_ei_riittava(
            self):
        self.kassapaate.syo_edullisesti_kateisella(150)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_vaihtorahan_maara_oikein_kun_edullisen_lounaan_maksu_ei_riittava(
            self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(150), 150)

    def test_myytyjen_edullisten_lounaiden_maara_oikein_kun_kateisosto_ei_mene_lapi(
            self):
        self.kassapaate.syo_edullisesti_kateisella(150)
        self.assertEqual(self.kassapaate.edulliset, 0)

    #Käteisosto toimii maksullisten lounaiden osalta:
    def test_vaihtoraha_oikein_kun_maukkaan_lounaan_kateisosto_onnistuu(self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(420), 20)

    def test_kassan_rahamaara_kasvaa_oikein_kun_ostetaan_kateisella_maukas_lounas(
            self):
        self.kassapaate.syo_maukkaasti_kateisella(420)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100400)

    def test_myytyjen_maukkaiden_lounaiden_maara_oikein_kun_kateisosto_onnistuu(
            self):
        self.kassapaate.syo_maukkaasti_kateisella(420)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_kassan_rahamaara_oikein_kun_maukkaan_lounaan_maksu_ei_riittava(
            self):
        self.kassapaate.syo_maukkaasti_kateisella(350)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_vaihtorahan_maara_oikein_kun_maukkaan_lounaan_maksu_ei_riittava(
            self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(350), 350)

    def test_myytyjen_maukkaiden_lounaiden_maara_oikein_kun_kateisosto_ei_mene_lapi(
            self):
        self.kassapaate.syo_maukkaasti_kateisella(350)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    #Korttiostot edullisten lounaiden osalta:
    def test_kortilta_veloitetaan_oikein_kun_edullisen_lounaan_korttiosto_onnistuu(
            self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.maksukortti.saldo, 760)

    def test_palauttaa_True_kun_ostetaan_edullinen_lounas_kortilla_onnistuneesti(
            self):
        self.assertEqual(
            self.kassapaate.syo_edullisesti_kortilla(self.maksukortti), True)

    def test_myytyjen_edullisten_lounaiden_maara_oikein_kun_korttiosto_onnistuu(
            self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_kortilta_ei_veloiteta_jos_edullisen_lounaan_korttimaksu_ei_onnistu(
            self):
        self.maksukortti.ota_rahaa(800)
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.maksukortti.saldo, 200)

    def test_myytyjen_edullisten_lounaiden_maara_ei_muutu_kun_korttiosto_epaonnistuu(
            self):
        self.maksukortti.ota_rahaa(800)
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_palauttaa_False_kun_ostetaan_edullinen_lounas_kortilla_epaonnistuneesti(
            self):
        self.maksukortti.ota_rahaa(800)
        self.assertEqual(
            self.kassapaate.syo_edullisesti_kortilla(self.maksukortti), False)

    def test_kassassa_oleva_rahamaara_ei_muutu_kun_kortilla_ostetaan_edullinen_lounas(
            self):
        self.kassapaate.syo_edullisesti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    #Korttiostot maukkaan lounaan osalta:
    def test_kortilta_veloitetaan_oikein_kun_maukkaan_lounaan_korttiosto_onnistuu(
            self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.maksukortti.saldo, 600)

    def test_palauttaa_True_kun_ostetaan_maukas_lounas_kortilla_onnistuneesti(
            self):
        self.assertEqual(
            self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti), True)

    def test_myytyjen_maukkaiden_lounaiden_maara_oikein_kun_korttiosto_onnistuu(
            self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_kortilta_ei_veloiteta_jos_maukkaan_lounaan_korttimaksu_ei_onnistu(
            self):
        self.maksukortti.ota_rahaa(800)
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.maksukortti.saldo, 200)

    def test_myytyjen_maukkaiden_lounaiden_maara_ei_muutu_kun_korttiosto_epaonnistuu(
            self):
        self.maksukortti.ota_rahaa(800)
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_palauttaa_False_kun_ostetaan_maukas_lounas_kortilla_epaonnistuneesti(
            self):
        self.maksukortti.ota_rahaa(800)
        self.assertEqual(
            self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti), False)

    def test_kassassa_oleva_rahamaara_ei_muutu_kun_kortilla_ostetaan_maukas_lounas(
            self):
        self.kassapaate.syo_maukkaasti_kortilla(self.maksukortti)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    #Rahan lataus:
    def test_kortin_saldo_muuttuu_oikein_kun_ladataan_rahaa_kortille(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, 500)
        self.assertEqual(self.maksukortti.saldo, 1500)

    def test_kassan_rahamaara_kasvaa_oikein_kun_ladataan_rahaa_kortille(self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, 500)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100500)

    def test_kortin_saldo_ei_muutu_kun_ladataan_kortille_negatiivinen_summa(
            self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, -500)
        self.assertEqual(self.maksukortti.saldo, 1000)

    def test_kassan_rahamaara_ei_muutu_kun_ladataan_kortille_negatiivinen_summa(
            self):
        self.kassapaate.lataa_rahaa_kortille(self.maksukortti, -500)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)
class TestKassapaate(unittest.TestCase):
    def setUp(self):
        self.kassapaate = Kassapaate()

    # konstruktorin testit
    def test_luotu_kassapaate_on_olemassa(self):
        self.assertNotEqual(self.kassapaate, None)

    def test_luodussa_kassassa_oikea_summa_rahaa(self):
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_luodussa_kassassa_ei_myytyja_edullisia(self):
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_luodussa_kassassa_ei_myytyja_maukkaita(self):
        self.assertEqual(self.kassapaate.maukkaat, 0)

    # edullisesti käteisellä -testit
    def test_edullisesti_kateisella_kasvattaa_kassaa_oikein(self):
        self.kassapaate.syo_edullisesti_kateisella(240)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100240)

    def test_edullisesti_kateisella_antaa_oikean_vaihtorahan(self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(500), 260)

    def test_edullisesti_kateisella_kasvattaa_myytyja(self):
        self.kassapaate.syo_edullisesti_kateisella(240)
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_edullisesti_riittamaton_kateinen_ei_muuta_kassaa(self):
        self.kassapaate.syo_edullisesti_kateisella(1)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_edullisesti_riittamaton_kateinen_ei_muuta_myytyja(self):
        self.kassapaate.syo_edullisesti_kateisella(1)
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_edullisesti_riittamaton_kateinen_palauttaa_rahat(self):
        self.assertEqual(self.kassapaate.syo_edullisesti_kateisella(1), 1)

    # maukkaasti käteisellä -testit
    def test_maukkaasti_kateisella_kasvattaa_kassaa_oikein(self):
        self.kassapaate.syo_maukkaasti_kateisella(400)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100400)

    def test_maukkaasti_kateisella_antaa_oikean_vaihtorahan(self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(500), 100)

    def test_maukkaasti_kateisella_kasvattaa_myytyja(self):
        self.kassapaate.syo_maukkaasti_kateisella(400)
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_maukkaasti_riittamaton_kateinen_ei_muuta_kassaa(self):
        self.kassapaate.syo_maukkaasti_kateisella(1)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_maukkaasti_riittamaton_kateinen_ei_muuta_myytyja(self):
        self.kassapaate.syo_maukkaasti_kateisella(1)
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_maukkaasti_riittamaton_kateinen_palauttaa_rahat(self):
        self.assertEqual(self.kassapaate.syo_maukkaasti_kateisella(1), 1)

    # edullisesti kortilla -testit
    def test_edullisesti_kortilla_ei_kasvata_kassan_rahaa(self):
        self.kassapaate.syo_edullisesti_kortilla(Maksukortti(1000))
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_edullisesti_veloittaa_korttia_oikein(self):
        mk = Maksukortti(1000)
        self.kassapaate.syo_edullisesti_kortilla(mk)
        self.assertEqual(str(mk), "saldo: 7.6")

    def test_edullisesti_kortilla_palauttaa_rahan_riittaessa_true(self):
        self.assertEqual(
            self.kassapaate.syo_edullisesti_kortilla(Maksukortti(240)), True)

    def test_edullisesti_kortilla_kasvattaa_myytyja(self):
        self.kassapaate.syo_edullisesti_kortilla(Maksukortti(240))
        self.assertEqual(self.kassapaate.edulliset, 1)

    def test_edullisesti_riittamaton_saldo_ei_vahene_kortilta(self):
        mk = Maksukortti(1)
        self.kassapaate.syo_edullisesti_kortilla(mk)
        self.assertEqual(str(mk), "saldo: 0.01")

    def test_edullisesti_riittamaton_saldo_ei_muuta_myytyja(self):
        self.kassapaate.syo_edullisesti_kortilla(Maksukortti(1))
        self.assertEqual(self.kassapaate.edulliset, 0)

    def test_edullisesti_kortilla_palauttaa_riittamattomalle_rahalle_false(
            self):
        self.assertEqual(
            self.kassapaate.syo_edullisesti_kortilla(Maksukortti(1)), False)

    # maukkaasti kortilla -testit
    def test_maukkaasti_kortilla_ei_kasvata_kassan_rahaa(self):
        self.kassapaate.syo_maukkaasti_kortilla(Maksukortti(1000))
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_maukkaasti_veloittaa_korttia_oikein(self):
        mk = Maksukortti(1000)
        self.kassapaate.syo_maukkaasti_kortilla(mk)
        self.assertEqual(str(mk), "saldo: 6.0")

    def test_maukkaasti_kortilla_palauttaa_rahan_riittaessa_true(self):
        self.assertEqual(
            self.kassapaate.syo_maukkaasti_kortilla(Maksukortti(400)), True)

    def test_maukkaasti_kortilla_kasvattaa_myytyja(self):
        self.kassapaate.syo_maukkaasti_kortilla(Maksukortti(400))
        self.assertEqual(self.kassapaate.maukkaat, 1)

    def test_maukkaasti_riittamaton_saldo_ei_vahene_kortilta(self):
        mk = Maksukortti(1)
        self.kassapaate.syo_maukkaasti_kortilla(mk)
        self.assertEqual(str(mk), "saldo: 0.01")

    def test_maukkaasti_riittamaton_saldo_ei_muuta_myytyja(self):
        self.kassapaate.syo_maukkaasti_kortilla(Maksukortti(1))
        self.assertEqual(self.kassapaate.maukkaat, 0)

    def test_maukkaasti_kortilla_palauttaa_riittamattomalle_rahalle_false(
            self):
        self.assertEqual(
            self.kassapaate.syo_maukkaasti_kortilla(Maksukortti(1)), False)

    # kortinlataustestit
    def test_negatiivista_summaa_ei_ladata_kortille(self):
        mk = Maksukortti(500)
        self.kassapaate.lataa_rahaa_kortille(mk, -50)
        self.assertEqual(str(mk), "saldo: 5.0")

    def test_negatiivista_summaa_ei_lisata_kassaan(self):
        self.kassapaate.lataa_rahaa_kortille(Maksukortti(500), -50)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 100000)

    def test_kortille_ladattava_summa_siirtyy_kortin_saldoon(self):
        mk = Maksukortti(500)
        self.kassapaate.lataa_rahaa_kortille(mk, 5000)
        self.assertEqual(str(mk), "saldo: 55.0")

    def test_kortille_ladattava_summa_siirtyy_kassaan(self):
        self.kassapaate.lataa_rahaa_kortille(Maksukortti(500), 5000)
        self.assertEqual(self.kassapaate.kassassa_rahaa, 105000)