Ejemplo n.º 1
0
    def test_ostoksen_paaytyttya_pankin_metodia_tilisiirto_kutsutaan(self):
        pankki_mock = Mock()
        viitegeneraattori_mock = Mock()

        # palautetaan aina arvo 42
        viitegeneraattori_mock.uusi.return_value = 42

        varasto_mock = Mock()

        # tehdään toteutus saldo-metodille
        def varasto_saldo(tuote_id):
            if tuote_id == 1:
                return 10

        # tehdään toteutus hae_tuote-metodille
        def varasto_hae_tuote(tuote_id):
            if tuote_id == 1:
                return Tuote(1, "maito", 5)

        # otetaan toteutukset käyttöön
        varasto_mock.saldo.side_effect = varasto_saldo
        varasto_mock.hae_tuote.side_effect = varasto_hae_tuote

        # alustetaan kauppa
        kauppa = Kauppa(varasto_mock, pankki_mock, viitegeneraattori_mock)

        # tehdään ostokset
        kauppa.aloita_asiointi()
        kauppa.lisaa_koriin(1)
        kauppa.tilimaksu("pekka", "12345")

        # varmistetaan, että metodia tilisiirto on kutsuttu
        pankki_mock.tilisiirto.assert_called()
Ejemplo n.º 2
0
    def test_pankin_metodia_tilisiirto_kutsutaan_kun_lisataan_kaksi_tuotetta(self):
        pankki_mock = Mock()
        viitegeneraattori_mock = Mock()
        viitegeneraattori_mock.uusi.return_value = 42

        varasto_mock = Mock()

         
        def varasto_saldo(tuote_id):
            if tuote_id == 1:
                return 10
            if tuote_id == 2:
                return 20

        
        def varasto_hae_tuote(tuote_id):
            if tuote_id == 1:
                return Tuote(1, "maito", 5)
            if tuote_id == 2:
                return Tuote(2, "lihis", 5)

        varasto_mock.saldo.side_effect = varasto_saldo
        varasto_mock.hae_tuote.side_effect = varasto_hae_tuote

        
        kauppa = Kauppa(varasto_mock, pankki_mock, viitegeneraattori_mock)

        kauppa.aloita_asiointi()
        kauppa.lisaa_koriin(1)
        kauppa.lisaa_koriin(2)
        kauppa.tilimaksu("pekka", "12345")

        pankki_mock.tilisiirto.assert_called_with("pekka",42,"12345", "33333-44455", 10)
Ejemplo n.º 3
0
    def test_negatiivinen_saldo_ei_tee_mitaan(self):

        pankki_mock = Mock()
        viitegeneraattori_mock = Mock()
        viitegeneraattori_mock.uusi.return_value = 42

        varasto_mock = Mock()

         
        def varasto_saldo(tuote_id):
            return -10
            

        
        def varasto_hae_tuote(tuote_id):
            if tuote_id == 1:
                return Tuote(1, "maito", 5)
            

        varasto_mock.saldo.side_effect = varasto_saldo
        varasto_mock.hae_tuote.side_effect = varasto_hae_tuote

        
        kauppa = Kauppa(varasto_mock, pankki_mock, viitegeneraattori_mock)

        kauppa.aloita_asiointi()
        kauppa.lisaa_koriin(1)
        kauppa.tilimaksu("pekka", "12345")

        pankki_mock.tilisiirto.assert_called_with("pekka",42,"12345", "33333-44455", 0)
Ejemplo n.º 4
0
def main():
    #viitegeneraattori = Viitegeneraattori()
    #kirjanpito = Kirjanpito()
    #varasto = Varasto(kirjanpito)
    #pankki = Pankki(kirjanpito)
    #kauppa = Kauppa(varasto, pankki, viitegeneraattori)
    kauppa = Kauppa()

    # kauppa hoitaa yhden asiakkaan kerrallaan seuraavaan tapaan:
    kauppa.aloita_asiointi()
    kauppa.lisaa_koriin(1)
    kauppa.lisaa_koriin(3)
    kauppa.lisaa_koriin(3)
    kauppa.poista_korista(1)
    kauppa.tilimaksu("Pekka Mikkola", "1234-12345")

    # seuraava asiakas
    kauppa.aloita_asiointi()

    for _ in range(0, 24):
        kauppa.lisaa_koriin(5)

    kauppa.tilimaksu("Arto Vihavainen", "3425-1652")

    # kirjanpito
    for tapahtuma in kauppa._pankki._kirjanpito.tapahtumat:
        print(tapahtuma)
