462 lines
18 KiB
C#
462 lines
18 KiB
C#
using LehrerApp.Core.Importing;
|
|
using LehrerApp.Core.Interfaces;
|
|
using LehrerApp.Core.Models;
|
|
using LehrerApp.Core.Services;
|
|
using Xunit;
|
|
|
|
namespace LehrerApp.Tests;
|
|
|
|
public sealed class StudentImportServiceTests
|
|
{
|
|
private static readonly ImportFormatId TestFormat = new("test.students");
|
|
|
|
[Fact]
|
|
public void ImportFormatId_NormalisiertDenWert()
|
|
{
|
|
var id = new ImportFormatId(" TEST.Students ");
|
|
|
|
Assert.Equal(TestFormat, id);
|
|
Assert.Equal("test.students", id.ToString());
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Catalog_WaehltBeiGleicherKonfidenzDiePassendeDateiendung()
|
|
{
|
|
var csv = new FakeHandler(new ImportFormatId("test.csv"), "CSV", [".csv"], 80, []);
|
|
var xml = new FakeHandler(new ImportFormatId("test.xml"), "XML", [".xml"], 80, []);
|
|
var catalog = new ImportHandlerCatalog<ImportedStudent>([xml, csv]);
|
|
|
|
var detected = await catalog.DetectAsync(new ImportFile("klasse.csv", "data"u8.ToArray()));
|
|
|
|
Assert.Same(csv, detected.Handler);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Analyze_EindeutigerTrefferWirdAutomatischVorhandenemSchuelerZugeordnet()
|
|
{
|
|
var existing = ExistingStudent();
|
|
var repository = new InMemoryStudentRepository([existing]);
|
|
var service = Service(repository,
|
|
[
|
|
new ImportedStudent
|
|
{
|
|
FirstName = " Erika ", LastName = " Mustermann ",
|
|
DateOfBirth = new DateOnly(2012, 4, 5),
|
|
},
|
|
]);
|
|
|
|
var preview = await service.AnalyzeAsync(File());
|
|
|
|
Assert.True(preview.CanApply);
|
|
Assert.Empty(preview.Conflicts);
|
|
var resolution = Assert.Single(preview.Entries).AutomaticResolution;
|
|
Assert.Equal(StudentImportResolutionKind.UseExisting, resolution?.Kind);
|
|
Assert.Equal(existing.Id, resolution?.ExistingStudentId);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Analyze_GleicherNameOhneEindeutigesGeburtsdatumErzeugtUINeutralenKonflikt()
|
|
{
|
|
var repository = new InMemoryStudentRepository([ExistingStudent()]);
|
|
var service = Service(repository,
|
|
[
|
|
new ImportedStudent { FirstName = "Erika", LastName = "Mustermann" },
|
|
]);
|
|
|
|
var preview = await service.AnalyzeAsync(File());
|
|
|
|
var conflict = Assert.Single(preview.Conflicts);
|
|
Assert.Equal(conflict.Id, Assert.Single(preview.Entries).ConflictId);
|
|
Assert.Contains(conflict.Options, option => option.Id == "create");
|
|
Assert.Contains(conflict.Options, option => option.Id == "skip");
|
|
Assert.Contains(conflict.Options, option => option.Id.StartsWith("existing:"));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Apply_VerlangtFuerJedenKonfliktEineEntscheidung()
|
|
{
|
|
var repository = new InMemoryStudentRepository([ExistingStudent()]);
|
|
var service = Service(repository,
|
|
[
|
|
new ImportedStudent { FirstName = "Erika", LastName = "Mustermann" },
|
|
]);
|
|
var preview = await service.AnalyzeAsync(File());
|
|
|
|
var exception = await Assert.ThrowsAsync<InvalidOperationException>(
|
|
() => service.ApplyAsync(preview));
|
|
|
|
Assert.Contains("alle Konflikte", exception.Message);
|
|
Assert.Single(repository.Students);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Apply_LegtNeueSchuelerErstNachDerVorschauAn()
|
|
{
|
|
var repository = new InMemoryStudentRepository();
|
|
var service = Service(repository,
|
|
[
|
|
new ImportedStudent
|
|
{
|
|
FirstName = "Max", LastName = "Beispiel",
|
|
DateOfBirth = new DateOnly(2011, 9, 10), Gender = Gender.M,
|
|
},
|
|
]);
|
|
|
|
var preview = await service.AnalyzeAsync(File());
|
|
Assert.Empty(repository.Students);
|
|
|
|
var result = await service.ApplyAsync(preview);
|
|
|
|
Assert.Equal(1, result.CreatedStudents);
|
|
var created = Assert.Single(repository.Students);
|
|
Assert.Equal("Max", created.FirstName);
|
|
Assert.Equal(Gender.M, created.Gender);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Apply_NachAenderungDerBestandsdatenVerlangtNeueVorschau()
|
|
{
|
|
var existing = ExistingStudent();
|
|
var repository = new InMemoryStudentRepository([existing]);
|
|
var service = Service(repository,
|
|
[
|
|
new ImportedStudent { FirstName = "Max", LastName = "Beispiel" },
|
|
]);
|
|
var preview = await service.AnalyzeAsync(File());
|
|
existing.UpdatedAt = existing.UpdatedAt.AddSeconds(1);
|
|
|
|
var exception = await Assert.ThrowsAsync<InvalidOperationException>(
|
|
() => service.ApplyAsync(preview));
|
|
|
|
Assert.Contains("Vorschau", exception.Message);
|
|
Assert.Single(repository.Students);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Analyze_FehlenderNachnameVerhindertApply()
|
|
{
|
|
var repository = new InMemoryStudentRepository();
|
|
var service = Service(repository,
|
|
[
|
|
new ImportedStudent { FirstName = "Max", LastName = " " },
|
|
]);
|
|
|
|
var preview = await service.AnalyzeAsync(File());
|
|
|
|
Assert.False(preview.CanApply);
|
|
Assert.Contains(preview.Messages, message => message.Code == "student.last-name.required");
|
|
await Assert.ThrowsAsync<InvalidOperationException>(() => service.ApplyAsync(preview));
|
|
Assert.Empty(repository.Students);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Analyze_EindeutigDoppelteImportzeilenWerdenNichtGespeichert()
|
|
{
|
|
var repository = new InMemoryStudentRepository();
|
|
var student = new ImportedStudent
|
|
{
|
|
FirstName = "Max", LastName = "Beispiel",
|
|
DateOfBirth = new DateOnly(2011, 9, 10),
|
|
};
|
|
var service = Service(repository, [student, student]);
|
|
|
|
var preview = await service.AnalyzeAsync(File());
|
|
|
|
Assert.False(preview.CanApply);
|
|
Assert.Contains(preview.Messages, message => message.Code == "student.duplicate");
|
|
await Assert.ThrowsAsync<InvalidOperationException>(() => service.ApplyAsync(preview));
|
|
Assert.Empty(repository.Students);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Apply_ErgaenztEinenAusgewaehltenVorhandenenSchuelerOhneBestehendeWerteZuUeberschreiben()
|
|
{
|
|
var existing = new Student
|
|
{
|
|
FirstName = "Max",
|
|
LastName = "Beispiel",
|
|
Gender = Gender.M,
|
|
};
|
|
var repository = new InMemoryStudentRepository([existing]);
|
|
var service = Service(repository,
|
|
[
|
|
new ImportedStudent
|
|
{
|
|
FirstName = "Max",
|
|
LastName = "Beispiel",
|
|
Gender = Gender.W,
|
|
DateOfBirth = new DateOnly(2011, 9, 10),
|
|
ExternalId = "4711",
|
|
Contact = new ImportedStudentContact
|
|
{
|
|
Email = "max@example.invalid",
|
|
MobilePhone = "01234",
|
|
Street = "Musterweg 1",
|
|
},
|
|
},
|
|
]);
|
|
var preview = await service.AnalyzeAsync(File());
|
|
var conflict = Assert.Single(preview.Conflicts);
|
|
var useExisting = conflict.Options.Single(option => option.Id.StartsWith("existing:"));
|
|
|
|
var result = await service.ApplyAsync(preview,
|
|
[new ImportDecision(conflict.Id, useExisting.Id)]);
|
|
|
|
Assert.Equal(1, result.UpdatedStudents);
|
|
Assert.Equal(new DateOnly(2011, 9, 10), existing.DateOfBirth);
|
|
Assert.Equal(Gender.M, existing.Gender);
|
|
Assert.Equal("4711", existing.ExternalIds[TestFormat.Value]);
|
|
var contact = Assert.Single(existing.Contacts);
|
|
Assert.Equal("Stammdaten", contact.Relation);
|
|
Assert.Equal("max@example.invalid", contact.Email);
|
|
Assert.Equal("01234", contact.MobilePhone);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Apply_OrdnetBeiEindeutigerAktiverGruppeImAktuellenSchuljahrAutomatischZu()
|
|
{
|
|
var repository = new InMemoryStudentRepository();
|
|
var schoolYears = new SchoolYearService();
|
|
var group = new LearningGroup
|
|
{
|
|
Name = "10c",
|
|
SchoolYear = schoolYears.CurrentSchoolYear(),
|
|
GradeLevel = 10,
|
|
IsActive = true,
|
|
};
|
|
var groups = new InMemoryGroupRepository([group]);
|
|
var memberships = new InMemoryGroupMembershipRepository();
|
|
var service = Service(repository,
|
|
[
|
|
new ImportedStudent
|
|
{
|
|
FirstName = "Max", LastName = "Beispiel", GroupName = "10C",
|
|
},
|
|
], groups, memberships, schoolYears);
|
|
|
|
var preview = await service.AnalyzeAsync(File());
|
|
Assert.Empty(preview.Conflicts);
|
|
Assert.Equal(group.Id, Assert.Single(preview.GroupAssignments).AutomaticGroupId);
|
|
|
|
var result = await service.ApplyAsync(preview);
|
|
|
|
Assert.Equal(1, result.CreatedMemberships);
|
|
var membership = Assert.Single(memberships.Memberships);
|
|
Assert.Equal(group.Id, membership.GroupId);
|
|
Assert.Equal(Assert.Single(repository.Students).Id, membership.StudentId);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Analyze_GruppeAusAnderemSchuljahrWirdNichtAutomatischVerwendet()
|
|
{
|
|
var repository = new InMemoryStudentRepository();
|
|
var schoolYears = new SchoolYearService();
|
|
var oldGroup = new LearningGroup
|
|
{
|
|
Name = "10c",
|
|
SchoolYear = schoolYears.RecentSchoolYears(2)[1],
|
|
GradeLevel = 10,
|
|
IsActive = true,
|
|
};
|
|
var groups = new InMemoryGroupRepository([oldGroup]);
|
|
var memberships = new InMemoryGroupMembershipRepository();
|
|
var service = Service(repository,
|
|
[
|
|
new ImportedStudent
|
|
{
|
|
FirstName = "Max", LastName = "Beispiel", GroupName = "10c",
|
|
},
|
|
], groups, memberships, schoolYears);
|
|
|
|
var preview = await service.AnalyzeAsync(File());
|
|
|
|
Assert.Null(Assert.Single(preview.GroupAssignments).AutomaticGroupId);
|
|
Assert.Contains(preview.Messages, message => message.Code == "student.group.not-found");
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Analyze_BevorzugtBeiMehrerenNamensgleichenGruppenDieEigeneKlasse()
|
|
{
|
|
var repository = new InMemoryStudentRepository();
|
|
var schoolYears = new SchoolYearService();
|
|
var schoolYear = schoolYears.CurrentSchoolYear();
|
|
var subjectGroup = new LearningGroup
|
|
{
|
|
Name = "10c", SchoolYear = schoolYear, GradeLevel = 10,
|
|
Type = GroupType.Class, IsOwnClass = false,
|
|
};
|
|
var ownClass = new LearningGroup
|
|
{
|
|
Name = "10c", SchoolYear = schoolYear, GradeLevel = 10,
|
|
Type = GroupType.Class, IsOwnClass = true,
|
|
};
|
|
var service = Service(repository,
|
|
[
|
|
new ImportedStudent
|
|
{
|
|
FirstName = "Max", LastName = "Beispiel", GroupName = "10c",
|
|
},
|
|
], new InMemoryGroupRepository([subjectGroup, ownClass]),
|
|
new InMemoryGroupMembershipRepository(), schoolYears);
|
|
|
|
var preview = await service.AnalyzeAsync(File());
|
|
|
|
Assert.Empty(preview.Conflicts);
|
|
Assert.Equal(ownClass.Id, Assert.Single(preview.GroupAssignments).AutomaticGroupId);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Apply_ExpliziteZielgruppeIgnoriertHeimatklasseUndVervollstaendigtTeilnehmerliste()
|
|
{
|
|
var repository = new InMemoryStudentRepository();
|
|
var target = new LearningGroup { Name = "Mathematik 10", IsActive = true };
|
|
var groups = new InMemoryGroupRepository([target]);
|
|
var memberships = new InMemoryGroupMembershipRepository();
|
|
var service = Service(repository,
|
|
[
|
|
new ImportedStudent
|
|
{
|
|
FirstName = "Max", LastName = "Beispiel", GroupName = "10c",
|
|
},
|
|
], groups, memberships);
|
|
|
|
var preview = await service.AnalyzeAsync(File(), target.Id);
|
|
var result = await service.ApplyAsync(preview);
|
|
|
|
Assert.True(preview.CanApply);
|
|
Assert.Equal(target.Id, preview.TargetGroupId);
|
|
Assert.Equal(target.Id, Assert.Single(preview.GroupAssignments).AutomaticGroupId);
|
|
Assert.Equal(1, result.CreatedStudents);
|
|
Assert.Equal(1, result.CreatedMemberships);
|
|
Assert.Equal(target.Id, Assert.Single(memberships.Memberships).GroupId);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Analyze_ExpliziteZielgruppeErkenntBereitsZugeordnetenNamensgleichenSchueler()
|
|
{
|
|
var existing = new Student { FirstName = "Max", LastName = "Beispiel" };
|
|
var repository = new InMemoryStudentRepository([existing]);
|
|
var target = new LearningGroup { Name = "Mathematik 10", IsActive = true };
|
|
var groups = new InMemoryGroupRepository([target]);
|
|
var memberships = new InMemoryGroupMembershipRepository();
|
|
memberships.Save(new GroupMembership { StudentId = existing.Id, GroupId = target.Id });
|
|
var service = Service(repository,
|
|
[new ImportedStudent { FirstName = "Max", LastName = "Beispiel" }],
|
|
groups, memberships);
|
|
|
|
var preview = await service.AnalyzeAsync(File(), target.Id);
|
|
|
|
Assert.Empty(preview.Conflicts);
|
|
var resolution = Assert.Single(preview.Entries).AutomaticResolution;
|
|
Assert.Equal(StudentImportResolutionKind.UseExisting, resolution?.Kind);
|
|
Assert.Equal(existing.Id, resolution?.ExistingStudentId);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Analyze_ArchivierteZielgruppeVerhindertImport()
|
|
{
|
|
var target = new LearningGroup { Name = "Alter Kurs", IsActive = false };
|
|
var service = Service(new InMemoryStudentRepository(),
|
|
[new ImportedStudent { FirstName = "Max", LastName = "Beispiel" }],
|
|
new InMemoryGroupRepository([target]));
|
|
|
|
var preview = await service.AnalyzeAsync(File(), target.Id);
|
|
|
|
Assert.False(preview.CanApply);
|
|
Assert.Contains(preview.Messages, message => message.Code == "student.target-group.unavailable");
|
|
}
|
|
|
|
private static StudentImportService Service(
|
|
InMemoryStudentRepository repository,
|
|
IReadOnlyList<ImportedStudent> imported,
|
|
InMemoryGroupRepository? groups = null,
|
|
InMemoryGroupMembershipRepository? memberships = null,
|
|
SchoolYearService? schoolYears = null) =>
|
|
new(
|
|
[new FakeHandler(TestFormat, "Testformat", [".test"], 100, imported)],
|
|
repository,
|
|
groups ?? new InMemoryGroupRepository(),
|
|
memberships ?? new InMemoryGroupMembershipRepository(),
|
|
schoolYears ?? new SchoolYearService());
|
|
|
|
private static ImportFile File() => new("schueler.test", "test"u8.ToArray());
|
|
|
|
private static Student ExistingStudent() => new()
|
|
{
|
|
FirstName = "Erika",
|
|
LastName = "Mustermann",
|
|
DateOfBirth = new DateOnly(2012, 4, 5),
|
|
};
|
|
|
|
private sealed class FakeHandler(
|
|
ImportFormatId formatId,
|
|
string displayName,
|
|
IReadOnlyCollection<string> extensions,
|
|
int confidence,
|
|
IReadOnlyList<ImportedStudent> imported) : IImportHandler<ImportedStudent>
|
|
{
|
|
public ImportFormatId FormatId => formatId;
|
|
public string DisplayName => displayName;
|
|
public IReadOnlyCollection<string> SupportedExtensions => extensions;
|
|
|
|
public ValueTask<ImportDetection> DetectAsync(
|
|
ImportFile file,
|
|
CancellationToken cancellationToken = default) =>
|
|
ValueTask.FromResult(ImportDetection.Match(confidence));
|
|
|
|
public ValueTask<ImportParseResult<ImportedStudent>> ParseAsync(
|
|
ImportFile file,
|
|
CancellationToken cancellationToken = default) =>
|
|
ValueTask.FromResult(new ImportParseResult<ImportedStudent>(imported));
|
|
}
|
|
|
|
private sealed class InMemoryStudentRepository(IEnumerable<Student>? initial = null)
|
|
: IStudentRepository
|
|
{
|
|
public List<Student> Students { get; } = initial?.ToList() ?? [];
|
|
|
|
public Student? GetById(Guid id) => Students.FirstOrDefault(student => student.Id == id);
|
|
public List<Student> GetAll(bool includeInactive = false) => Students
|
|
.Where(student => includeInactive || student.IsActive)
|
|
.ToList();
|
|
public List<Student> GetByGroup(Guid groupId) => [];
|
|
public StudentReferenceSummary GetReferenceSummary(Guid studentId) => new(0, 0, 0, 0, 0, 0);
|
|
public void Save(Student student)
|
|
{
|
|
var index = Students.FindIndex(existing => existing.Id == student.Id);
|
|
if (index >= 0) Students[index] = student;
|
|
else Students.Add(student);
|
|
}
|
|
public void Delete(Guid id) => Students.RemoveAll(student => student.Id == id);
|
|
}
|
|
|
|
private sealed class InMemoryGroupRepository(IEnumerable<LearningGroup>? initial = null)
|
|
: IGroupRepository
|
|
{
|
|
public List<LearningGroup> Groups { get; } = initial?.ToList() ?? [];
|
|
public LearningGroup? GetById(Guid id) => Groups.FirstOrDefault(group => group.Id == id);
|
|
public List<LearningGroup> GetAll(bool includeInactive = false) => Groups
|
|
.Where(group => includeInactive || group.IsActive)
|
|
.ToList();
|
|
public List<LearningGroup> GetBySchoolYear(string schoolYear, bool includeInactive = false) => Groups
|
|
.Where(group => group.SchoolYear == schoolYear && (includeInactive || group.IsActive))
|
|
.ToList();
|
|
public void Save(LearningGroup group) => Groups.Add(group);
|
|
public void Delete(Guid id) => Groups.RemoveAll(group => group.Id == id);
|
|
}
|
|
|
|
private sealed class InMemoryGroupMembershipRepository : IGroupMembershipRepository
|
|
{
|
|
public List<GroupMembership> Memberships { get; } = [];
|
|
public List<GroupMembership> GetByStudent(Guid studentId) =>
|
|
Memberships.Where(membership => membership.StudentId == studentId).ToList();
|
|
public List<GroupMembership> GetByGroup(Guid groupId) =>
|
|
Memberships.Where(membership => membership.GroupId == groupId).ToList();
|
|
public GroupMembership? GetByStudentAndGroup(Guid studentId, Guid groupId) =>
|
|
Memberships.FirstOrDefault(membership =>
|
|
membership.StudentId == studentId && membership.GroupId == groupId);
|
|
public void Save(GroupMembership membership) => Memberships.Add(membership);
|
|
public void Delete(Guid id) => Memberships.RemoveAll(membership => membership.Id == id);
|
|
}
|
|
}
|