Ejemplo n.º 1
0
        public void StandaardAdressenBewarenTest()
        {
            // ARRANGE

            var adres = new BuitenLandsAdres {
                Land = new Land()
            };

            var persoonsAdres1 = new PersoonsAdres {
                Adres = adres, Persoon = new Persoon {
                    InSync = true
                }
            };
            var persoonsAdres2 = new PersoonsAdres {
                Adres = adres, Persoon = new Persoon {
                    InSync = true
                }
            };

            adres.PersoonsAdres.Add(persoonsAdres1);
            adres.PersoonsAdres.Add(persoonsAdres2);

            IEnumerable <Bewoner> teSyncenBewoners = null;

            // we mocken kipsync; registreer te syncen bewoners
            var kipSyncMock = new Mock <ISyncPersoonService>();

            kipSyncMock.Setup(
                src =>
                src.StandaardAdresBewaren(It.IsAny <Adres>(),
                                          It.IsAny <IEnumerable <Bewoner> >()))
            .Callback <Adres, IEnumerable <Bewoner> >(
                (a, b) => teSyncenBewoners = b);

            Factory.InstantieRegistreren(kipSyncMock.Object);

            // ACT

            var target = Factory.Maak <AdressenSync>();

            target.StandaardAdressenBewaren(new List <PersoonsAdres> {
                persoonsAdres1
            });

            // ASSERT

            Assert.IsNotNull(teSyncenBewoners);
            Assert.AreEqual(1, teSyncenBewoners.Count());
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Maakt een nieuw adres op basis van de info in <paramref name="adresInfo"/>, en persisteert
        /// </summary>
        /// <param name="adresInfo">
        /// Gegevens voor het nieuwe adres
        /// </param>
        /// <param name="straatNamen">beschikbare straatnamen als queryable</param>
        /// <param name="woonPlaatsen">beschikbare woonplaatsen als queryable</param>
        /// <param name="landen">beschikbare landen als queryable</param>
        /// <returns>
        /// Het nieuw gemaakte adres
        /// </returns>
        /// <remarks>
        /// TODO: Dit ziet er een veel te ingewikkelde method uit. Best eens refactoren.
        /// </remarks>
        private Adres Maken(AdresInfo adresInfo, IQueryable <StraatNaam> straatNamen,
                            IQueryable <WoonPlaats> woonPlaatsen, IQueryable <Land> landen)
        {
            var problemen = new Dictionary <string, FoutBericht>();

            // Al maar preventief een collectie fouten verzamelen.  Als daar uiteindelijk
            // geen foutberichten in zitten, dan is er geen probleem.  Anders
            // creëer ik een exception.
            // FIXME: de manier waarop de problemen worden doorgegeven, is niet erg proper.
            // Kan dat niet eleganter?

            if (adresInfo.StraatNaamNaam == string.Empty)
            {
                problemen.Add("StraatNaamNaam",
                              new FoutBericht
                {
                    FoutNummer = FoutNummer.StraatOntbreekt,
                    Bericht    = string.Format(
                        Resources.StraatOntbreekt,
                        adresInfo.StraatNaamNaam,
                        adresInfo.PostNr)
                });
            }

            // Controle formaat postnummer enkel voor Belgische adressen.
            if ((string.IsNullOrEmpty(adresInfo.LandNaam) ||
                 String.Compare(adresInfo.LandNaam, Resources.Belgie, StringComparison.OrdinalIgnoreCase) == 0) &&
                (adresInfo.PostNr < 1000 || adresInfo.PostNr > 9999))
            {
                problemen.Add("PostNr",
                              new FoutBericht
                {
                    FoutNummer = FoutNummer.OngeldigPostNummer,
                    Bericht    = string.Format(
                        Resources.OngeldigPostNummer,
                        adresInfo.StraatNaamNaam,
                        adresInfo.PostNr)
                });
            }

            if (adresInfo.WoonPlaatsNaam == string.Empty)
            {
                problemen.Add("WoonPlaatsNaam",
                              new FoutBericht
                {
                    FoutNummer = FoutNummer.WoonPlaatsOntbreekt,
                    Bericht    = string.Format(
                        Resources.WoonPlaatsOntbreekt,
                        adresInfo.StraatNaamNaam,
                        adresInfo.PostNr)
                });
            }

            // Als er hier al fouten zijn: gewoon throwen.  Me hiel 't stad, mor ni me maa!
            if (problemen.Count != 0)
            {
                throw new OngeldigObjectException(problemen);
            }


            Adres adr;

            if (string.IsNullOrEmpty(adresInfo.LandNaam) ||
                String.Compare(adresInfo.LandNaam, Resources.Belgie, StringComparison.OrdinalIgnoreCase) == 0)
            {
                // Belgisch adres.  Zoek en koppel straat en gemeente
                adr = new BelgischAdres();

                var s = (from strt in straatNamen
                         where
                         String.Compare(adresInfo.StraatNaamNaam, strt.Naam,
                                        StringComparison.OrdinalIgnoreCase) == 0 &&
                         adresInfo.PostNr == strt.PostNummer
                         select strt).FirstOrDefault();

                if (s != null)
                {
                    // Straat gevonden: aan adres koppelen
                    ((BelgischAdres)adr).StraatNaam = s;
                    s.BelgischAdres.Add((BelgischAdres)adr);
                }
                else
                {
                    // Straat niet gevonden: foutbericht toevoegen
                    problemen.Add("StraatNaamNaam",
                                  new FoutBericht
                    {
                        FoutNummer = FoutNummer.StraatNietGevonden,
                        Bericht    = string.Format(
                            Resources.StraatNietGevonden,
                            adresInfo.StraatNaamNaam,
                            adresInfo.PostNr)
                    });
                }

                var sg = (from wpl in woonPlaatsen
                          where
                          String.Compare(adresInfo.WoonPlaatsNaam, wpl.Naam,
                                         StringComparison.OrdinalIgnoreCase) == 0 &&
                          adresInfo.PostNr == wpl.PostNummer
                          select wpl).FirstOrDefault();

                if (sg != null)
                {
                    // Gemeente gevonden: aan adres koppelen
                    ((BelgischAdres)adr).WoonPlaats = sg;
                    sg.BelgischAdres.Add((BelgischAdres)adr);
                }
                else
                {
                    // Gemeente niet gevonden: foutbericht toevoegen
                    problemen.Add("WoonPlaatsNaam",
                                  new FoutBericht
                    {
                        FoutNummer = FoutNummer.WoonPlaatsNietGevonden,
                        Bericht    = Resources.GemeenteNietGevonden
                    });
                }
            }
            else
            {
                // Buitenlands adres.  Straat en gemeente zijn gewone strings.
                // Zoek en koppel land.
                adr = new BuitenLandsAdres();

                ((BuitenLandsAdres)adr).Straat     = adresInfo.StraatNaamNaam;
                ((BuitenLandsAdres)adr).WoonPlaats = adresInfo.WoonPlaatsNaam;
                ((BuitenLandsAdres)adr).PostCode   = adresInfo.PostCode;

                Land l = (from lnd in landen
                          where String.Compare(lnd.Naam, adresInfo.LandNaam, StringComparison.OrdinalIgnoreCase) == 0
                          select lnd).FirstOrDefault();

                if (l != null)
                {
                    // Gemeente gevonden: aan adres koppelen
                    ((BuitenLandsAdres)adr).Land = l;
                    l.BuitenLandsAdres.Add((BuitenLandsAdres)adr);
                }
                else
                {
                    // Gemeente niet gevonden: foutbericht toevoegen
                    problemen.Add("LandNaam",
                                  new FoutBericht
                    {
                        FoutNummer = FoutNummer.LandNietGevonden,
                        Bericht    = Resources.LandNietGevonden
                    });
                }
            }

            if (problemen.Count != 0)
            {
                throw new OngeldigObjectException(problemen);
            }

            adr.HuisNr = adresInfo.HuisNr;
            adr.Bus    = adresInfo.Bus;

            // bewaren brengt Versie en ID automatisch in orde.
            return(adr);
        }
Ejemplo n.º 3
0
        public void PlaatsVervangenTest()
        {
            // ARRANGE

            var groep = new ChiroGroep {
                ID = 3
            };
            var bivak = new Uitstap {
                ID = 1, GroepsWerkJaar = new GroepsWerkJaar {
                    Groep = groep
                }
            };
            var adres = new BuitenLandsAdres
            {
                Straat     = "Vorststraat",
                HuisNr     = 3,
                PostCode   = "BR 1234",
                WoonPlaats = "Killegem",
                Land       = new Land {
                    Naam = "Nederland"
                }
            };
            var plaats = new Plaats {
                ID = 2, Naam = "Coole bivakplaats", Adres = adres, Groep = groep
            };

            bivak.Plaats = plaats; // Bivak heeft al een plaats

            // dependency injection voor data access

            var dummyRepositoryProvider = new Mock <IRepositoryProvider>();

            dummyRepositoryProvider.Setup(src => src.RepositoryGet <Uitstap>())
            .Returns(new DummyRepo <Uitstap>(new List <Uitstap> {
                bivak
            }));
            dummyRepositoryProvider.Setup(src => src.RepositoryGet <Plaats>())
            .Returns(new DummyRepo <Plaats>(new List <Plaats> {
                plaats
            }));
            dummyRepositoryProvider.Setup(src => src.RepositoryGet <Adres>())
            .Returns(new DummyRepo <Adres>(new List <Adres> {
                adres
            }));
            dummyRepositoryProvider.Setup(src => src.RepositoryGet <Land>())
            .Returns(new DummyRepo <Land>(new List <Land> {
                adres.Land
            }));
            dummyRepositoryProvider.Setup(src => src.RepositoryGet <WoonPlaats>())
            .Returns(new DummyRepo <WoonPlaats>(new List <WoonPlaats>()));
            dummyRepositoryProvider.Setup(src => src.RepositoryGet <StraatNaam>())
            .Returns(new DummyRepo <StraatNaam>(new List <StraatNaam>()));

            Factory.InstantieRegistreren(dummyRepositoryProvider.Object);

            // ACT

            var target = Factory.Maak <UitstappenService>();

            target.PlaatsBewaren(bivak.ID, "Warme Bivakplaats",
                                 new AdresInfo
            {
                StraatNaamNaam = "Zonnestraat",
                HuisNr         = 8,
                PostNr         = 9876,
                PostCode       = "PF",
                WoonPlaatsNaam = "Warmegem",
                LandNaam       = "Nederland"
            });

            // ASSERT

            Assert.AreNotEqual(bivak.Plaats.ID, plaats.ID); // is de plaats wel veranderd?
        }
Ejemplo n.º 4
0
        public void PlaatsOpGekendAdresBewarenTest()
        {
            // ARRANGE

            var groep = new ChiroGroep {
                ID = 3
            };
            var bivak = new Uitstap {
                ID = 1, GroepsWerkJaar = new GroepsWerkJaar {
                    Groep = groep
                }
            };
            var adres = new BuitenLandsAdres
            {
                Straat     = "Vorststraat",
                HuisNr     = 3,
                PostCode   = "BR 1234",
                WoonPlaats = "Killegem",
                Land       = new Land {
                    Naam = "Nederland"
                }
            };

            // dependency injection voor data access

            var dummyRepositoryProvider = new Mock <IRepositoryProvider>();

            dummyRepositoryProvider.Setup(src => src.RepositoryGet <Uitstap>())
            .Returns(new DummyRepo <Uitstap>(new List <Uitstap> {
                bivak
            }));
            dummyRepositoryProvider.Setup(src => src.RepositoryGet <Plaats>())
            .Returns(new DummyRepo <Plaats>(new List <Plaats>()));
            dummyRepositoryProvider.Setup(src => src.RepositoryGet <Adres>())
            .Returns(new DummyRepo <Adres>(new List <Adres> {
                adres
            }));
            dummyRepositoryProvider.Setup(src => src.RepositoryGet <Land>())
            .Returns(new DummyRepo <Land>(new List <Land> {
                adres.Land
            }));
            dummyRepositoryProvider.Setup(src => src.RepositoryGet <WoonPlaats>())
            .Returns(new DummyRepo <WoonPlaats>(new List <WoonPlaats>()));
            dummyRepositoryProvider.Setup(src => src.RepositoryGet <StraatNaam>())
            .Returns(new DummyRepo <StraatNaam>(new List <StraatNaam>()));
            Factory.InstantieRegistreren(dummyRepositoryProvider.Object);

            // ACT

            var target = Factory.Maak <UitstappenService>();

            target.PlaatsBewaren(bivak.ID, "Warme Bivakplaats",
                                 new AdresInfo
            {
                StraatNaamNaam = adres.Straat,
                HuisNr         = adres.HuisNr,
                PostCode       = adres.PostCode,
                WoonPlaatsNaam = adres.WoonPlaats,
                LandNaam       = adres.Land.Naam
            });

            // ASSERT

            Assert.AreEqual(bivak.Plaats.Adres.ID, adres.ID);
        }