Ejemplo n.º 5
0
def main():
    
    kirjanpito = kp.kirjanpito
    kauppa = Kauppa()


    # kauppa hoitaa yhden asiakkaan kerrallaan seuraavaan tapaan:
    kauppa.aloita_asiointi()
    kauppa.lisaa_koriin(1)
    kauppa.lisaa_koriin(3)
    kauppa.lisaa_koriin(3)
    kauppa.poista_korista(1)
    kauppa.tilimaksu("Pekka Mikkola", "1234-12345")

    # seuraava asiakas
    kauppa.aloita_asiointi()

    for _ in range(0, 24):
        kauppa.lisaa_koriin(5)

    kauppa.tilimaksu("Arto Vihavainen", "3425-1652")

    # kirjanpito
    for tapahtuma in kirjanpito.tapahtumat:
        print(tapahtuma)
Ejemplo n.º 6
0
class TestKauppa(unittest.TestCase):
    def setUp(self):
        self.pankki_mock = Mock()
        self.viitegeneraattori_mock = Mock()
        self.varasto_mock = Mock()

        self.viitegeneraattori_mock.uusi.return_value = 42

        def varasto_saldo(tuote_id):
            if tuote_id == 1:
                return 10
            elif tuote_id == 2:
                return 15
            elif tuote_id == 3:
                return 0

        def varasto_hae_tuote(tuote_id):
            if tuote_id == 1:
                return Tuote(1, "maito", 5)
            elif tuote_id == 2:
                return Tuote(2, "Voi", 3)
            elif tuote_id == 3:
                return Tuote(3, "Keksi", 8)

        self.varasto_mock.saldo.side_effect = varasto_saldo
        self.varasto_mock.hae_tuote.side_effect = varasto_hae_tuote

        self.kauppa = Kauppa(
                self.varasto_mock, self.
                pankki_mock, self.
                viitegeneraattori_mock
                )

    def test_ostoksen_paaytyttya_pankin_metodia_tilisiirto_kutsutaan(self):
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.tilimaksu("pekka", "12345")

        self.pankki_mock.tilisiirto.assert_called_with(
                "pekka",
                42,
                "12345",
                self.kauppa._kaupan_tili,
                5
                )

    def test_voi_ostaa_kaksi_eri_tuotetta(self):
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.lisaa_koriin(2)
        self.kauppa.tilimaksu("pekka", "12345")

        self.pankki_mock.tilisiirto.assert_called_with(
                "pekka",
                42,
                "12345",
                self.kauppa._kaupan_tili,
                8
                )

    def test_voi_ostaa_kaksi_samaa_tuotetta(self):
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.lisaa_koriin(1)
        self.kauppa.tilimaksu("pekka", "12345")

        self.pankki_mock.tilisiirto.assert_called_with(
                "pekka",
                42,
                "12345",
                self.kauppa._kaupan_tili,
                10
                )

    def test_ei_voi_ostaa_loppuneita_tuotteita(self):
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.lisaa_koriin(3)
        self.kauppa.tilimaksu("pekka", "12345")

        self.pankki_mock.tilisiirto.assert_called_with(
                "pekka",
                42,
                "12345",
                self.kauppa._kaupan_tili,
                5
                )

    def test_aloita_asiointi_nollaa_edellisen_ostoksen_tiedot(self):
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.tilimaksu("pekka", "12345")

        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(2)
        self.kauppa.tilimaksu("pekka", "12345")

        self.pankki_mock.tilisiirto.assert_called_with(
                "pekka",
                42,
                "12345",
                self.kauppa._kaupan_tili,
                3
                )

    def test_jokainen_maksutapahtuma_pyytaa_uutta_viitenumeroa(self):
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.tilimaksu("pekka", "12345")

        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(2)
        self.kauppa.tilimaksu("pekka", "12345")

        self.assertEqual(self.viitegeneraattori_mock.uusi.call_count, 2)

    def test_korista_poisto_palauttaa_saldoa_varastoon(self):
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.poista_korista(1)

        self.varasto_mock.palauta_varastoon.assert_called_with(self.varasto_mock.hae_tuote(1))
