993 lines
43 KiB
C#
993 lines
43 KiB
C#
using Elwig.Helpers;
|
|
using Elwig.Models.Entities;
|
|
using Elwig.Services;
|
|
using Elwig.ViewModels;
|
|
using Microsoft.EntityFrameworkCore;
|
|
|
|
namespace Tests.UnitTests.ServiceTests {
|
|
[TestFixture]
|
|
public class DeliveryServiceTest {
|
|
|
|
private static async Task InitViewModel(DeliveryAdminViewModel vm) {
|
|
using var ctx = new AppDbContext();
|
|
vm.MemberSource = await ctx.FetchMembers(includeNotActive: true).ToListAsync();
|
|
vm.BranchSource = await ctx.FetchBranches().ToListAsync();
|
|
vm.WineVarSource = await ctx.FetchWineVarieties().ToListAsync();
|
|
List<object> attrs = await ctx.FetchWineAttributes().Cast<object>().ToListAsync();
|
|
attrs.Insert(0, new NullItem());
|
|
vm.WineAttrSource = attrs;
|
|
List<object> cults = await ctx.FetchWineCultivations().Cast<object>().ToListAsync();
|
|
cults.Insert(0, new NullItem());
|
|
vm.WineCultSource = cults;
|
|
vm.WineQualityLevelSource = await ctx.FetchWineQualityLevels().ToListAsync();
|
|
vm.WineOriginSource = await ctx.WineOrigins.ToListAsync();
|
|
vm.WineKgSource = await ctx.Katastralgemeinden.ToListAsync();
|
|
vm.ModifiersSource = await ctx.FetchModifiers(2022).ToListAsync();
|
|
}
|
|
|
|
private static async Task<Delivery?> GetDelivery(string lsnr) {
|
|
using var ctx = new AppDbContext();
|
|
return await ctx.Deliveries
|
|
.Where(d => d.LsNr == lsnr)
|
|
.Include(d => d.Parts)
|
|
.ThenInclude(p => p.PartModifiers)
|
|
.ThenInclude(m => m.Modifier)
|
|
.FirstOrDefaultAsync();
|
|
}
|
|
|
|
private static DeliveryPart[] GetParts(Delivery d) {
|
|
return [.. d.Parts.OrderBy(p => p.DPNr)];
|
|
}
|
|
|
|
[Test]
|
|
public async Task TestCreate_01_Minimal() {
|
|
var vm = new DeliveryAdminViewModel();
|
|
await InitViewModel(vm);
|
|
|
|
vm.Date = "01.10.2022";
|
|
vm.Branch = vm.BranchSource.First();
|
|
vm.MgNr = 101;
|
|
vm.Member = vm.MemberSource.First(m => m.MgNr == vm.MgNr);
|
|
vm.SortId = "GV";
|
|
vm.WineVar = vm.WineVarSource.First(v => v.SortId == vm.SortId);
|
|
vm.GradationKmw = 15.0;
|
|
vm.GradationOe = 73;
|
|
vm.Weight = 1234;
|
|
vm.IsManualWeighing = true;
|
|
vm.IsNetWeight = false;
|
|
vm.WineQualityLevel = vm.WineQualityLevelSource.First(l => l.QualId == "QUW");
|
|
vm.WineOrigin = vm.WineOriginSource.First(o => o.HkId == "WLNO");
|
|
|
|
var p1 = await vm.UpdateDeliveryPart(2022, null, null, false, false, true);
|
|
Assert.That(p1.Delivery.LsNr, Is.EqualTo("20221001X001"));
|
|
|
|
var d = await GetDelivery("20221001X001");
|
|
|
|
Assert.That(d, Is.Not.Null);
|
|
Assert.That(d.Parts, Has.Count.EqualTo(1));
|
|
var p = d.Parts.First();
|
|
Assert.That(p, Is.Not.Null);
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(d.LsNr, Is.EqualTo("20221001X001"));
|
|
Assert.That(d.Date, Is.EqualTo(new DateOnly(2022, 10, 1)));
|
|
Assert.That(d.ZwstId, Is.EqualTo("X"));
|
|
Assert.That(d.MgNr, Is.EqualTo(101));
|
|
Assert.That(p.SortId, Is.EqualTo("GV"));
|
|
Assert.That(p.AttrId, Is.Null);
|
|
Assert.That(p.CultId, Is.Null);
|
|
Assert.That(p.Kmw, Is.EqualTo(15.0));
|
|
Assert.That(p.Oe, Is.EqualTo(73));
|
|
Assert.That(p.QualId, Is.EqualTo("QUW"));
|
|
Assert.That(p.Weight, Is.EqualTo(1234));
|
|
Assert.That(p.IsNetWeight, Is.False);
|
|
Assert.That(p.IsManualWeighing, Is.True);
|
|
Assert.That(p.HkId, Is.EqualTo("WLNO"));
|
|
}
|
|
|
|
vm = new DeliveryAdminViewModel();
|
|
await InitViewModel(vm);
|
|
Assert.DoesNotThrow(() => {
|
|
vm.FillInputs(d);
|
|
vm.FillInputs(p);
|
|
});
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(vm.LsNr, Is.EqualTo("20221001X001"));
|
|
Assert.That(vm.Date, Is.EqualTo("01.10.2022"));
|
|
Assert.That(vm.Branch?.ZwstId, Is.EqualTo("X"));
|
|
Assert.That(vm.MgNr, Is.EqualTo(101));
|
|
Assert.That(vm.SortId, Is.EqualTo("GV"));
|
|
Assert.That(vm.WineAttr?.AttrId, Is.Null);
|
|
Assert.That(vm.WineCult?.CultId, Is.Null);
|
|
Assert.That(vm.GradationKmw, Is.EqualTo(15.0));
|
|
Assert.That(vm.WineQualityLevel?.QualId, Is.EqualTo("QUW"));
|
|
Assert.That(vm.Weight, Is.EqualTo(1234));
|
|
Assert.That(vm.IsNetWeight, Is.False);
|
|
Assert.That(vm.IsManualWeighing, Is.True);
|
|
Assert.That(vm.WineOrigin?.HkId, Is.EqualTo("WLNO"));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task TestCreate_02_Advanced() {
|
|
var vm = new DeliveryAdminViewModel();
|
|
await InitViewModel(vm);
|
|
|
|
vm.Date = "02.10.2022";
|
|
vm.Branch = vm.BranchSource.First();
|
|
vm.MgNr = 102;
|
|
vm.Member = vm.MemberSource.First(m => m.MgNr == vm.MgNr);
|
|
vm.SortId = "ZW";
|
|
vm.WineVar = vm.WineVarSource.First(v => v.SortId == vm.SortId);
|
|
vm.WineAttr = vm.WineAttrSource.Skip(1).First() as WineAttr;
|
|
vm.WineCult = vm.WineCultSource.Skip(1).First() as WineCult;
|
|
vm.GradationKmw = 15.9;
|
|
vm.GradationOe = 78;
|
|
vm.Weight = 3456;
|
|
vm.IsManualWeighing = false;
|
|
vm.IsNetWeight = true;
|
|
vm.WeighingData = "{}";
|
|
vm.WineQualityLevel = vm.WineQualityLevelSource.First(l => l.QualId == "QUW");
|
|
vm.WineOrigin = vm.WineOriginSource.First(o => o.HkId == "WLNO");
|
|
vm.Modifiers.Add(vm.ModifiersSource.First());
|
|
|
|
var p1 = await vm.UpdateDeliveryPart(2022, null, null, false, false, true);
|
|
Assert.That(p1.Delivery.LsNr, Is.EqualTo("20221002X001"));
|
|
|
|
var d = await GetDelivery("20221002X001");
|
|
|
|
Assert.That(d, Is.Not.Null);
|
|
Assert.That(d.Parts, Has.Count.EqualTo(1));
|
|
var p = d.Parts.First();
|
|
Assert.That(p, Is.Not.Null);
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(d.LsNr, Is.EqualTo("20221002X001"));
|
|
Assert.That(d.Date, Is.EqualTo(new DateOnly(2022, 10, 2)));
|
|
Assert.That(d.ZwstId, Is.EqualTo("X"));
|
|
Assert.That(d.MgNr, Is.EqualTo(102));
|
|
Assert.That(p.SortId, Is.EqualTo("ZW"));
|
|
Assert.That(p.AttrId, Is.Not.Null);
|
|
Assert.That(p.CultId, Is.Not.Null);
|
|
Assert.That(p.Kmw, Is.EqualTo(15.9));
|
|
Assert.That(p.Oe, Is.EqualTo(78));
|
|
Assert.That(p.QualId, Is.EqualTo("QUW"));
|
|
Assert.That(p.Weight, Is.EqualTo(3456));
|
|
Assert.That(p.IsNetWeight, Is.True);
|
|
Assert.That(p.IsManualWeighing, Is.False);
|
|
Assert.That(p.WeighingData, Is.EqualTo("{}"));
|
|
Assert.That(p.HkId, Is.EqualTo("WLNO"));
|
|
Assert.That(p.Modifiers.Count(), Is.EqualTo(1));
|
|
}
|
|
|
|
vm = new DeliveryAdminViewModel();
|
|
await InitViewModel(vm);
|
|
Assert.DoesNotThrow(() => {
|
|
vm.FillInputs(d);
|
|
vm.FillInputs(p);
|
|
});
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(vm.LsNr, Is.EqualTo("20221002X001"));
|
|
Assert.That(vm.Date, Is.EqualTo("02.10.2022"));
|
|
Assert.That(vm.Branch?.ZwstId, Is.EqualTo("X"));
|
|
Assert.That(vm.MgNr, Is.EqualTo(102));
|
|
Assert.That(vm.SortId, Is.EqualTo("ZW"));
|
|
Assert.That(vm.WineAttr?.AttrId, Is.Not.Null);
|
|
Assert.That(vm.WineCult?.CultId, Is.Not.Null);
|
|
Assert.That(vm.GradationKmw, Is.EqualTo(15.9));
|
|
Assert.That(vm.WineQualityLevel?.QualId, Is.EqualTo("QUW"));
|
|
Assert.That(vm.Weight, Is.EqualTo(3456));
|
|
Assert.That(vm.IsNetWeight, Is.True);
|
|
Assert.That(vm.IsManualWeighing, Is.False);
|
|
Assert.That(vm.WeighingData, Is.EqualTo("{}"));
|
|
Assert.That(vm.WineOrigin?.HkId, Is.EqualTo("WLNO"));
|
|
Assert.That(vm.Modifiers, Has.Count.EqualTo(1));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task TestCreate_03_TwoParts() {
|
|
var vm = new DeliveryAdminViewModel();
|
|
await InitViewModel(vm);
|
|
|
|
vm.Date = "03.10.2022";
|
|
vm.Branch = vm.BranchSource.First();
|
|
vm.MgNr = 101;
|
|
vm.Member = vm.MemberSource.First(m => m.MgNr == vm.MgNr);
|
|
vm.SortId = "GV";
|
|
vm.WineVar = vm.WineVarSource.First(v => v.SortId == vm.SortId);
|
|
vm.GradationKmw = 15.0;
|
|
vm.GradationOe = 73;
|
|
vm.WineQualityLevel = vm.WineQualityLevelSource.First(l => l.QualId == "QUW");
|
|
vm.Weight = 1234;
|
|
vm.IsManualWeighing = true;
|
|
vm.IsNetWeight = true;
|
|
vm.WineOrigin = vm.WineOriginSource.First(o => o.HkId == "WLNO");
|
|
var p1 = await vm.UpdateDeliveryPart(2022, null, null, false, false, true);
|
|
|
|
Assert.That(p1.Delivery.LsNr, Is.EqualTo("20221003X001"));
|
|
vm.FillInputs(p1.Delivery);
|
|
|
|
vm.SortId = "WR";
|
|
vm.WineVar = vm.WineVarSource.First(v => v.SortId == vm.SortId);
|
|
vm.GradationKmw = 18.0;
|
|
vm.GradationOe = 89;
|
|
vm.WineQualityLevel = vm.WineQualityLevelSource.First(l => l.QualId == "KAB");
|
|
vm.Weight = 2345;
|
|
var p2 = await vm.UpdateDeliveryPart(p1.Year, p1.DId, null, false, false, true);
|
|
|
|
Assert.That(p2.Delivery.LsNr, Is.EqualTo("20221003X001"));
|
|
|
|
var d = await GetDelivery("20221003X001");
|
|
|
|
Assert.That(d, Is.Not.Null);
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(d.Parts, Has.Count.EqualTo(2));
|
|
Assert.That(d.MgNr, Is.EqualTo(101));
|
|
}
|
|
var p = d.Parts.First();
|
|
Assert.That(p, Is.Not.Null);
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(p.DPNr, Is.EqualTo(1));
|
|
Assert.That(p.SortId, Is.EqualTo("GV"));
|
|
}
|
|
p = d.Parts.Skip(1).First();
|
|
Assert.That(p, Is.Not.Null);
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(p.DPNr, Is.EqualTo(2));
|
|
Assert.That(p.SortId, Is.EqualTo("WR"));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task TestCreate_04_ChangeMember() {
|
|
var vm = new DeliveryAdminViewModel();
|
|
await InitViewModel(vm);
|
|
|
|
vm.Date = "04.10.2022";
|
|
vm.Branch = vm.BranchSource.First();
|
|
vm.MgNr = 101;
|
|
vm.Member = vm.MemberSource.First(m => m.MgNr == vm.MgNr);
|
|
vm.SortId = "GV";
|
|
vm.WineVar = vm.WineVarSource.First(v => v.SortId == vm.SortId);
|
|
vm.GradationKmw = 15.0;
|
|
vm.GradationOe = 73;
|
|
vm.WineQualityLevel = vm.WineQualityLevelSource.First(l => l.QualId == "QUW");
|
|
vm.Weight = 1234;
|
|
vm.IsManualWeighing = true;
|
|
vm.IsNetWeight = true;
|
|
vm.WineOrigin = vm.WineOriginSource.First(o => o.HkId == "WLNO");
|
|
var p1 = await vm.UpdateDeliveryPart(2022, null, null, false, false, true);
|
|
|
|
Assert.That(p1.Delivery.LsNr, Is.EqualTo("20221004X001"));
|
|
vm.FillInputs(p1.Delivery);
|
|
|
|
vm.MgNr = 102;
|
|
vm.Member = vm.MemberSource.First(m => m.MgNr == vm.MgNr);
|
|
vm.SortId = "GV";
|
|
vm.WineVar = vm.WineVarSource.First(v => v.SortId == vm.SortId);
|
|
vm.GradationKmw = 15.0;
|
|
vm.GradationOe = 73;
|
|
vm.WineQualityLevel = vm.WineQualityLevelSource.First(l => l.QualId == "QUW");
|
|
vm.Weight = 1234;
|
|
vm.IsManualWeighing = true;
|
|
vm.IsNetWeight = true;
|
|
vm.WineOrigin = vm.WineOriginSource.First(o => o.HkId == "WLNO");
|
|
|
|
var p2 = await vm.UpdateDeliveryPart(p1.Year, p1.DId, null, false, false, true);
|
|
|
|
Assert.That(p2.Delivery.LsNr, Is.EqualTo("20221004X001"));
|
|
|
|
var d = await GetDelivery("20221004X001");
|
|
|
|
Assert.That(d, Is.Not.Null);
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(d.Parts, Has.Count.EqualTo(2));
|
|
Assert.That(d.MgNr, Is.EqualTo(102));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task TestCreate_05_LNrChanged() {
|
|
var vm = new DeliveryAdminViewModel();
|
|
await InitViewModel(vm);
|
|
|
|
vm.Date = "29.09.2022";
|
|
vm.Branch = vm.BranchSource.First();
|
|
vm.LsNr = "20220929X001"; // "old" LNr, simulated change in DB
|
|
vm.MgNr = 101;
|
|
vm.Member = vm.MemberSource.First(m => m.MgNr == vm.MgNr);
|
|
vm.SortId = "GV";
|
|
vm.WineVar = vm.WineVarSource.First(v => v.SortId == vm.SortId);
|
|
vm.GradationKmw = 15.0;
|
|
vm.GradationOe = 73;
|
|
vm.WineQualityLevel = vm.WineQualityLevelSource.First(l => l.QualId == "QUW");
|
|
vm.Weight = 1234;
|
|
vm.IsManualWeighing = true;
|
|
vm.IsNetWeight = true;
|
|
vm.WineOrigin = vm.WineOriginSource.First(o => o.HkId == "WLNO");
|
|
var p1 = await vm.UpdateDeliveryPart(2022, null, null, false, false, true);
|
|
|
|
Assert.That(p1.Delivery.LsNr, Is.EqualTo("20220929X002"));
|
|
|
|
var d = GetDelivery("20220929X002");
|
|
Assert.That(d, Is.Not.Null);
|
|
}
|
|
|
|
[Test]
|
|
public async Task TestUpdate_01_Simple() {
|
|
var vm = new DeliveryAdminViewModel();
|
|
await InitViewModel(vm);
|
|
|
|
var d = await GetDelivery("20231010X001");
|
|
Assert.That(d, Is.Not.Null);
|
|
var p = d.Parts.First();
|
|
Assert.That(p, Is.Not.Null);
|
|
Assert.DoesNotThrow(() => {
|
|
vm.FillInputs(d);
|
|
vm.FillInputs(p);
|
|
});
|
|
|
|
vm.SortId = "WR";
|
|
vm.WineVar = vm.WineVarSource.First(v => v.SortId == vm.SortId);
|
|
vm.GradationKmw = 15.9;
|
|
vm.GradationOe = 79;
|
|
|
|
Assert.DoesNotThrowAsync(async () => await DeliveryService.UpdateDeliveryPart(vm, p.Year, p.DId, p.DPNr, false, false, true));
|
|
|
|
d = await GetDelivery("20231010X001");
|
|
Assert.That(d, Is.Not.Null);
|
|
p = d.Parts.First();
|
|
Assert.That(p, Is.Not.Null);
|
|
|
|
vm = new DeliveryAdminViewModel();
|
|
await InitViewModel(vm);
|
|
Assert.DoesNotThrow(() => {
|
|
vm.FillInputs(d);
|
|
vm.FillInputs(p);
|
|
});
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(vm.SortId, Is.EqualTo("WR"));
|
|
Assert.That(vm.GradationKmw, Is.EqualTo(15.9));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task TestUpdate_02_Member() {
|
|
var vm = new DeliveryAdminViewModel();
|
|
await InitViewModel(vm);
|
|
|
|
var d = await GetDelivery("20231010X002");
|
|
Assert.That(d, Is.Not.Null);
|
|
var p = d.Parts.First();
|
|
Assert.That(p, Is.Not.Null);
|
|
Assert.DoesNotThrow(() => {
|
|
vm.FillInputs(d);
|
|
vm.FillInputs(p);
|
|
});
|
|
Assert.That(d.MgNr, Is.EqualTo(101));
|
|
|
|
vm.SortId = "GV";
|
|
vm.WineVar = vm.WineVarSource.First(v => v.SortId == vm.SortId);
|
|
vm.MgNr = 102;
|
|
vm.Member = vm.MemberSource.First(m => m.MgNr == vm.MgNr);
|
|
|
|
Assert.DoesNotThrowAsync(async () => await DeliveryService.UpdateDeliveryPart(vm, p.Year, p.DId, p.DPNr, false, false, true));
|
|
|
|
d = await GetDelivery("20231010X002");
|
|
Assert.That(d, Is.Not.Null);
|
|
Assert.That(d.MgNr, Is.EqualTo(102));
|
|
}
|
|
|
|
[Test]
|
|
public async Task TestUpdate_03_DateAndTime() {
|
|
var vm = new DeliveryAdminViewModel();
|
|
await InitViewModel(vm);
|
|
|
|
var d = await GetDelivery("20231015X001");
|
|
Assert.That(d, Is.Null);
|
|
d = await GetDelivery("20231010X003");
|
|
Assert.That(d, Is.Not.Null);
|
|
var p = d.Parts.First();
|
|
Assert.That(p, Is.Not.Null);
|
|
Assert.DoesNotThrow(() => {
|
|
vm.FillInputs(d);
|
|
vm.FillInputs(p);
|
|
});
|
|
Assert.That(d.MgNr, Is.EqualTo(101));
|
|
|
|
vm.SortId = "GV";
|
|
vm.WineVar = vm.WineVarSource.First(v => v.SortId == vm.SortId);
|
|
vm.Date = "15.10.2023";
|
|
vm.Time = "12:00";
|
|
|
|
Assert.DoesNotThrowAsync(async () => await DeliveryService.UpdateDeliveryPart(vm, p.Year, p.DId, p.DPNr, true, true, false));
|
|
|
|
d = await GetDelivery("20231010X003");
|
|
Assert.That(d, Is.Null);
|
|
d = await GetDelivery("20231015X001");
|
|
Assert.That(d, Is.Not.Null);
|
|
}
|
|
|
|
[Test]
|
|
public async Task TestSplit_01_Depreciate_One() {
|
|
var d = await GetDelivery("20231001X001");
|
|
Assert.That(d, Is.Not.Null);
|
|
using (Assert.EnterMultipleScope()) {
|
|
var ps = GetParts(d);
|
|
Assert.That(ps, Has.Length.EqualTo(3));
|
|
Assert.That(ps[0].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps[0].QualId, Is.Not.EqualTo("WEI"));
|
|
Assert.That(ps[1].QualId, Is.Not.EqualTo("WEI"));
|
|
Assert.That(ps[2].QualId, Is.Not.EqualTo("WEI"));
|
|
}
|
|
|
|
Assert.DoesNotThrowAsync(async () => await DeliveryService.DepreciateDelivery(d.Year, d.DId, [1000, 0, 0]));
|
|
d = await GetDelivery("20231001X001");
|
|
Assert.That(d, Is.Not.Null);
|
|
using (Assert.EnterMultipleScope()) {
|
|
var ps = GetParts(d);
|
|
Assert.That(ps, Has.Length.EqualTo(3));
|
|
Assert.That(ps[0].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps[0].QualId, Is.EqualTo("WEI"));
|
|
Assert.That(ps[1].QualId, Is.Not.EqualTo("WEI"));
|
|
Assert.That(ps[2].QualId, Is.Not.EqualTo("WEI"));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task TestSplit_02_Depreciate_Partial() {
|
|
var d = await GetDelivery("20231001X002");
|
|
Assert.That(d, Is.Not.Null);
|
|
using (Assert.EnterMultipleScope()) {
|
|
var ps = GetParts(d);
|
|
Assert.That(ps, Has.Length.EqualTo(3));
|
|
Assert.That(ps[0].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps[0].QualId, Is.Not.EqualTo("WEI"));
|
|
Assert.That(ps[1].QualId, Is.Not.EqualTo("WEI"));
|
|
Assert.That(ps[2].QualId, Is.Not.EqualTo("WEI"));
|
|
}
|
|
|
|
Assert.DoesNotThrowAsync(async () => await DeliveryService.DepreciateDelivery(d.Year, d.DId, [600, 0, 0]));
|
|
d = await GetDelivery("20231001X002");
|
|
Assert.That(d, Is.Not.Null);
|
|
using (Assert.EnterMultipleScope()) {
|
|
var ps = GetParts(d);
|
|
Assert.That(ps, Has.Length.EqualTo(4));
|
|
Assert.That(ps[0].Weight, Is.EqualTo(400));
|
|
Assert.That(ps[0].QualId, Is.Not.EqualTo("WEI"));
|
|
Assert.That(ps[1].QualId, Is.Not.EqualTo("WEI"));
|
|
Assert.That(ps[2].QualId, Is.Not.EqualTo("WEI"));
|
|
Assert.That(ps[3].Weight, Is.EqualTo(600));
|
|
Assert.That(ps[3].QualId, Is.EqualTo("WEI"));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task TestSplit_03_Depreciate_Mixed() {
|
|
var d = await GetDelivery("20231001X003");
|
|
Assert.That(d, Is.Not.Null);
|
|
using (Assert.EnterMultipleScope()) {
|
|
var ps = GetParts(d);
|
|
Assert.That(ps, Has.Length.EqualTo(3));
|
|
Assert.That(ps[0].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps[0].QualId, Is.Not.EqualTo("WEI"));
|
|
Assert.That(ps[1].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps[1].QualId, Is.Not.EqualTo("WEI"));
|
|
Assert.That(ps[2].QualId, Is.Not.EqualTo("WEI"));
|
|
}
|
|
|
|
Assert.DoesNotThrowAsync(async () => await DeliveryService.DepreciateDelivery(d.Year, d.DId, [1000, 700, -5]));
|
|
d = await GetDelivery("20231001X003");
|
|
Assert.That(d, Is.Not.Null);
|
|
using (Assert.EnterMultipleScope()) {
|
|
var ps = GetParts(d);
|
|
Assert.That(ps, Has.Length.EqualTo(4));
|
|
Assert.That(ps[0].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps[0].QualId, Is.EqualTo("WEI"));
|
|
Assert.That(ps[1].Weight, Is.EqualTo(300));
|
|
Assert.That(ps[1].QualId, Is.Not.EqualTo("WEI"));
|
|
Assert.That(ps[2].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps[2].QualId, Is.Not.EqualTo("WEI"));
|
|
Assert.That(ps[3].Weight, Is.EqualTo(700));
|
|
Assert.That(ps[3].QualId, Is.EqualTo("WEI"));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task TestSplit_04_Depreciate_Complete() {
|
|
var d = await GetDelivery("20231001X004");
|
|
Assert.That(d, Is.Not.Null);
|
|
using (Assert.EnterMultipleScope()) {
|
|
var ps = GetParts(d);
|
|
Assert.That(ps, Has.Length.EqualTo(3));
|
|
Assert.That(ps[0].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps[0].QualId, Is.Not.EqualTo("WEI"));
|
|
Assert.That(ps[1].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps[1].QualId, Is.Not.EqualTo("WEI"));
|
|
Assert.That(ps[2].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps[2].QualId, Is.Not.EqualTo("WEI"));
|
|
}
|
|
|
|
Assert.DoesNotThrowAsync(async () => await DeliveryService.DepreciateDelivery(d.Year, d.DId, [1000, 1100, int.MaxValue]));
|
|
d = await GetDelivery("20231001X004");
|
|
Assert.That(d, Is.Not.Null);
|
|
using (Assert.EnterMultipleScope()) {
|
|
var ps = GetParts(d);
|
|
Assert.That(ps, Has.Length.EqualTo(3));
|
|
Assert.That(ps[0].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps[0].QualId, Is.EqualTo("WEI"));
|
|
Assert.That(ps[1].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps[1].QualId, Is.EqualTo("WEI"));
|
|
Assert.That(ps[2].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps[2].QualId, Is.EqualTo("WEI"));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task TestSplit_05_OtherMember_One() {
|
|
var d1 = await GetDelivery("20231002X001");
|
|
var d2 = await GetDelivery("20231002X002");
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(d1, Is.Not.Null);
|
|
Assert.That(d2, Is.Null);
|
|
}
|
|
using (Assert.EnterMultipleScope()) {
|
|
var ps1 = GetParts(d1);
|
|
Assert.That(d1.MgNr, Is.EqualTo(101));
|
|
Assert.That(ps1, Has.Length.EqualTo(3));
|
|
Assert.That(ps1[0].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps1[1].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps1[2].Weight, Is.EqualTo(1000));
|
|
}
|
|
|
|
Assert.DoesNotThrowAsync(async () => await DeliveryService.SplitDeliveryToMember(d1.Year, d1.DId, [1000, 0, 0], 102));
|
|
d1 = await GetDelivery("20231002X001");
|
|
d2 = await GetDelivery("20231002X002");
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(d1, Is.Not.Null);
|
|
Assert.That(d2, Is.Not.Null);
|
|
}
|
|
using (Assert.EnterMultipleScope()) {
|
|
var ps1 = GetParts(d1);
|
|
var ps2 = GetParts(d2);
|
|
Assert.That(d1.MgNr, Is.EqualTo(101));
|
|
Assert.That(d2.MgNr, Is.EqualTo(102));
|
|
Assert.That(ps1, Has.Length.EqualTo(2));
|
|
Assert.That(ps1[0].DPNr, Is.EqualTo(2));
|
|
Assert.That(ps1[0].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps1[1].DPNr, Is.EqualTo(3));
|
|
Assert.That(ps1[1].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps2, Has.Length.EqualTo(1));
|
|
Assert.That(ps2[0].DPNr, Is.EqualTo(1));
|
|
Assert.That(ps2[0].Weight, Is.EqualTo(1000));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task TestSplit_06_OtherMember_Partial() {
|
|
var d1 = await GetDelivery("20231003X001");
|
|
var d2 = await GetDelivery("20231003X002");
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(d1, Is.Not.Null);
|
|
Assert.That(d2, Is.Null);
|
|
}
|
|
using (Assert.EnterMultipleScope()) {
|
|
var ps1 = GetParts(d1);
|
|
Assert.That(d1.MgNr, Is.EqualTo(101));
|
|
Assert.That(ps1, Has.Length.EqualTo(3));
|
|
Assert.That(ps1[0].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps1[1].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps1[2].Weight, Is.EqualTo(1000));
|
|
}
|
|
|
|
Assert.DoesNotThrowAsync(async () => await DeliveryService.SplitDeliveryToMember(d1.Year, d1.DId, [400, -1, -2], 102));
|
|
d1 = await GetDelivery("20231003X001");
|
|
d2 = await GetDelivery("20231003X002");
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(d1, Is.Not.Null);
|
|
Assert.That(d2, Is.Not.Null);
|
|
}
|
|
using (Assert.EnterMultipleScope()) {
|
|
var ps1 = GetParts(d1);
|
|
var ps2 = GetParts(d2);
|
|
Assert.That(d1.MgNr, Is.EqualTo(101));
|
|
Assert.That(d2.MgNr, Is.EqualTo(102));
|
|
Assert.That(ps1, Has.Length.EqualTo(3));
|
|
Assert.That(ps1[0].Weight, Is.EqualTo(600));
|
|
Assert.That(ps1[1].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps1[2].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps2, Has.Length.EqualTo(1));
|
|
Assert.That(ps2[0].Weight, Is.EqualTo(400));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task TestSplit_07_OtherMember_Mixed() {
|
|
var d1 = await GetDelivery("20231004X001");
|
|
var d2 = await GetDelivery("20231004X002");
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(d1, Is.Not.Null);
|
|
Assert.That(d2, Is.Null);
|
|
}
|
|
using (Assert.EnterMultipleScope()) {
|
|
var ps1 = GetParts(d1);
|
|
Assert.That(d1.MgNr, Is.EqualTo(101));
|
|
Assert.That(ps1, Has.Length.EqualTo(3));
|
|
Assert.That(ps1[0].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps1[1].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps1[2].Weight, Is.EqualTo(1000));
|
|
}
|
|
|
|
Assert.DoesNotThrowAsync(async () => await DeliveryService.SplitDeliveryToMember(d1.Year, d1.DId, [200, 1000, int.MinValue], 102));
|
|
d1 = await GetDelivery("20231004X001");
|
|
d2 = await GetDelivery("20231004X002");
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(d1, Is.Not.Null);
|
|
Assert.That(d2, Is.Not.Null);
|
|
}
|
|
using (Assert.EnterMultipleScope()) {
|
|
var ps1 = GetParts(d1);
|
|
var ps2 = GetParts(d2);
|
|
Assert.That(d1.MgNr, Is.EqualTo(101));
|
|
Assert.That(d2.MgNr, Is.EqualTo(102));
|
|
Assert.That(ps1, Has.Length.EqualTo(2));
|
|
Assert.That(ps1[0].DPNr, Is.EqualTo(1));
|
|
Assert.That(ps1[0].Weight, Is.EqualTo(800));
|
|
Assert.That(ps1[1].DPNr, Is.EqualTo(3));
|
|
Assert.That(ps1[1].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps2, Has.Length.EqualTo(2));
|
|
Assert.That(ps2[0].DPNr, Is.EqualTo(1));
|
|
Assert.That(ps2[0].Weight, Is.EqualTo(200));
|
|
Assert.That(ps2[1].DPNr, Is.EqualTo(2));
|
|
Assert.That(ps2[1].Weight, Is.EqualTo(1000));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task TestSplit_08_OtherMember_Complete() {
|
|
var d1 = await GetDelivery("20231005X001");
|
|
var d2 = await GetDelivery("20231005X002");
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(d1, Is.Not.Null);
|
|
Assert.That(d2, Is.Null);
|
|
}
|
|
using (Assert.EnterMultipleScope()) {
|
|
var ps1 = GetParts(d1);
|
|
Assert.That(d1.MgNr, Is.EqualTo(101));
|
|
Assert.That(ps1, Has.Length.EqualTo(3));
|
|
Assert.That(ps1[0].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps1[1].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps1[2].Weight, Is.EqualTo(1000));
|
|
}
|
|
|
|
Assert.DoesNotThrowAsync(async () => await DeliveryService.SplitDeliveryToMember(d1.Year, d1.DId, [1000, int.MaxValue, 1100], 102));
|
|
d1 = await GetDelivery("20231005X001");
|
|
d2 = await GetDelivery("20231005X002");
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(d1, Is.Null);
|
|
Assert.That(d2, Is.Not.Null);
|
|
}
|
|
using (Assert.EnterMultipleScope()) {
|
|
var ps2 = GetParts(d2);
|
|
Assert.That(d2.MgNr, Is.EqualTo(102));
|
|
Assert.That(ps2, Has.Length.EqualTo(3));
|
|
Assert.That(ps2[0].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps2[1].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps2[2].Weight, Is.EqualTo(1000));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task TestSplit_09_OtherDelivery_One() {
|
|
var d1 = await GetDelivery("20231006X001");
|
|
var d2 = await GetDelivery("20231006X002");
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(d1, Is.Not.Null);
|
|
Assert.That(d2, Is.Not.Null);
|
|
}
|
|
using (Assert.EnterMultipleScope()) {
|
|
var ps1 = GetParts(d1);
|
|
var ps2 = GetParts(d2);
|
|
Assert.That(ps1, Has.Length.EqualTo(3));
|
|
Assert.That(ps1[0].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps1[1].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps1[2].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps2, Has.Length.EqualTo(1));
|
|
Assert.That(ps2[0].Weight, Is.EqualTo(1000));
|
|
}
|
|
|
|
Assert.DoesNotThrowAsync(async () => await DeliveryService.SplitDeliveryToLsNr(d1.Year, d1.DId, [0, 1000, -4], d2.LsNr));
|
|
d1 = await GetDelivery("20231006X001");
|
|
d2 = await GetDelivery("20231006X002");
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(d1, Is.Not.Null);
|
|
Assert.That(d2, Is.Not.Null);
|
|
}
|
|
using (Assert.EnterMultipleScope()) {
|
|
var ps1 = GetParts(d1);
|
|
var ps2 = GetParts(d2);
|
|
Assert.That(ps1, Has.Length.EqualTo(2));
|
|
Assert.That(ps1[0].DPNr, Is.EqualTo(1));
|
|
Assert.That(ps1[0].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps1[1].DPNr, Is.EqualTo(3));
|
|
Assert.That(ps1[1].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps2, Has.Length.EqualTo(2));
|
|
Assert.That(ps2[0].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps2[1].Weight, Is.EqualTo(1000));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task TestSplit_10_OtherDelivery_Partial() {
|
|
var d1 = await GetDelivery("20231007X001");
|
|
var d2 = await GetDelivery("20231007X002");
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(d1, Is.Not.Null);
|
|
Assert.That(d2, Is.Not.Null);
|
|
}
|
|
using (Assert.EnterMultipleScope()) {
|
|
var ps1 = GetParts(d1);
|
|
var ps2 = GetParts(d2);
|
|
Assert.That(ps1, Has.Length.EqualTo(3));
|
|
Assert.That(ps1[0].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps1[1].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps1[2].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps2, Has.Length.EqualTo(1));
|
|
Assert.That(ps2[0].Weight, Is.EqualTo(1000));
|
|
}
|
|
|
|
Assert.DoesNotThrowAsync(async () => await DeliveryService.SplitDeliveryToLsNr(d1.Year, d1.DId, [0, 300, int.MinValue], d2.LsNr));
|
|
d1 = await GetDelivery("20231007X001");
|
|
d2 = await GetDelivery("20231007X002");
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(d1, Is.Not.Null);
|
|
Assert.That(d2, Is.Not.Null);
|
|
}
|
|
using (Assert.EnterMultipleScope()) {
|
|
var ps1 = GetParts(d1);
|
|
var ps2 = GetParts(d2);
|
|
Assert.That(ps1, Has.Length.EqualTo(3));
|
|
Assert.That(ps1[0].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps1[1].Weight, Is.EqualTo(700));
|
|
Assert.That(ps1[2].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps2, Has.Length.EqualTo(2));
|
|
Assert.That(ps2[0].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps2[1].Weight, Is.EqualTo(300));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task TestSplit_11_OtherDelivery_Mixed() {
|
|
var d1 = await GetDelivery("20231008X001");
|
|
var d2 = await GetDelivery("20231008X002");
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(d1, Is.Not.Null);
|
|
Assert.That(d2, Is.Not.Null);
|
|
}
|
|
using (Assert.EnterMultipleScope()) {
|
|
var ps1 = GetParts(d1);
|
|
var ps2 = GetParts(d2);
|
|
Assert.That(ps1, Has.Length.EqualTo(3));
|
|
Assert.That(ps1[0].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps1[1].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps1[2].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps2, Has.Length.EqualTo(1));
|
|
Assert.That(ps2[0].Weight, Is.EqualTo(1000));
|
|
}
|
|
|
|
Assert.DoesNotThrowAsync(async () => await DeliveryService.SplitDeliveryToLsNr(d1.Year, d1.DId, [850, 1000, -4], d2.LsNr));
|
|
d1 = await GetDelivery("20231008X001");
|
|
d2 = await GetDelivery("20231008X002");
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(d1, Is.Not.Null);
|
|
Assert.That(d2, Is.Not.Null);
|
|
}
|
|
using (Assert.EnterMultipleScope()) {
|
|
var ps1 = GetParts(d1);
|
|
var ps2 = GetParts(d2);
|
|
Assert.That(ps1, Has.Length.EqualTo(2));
|
|
Assert.That(ps1[0].DPNr, Is.EqualTo(1));
|
|
Assert.That(ps1[0].Weight, Is.EqualTo(150));
|
|
Assert.That(ps1[1].DPNr, Is.EqualTo(3));
|
|
Assert.That(ps1[1].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps2, Has.Length.EqualTo(3));
|
|
Assert.That(ps2[0].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps2[1].Weight, Is.EqualTo(850));
|
|
Assert.That(ps2[2].Weight, Is.EqualTo(1000));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task TestSplit_12_OtherDelivery_Complete() {
|
|
var d1 = await GetDelivery("20231009X001");
|
|
var d2 = await GetDelivery("20231009X002");
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(d1, Is.Not.Null);
|
|
Assert.That(d2, Is.Not.Null);
|
|
}
|
|
using (Assert.EnterMultipleScope()) {
|
|
var ps1 = GetParts(d1);
|
|
var ps2 = GetParts(d2);
|
|
Assert.That(ps1, Has.Length.EqualTo(3));
|
|
Assert.That(ps1[0].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps1[1].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps1[2].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps2, Has.Length.EqualTo(1));
|
|
Assert.That(ps2[0].Weight, Is.EqualTo(1000));
|
|
}
|
|
|
|
Assert.DoesNotThrowAsync(async () => await DeliveryService.SplitDeliveryToLsNr(d1.Year, d1.DId, [1200, int.MaxValue, 1000], d2.LsNr));
|
|
d1 = await GetDelivery("20231009X001");
|
|
d2 = await GetDelivery("20231009X002");
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(d1, Is.Null);
|
|
Assert.That(d2, Is.Not.Null);
|
|
}
|
|
using (Assert.EnterMultipleScope()) {
|
|
var ps2 = GetParts(d2);
|
|
Assert.That(ps2, Has.Length.EqualTo(4));
|
|
Assert.That(ps2[0].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps2[1].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps2[2].Weight, Is.EqualTo(1000));
|
|
Assert.That(ps2[3].Weight, Is.EqualTo(1000));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task TestDelete_01_Normal() {
|
|
using (var ctx = new AppDbContext()) {
|
|
Assert.That(await ctx.Deliveries.FindAsync(2022, 2), Is.Not.Null);
|
|
}
|
|
Assert.DoesNotThrowAsync(async () => await DeliveryService.DeleteDelivery("20220930X001"));
|
|
using (var ctx = new AppDbContext()) {
|
|
Assert.That(await ctx.Deliveries.FindAsync(2022, 2), Is.Null);
|
|
}
|
|
}
|
|
|
|
private static readonly DateTime[] DeliveryDates = [
|
|
new(2020, 10, 1, 17, 45, 0),
|
|
new(2020, 10, 1, 18, 30, 0),
|
|
|
|
new(2020, 10, 2, 8, 34, 0),
|
|
new(2020, 10, 2, 9, 45, 0),
|
|
new(2020, 10, 2, 10, 19, 0),
|
|
new(2020, 10, 2, 11, 22, 0),
|
|
new(2020, 10, 2, 13, 39, 0),
|
|
new(2020, 10, 2, 14, 2, 0),
|
|
new(2020, 10, 2, 15, 55, 0),
|
|
new(2020, 10, 2, 16, 28, 0),
|
|
new(2020, 10, 2, 17, 13, 0),
|
|
new(2020, 10, 2, 18, 10, 0),
|
|
|
|
new(2020, 10, 3, 8, 13, 0),
|
|
new(2020, 10, 3, 9, 39, 0),
|
|
new(2020, 10, 3, 10, 20, 0),
|
|
new(2020, 10, 3, 11, 46, 0),
|
|
new(2020, 10, 3, 13, 56, 0),
|
|
new(2020, 10, 3, 14, 4, 0),
|
|
new(2020, 10, 3, 15, 33, 0),
|
|
new(2020, 10, 3, 16, 23, 0),
|
|
new(2020, 10, 3, 17, 18, 0),
|
|
new(2020, 10, 3, 18, 19, 0),
|
|
new(2020, 10, 3, 19, 10, 0),
|
|
new(2020, 10, 3, 20, 25, 0),
|
|
|
|
new(2020, 10, 4, 5, 57, 0),
|
|
new(2020, 10, 4, 6, 13, 0),
|
|
new(2020, 10, 4, 7, 42, 0),
|
|
new(2020, 10, 4, 8, 34, 0),
|
|
new(2020, 10, 4, 9, 45, 0),
|
|
new(2020, 10, 4, 10, 19, 0),
|
|
new(2020, 10, 4, 11, 22, 0),
|
|
new(2020, 10, 4, 13, 39, 0),
|
|
new(2020, 10, 4, 14, 2, 0),
|
|
new(2020, 10, 4, 15, 55, 0),
|
|
new(2020, 10, 4, 16, 28, 0),
|
|
new(2020, 10, 4, 17, 13, 0),
|
|
new(2020, 10, 4, 18, 10, 0),
|
|
|
|
new(2020, 10, 5, 5, 57, 0),
|
|
new(2020, 10, 5, 6, 13, 0),
|
|
new(2020, 10, 5, 7, 42, 0),
|
|
new(2020, 10, 5, 8, 34, 0),
|
|
new(2020, 10, 5, 9, 45, 0),
|
|
new(2020, 10, 5, 10, 19, 0),
|
|
new(2020, 10, 5, 11, 22, 0),
|
|
new(2020, 10, 5, 13, 39, 0),
|
|
new(2020, 10, 5, 14, 2, 0),
|
|
new(2020, 10, 5, 15, 55, 0),
|
|
new(2020, 10, 5, 16, 28, 0),
|
|
new(2020, 10, 5, 17, 13, 0),
|
|
new(2020, 10, 5, 18, 10, 0),
|
|
new(2020, 10, 5, 19, 10, 0),
|
|
new(2020, 10, 5, 20, 25, 0),
|
|
|
|
new(2020, 10, 6, 16, 23, 0),
|
|
new(2020, 10, 6, 22, 24, 0),
|
|
new(2020, 10, 6, 23, 45, 0),
|
|
new(2020, 10, 7, 0, 32, 0),
|
|
new(2020, 10, 7, 1, 12, 0),
|
|
new(2020, 10, 7, 2, 16, 0),
|
|
new(2020, 10, 7, 3, 24, 0),
|
|
new(2020, 10, 7, 4, 9, 0),
|
|
new(2020, 10, 7, 5, 57, 0),
|
|
new(2020, 10, 7, 6, 41, 0),
|
|
new(2020, 10, 7, 7, 10, 0),
|
|
|
|
new(2020, 10, 7, 17, 23, 0),
|
|
new(2020, 10, 7, 18, 16, 0),
|
|
new(2020, 10, 7, 19, 39, 0),
|
|
new(2020, 10, 7, 20, 31, 0),
|
|
new(2020, 10, 7, 21, 23, 0),
|
|
new(2020, 10, 7, 22, 24, 0),
|
|
new(2020, 10, 7, 23, 45, 0),
|
|
new(2020, 10, 8, 0, 32, 0),
|
|
new(2020, 10, 8, 1, 12, 0),
|
|
new(2020, 10, 8, 2, 16, 0),
|
|
new(2020, 10, 8, 3, 24, 0),
|
|
new(2020, 10, 8, 4, 9, 0),
|
|
new(2020, 10, 8, 5, 57, 0),
|
|
new(2020, 10, 8, 6, 41, 0),
|
|
new(2020, 10, 8, 7, 10, 0),
|
|
|
|
new(2020, 10, 9, 7, 53, 0),
|
|
new(2020, 10, 9, 12, 36, 0),
|
|
new(2020, 10, 9, 16, 26, 0),
|
|
new(2020, 10, 9, 20, 19, 0),
|
|
];
|
|
|
|
[Test]
|
|
public void Test_GetFilterToday_01_Empty() {
|
|
Assert.That(DeliveryService.GetFilterToday(new(2020, 10, 10), DeliveryDates),
|
|
Is.Null);
|
|
}
|
|
|
|
[Test]
|
|
public void Test_GetFilterToday_02_Normal() {
|
|
Assert.That(DeliveryService.GetFilterToday(new(2020, 10, 2), DeliveryDates),
|
|
Is.EqualTo((new DateTime(2020, 10, 2, 8, 0, 0), new DateTime(2020, 10, 2, 19, 0, 0))));
|
|
}
|
|
|
|
[Test]
|
|
public void Test_GetFilterToday_03_Overtime() {
|
|
Assert.That(DeliveryService.GetFilterToday(new(2020, 10, 3), DeliveryDates),
|
|
Is.EqualTo((new DateTime(2020, 10, 3, 8, 0, 0), new DateTime(2020, 10, 3, 21, 0, 0))));
|
|
}
|
|
|
|
[Test]
|
|
public void Test_GetFilterToday_04_EarlyStart() {
|
|
Assert.That(DeliveryService.GetFilterToday(new(2020, 10, 4), DeliveryDates),
|
|
Is.EqualTo((new DateTime(2020, 10, 4, 5, 0, 0), new DateTime(2020, 10, 4, 19, 0, 0))));
|
|
}
|
|
|
|
[Test]
|
|
public void Test_GetFilterToday_05_EarlyStartAndOvertime() {
|
|
Assert.That(DeliveryService.GetFilterToday(new(2020, 10, 5), DeliveryDates),
|
|
Is.EqualTo((new DateTime(2020, 10, 5, 5, 0, 0), new DateTime(2020, 10, 5, 21, 0, 0))));
|
|
}
|
|
|
|
[Test]
|
|
public void Test_GetFilterToday_06_NightShift() {
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(DeliveryService.GetFilterToday(new(2020, 10, 6), DeliveryDates),
|
|
Is.EqualTo((new DateTime(2020, 10, 6, 22, 0, 0), new DateTime(2020, 10, 7, 0, 0, 0))));
|
|
Assert.That(DeliveryService.GetFilterToday(new(2020, 10, 7), DeliveryDates.Where(d => d <= new DateTime(2020, 10, 7, 12, 0, 0))),
|
|
Is.EqualTo((new DateTime(2020, 10, 6, 22, 0, 0), new DateTime(2020, 10, 7, 8, 0, 0))));
|
|
Assert.That(DeliveryService.GetFilterToday(new(2020, 10, 7), DeliveryDates.Where(d => d <= new DateTime(2020, 10, 7, 12, 0, 0)).Append(new(2020, 10, 7, 15, 10, 0))),
|
|
Is.EqualTo((new DateTime(2020, 10, 7, 15, 0, 0), new DateTime(2020, 10, 7, 16, 0, 0))));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void Test_GetFilterToday_07_EarlyStartNightShift() {
|
|
using (Assert.EnterMultipleScope()) {
|
|
Assert.That(DeliveryService.GetFilterToday(new(2020, 10, 7), DeliveryDates),
|
|
Is.EqualTo((new DateTime(2020, 10, 7, 17, 0, 0), new DateTime(2020, 10, 8, 0, 0, 0))));
|
|
Assert.That(DeliveryService.GetFilterToday(new(2020, 10, 8), DeliveryDates),
|
|
Is.EqualTo((new DateTime(2020, 10, 7, 17, 0, 0), new DateTime(2020, 10, 8, 8, 0, 0))));
|
|
Assert.That(DeliveryService.GetFilterToday(new(2020, 10, 8), DeliveryDates.Append(new(2020, 10, 8, 15, 10, 0))),
|
|
Is.EqualTo((new DateTime(2020, 10, 8, 15, 0, 0), new DateTime(2020, 10, 8, 16, 0, 0))));
|
|
}
|
|
}
|
|
}
|
|
}
|