public async Task VecPostoji_DodajeStavke()
        {
            var cmd         = new ProknjiziIzvodCommand(Guid.NewGuid(), null, "1", new DateTime(2018, 10, 20), new List <StavkaIzvodaDTO>());
            var nalogIzBaze = FinNalogHelper.NalogFromDb(callBase: false);

            nalogIzBaze.SetupGet(x => x.Version).Returns(17);
            var fakeNalogRepo = new Mock <IFinNalogRepository>();

            fakeNalogRepo.Setup(x => x.GetPostojeciAsync(TipNaloga.Izvodi, cmd.Datum)).ReturnsAsync(nalogIzBaze.Object.Id);
            fakeNalogRepo.Setup(x => x.GetAsync(nalogIzBaze.Object.Id)).ReturnsAsync(nalogIzBaze.Object);
            var fakeLogger   = new Mock <ILogger <ProknjiziIzvodCommandHandler> >();
            var fakeIzvodSvc = new Mock <IIzvodService>();

            fakeIzvodSvc.Setup(x => x.FormirajStavkeNalogaAsync(It.IsAny <IEnumerable <StavkaIzvoda> >())).ReturnsAsync(new List <FinStavka>
            {
                new FinStavka(1, 100, 0, "opis stavke 1"),
                new FinStavka(2, 200, 0, "opis stavke 2")
            });
            var handler = new ProknjiziIzvodCommandHandler(fakeNalogRepo.Object, fakeIzvodSvc.Object, fakeLogger.Object);

            await handler.Handle(cmd, default);

            nalogIzBaze.Verify(x => x.ProknjiziStavku(It.IsNotNull <FinStavka>()), Times.Exactly(2));
            nalogIzBaze.Verify(x => x.ProknjiziStavku(It.Is <FinStavka>(s =>
                                                                        s.IdKonto == 1 && s.Iznos.Duguje == 100 && s.Iznos.Potrazuje == 0 && s.Opis == "opis stavke 1")));
            nalogIzBaze.Verify(x => x.ProknjiziStavku(It.Is <FinStavka>(s =>
                                                                        s.IdKonto == 2 && s.Iznos.Duguje == 200 && s.Iznos.Potrazuje == 0 && s.Opis == "opis stavke 2")));
            fakeNalogRepo.Verify(x => x.SaveAsync(nalogIzBaze.Object, cmd.CommandId, nalogIzBaze.Object.Version, cmd.UserId));
        }
        public async Task StornirajStavku_Korektno()
        {
            var nalogIzBaze = FinNalogHelper.NalogFromDb(callBase: false);

            nalogIzBaze.SetupGet(x => x.Stavke).Returns(new List <FinStavka>
            {
                new FinStavka(Guid.NewGuid(), 1, 100, 0, "opis stavke 1", new DateTime(2018, 10, 30)),
                new FinStavka(Guid.NewGuid(), 2, 200, 0, "opis stavke 2", new DateTime(2018, 10, 30))
            });
            var cmd = new IzmeniNalogCommand(Guid.NewGuid(), 0, "1", nalogIzBaze.Object.Id.Id, TipNaloga.UlazneFakture.Id,
                                             new DateTime(2018, 10, 21), "opis new", new List <StavkaDTO>
            {
                new StavkaDTO(nalogIzBaze.Object.Stavke.ElementAt(0).Id, 1, 100, 0, "opis stavke 1", true),
                new StavkaDTO(nalogIzBaze.Object.Stavke.ElementAt(1).Id, 2, 200, 0, "opis stavke 2", false),
                new StavkaDTO(Guid.NewGuid(), 3, 300, 0, "opis stavke 3", true)
            });
            var fakeNalogRepo = new Mock <IFinNalogRepository>();

            fakeNalogRepo.Setup(x => x.GetAsync(nalogIzBaze.Object.Id)).ReturnsAsync(nalogIzBaze.Object);
            var fakeNalogSvc = new Mock <IFinNalogService>();
            var fakeLogger   = new Mock <ILogger <IzmeniNalogCommandHandler> >();
            var handler      = new IzmeniNalogCommandHandler(fakeNalogRepo.Object, fakeNalogSvc.Object, fakeLogger.Object);

            await handler.Handle(cmd, default);

            nalogIzBaze.Verify(x => x.StornirajStavku(It.IsNotNull <FinStavka>()), Times.Once);
            nalogIzBaze.Verify(x => x.StornirajStavku(It.Is <FinStavka>(s => s.Id == nalogIzBaze.Object.Stavke.ElementAt(0).Id)));
            fakeNalogRepo.Verify(x => x.SaveAsync(nalogIzBaze.Object, cmd.CommandId, cmd.Version, cmd.UserId));
        }
        public void StornirajStavku_DodajeEvent()
        {
            var nalog = FinNalogHelper.NalogFromDb(callBase: true);

            nalog.Protected().SetupGet <List <FinStavka> >("_stavke").Returns(new List <FinStavka>
            {
                new FinStavka(Guid.NewGuid(), 1, 100, 0, "opis stavke 1", new DateTime(2018, 10, 30)),
                new FinStavka(Guid.NewGuid(), 2, 200, 0, "opis stavke 2", new DateTime(2018, 10, 30))
            });
            var stavka = nalog.Object.Stavke.First();

            nalog.Object.StornirajStavku(stavka);

            Assert.Equal(1, nalog.Object.UncommittedEvents.Count);
            Assert.Collection(nalog.Object.UncommittedEvents.OfType <StavkaProknjizena>(), e =>
            {
                Assert.Equal(nalog.Object.Id, e.IdNaloga);
                Assert.NotEqual(Guid.Empty, e.IdNaloga.Id);
                Assert.NotEqual(stavka.Id, e.IdStavke);
                Assert.NotEqual(Guid.Empty, e.IdStavke);
                Assert.Equal(-stavka.Iznos.Duguje, e.Duguje);
                Assert.Equal(-stavka.Iznos.Potrazuje, e.Potrazuje);
                Assert.Null(e.Opis);
            });
        }
        public void ProknjiziStavku_StavkaNull_Greska()
        {
            var nalog = FinNalogHelper.NalogFromDb(callBase: true);

            Action proknjizi = () => nalog.Object.ProknjiziStavku(null);

            Assert.Throws <ArgumentNullException>(proknjizi);
        }
        public void IzmeniZaglavlje_TipNull_Greska()
        {
            var nalog = FinNalogHelper.NalogFromDb(callBase: true);

            Action izmeni = () => nalog.Object.IzmeniZaglavlje(null, new DateTime(1987, 5, 2), "promenjen opis");

            Assert.Throws <ArgumentNullException>(izmeni);
        }
        public void StornirajStavku_StavkaNull_Greska()
        {
            var nalog = FinNalogHelper.NalogFromDb(callBase: true);

            Action storniraj = () => nalog.Object.StornirajStavku(null);

            Assert.Throws <ArgumentNullException>(storniraj);
        }
        public void UkloniStavku_StavkaNull_Greska()
        {
            var nalog = FinNalogHelper.NalogFromDb(callBase: true);

            Action ukloni = () => nalog.Object.UkloniStavku(null);

            Assert.Throws <ArgumentNullException>(ukloni);
        }
        public void Otkljucaj_VecOtkljucan()
        {
            var nalog = FinNalogHelper.NalogFromDb(callBase: true);

            nalog.SetupGet(x => x.Zakljucan).Returns(false);

            nalog.Object.Otkljucaj();

            Assert.Empty(nalog.Object.UncommittedEvents);
        }
        public void ProknjiziStavku_NalogZakljucan_Greska()
        {
            var nalog = FinNalogHelper.NalogFromDb(callBase: true);

            nalog.SetupGet(x => x.Zakljucan).Returns(true);

            Action proknjizi = () => nalog.Object.ProknjiziStavku(new FinStavka(3, 400, 0, "opis"));

            Assert.Throws <KnjizenjeException>(proknjizi);
        }
        public void IzmeniZaglavlje_NalogZakljucan_Greska()
        {
            var nalog = FinNalogHelper.NalogFromDb(callBase: true);

            nalog.SetupGet(x => x.Zakljucan).Returns(true);

            Action izmeni = () => nalog.Object.IzmeniZaglavlje(TipNaloga.Izvodi, new DateTime(1987, 5, 2), "promenjen opis");

            Assert.Throws <KnjizenjeException>(izmeni);
        }
        public void Obrisi_VecObrisan()
        {
            var nalog = FinNalogHelper.NalogFromDb(callBase: true);

            nalog.SetupGet(x => x.Obrisan).Returns(true);

            nalog.Object.Obrisi();

            Assert.Empty(nalog.Object.UncommittedEvents);
        }
        public void Primeni_NalogObrisan()
        {
            var nalog = FinNalogHelper.NalogFromDb(callBase: true);

            nalog.SetupProperty(x => x.Obrisan, false);

            nalog.Object.Primeni(new NalogObrisan(nalog.Object.Id));

            Assert.True(nalog.Object.Obrisan);
        }
        public void Primeni_NalogOtkljucan()
        {
            var nalog = FinNalogHelper.NalogFromDb(callBase: true);

            nalog.SetupProperty(x => x.Zakljucan, true);

            nalog.Object.Primeni(new NalogOtkljucan(nalog.Object.Id));

            Assert.False(nalog.Object.Zakljucan);
        }
        public void ProknjiziStavku_IdStavkeDefault_Greska()
        {
            var nalog  = FinNalogHelper.NalogFromDb(callBase: true);
            var stavka = new Mock <FinStavka>();

            stavka.SetupGet(x => x.Id).Returns(default(Guid));

            Action proknjizi = () => nalog.Object.ProknjiziStavku(stavka.Object);

            Assert.Throws <KnjizenjeException>(proknjizi);
        }
        public void Obrisi_NalogZakljucan_Greska()
        {
            var nalog = FinNalogHelper.NalogFromDb(callBase: true);

            nalog.SetupGet(x => x.Obrisan).Returns(false);
            nalog.SetupGet(x => x.Zakljucan).Returns(true);

            Action obrisi = () => nalog.Object.Obrisi();

            Assert.Throws <KnjizenjeException>(obrisi);
        }
        public void IzmeniZaglavlje_NistaPromenjeno()
        {
            var nalog = FinNalogHelper.NalogFromDb(callBase: true);

            nalog.SetupGet(x => x.Tip).Returns(TipNaloga.Izvodi);
            nalog.SetupGet(x => x.DatumNaloga).Returns(new DateTime(1987, 5, 2));
            nalog.SetupGet(x => x.Opis).Returns("promenjen opis");

            nalog.Object.IzmeniZaglavlje(TipNaloga.Izvodi, new DateTime(1987, 5, 2), "promenjen opis");

            Assert.Empty(nalog.Object.UncommittedEvents);
        }
        public async Task NePostoji_KorektnoMenja()
        {
            var nalogIzBaze   = FinNalogHelper.NalogFromDb(callBase: false);
            var fakeNalogRepo = new Mock <IFinNalogRepository>();

            fakeNalogRepo.Setup(x => x.GetPostojeciAsync(TipNaloga.Izvodi, new DateTime(2018, 10, 20))).ReturnsAsync(null as FinNalogId);
            var nalogSvc = new FinNalogService(fakeNalogRepo.Object);

            await nalogSvc.IzmeniZaglavljeAsync(nalogIzBaze.Object, TipNaloga.Izvodi, new DateTime(2018, 10, 20), "opis new");

            nalogIzBaze.Verify(x => x.IzmeniZaglavlje(TipNaloga.Izvodi, new DateTime(2018, 10, 20), "opis new"));
        }
        public void UkloniStavku_NalogImaJednuStavku_Greska()
        {
            var nalog = FinNalogHelper.NalogFromDb(callBase: true);

            nalog.Protected().SetupGet <List <FinStavka> >("_stavke").Returns(new List <FinStavka>
            {
                new FinStavka(Guid.NewGuid(), 1, 100, 0, "opis stavke 1", new DateTime(2018, 10, 30))
            });
            var stavka = nalog.Object.Stavke.First();

            Action ukloni = () => nalog.Object.UkloniStavku(stavka);

            Assert.Throws <KnjizenjeException>(ukloni);
        }
        public void Obrisi_DodajeEvent()
        {
            var nalog = FinNalogHelper.NalogFromDb(callBase: true);

            nalog.SetupGet(x => x.Obrisan).Returns(false);

            nalog.Object.Obrisi();

            Assert.Equal(1, nalog.Object.UncommittedEvents.Count);
            Assert.Collection(nalog.Object.UncommittedEvents.OfType <NalogObrisan>(), e =>
            {
                Assert.Equal(nalog.Object.Id, e.IdNaloga);
            });
        }
        public void StornirajStavku_StavkaNePripadaNalogu_Greska()
        {
            var nalog = FinNalogHelper.NalogFromDb(callBase: true);

            nalog.Protected().SetupGet <List <FinStavka> >("_stavke").Returns(new List <FinStavka>
            {
                new FinStavka(Guid.NewGuid(), 1, 100, 0, "opis stavke 1", new DateTime(2018, 10, 30)),
                new FinStavka(Guid.NewGuid(), 2, 200, 0, "opis stavke 2", new DateTime(2018, 10, 30))
            });
            var stavka = new FinStavka(Guid.NewGuid(), 3, 300, 0, "opis stavke 3", new DateTime(2018, 10, 30));

            Action storniraj = () => nalog.Object.StornirajStavku(stavka);

            Assert.Throws <KnjizenjeException>(storniraj);
        }
        public async Task Zakljucaj_Korektno()
        {
            var nalogIzBaze   = FinNalogHelper.NalogFromDb(callBase: false);
            var cmd           = new ZakljucajNalogCommand(Guid.NewGuid(), 0, "1", nalogIzBaze.Object.Id.Id);
            var fakeNalogRepo = new Mock <IFinNalogRepository>();

            fakeNalogRepo.Setup(x => x.GetAsync(nalogIzBaze.Object.Id)).ReturnsAsync(nalogIzBaze.Object);
            var fakeLogger = new Mock <ILogger <ZakljucajNalogCommandHandler> >();
            var handler    = new ZakljucajNalogCommandHandler(fakeNalogRepo.Object, fakeLogger.Object);

            await handler.Handle(cmd, default);

            nalogIzBaze.Verify(x => x.Zakljucaj());
            fakeNalogRepo.Verify(x => x.SaveAsync(nalogIzBaze.Object, cmd.CommandId, cmd.Version, cmd.UserId));
        }
        public async Task Proknjizi_Korektno()
        {
            var nalogIzBaze   = FinNalogHelper.NalogFromDb(callBase: false);
            var cmd           = new ProknjiziStavkuCommand(Guid.NewGuid(), 0, "1", nalogIzBaze.Object.Id.Id, 1, 100, 0, "opis stavke 1");
            var fakeNalogRepo = new Mock <IFinNalogRepository>();

            fakeNalogRepo.Setup(x => x.GetAsync(nalogIzBaze.Object.Id)).ReturnsAsync(nalogIzBaze.Object);
            var fakeLogger = new Mock <ILogger <ProknjiziStavkuCommandHandler> >();
            var handler    = new ProknjiziStavkuCommandHandler(fakeNalogRepo.Object, fakeLogger.Object);

            await handler.Handle(cmd, default);

            nalogIzBaze.Verify(x => x.ProknjiziStavku(It.Is <FinStavka>(s =>
                                                                        s.IdKonto == 1 && s.Iznos.Duguje == 100 && s.Iznos.Potrazuje == 0 && s.Opis == "opis stavke 1")));
            fakeNalogRepo.Verify(x => x.SaveAsync(nalogIzBaze.Object, cmd.CommandId, cmd.Version, cmd.UserId));
        }
        public void Primeni_StavkaUklonjena()
        {
            var nalog = FinNalogHelper.NalogFromDb(callBase: true);

            nalog.Protected().SetupGet <List <FinStavka> >("_stavke").Returns(new List <FinStavka>
            {
                new FinStavka(Guid.NewGuid(), 1, 100, 0, "opis stavke 1", new DateTime(2018, 10, 30)),
                new FinStavka(Guid.NewGuid(), 2, 200, 0, "opis stavke 2", new DateTime(2018, 10, 30))
            });
            var stavka = nalog.Object.Stavke.First();
            var evnt   = new StavkaUklonjena(nalog.Object.Id, stavka.Id, stavka.DatumKnjizenja,
                                             stavka.IdKonto, stavka.Iznos.Duguje, stavka.Iznos.Potrazuje, stavka.Opis);

            nalog.Object.Primeni(evnt);

            Assert.Equal(1, nalog.Object.Stavke.Count);
            Assert.DoesNotContain(nalog.Object.Stavke, s => s.Id == evnt.IdStavke);
        }
        public async Task VecPostoji_Greska()
        {
            var nalogIzBaze         = FinNalogHelper.NalogFromDb(callBase: false);
            var fakeNalogRepo       = new Mock <IFinNalogRepository>();
            var nalogIzBazeIdRandom = new Mock <FinNalogId>
            {
                CallBase = true
            };

            nalogIzBazeIdRandom.SetupGet(x => x.Id).Returns(Guid.NewGuid());
            fakeNalogRepo.Setup(x => x.GetPostojeciAsync(TipNaloga.UlazneFakture, new DateTime(2018, 10, 21))).ReturnsAsync(nalogIzBazeIdRandom.Object);

            var nalogSvc = new FinNalogService(fakeNalogRepo.Object);

            Func <Task> izmeni = async() => await nalogSvc.IzmeniZaglavljeAsync(nalogIzBaze.Object, TipNaloga.UlazneFakture, new DateTime(2018, 10, 21), "opis");

            await Assert.ThrowsAsync <KnjizenjeException>(izmeni);
        }