Ejemplo n.º 7
0
class TestKauppa(unittest.TestCase):
    def setUp(self):
        self.pankki_mock = Mock()
        self.viitegeneraattori_mock = Mock()

        # palautetaan aina arvo 42
        self.viitegeneraattori_mock.uusi.return_value = 42

        varasto_mock = Mock()

        # tehdään toteutus saldo-metodille
        def varasto_saldo(tuote_id):
            if tuote_id == 1:
                return 10
            if tuote_id == 2:
                return 5
            if tuote_id == 3:
                return 0

        # tehdään toteutus hae_tuote-metodille
        def varasto_hae_tuote(tuote_id):
            if tuote_id == 1:
                return Tuote(1, "maito", 5)
            if tuote_id == 2:
                return Tuote(2, "piima", 10)
            if tuote_id == 3:
                return Tuote(3, "olut", 100)

        # otetaan toteutukset käyttöön
        varasto_mock.saldo.side_effect = varasto_saldo
        varasto_mock.hae_tuote.side_effect = varasto_hae_tuote

        # alustetaan kauppa
        self.kauppa = Kauppa(varasto_mock, self.pankki_mock,
                             self.viitegeneraattori_mock)

    def test_ostoksen_paaytyttya_pankin_metodia_tilisiirto_kutsutaan(self):
        # tehdään ostokset
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.tilimaksu("pekka", "12345")

        # varmistetaan, että metodia tilisiirto on kutsuttu
        self.pankki_mock.tilisiirto.assert_called()
        # toistaiseksi ei välitetä kutsuun liittyvistä argumenteista

    def test_ostoksen_paaytyttya_pankin_metodia_tilisiirto_kutsutaan_oikeilla_argumenteilla(
            self):
        # tehdään ostokset
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.tilimaksu("pekka", "12345")

        # varmistetaan, että metodia tilisiirto on kutsuttu
        self.pankki_mock.tilisiirto.assert_called_with("pekka", 42, "12345",
                                                       "33333-44455", 5)

    def test_ostetaan_kaksi_eri_tuotetta(self):
        # tehdään ostokset
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.lisaa_koriin(2)
        self.kauppa.tilimaksu("pekka", "12345")

        # varmistetaan, että metodia tilisiirto on kutsuttu
        self.pankki_mock.tilisiirto.assert_called_with("pekka", 42, "12345",
                                                       "33333-44455", 15)

    def test_ostetaan_kaksi_samaa_tuotetta(self):
        # tehdään ostokset
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.lisaa_koriin(1)
        self.kauppa.tilimaksu("pekka", "12345")

        # varmistetaan, että metodia tilisiirto on kutsuttu
        self.pankki_mock.tilisiirto.assert_called_with("pekka", 42, "12345",
                                                       "33333-44455", 10)

    def test_ostetaan_tuote_joka_on_loppu(self):
        # tehdään ostokset
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.lisaa_koriin(3)
        self.kauppa.tilimaksu("pekka", "12345")

        # varmistetaan, että metodia tilisiirto on kutsuttu
        self.pankki_mock.tilisiirto.assert_called_with("pekka", 42, "12345",
                                                       "33333-44455", 5)

    def test_aloita_asiointi_nollaa(self):
        # tehdään ostokset
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)

        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.tilimaksu("pekka", "12345")

        # varmistetaan, että metodia tilisiirto on kutsuttu
        self.pankki_mock.tilisiirto.assert_called_with("pekka", 42, "12345",
                                                       "33333-44455", 5)

    def test_uusi_viitenumero(self):
        # tehdään ostokset
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)

        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.tilimaksu("pekka", "12345")

        # varmistetaan, että metodia tilisiirto on kutsuttu
        self.pankki_mock.tilisiirto.assert_called_with("pekka", 42, "12345",
                                                       "33333-44455", 5)

        # tehdään ostokset
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)

        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.tilimaksu("pekka", "12345")

        # varmistetaan, että metodia tilisiirto on kutsuttu
        self.pankki_mock.tilisiirto.assert_called_with("pekka", 42, "12345",
                                                       "33333-44455", 5)

        self.assertEqual(self.viitegeneraattori_mock.uusi.call_count, 2)

    def test_poistetaan_korista(self):
        # tehdään ostokset
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.lisaa_koriin(1)
        self.kauppa.poista_korista(1)
        self.kauppa.lisaa_koriin(2)
        self.kauppa.tilimaksu("pekka", "12345")

        # varmistetaan, että metodia tilisiirto on kutsuttu
        self.pankki_mock.tilisiirto.assert_called_with("pekka", 42, "12345",
                                                       "33333-44455", 10)
