public void ToekennenFunctieOngeldigWerkJaar()
{
// ARRANGE
var groepsWerkJaar = new GroepsWerkJaar
{
Groep = new ChiroGroep(),
WerkJaar = 2012
};
groepsWerkJaar.Groep.GroepsWerkJaar.Add(groepsWerkJaar);
var lid = new Leiding {
GroepsWerkJaar = groepsWerkJaar
};
var vervallenFunctie = new Functie
{
WerkJaarTot = groepsWerkJaar.WerkJaar - 1,
MinAantal = 1,
Groep = groepsWerkJaar.Groep,
Niveau = Niveau.Groep
};
var functiesManager = Factory.Maak <FunctiesManager>();
// ASSERT
Assert.Throws <FoutNummerException>(() => functiesManager.Toekennen(lid, new List <Functie> {
vervallenFunctie
}));
// Als er geen exception gethrowd worden, zal de test failen.
}
public void ContactZonderEmail()
{
// ARRANGE
var groepsWerkJaar = new GroepsWerkJaar {
Groep = new ChiroGroep(), WerkJaar = 2012
};
groepsWerkJaar.Groep.GroepsWerkJaar.Add(groepsWerkJaar);
var contactPersoonFunctie = new Functie
{
ID = (int)NationaleFunctie.ContactPersoon,
MinAantal = 1,
IsNationaal = true,
Niveau = Niveau.LeidingInGroep,
};
var lid = new Leiding
{
GroepsWerkJaar = groepsWerkJaar,
GelieerdePersoon = new GelieerdePersoon()
};
var functiesManager = Factory.Maak <FunctiesManager>();
// ASSERT
var ex = Assert.Throws <FoutNummerException>(
() => functiesManager.Toekennen(lid, new List <Functie> {
contactPersoonFunctie
}));
Assert.AreEqual(FoutNummer.EMailVerplicht, ex.FoutNummer);
}
public TotemEntryRepositoryTest()
{
_adjective = new Adjectief
{
Naam = "Wijze"
};
_totem = new Totem
{
Naam = "Nachtegaal"
};
_leader1 = new Leiding
{
Naam = "pierlala",
Voornaam = "Jantje"
};
_leader2 = new Leiding
{
Naam = "Lothbrok",
Voornaam = "Ragnar"
};
_dbContext = CreateDbContext();
_dbContext.Adjectieven.Add(_adjective);
_dbContext.Leiding.Add(_leader1);
_dbContext.Leiding.Add(_leader2);
_dbContext.Totems.Add(_totem);
_dbContext.SaveChanges();
}
public void FunctieDitJaarInGebruikVerwijderenTest()
{
// arrange
// testsituatie creeren
var functie = new Functie();
var groepswerkjaar = new GroepsWerkJaar
{
ID = 11,
Groep =
new ChiroGroep
{
ID = 1,
GroepsWerkJaar = new List <GroepsWerkJaar>()
}
};
groepswerkjaar.Groep.GroepsWerkJaar.Add(groepswerkjaar);
functie.Groep = groepswerkjaar.Groep;
var lid = new Leiding {
Functie = new List <Functie>()
{
functie
}, GroepsWerkJaar = groepswerkjaar
};
functie.Lid.Add(lid);
var mgr = Factory.Maak <FunctiesManager>();
// assert
Assert.Throws <BlokkerendeObjectenException <Lid> >(() => mgr.Verwijderen(functie, false));
}
public static Order Create(Leiding orderedBy)
{
return(new Order()
{
OrderedBy = orderedBy,
CreatedOn = DateTime.Now.ToLocalTime()
});
}
public void WerkjaarVerzekeringGeenOverlap()
{
// ARRANGE
var groepsWerkJarenManager = Factory.Maak <IGroepsWerkJarenManager>();
var vtype = new VerzekeringsType
{
TotEindeWerkJaar = true
};
var groepsWerkJaar = new GroepsWerkJaar
{
Groep = new ChiroGroep(),
WerkJaar = 2012
};
var vorigGroepsWerkJaar = new GroepsWerkJaar
{
Groep = new ChiroGroep(),
WerkJaar = 2011
};
groepsWerkJaar.Groep.GroepsWerkJaar.Add(groepsWerkJaar);
groepsWerkJaar.Groep.GroepsWerkJaar.Add(vorigGroepsWerkJaar);
var persoon = new Persoon
{
PersoonsVerzekering = new List <PersoonsVerzekering>
{
new PersoonsVerzekering
{
VerzekeringsType = vtype,
Van = new DateTime(2011, 10, 1),
// De einddatum moeten we via de groepsWerkJarenManager laten
// berekenen, want het einde van een groepswerkjaar valt bijv.
// anders bij staging als bij dev.
Tot = groepsWerkJarenManager.EindDatum(vorigGroepsWerkJaar)
}
}
};
var lid1 = new Leiding
{
GroepsWerkJaar = groepsWerkJaar,
GelieerdePersoon = new GelieerdePersoon {
Persoon = persoon
}
};
// ACT
var verzekeringenManager = Factory.Maak <VerzekeringenManager>();
verzekeringenManager.Verzekeren(lid1, vtype, new DateTime(2012, 10, 1), groepsWerkJarenManager.EindDatum(groepsWerkJaar));
// ASSERT
Assert.AreEqual(2, persoon.PersoonsVerzekering.Count);
}
public void FunctieLangerInGebruikGeforceerdVerwijderenTest()
{
// ARRANGE
// model
var groep = new ChiroGroep();
var vorigWerkJaar = new GroepsWerkJaar {
WerkJaar = 2011, Groep = groep, ID = 2
};
var ditWerkJaar = new GroepsWerkJaar {
WerkJaar = 2012, Groep = groep, ID = 3
};
groep.GroepsWerkJaar.Add(vorigWerkJaar);
groep.GroepsWerkJaar.Add(ditWerkJaar);
var functie = new Functie {
Groep = groep, ID = 1
};
groep.Functie.Add(functie);
var gelieerdePersoon = new GelieerdePersoon {
Groep = groep
};
groep.GelieerdePersoon.Add(gelieerdePersoon);
var leidingToen = new Leiding {
GelieerdePersoon = gelieerdePersoon, GroepsWerkJaar = vorigWerkJaar
};
var leidingNu = new Leiding {
GelieerdePersoon = gelieerdePersoon, GroepsWerkJaar = ditWerkJaar
};
vorigWerkJaar.Lid.Add(leidingToen);
ditWerkJaar.Lid.Add(leidingNu);
leidingToen.Functie.Add(functie);
leidingNu.Functie.Add(functie);
functie.Lid.Add(leidingToen);
functie.Lid.Add(leidingNu);
// ACT
var mgr = Factory.Maak <FunctiesManager>();
var result = mgr.Verwijderen(functie, true);
// ASSERT
// functie niet meer geldig
Assert.IsTrue(groep.Functie.Contains(functie));
Assert.AreEqual(result.WerkJaarTot, ditWerkJaar.WerkJaar - 1);
// enkel het lid van dit werkJaar blijft over
Assert.AreEqual(result.Lid.Count, 1);
}
public async Task Cant_Place_Order_If_OrderedFor_Section_Cant_Use_Tab()
{
var section = new Tak()
{
TabIsAllowed = false
};
var person = new Leiding()
{
Tak = section
};
var account = new Account(AccountType.Tab);
person.Accounts = new List <Account> {
account
};
var order = Order.Create(person);
var orderline = Orderline.Create(_defaultDrank, person, order, 1);
var orderRepository = new Mock <IOrderRepository>();
var leidingRepo = new Mock <ILeidingRepository>();
leidingRepo.Setup(x => x.FindByEmailAsync(It.IsAny <string>())).Returns(Task.FromResult <Leiding>(person));
leidingRepo.Setup(x => x.FindByIdAsync(It.IsAny <int>())).Returns(Task.FromResult <Leiding>(person));
var drankRepo = new Mock <IDrankRepository>();
drankRepo.Setup(x => x.FindByIdAsync(It.IsAny <int>())).Returns(Task.FromResult <Drank>(_defaultDrank));
var orderlineRepo = new Mock <IOrderlineRepository>();
var accountRepo = new Mock <IAccountRepository>();
accountRepo.Setup(x => x.FindAccountAsync(It.IsAny <int>(), AccountType.Tab))
.Returns(Task.FromResult <Account>(account));
var accountService = new Mock <IAccountService>();
var service = new OrderService(orderRepository.Object, leidingRepo.Object, drankRepo.Object, orderlineRepo.Object, accountRepo.Object, accountService.Object);
var orderlines = new List <CreateOrderlineDTO>();
orderlines.Add(item: new CreateOrderlineDTO
{
DrankId = 10,
OrderedForId = 10,
Quantity = 10
});
var orderDto = new CreateOrderDTO()
{
Orderlines = orderlines
};
await Assert.ThrowsAsync <InvalidOperationException>(() => service.CreateOrder(orderDto, String.Empty));
}
public void RechtenOpLidAndereGroepTest()
{
// ARRANGE
var ik = new Persoon {
AdNummer = 1234
};
var gp = new GelieerdePersoon {
Persoon = new Persoon()
};
var groep = new ChiroGroep
{
GebruikersRechtV2 = new[]
{
new GebruikersRechtV2
{
Persoon = ik,
VervalDatum = DateTime.Today.AddDays(1),
IedereenPermissies = Permissies.Lezen
}
},
GelieerdePersoon = new[]
{
gp
}
};
gp.Groep = groep;
var leiding = new Leiding
{
GelieerdePersoon = gp,
GroepsWerkJaar = new GroepsWerkJaar {
Groep = groep
}
};
// Zet mock op voor het opleveren van gebruikersnaam
var authenticatieManagerMock = new Mock <IAuthenticatieManager>();
authenticatieManagerMock.Setup(src => src.AdNummerGet()).Returns(ik.AdNummer);
Factory.InstantieRegistreren(authenticatieManagerMock.Object);
// ACT
var target = Factory.Maak <AutorisatieManager>();
var actual = target.PermissiesOphalen(leiding);
// ASSERT
Assert.IsTrue(actual.HasFlag(Permissies.Lezen));
}
public void TweeKeerUniekeFunctieToekennenTestVerschillendLid()
{
// ARRANGE
var groepsWerkJaar = new GroepsWerkJaar
{
Groep = new ChiroGroep(),
WerkJaar = 2012
};
groepsWerkJaar.Groep.GroepsWerkJaar.Add(groepsWerkJaar);
var uniekeFunctie = new Functie
{
MaxAantal = 1,
Groep = groepsWerkJaar.Groep,
Niveau = Niveau.Groep
};
var lid1 = new Leiding {
GroepsWerkJaar = groepsWerkJaar, Functie = new List <Functie> {
uniekeFunctie
}
};
var lid2 = new Leiding {
GroepsWerkJaar = groepsWerkJaar
};
uniekeFunctie.Lid.Add(lid1);
groepsWerkJaar.Lid.Add(lid1);
groepsWerkJaar.Lid.Add(lid2);
// ACT
var functiesManager = Factory.Maak <FunctiesManager>();
functiesManager.Toekennen(lid2, new List <Functie> {
uniekeFunctie
});
// ASSERT
var issues = functiesManager.AantallenControleren(groepsWerkJaar, new List <Functie> {
uniekeFunctie
});
Assert.IsTrue(issues.Select(src => src.ID).Contains(uniekeFunctie.ID));
}
public void NooitAangeslotenLedenAansluitenTest()
{
// ARRANGE
const int huidigWerkjaar = 2014;
DateTime vandaagZoGezegd = new DateTime(2015, 02, 23);
// We hebben 1 leidster, die niet meer in haar probeerperiode zit.
var leidster = new Leiding
{
ID = 1,
EindeInstapPeriode = vandaagZoGezegd.AddDays(-7),
GelieerdePersoon = new GelieerdePersoon
{
ID = 2,
Persoon = new Persoon
{
ID = 3,
VoorNaam = "Kelly",
Naam = "Pfaff"
}
},
GroepsWerkJaar = new GroepsWerkJaar
{
ID = 4,
WerkJaar = huidigWerkjaar,
Groep = new ChiroGroep {
ID = 5
}
}
};
leidster.GroepsWerkJaar.Groep.GroepsWerkJaar = new List <GroepsWerkJaar> {
leidster.GroepsWerkJaar
};
// ACT
var target = new LedenManager();
var result = target.AanTeSluitenLedenOphalen((new List <Lid> {
leidster
}).AsQueryable(), huidigWerkjaar,
vandaagZoGezegd, null);
// ASSERT
Assert.IsNotEmpty(result);
}
public void GeenAansluitingenOudWerkjaarTest()
{
// Stel: het is juli 2016.
var datum = new DateTime(2016, 7, 15);
var groep = new ChiroGroep
{
GroepsWerkJaar = new List <GroepsWerkJaar>()
};
var gwj1 = new GroepsWerkJaar {
Groep = groep, WerkJaar = 2016
};
// De groep heeft zijn jaarovergang al gedaan, en er bestaat dus een werkjaar 2017-2018.
var gwj2 = new GroepsWerkJaar {
Groep = groep, WerkJaar = 2017
};
groep.GroepsWerkJaar.Add(gwj1);
groep.GroepsWerkJaar.Add(gwj2);
var lid = new Leiding
{
GroepsWerkJaar = gwj1,
EindeInstapPeriode = datum.AddDays(-5),
GelieerdePersoon = new GelieerdePersoon
{
Groep = groep,
Persoon = new Persoon()
}
};
lid.GelieerdePersoon.Persoon.GelieerdePersoon.Add(lid.GelieerdePersoon);
gwj1.Lid = new List <Lid> {
lid
};
var target = new LedenManager();
// Nu proberen we uit te zoeken welke leden er nog aangesloten moeten worden in 2016-2017.
var result = target.AanTeSluitenLedenOphalen(groep.GroepsWerkJaar.SelectMany(gwj => gwj.Lid).AsQueryable(),
2016, datum, null);
Assert.IsEmpty(result);
}
public void NietWerkjaarVerzekeringWelOverlap()
{
// ARRANGE
var vtype = new VerzekeringsType
{
TotEindeWerkJaar = false
};
var groepsWerkJaar = new GroepsWerkJaar
{
Groep = new ChiroGroep(),
WerkJaar = 2012
};
groepsWerkJaar.Groep.GroepsWerkJaar.Add(groepsWerkJaar);
var persoon = new Persoon
{
PersoonsVerzekering = new List <PersoonsVerzekering>
{
new PersoonsVerzekering
{
VerzekeringsType = vtype,
Van = new DateTime(2011, 10, 1),
Tot = new DateTime(2012, 8, 31)
}
}
};
var lid1 = new Leiding
{
GroepsWerkJaar = groepsWerkJaar,
GelieerdePersoon = new GelieerdePersoon {
Persoon = persoon
}
};
// ASSERT
var verzekeringenManager = Factory.Maak <VerzekeringenManager>();
Assert.Throws <BlokkerendeObjectenException <PersoonsVerzekering> >(() => verzekeringenManager.Verzekeren(lid1,
vtype, new DateTime(2012, 8, 1), new DateTime(2013, 8, 31)));
}
public void AantallenControlerenBovengrensTest()
{
// ARRANGE
var functie = new Functie {
IsNationaal = true, MaxAantal = 1
};
var groepsWerkJaar1 = new GroepsWerkJaar();
var leiding1 = new Leiding {
Functie = new List <Functie> {
functie
}
};
functie.Lid.Add(leiding1);
groepsWerkJaar1.Lid.Add(leiding1);
var groepsWerkJaar2 = new GroepsWerkJaar();
var leiding2 = new Leiding {
Functie = new List <Functie> {
functie
}
};
functie.Lid.Add(leiding2);
groepsWerkJaar2.Lid.Add(leiding2);
// ACT
var target = Factory.Maak <FunctiesManager>();
var actual = target.AantallenControleren(groepsWerkJaar1, new List <Functie> {
functie
});
// controleer enkel op functie2.
// ASSERT
Assert.AreEqual(0, actual.Count);
}
public async Task <BasicLeaderDTO> CreateLeader(CreateLeaderDTO dto)
{
//Check if a section is provided for the leader
Tak tak = null;
if (dto.TakId != 0)
{
tak = await _takRepository.FindByIdAsync(dto.TakId);
if (tak == null)
{
throw new EntityNotFoundException($"Tak met id {dto.TakId} werd niet gevonden.");
}
}
//Map the dto to the leader entity. TODO: This smells fishy. I don't like new()
var leader = new Leiding
{
Naam = dto.Naam.Trim(),
Voornaam = dto.Voornaam.Trim(),
LeidingSinds = dto.LeidingSinds.ToLocalTime(),
Tak = tak,
Email = dto.Email?.Trim().ToLower(),
Accounts = new List <Account>(2)
};
//Only create accounts if needed. E.g.: leaders created through the totemdatabase probably shouldn't have an account at first.
if (dto.CreateAccounts)
{
leader.Accounts.Add(new Account(AccountType.Debt));
leader.Accounts.Add(new Account(AccountType.Tab));
}
await _leidingRepository.AddAsync(leader);
await _leidingRepository.SaveChangesAsync();
return(_mapper.Map <BasicLeaderDTO>(leader));
}
public void TweeKeerUniekeFunctieToekennenTestZelfdeLid()
{
// Arrange
// Genereer de situatie
var groep = new ChiroGroep();
var groepsWerkJaar = new GroepsWerkJaar {
Groep = groep
};
groep.GroepsWerkJaar = new List <GroepsWerkJaar> {
groepsWerkJaar
};
var leider = new Leiding {
GroepsWerkJaar = groepsWerkJaar
};
var functie = new Functie
{
MaxAantal = 1,
Type = LidType.Alles,
IsNationaal = true,
Niveau = Niveau.Alles
};
var fm = Factory.Maak <FunctiesManager>();
// Act
fm.Toekennen(leider, new[] { functie });
fm.Toekennen(leider, new[] { functie });
// Assert
var problemen = fm.AantallenControleren(groepsWerkJaar, new[] { functie });
Assert.AreEqual(problemen.Count(), 0);
}
public void ToekennenLidFunctieAanLeiding()
{
// Arrange
var fm = Factory.Maak <FunctiesManager>();
Groep groep = new ChiroGroep
{
Functie = new List <Functie>()
};
var functie = new Functie
{
Groep = groep,
MaxAantal = 1,
MinAantal = 0,
Niveau = Niveau.LidInGroep
};
groep.Functie.Add(functie);
var leider = new Leiding
{
GroepsWerkJaar = new GroepsWerkJaar {
Groep = groep
}
};
groep.GroepsWerkJaar.Add(leider.GroepsWerkJaar);
// Assert
Assert.Throws <FoutNummerException>(() => fm.Toekennen(leider, new List <Functie> {
functie
}));
}
public void DubbelVerwijderenTestOrigineelLidInactief()
{
// ARRANGE
var groep = new ChiroGroep();
var groepsWerkJaar = new GroepsWerkJaar {
Groep = groep
};
var origineel = new Persoon();
var dubbel = new Persoon();
var origineleGp = new GelieerdePersoon {
Persoon = origineel, Groep = groep
};
var dubbeleGp = new GelieerdePersoon {
Persoon = dubbel, Groep = groep
};
origineel.GelieerdePersoon.Add(origineleGp);
dubbel.GelieerdePersoon.Add(dubbeleGp);
groep.GelieerdePersoon.Add(origineleGp);
groep.GelieerdePersoon.Add(dubbeleGp);
var origineelLid = new Leiding
{
GelieerdePersoon = origineleGp,
GroepsWerkJaar = groepsWerkJaar,
UitschrijfDatum = DateTime.Today.AddDays(-1),
NonActief = true,
ID = 1
};
var dubbelLid = new Leiding
{
GelieerdePersoon = dubbeleGp,
GroepsWerkJaar = groepsWerkJaar,
UitschrijfDatum = null,
NonActief = false,
ID = 2
};
origineleGp.Lid.Add(origineelLid);
dubbeleGp.Lid.Add(dubbelLid);
groepsWerkJaar.Lid.Add(origineelLid);
groepsWerkJaar.Lid.Add(dubbelLid);
var allePersonen = new List <Persoon> {
origineel, dubbel
};
var repositoryProviderMock = new Mock <IRepositoryProvider>();
repositoryProviderMock.Setup(src => src.RepositoryGet <Persoon>())
.Returns(new DummyRepo <Persoon>(allePersonen));
repositoryProviderMock.Setup(src => src.RepositoryGet <Lid>())
.Returns(new DummyRepo <Lid>(new List <Lid> {
origineelLid, dubbelLid
}));
repositoryProviderMock.Setup(src => src.RepositoryGet <GelieerdePersoon>())
.Returns(new DummyRepo <GelieerdePersoon>(new List <GelieerdePersoon> {
origineleGp, dubbeleGp
}));
Factory.InstantieRegistreren(repositoryProviderMock.Object);
// ACT
var target = Factory.Maak <GapUpdater>();
target.DubbelVerwijderen(origineel, dubbel);
// ASSERT
Assert.IsTrue(origineleGp.Lid.Contains(dubbelLid));
Assert.IsFalse(groepsWerkJaar.Lid.Contains(origineelLid));
}
public OrderlineTest()
{
_drank = Drank.Create(_naam, _prijs, _type, _inStock);
_leiding = new Leiding();
_order = Order.Create(_leiding);
}
/// <summary>
/// Maakt een gelieerde persoon <paramref name="gp"/> lid in groepswerkjaar <paramref name="gwj"/>,
/// met lidtype <paramref name="type"/>, persisteert niet.
/// </summary>
/// <param name="gp">
/// Lid te maken gelieerde persoon, gekoppeld met groep en persoon
/// </param>
/// <param name="gwj">
/// Groepswerkjaar waarin de gelieerde persoon lid moet worden
/// </param>
/// <param name="type">
/// LidType.Kind of LidType.Leiding
/// </param>
/// <param name="isJaarOvergang">
/// Als deze true is, is einde probeerperiode steeds
/// 15 oktober als het nog geen 15 oktober is
/// </param>
/// <remarks>
/// Private; andere lagen moeten via 'Inschrijven' gaan.
/// <para>
/// </para>
/// Deze method test niet of het groepswerkjaar wel het recentste is. (Voor de unit tests moeten
/// we ook leden kunnen maken in oude groepswerkjaren.)
/// Roep deze method ook niet rechtstreeks aan, maar wel via KindMaken of LeidingMaken
/// </remarks>
/// <returns>
/// Het aangepaste Lid-object
/// </returns>
/// <throws>FoutNummerException</throws>
/// <throws>GeenGavException</throws>
/// <throws>InvalidOperationException</throws>
private Lid LidMaken(GelieerdePersoon gp, GroepsWerkJaar gwj, LidType type, bool isJaarOvergang)
{
Lid lid;
switch (type)
{
case LidType.Kind:
lid = new Kind();
break;
case LidType.Leiding:
lid = new Leiding();
break;
default:
lid = new Lid();
break;
}
// GroepsWerkJaar en GelieerdePersoon invullen
lid.GroepsWerkJaar = gwj;
lid.GelieerdePersoon = gp;
gp.Lid.Add(lid);
gwj.Lid.Add(lid);
var stdProbeerPeriode = DateTime.Today.AddDays(Settings.Default.LengteProbeerPeriode);
var eindeJaarOvergang = Settings.Default.WerkjaarVerplichteOvergang;
eindeJaarOvergang = new DateTime(gwj.WerkJaar, eindeJaarOvergang.Month, eindeJaarOvergang.Day);
if ((gp.Groep.Niveau & (Niveau.Gewest | Niveau.Verbond)) != 0)
{
lid.EindeInstapPeriode = DateTime.Today;
}
else if (!isJaarOvergang)
{
// Standaardinstapperiode indien niet in jaarovergang
lid.EindeInstapPeriode = eindeJaarOvergang >= stdProbeerPeriode
? eindeJaarOvergang
: stdProbeerPeriode;
}
else
{
// Voor jaarovergang: vaste deadline (gek idee, maar blijkbaar in de specs)
lid.EindeInstapPeriode = eindeJaarOvergang >= DateTime.Now
? eindeJaarOvergang
: stdProbeerPeriode;
}
FoutNummer?fout = new LidValidator().FoutNummer(lid);
if (fout == FoutNummer.GroepsWerkJaarNietVanGroep)
{
throw new FoutNummerException(FoutNummer.GroepsWerkJaarNietVanGroep,
Resources.GroepsWerkJaarNietVanGroep);
}
// Geboortedatum is verplicht als je lid wilt worden
if (fout == FoutNummer.GeboorteDatumOntbreekt)
{
throw new FoutNummerException(FoutNummer.GeboorteDatumOntbreekt, Resources.GeboorteDatumOntbreekt);
}
// Je moet oud genoeg zijn
if (fout == FoutNummer.LidTeJong)
{
throw new FoutNummerException(FoutNummer.LidTeJong, Resources.MinimumLeeftijd);
}
// en nog leven ook
if (fout == FoutNummer.PersoonOverleden)
{
throw new FoutNummerException(FoutNummer.PersoonOverleden, Resources.PersoonIsOverleden);
}
return(lid);
}
public void LedenInProbeerPeriodeNietSyncen()
{
// ARRANGE
const int huidigWerkjaar = 2014;
DateTime vandaagZoGezegd = new DateTime(2015, 02, 23);
// We hebben 1 leidster, die nog in haar probeerperiode zit.
var leidster = new Leiding
{
ID = 1,
EindeInstapPeriode = vandaagZoGezegd.AddDays(7),
GelieerdePersoon = new GelieerdePersoon
{
ID = 2,
Persoon = new Persoon
{
ID = 3,
VoorNaam = "Kelly",
Naam = "Pfaff"
}
},
GroepsWerkJaar = new GroepsWerkJaar
{
ID = 4,
WerkJaar = huidigWerkjaar
}
};
// De repository bevat enkel deze leidster.
var ledenRepo = new DummyRepo <Lid>(new List <Lid> {
leidster
});
// Repositoryprovidermock opzetten
var repoProviderMock = new Mock <IRepositoryProvider>();
repoProviderMock.Setup(src => src.RepositoryGet <Lid>()).Returns(ledenRepo);
// Mock voor personenSync
var personenSyncMock = new Mock <IPersonenSync>();
personenSyncMock.Setup(
src =>
src.MembershipRegistreren(It.Is <Lid>(l => l.ID == leidster.ID))).Verifiable();
// Meer mocks.
var groepsWerkJaarManagerMock = new Mock <IGroepsWerkJarenManager>();
groepsWerkJaarManagerMock.Setup(src => src.HuidigWerkJaarNationaal()).Returns(huidigWerkjaar);
groepsWerkJaarManagerMock.Setup(src => src.Vandaag()).Returns(vandaagZoGezegd);
// Mocks registeren
Factory.InstantieRegistreren(repoProviderMock.Object);
Factory.InstantieRegistreren(personenSyncMock.Object);
Factory.InstantieRegistreren(groepsWerkJaarManagerMock.Object);
// ACT
var target = Factory.Maak <MembershipMaintenance>();
target.MembershipsMaken();
// ASSERT
personenSyncMock.Verify(
src => src.MembershipRegistreren(It.Is <Lid>(l => l.ID == leidster.ID)), Times.Never);
}
public void VanGratisNaarBetalendMembershipTest()
{
// ARRANGE
const int huidigWerkjaar = 2015;
DateTime vandaagZoGezegd = new DateTime(2016, 1, 7);
var gewest = new KaderGroep {
ID = 6
};
// We hebben 1 leidster, die ook in het gewest actief is.
var leidster = new Leiding
{
ID = 1,
EindeInstapPeriode = vandaagZoGezegd.AddDays(-7),
GelieerdePersoon = new GelieerdePersoon
{
ID = 2,
Persoon = new Persoon
{
ID = 3,
VoorNaam = "Kelly",
Naam = "Pfaff"
}
},
GroepsWerkJaar = new GroepsWerkJaar
{
ID = 4,
WerkJaar = huidigWerkjaar,
Groep = new ChiroGroep {
ID = 5
}
}
};
leidster.GroepsWerkJaar.Groep.GroepsWerkJaar = new List <GroepsWerkJaar> {
leidster.GroepsWerkJaar
};
leidster.GelieerdePersoon.Persoon.GelieerdePersoon.Add(new GelieerdePersoon
{
ID = 5,
Groep = gewest,
Lid = new [] { new Leiding
{
ID = 7,
IsAangesloten = true,
GroepsWerkJaar = new GroepsWerkJaar
{
ID = 8,
WerkJaar = huidigWerkjaar,
Groep = gewest
}
} }
});
// ACT
var target = new LedenManager();
var result = target.AanTeSluitenLedenOphalen((new List <Lid> {
leidster
}).AsQueryable(), huidigWerkjaar,
vandaagZoGezegd, null);
// ASSERT
Assert.IsNotEmpty(result);
}
public void FunctiesVervangen()
{
// Arrange
// testdata
var gwj = new GroepsWerkJaar();
var groep = new ChiroGroep
{
GroepsWerkJaar = new List <GroepsWerkJaar> {
gwj
}
};
gwj.Groep = groep;
var contactPersoon = new Functie
{
ID = 1,
IsNationaal = true,
Niveau = Niveau.Alles,
Naam = "Contactpersoon",
Type = LidType.Leiding
};
var finVer = new Functie
{
ID = 2,
IsNationaal = true,
Niveau = Niveau.Alles,
Naam = "FinancieelVerantwoordelijke",
Type = LidType.Leiding
};
var vb = new Functie
{
ID = 3,
IsNationaal = true,
Niveau = Niveau.Alles,
Naam = "VB",
Type = LidType.Leiding
};
var redactie = new Functie
{
ID = 4,
IsNationaal = false,
Niveau = Niveau.Groep,
Naam = "RED",
Type = LidType.Leiding,
Groep = groep
};
var leiding = new Leiding
{
ID = 100,
GroepsWerkJaar = gwj,
Functie = new List <Functie> {
contactPersoon, redactie
},
GelieerdePersoon = new GelieerdePersoon {
Groep = groep
}
};
var functiesMgr = Factory.Maak <FunctiesManager>();
// ACT
var leidingsFuncties = leiding.Functie; // bewaren voor latere referentie
functiesMgr.Vervangen(leiding, new List <Functie> {
finVer, vb, redactie
});
// ASSERT
Assert.AreEqual(leiding.Functie.Count(), 3);
Assert.IsTrue(leiding.Functie.Contains(finVer));
Assert.IsTrue(leiding.Functie.Contains(vb));
Assert.IsTrue(leiding.Functie.Contains(redactie));
// om problemen te vermijden met entity framework, mag je bestaande collecties niet zomaar vervangen;
// je moet entiteiten toevoegen aan/verwijderen uit bestaande collecties.
Assert.AreEqual(leiding.Functie, leidingsFuncties);
}