Exemple #25
0
        public async Task IzmeniZaglavlje_Korektno()
        {
            var nalogIzBaze = FinNalogHelper.NalogFromDb(callBase: false);

            nalogIzBaze.SetupGet(x => x.Tip).Returns(TipNaloga.Izvodi);
            nalogIzBaze.SetupGet(x => x.DatumNaloga).Returns(new DateTime(2018, 10, 20));
            nalogIzBaze.SetupGet(x => x.Opis).Returns("opis");
            var cmd           = new IzmeniZaglavljeNalogaCommand(Guid.NewGuid(), 0, "1", nalogIzBaze.Object.Id.Id, TipNaloga.UlazneFakture.Id, new DateTime(2018, 10, 21), "opis new");
            var fakeNalogRepo = new Mock <IFinNalogRepository>();

            fakeNalogRepo.Setup(x => x.GetAsync(nalogIzBaze.Object.Id)).ReturnsAsync(nalogIzBaze.Object);
            var fakeNalogSvc = new Mock <IFinNalogService>();
            var fakeLogger   = new Mock <ILogger <IzmeniZaglavljeNalogaCommandHandler> >();
            var handler      = new IzmeniZaglavljeNalogaCommandHandler(fakeNalogRepo.Object, fakeNalogSvc.Object, fakeLogger.Object);

            await handler.Handle(cmd, default);

            fakeNalogSvc.Verify(x => x.IzmeniZaglavljeAsync(nalogIzBaze.Object, TipNaloga.Get(cmd.IdTip), cmd.DatumNaloga, cmd.Opis));
            fakeNalogRepo.Verify(x => x.SaveAsync(nalogIzBaze.Object, cmd.CommandId, cmd.Version, cmd.UserId));
        }
        public void Primeni_StavkaProknjizena()
        {
            var nalog = FinNalogHelper.NalogFromDb(callBase: true);
            var evnt  = new StavkaProknjizena(nalog.Object.Id, Guid.NewGuid(), new DateTime(2018, 10, 3), 4, 789, 0, "opis");

            nalog.Object.Primeni(evnt);

            Assert.Equal(1, nalog.Object.Stavke.Count);
            nalog.Object.Stavke.Should().BeEquivalentTo(new[]
            {
                new
                {
                    Id             = evnt.IdStavke,
                    IdKonto        = evnt.IdKonto,
                    DatumKnjizenja = evnt.DatumKnjizenja,
                    Iznos          = new IznosStavke(evnt.Duguje, evnt.Potrazuje),
                    Opis           = evnt.Opis
                }
            });
        }
        public void IzmeniZaglavlje_DodajeEvent()
        {
            var nalog = FinNalogHelper.NalogFromDb(callBase: true);

            nalog.SetupGet(x => x.Tip).Returns(TipNaloga.UlazneFakture);
            nalog.SetupGet(x => x.DatumNaloga).Returns(new DateTime(1987, 6, 2));
            nalog.SetupGet(x => x.Opis).Returns("promenjen opis");

            nalog.Object.IzmeniZaglavlje(TipNaloga.Izvodi, new DateTime(1987, 5, 2), "promenjen opis");

            Assert.Equal(1, nalog.Object.UncommittedEvents.Count);
            Assert.Collection(nalog.Object.UncommittedEvents.OfType <IzmenjenoZaglavljeNaloga>(), e =>
            {
                Assert.Equal(nalog.Object.Id, e.IdNaloga);
                Assert.NotEqual(Guid.Empty, e.IdNaloga.Id);
                Assert.Equal(new DateTime(1987, 5, 2), e.DatumNaloga);
                Assert.Equal(TipNaloga.Izvodi.Id, e.IdTip);
                Assert.Equal("promenjen opis", e.Opis);
            });
        }
        public void ProknjiziStavku_DodajeEvent(decimal dug, decimal pot)
        {
            var nalog = FinNalogHelper.NalogFromDb(callBase: true);

            var stavka = new FinStavka(56, dug, pot, "opis proknjizene stavke");

            nalog.Object.ProknjiziStavku(stavka);

            Assert.Equal(1, nalog.Object.UncommittedEvents.Count);
            Assert.Collection(nalog.Object.UncommittedEvents.OfType <StavkaProknjizena>(), e =>
            {
                Assert.NotEqual(Guid.Empty, e.IdNaloga.Id);
                Assert.Equal(nalog.Object.Id, e.IdNaloga);
                Assert.NotEqual(Guid.Empty, e.IdStavke);
                Assert.Equal(DateTime.Today, e.DatumKnjizenja);
                Assert.Equal(stavka.IdKonto, e.IdKonto);
                Assert.Equal(stavka.Iznos.Duguje, e.Duguje);
                Assert.Equal(stavka.Iznos.Potrazuje, e.Potrazuje);
                Assert.Equal(stavka.Opis, e.Opis);
            });
        }
        public async Task Ukloni_Korektno()
        {
            var nalogIzBaze = FinNalogHelper.NalogFromDb(callBase: false);
            var cmd         = new UkloniStavkuCommand(Guid.NewGuid(), 0, "1", nalogIzBaze.Object.Id.Id, Guid.NewGuid());

            nalogIzBaze.SetupGet(x => x.Stavke).Returns(new List <FinStavka>
            {
                new FinStavka(cmd.IdStavke, 1, 100, 0, "opis stavke 1", new DateTime(2018, 10, 30)),
                new FinStavka(Guid.NewGuid(), 2, 200, 0, "opis stavke 2", new DateTime(2018, 10, 30))
            });
            var fakeNalogRepo = new Mock <IFinNalogRepository>();

            fakeNalogRepo.Setup(x => x.GetAsync(nalogIzBaze.Object.Id)).ReturnsAsync(nalogIzBaze.Object);
            var fakeLogger = new Mock <ILogger <UkloniStavkuCommandHandler> >();
            var handler    = new UkloniStavkuCommandHandler(fakeNalogRepo.Object, fakeLogger.Object);

            await handler.Handle(cmd, default);

            nalogIzBaze.Verify(x => x.UkloniStavku(It.IsNotNull <FinStavka>()), Times.Once);
            nalogIzBaze.Verify(x => x.UkloniStavku(It.Is <FinStavka>(s => s.Id == cmd.IdStavke)));
            fakeNalogRepo.Verify(x => x.SaveAsync(nalogIzBaze.Object, cmd.CommandId, cmd.Version, cmd.UserId));
        }