Ejemplo n.º 8
0
class TestKauppa(unittest.TestCase):
    def setUp(self):
        self.pankki_mock = Mock()
        self.viitegeneraattori_mock = Mock(wraps=Viitegeneraattori())

        self.varasto_mock = Mock()

        # tehdään toteutus saldo-metodille
        def varasto_saldo(tuote_id):
            if tuote_id == 1:
                return 10
            if tuote_id == 2:
                return 24
            if tuote_id == 3:
                return 0

        # tehdään toteutus hae_tuote-metodille
        def varasto_hae_tuote(tuote_id):
            if tuote_id == 1:
                return Tuote(1, "maito", 5)
            if tuote_id == 2:
                return Tuote(2, "kalja", 10)
            if tuote_id == 3:
                return Tuote(3, "leipä", 3)

        # otetaan toteutukset käyttöön
        self.varasto_mock.saldo.side_effect = varasto_saldo
        self.varasto_mock.hae_tuote.side_effect = varasto_hae_tuote

        self.kauppa = Kauppa(self.varasto_mock, self.pankki_mock,
                             self.viitegeneraattori_mock)

    def test_ostoksen_paaytyttya_pankin_metodia_tilisiirto_kutsutaan(self):

        # tehdään ostokset
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.tilimaksu("pekka", "12345")

        # varmistetaan, että metodia tilisiirto on kutsuttu
        self.pankki_mock.tilisiirto.assert_called()
        # toistaiseksi ei välitetä kutsuun liittyvistä argumenteista

    def test_ostoksen_paaytyttya_pankin_metodia_tilisiirto_kutsutaan_parametreilla(
            self):

        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.tilimaksu("meri", "12")

        self.pankki_mock.tilisiirto.assert_called_with("meri", 2, "12", ANY, 5)

    def test_kahden_eri_tuotteen_ostaminen_onnistuu(self):

        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.lisaa_koriin(2)
        self.kauppa.tilimaksu("meri", "134")

        self.assertEqual(self.viitegeneraattori_mock.uusi.call_count, 1)
        self.pankki_mock.tilisiirto.assert_called_with("meri", 2, "134", ANY,
                                                       15)

    def test_kahden_saman_tuotteen_ostaminen_onnistuu(self):

        self.kauppa = Kauppa(self.varasto_mock, self.pankki_mock,
                             self.viitegeneraattori_mock)

        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(2)
        self.kauppa.lisaa_koriin(2)
        self.kauppa.tilimaksu("jokumuu", "54321")

        self.pankki_mock.tilisiirto.assert_called_with("jokumuu", ANY, "54321",
                                                       ANY, 20)

    def test_loppunutta_tuotetta_ei_veloiteta(self):

        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(2)
        self.kauppa.lisaa_koriin(3)
        self.kauppa.tilimaksu("jokumuu", "54321")

        self.pankki_mock.tilisiirto.assert_called_with("jokumuu", ANY, "54321",
                                                       ANY, 10)

    def test_korista_voi_poistaa_tuotteen_ja_varaston_saldo_kasvaa(self):

        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)

        self.varasto_mock.ota_varastosta.assert_called()

        self.kauppa.poista_korista(1)
        self.varasto_mock.palauta_varastoon.assert_called()
Ejemplo n.º 9
0
class TestKauppa(unittest.TestCase):

    def setUp(self):
      self.pankki_mock = Mock()
      self.viitegeneraattori_mock = Mock()

      # palautetaan aina arvo 42
      self.viitegeneraattori_mock.uusi.return_value = 42

      self.varasto_mock = Mock()

      # tehdään toteutus saldo-metodille
      def varasto_saldo(tuote_id):
        if tuote_id == 1:
          return 10
        if tuote_id== 2:
          return 5
        if tuote_id==3:
          return 0

      # tehdään toteutus hae_tuote-metodille
      def varasto_hae_tuote(tuote_id):
        if tuote_id == 1:
          return Tuote(1, "maito", 5)
        if tuote_id==2:
          return Tuote(2,"leipä", 3)
        if tuote_id==3:
          return Tuote(3, "juusto", 4)

      # otetaan toteutukset käyttöön
      self.varasto_mock.saldo.side_effect = varasto_saldo
      self.varasto_mock.hae_tuote.side_effect = varasto_hae_tuote

      # alustetaan kauppa
      self.kauppa = Kauppa(self.varasto_mock, self.pankki_mock, self.viitegeneraattori_mock)

    def test_ostoksen_paaytyttya_pankin_metodia_tilisiirto_kutsutaan(self):
      # tehdään ostokset
      self.kauppa.aloita_asiointi()
      self.kauppa.lisaa_koriin(1)
      self.kauppa.tilimaksu("pekka", "12345")

      # varmistetaan, että metodia tilisiirto on kutsuttu
      self.pankki_mock.tilisiirto.assert_called()
      # toistaiseksi ei välitetä kutsuun liittyvistä argumenteista

    def test_kun_tuote_lisatty_kutsutaan_pankin_metodia_tilisiirto_oikeilla_tiedoilla(self):
      self.kauppa.aloita_asiointi()
      self.kauppa.lisaa_koriin(1)
      self.kauppa.tilimaksu("joni","23456")
      
      self.pankki_mock.tilisiirto.assert_called_with("joni", ANY, "23456", ANY, 5)

    def test_ostosten_jalkeen_pankin_metodia_tilisiirto_kutsutaan_oikeilla_tiedoilla(self):
      self.kauppa.aloita_asiointi()
      self.kauppa.lisaa_koriin(1)
      self.kauppa.lisaa_koriin(2)
      self.kauppa.tilimaksu("joni","34567")

      self.pankki_mock.tilisiirto.assert_called_with("joni", ANY,"34567", ANY, 8)

    def test_kun_tuote_loppu_tilisiirron_kutsun_summaan_ei_lisatty_loppuneen_tuotteen_hintaa(self):
      self.kauppa.aloita_asiointi()
      self.kauppa.lisaa_koriin(1)
      self.kauppa.lisaa_koriin(3)
      self.kauppa.tilimaksu("joni", "34567")

      self.pankki_mock.tilisiirto.assert_called_with("joni", ANY, "34567", ANY, 5)

    def test_aloita_asiointi_metodin_kutsu_nollaa_ostosten_tiedot(self):
      self.kauppa.aloita_asiointi()
      self.kauppa.lisaa_koriin(1)
      #aloitetaan asiointi uudestaan ja tarkistetaan kutsutaanko tilisiirtoa uuden asioinnin summalla
      self.kauppa.aloita_asiointi()
      self.kauppa.lisaa_koriin(2)
      self.kauppa.tilimaksu("joni","23456")
      self.pankki_mock.tilisiirto.assert_called_with("joni",ANY,"23456",ANY,3)

    def test_kauppa_pyytaa_uuden_viitenumeron_joka_maksutapahtumalle(self):
      self.kauppa.aloita_asiointi()
      self.kauppa.lisaa_koriin(1)
      self.kauppa.tilimaksu("joni","23456")

      self.assertEqual(self.viitegeneraattori_mock.uusi.call_count,1)

      self.kauppa.aloita_asiointi()
      self.kauppa.lisaa_koriin(2)
      self.kauppa.tilimaksu("joni","23456")
      self.assertEqual(self.viitegeneraattori_mock.uusi.call_count,2)

    def test_ostoskorista_poistettu_tuote_palautuu_varaston_saldoon(self):
      self.kauppa.aloita_asiointi()
      self.kauppa.lisaa_koriin(1)
      self.kauppa.poista_korista(1)

      self.assertEqual(self.varasto_mock.palauta_varastoon.call_count,1)
Ejemplo n.º 10
0
class TestKauppa(unittest.TestCase):
    def setUp(self):
        self.pankki_mock = Mock()
        self.varasto_mock = Mock()
        self.viitegeneraattori_mock = Mock()
        self.kauppa = Kauppa(self.varasto_mock, self.pankki_mock,
                             self.viitegeneraattori_mock)
        self.viitegeneraattori_mock.uusi.side_effect = [42, 43, 44]

        tuotteet = {
            1: (Tuote(1, "maito", 5), 10),
            2: (Tuote(2, "liha", 10), 20),
            3: (Tuote(3, "tofu", 10), 0)
        }

        def varasto_saldo(tuote_id):
            return tuotteet[tuote_id][1]

        def varasto_hae_tuote(tuote_id):
            return tuotteet[tuote_id][0]

        self.varasto_mock.saldo.side_effect = varasto_saldo
        self.varasto_mock.hae_tuote.side_effect = varasto_hae_tuote

        self.kauppa = Kauppa(self.varasto_mock, self.pankki_mock,
                             self.viitegeneraattori_mock)

    def test_ostoksen_paaytyttya_pankin_metodia_tilisiirto_kutsutaan(self):
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.tilimaksu("pekka", "12345")

        self.pankki_mock.tilisiirto.assert_called()

    def test_pankin_metodia_tilisiirto_kutsutaan_oikeilla_parametreilla(self):
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.tilimaksu("pekka", "12345")

        self.pankki_mock.tilisiirto.assert_called_with("pekka", 42, "12345",
                                                       "33333-44455", 5)

    def test_pankin_metodia_tilisiirto_kutsutaan_oikeilla_parametreilla_kun_kaksi_eri_tuotetta(
            self):
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.lisaa_koriin(2)
        self.kauppa.tilimaksu("pekka", "12345")

        self.pankki_mock.tilisiirto.assert_called_with("pekka", 42, "12345",
                                                       "33333-44455", 15)

    def test_pankin_metodia_tilisiirto_kutsutaan_oikeilla_parametreilla_kun_kaksi_samaa_tuotetta(
            self):
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.lisaa_koriin(1)
        self.kauppa.tilimaksu("pekka", "12345")

        self.pankki_mock.tilisiirto.assert_called_with("pekka", 42, "12345",
                                                       "33333-44455", 10)

    def test_pankin_metodia_tilisiirto_kutsutaan_oikeilla_parametreilla_kun_toinen_tuote_loppu(
            self):
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.lisaa_koriin(3)
        self.kauppa.tilimaksu("pekka", "12345")

        self.pankki_mock.tilisiirto.assert_called_with("pekka", 42, "12345",
                                                       "33333-44455", 5)

    def test_asioinnin_aloittaminen_nollaa_edellisen_tilan(self):
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.tilimaksu("pekka", "12345")

        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.tilimaksu("tuomo", "6789")

        self.pankki_mock.tilisiirto.assert_called_with("tuomo", 43, "6789",
                                                       "33333-44455", 5)

    def test_pyydetaan_uusi_viite_jokaiseen_maksuun(self):
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.tilimaksu("pekka", "12345")

        self.assertEqual(self.viitegeneraattori_mock.uusi.call_count, 1)

        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.tilimaksu("pekka", "12345")

        self.assertEqual(self.viitegeneraattori_mock.uusi.call_count, 2)

    def test_tuote_voidaan_poistaa_korista(self):
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.lisaa_koriin(2)
        self.kauppa.poista_korista(2)
        self.kauppa.tilimaksu("pekka", "12345")

        self.assertEqual(self.varasto_mock.saldo(2), 20)
        self.pankki_mock.tilisiirto.assert_called_with("pekka", 42, "12345",
                                                       "33333-44455", 5)
Ejemplo n.º 11
0
class TestKauppa(unittest.TestCase):
    def setUp(self):

        self.pankki_mock = Mock()
        self.viitegeneraattori_mock = Mock()

        # palautetaan aina arvo 42
        self.viitegeneraattori_mock.uusi.return_value = 42

        self.varasto_mock = Mock()

        # tehdään toteutus saldo-metodille
        def varasto_saldo(tuote_id):
            if tuote_id == 1:
                return 10
            if tuote_id == 2:
                return 10

        # tehdään toteutus hae_tuote-metodille
        def varasto_hae_tuote(tuote_id):
            if tuote_id == 1:
                return Tuote(1, "maito", 5)
            if tuote_id == 2:
                return Tuote(2, "piimä", 6)

        # otetaan toteutukset käyttöön
        self.varasto_mock.saldo.side_effect = varasto_saldo
        self.varasto_mock.hae_tuote.side_effect = varasto_hae_tuote

        # alustetaan kauppa
        self.kauppa = Kauppa(self.varasto_mock, self.pankki_mock,
                             self.viitegeneraattori_mock)

    def test_ostoksen_paaytyttya_pankin_metodia_tilisiirto_kutsutaan(self):

        # tehdään ostokset
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.tilimaksu("pekka", "12345")

        # varmistetaan, että metodia tilisiirto on kutsuttu
        self.pankki_mock.tilisiirto.assert_called()
        # toistaiseksi ei välitetä kutsuun liittyvistä argumenteista

    def test_ostoksen_paatyttya_pankin_metodia_tilisiirto_kutsutaan_oikealla_asiakkaalla_tilinumerolla_ja_summalla(
            self):

        # tehdään ostokset
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.tilimaksu("pekka", "12345")

        # varmistetaan, että metodia tilisiirto on kutsuttu
        self.pankki_mock.tilisiirto.assert_called_with("pekka", ANY, "12345",
                                                       ANY, 5)
        # varmistetaan, että argumentit, nimi, tilinumero ja summa ovat oikein

    def test_2_tuotteen_ostoksen_paatyttya_pankin_metodia_tilisiirto_kutsutaan_oikealla_asiakkaalla_tilinumerolla_ja_summalla(
            self):

        # tehdään ostokset
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.lisaa_koriin(2)
        self.kauppa.tilimaksu("pekka", "12345")

        # varmistetaan, että metodia tilisiirto on kutsuttu
        self.pankki_mock.tilisiirto.assert_called_with("pekka", ANY, "12345",
                                                       ANY, 11)
        # varmistetaan, että argumentit, nimi, tilinumero ja summa ovat oikein

    def test_2_saman_tuotteen_ostoksen_paatyttya_pankin_metodia_tilisiirto_kutsutaan_oikealla_asiakkaalla_tilinumerolla_ja_summalla(
            self):

        # tehdään ostokset
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.lisaa_koriin(1)
        self.kauppa.tilimaksu("pekka", "12345")

        # varmistetaan, että metodia tilisiirto on kutsuttu
        self.pankki_mock.tilisiirto.assert_called_with("pekka", ANY, "12345",
                                                       ANY, 10)
        # varmistetaan, että argumentit, nimi, tilinumero ja summa ovat oikein

    def test_tuote_1_ok_ja_tuote_2_loppu(self):

        # tehdään toteutus saldo-metodille
        def varasto_saldo(tuote_id):
            if tuote_id == 1:
                return 10
            if tuote_id == 2:
                return 0

        # otetaan toteutukset käyttöön
        self.varasto_mock.saldo.side_effect = varasto_saldo

        # tehdään ostokset
        self.kauppa.aloita_asiointi()
        self.kauppa.lisaa_koriin(1)
        self.kauppa.lisaa_koriin(2)
        self.kauppa.tilimaksu("pekka", "12345")

        # varmistetaan, että metodia tilisiirto on kutsuttu
        self.pankki_mock.tilisiirto.assert_called_with("pekka", ANY, "12345",
                                                       ANY, 5)