public void GetIfHasNoTimeWithCategory_should_throw_ArugmentNullException_when_given_chipId_is_null()
{
var options = new DbContextOptionsBuilder <RunnerDbContext>()
.UseInMemoryDatabase(nameof(GetIfHasNoTimeWithCategory_should_throw_ArugmentNullException_when_given_chipId_is_null))
.Options;
var context = new RunnerDbContext(options);
var repository = new RunnerRepository(context);
Assert.Throws <ArgumentNullException>("chipId", () => repository.GetIfHasNoTimeWithCategory(null));
}
public void CanCreateInstance()
{
var options = new DbContextOptionsBuilder <RunnerDbContext>().Options;
using (var context = new RunnerDbContext(options))
{
Assert.NotNull(context);
Assert.NotNull(context.Categories);
Assert.NotNull(context.Runners);
}
}
private static void SaveCategories(IEnumerable <Category> categories, string connectionString = null)
{
var options = new DbContextOptionsBuilder <RunnerDbContext>()
.UseSqlServer(connectionString ?? "Data Source=(localdb)\\MSSQLLocalDB;Initial Catalog=MarathonManager;Integrated Security=True")
.Options;
using (var context = new RunnerDbContext(options))
{
context.AddRange(categories.ToList());
context.SaveChanges();
}
}
private static void EnsureNewDatabase(string connectionString = null)
{
var options = new DbContextOptionsBuilder <RunnerDbContext>()
.UseSqlServer(connectionString ?? "Data Source=(localdb)\\MSSQLLocalDB;Initial Catalog=MarathonManager;Integrated Security=True")
.Options;
using (var context = new RunnerDbContext(options))
{
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
}
}
public async Task GetIfHasNoTimeWithCategory_should_return_runner_with_category_with_given_chipId()
{
var databaseName = nameof(GetIfHasNoTimeWithCategory_should_return_runner_with_category_with_given_chipId);
var options = new DbContextOptionsBuilder <RunnerDbContext>()
.UseSqlServer(string.Format(TestConfiguration.ConnectionString, databaseName))
.Options;
using (var context = new RunnerDbContext(options))
{
await context.Database.EnsureDeletedAsync();
await context.Database.EnsureCreatedAsync();
await context.Runners.AddAsync(new Runner
{
ChipId = "4329085723",
Firstname = "Firstname",
Lastname = "Lastname",
Gender = Gender.Mann,
YearOfBirth = 2000,
TimeAtDestination = null,
Category = new Category
{
Name = "The Name of the Category"
}
});
await context.SaveChangesAsync();
}
using (var context = new RunnerDbContext(options))
{
var repository = new RunnerRepository(context);
var result = repository.GetIfHasNoTimeWithCategory("4329085723");
Assert.NotNull(result);
Assert.NotNull(result.Category);
Assert.Equal("Firstname", result.Firstname);
Assert.Equal("Lastname", result.Lastname);
Assert.Equal(Gender.Mann, result.Gender);
Assert.Equal(Gender.Mann, result.Gender);
Assert.Equal("The Name of the Category", result.Category.Name);
}
using (var context = new RunnerDbContext(options))
await context.Database.EnsureDeletedAsync();
}
public void Add_Category_with_name_longer_than_50_chars_AnyRandomDatabaseExeption()
{
var options = new DbContextOptionsBuilder <RunnerDbContext>()
.UseInMemoryDatabase(nameof(Add_Category_with_name_longer_than_50_chars_AnyRandomDatabaseExeption))
.Options;
using (var context = new RunnerDbContext(options))
{
var category = new Category
{
Name = "A Name longer than 50 Characters__40345678950Bllalbaldjflahsfduhalsdfj",
};
context.Categories.Add(category);
Assert.ThrowsAny <Exception>(() => context.SaveChanges());
}
}
private static void Export()
{
var path = string.Empty;
while (!Directory.Exists(path))
{
path = readPath();
}
var context = new RunnerDbContext(new DbContextOptionsBuilder <RunnerDbContext>()
.UseSqlServer(Configuration.GetConnectionString("Default"))
.Options);
var runnerService = new RunnerService(context);
var categories = context.Categories.ToImmutableList();
foreach (var c in categories)
{
var(maenner, frauen) = runnerService.GetResultsForCategory(c.Id);
CreateFile(maenner, Path.Combine(path, $"{c.Name.Replace(" ", "")}_Maenner.csv"));
CreateFile(frauen, Path.Combine(path, $"{c.Name.Replace(" ", "")}_Frauen.csv"));
}
var(aeltesteMaenner, aeltesteFrauen) = runnerService.GetOldestRunner();
CreateFile <ExportRunner, ExportOldestRunnerMap>(aeltesteMaenner, Path.Combine(path, $"Aelteste_Maenner.csv"));
CreateFile <ExportRunner, ExportOldestRunnerMap>(aeltesteFrauen, Path.Combine(path, $"Aelteste_Frauen.csv"));
var vereine = runnerService.GetSportclubsRangs();
CreateFile(vereine, Path.Combine(path, $"Vereine.csv"));
var angemeldeteVereine = runnerService.GetAngemeldeteSportclubsRangs();
CreateFile(angemeldeteVereine, Path.Combine(path, $"AngemeldeteLaeufer_Vereine.csv"));
var alleLäufer = runnerService.GetAllRunners();
CreateFile <ExportRunnerSimple, ExportRunnerSimpleMap>(alleLäufer, Path.Combine(path, $"Alle_Laeufer.csv"));
CreateFile <ExportRunnerSimple, ExportRunnerSimpleMap>(alleLäufer.OrderBy(r => r.Startnummer), Path.Combine(path, $"Alle_Laeufer_nach_Startnummer.csv"));
string readPath()
{
Write("Export Directory Path: ");
return(ReadLine());
}
}
private static void CalculateTimes()
{
var optionsBuilder = new DbContextOptionsBuilder <RunnerDbContext>();
optionsBuilder.UseSqlServer("Data Source=.;Initial Catalog=MarathonManager;Integrated Security=True");
using (var context = new RunnerDbContext(optionsBuilder.Options))
using (var unitOfWork = new UnitOfWork(context, new CategoryRepository(context), new RunnerRepository(context), new Database(context), new EmptyChangesFinder(), new EmptyChangesLogger()))
{
var r = context.Runners.SingleOrDefault(rx => rx.Startnumber == 193);
var category = context.Categories.Single(c => c.Id == 14);
r.RunningTime = r.TimeAtDestination - category.Starttime;
Console.WriteLine($"{r.Startnumber, 3} | {r.TimeAtDestination} | {r.RunningTime}");
context.SaveChanges();
}
Console.ReadKey();
}
private static void DeleteAndCreateDatabase()
{
var options = new DbContextOptionsBuilder <RunnerDbContext>()
.UseSqlServer(Configuration.GetConnectionString("Default"))
.Options;
using (var context = new RunnerDbContext(options))
{
if (context.Database.EnsureDeleted())
{
WriteLine("Database was successfully deleted.");
}
if (context.Database.EnsureCreated())
{
WriteLine("Database was successfully created.");
}
}
}
private static void InsertCategories()
{
var defaultCategories = ReadCategories();
var options = new DbContextOptionsBuilder <RunnerDbContext>()
.UseSqlServer(Configuration.GetConnectionString("Default"))
.Options;
using (var context = new RunnerDbContext(options))
{
var categories = defaultCategories.Select(c => new Category {
Name = c.Name
});
context.AddRange(categories);
context.SaveChanges();
WriteLine("Categories were successfully saved:");
categories.ForEach(c => WriteLine($"| {c.Name}"));
}
}
public async Task GetIfHasNoTimeWithCategory_should_return_null_for_given_chipId_because_runners_timeAtDestiantion_is_not_null()
{
var databaseName = nameof(GetIfHasNoTimeWithCategory_should_return_null_for_given_chipId_because_runners_timeAtDestiantion_is_not_null);
var options = new DbContextOptionsBuilder <RunnerDbContext>()
.UseSqlServer(string.Format(TestConfiguration.ConnectionString, databaseName))
.Options;
using (var context = new RunnerDbContext(options))
{
await context.Database.EnsureDeletedAsync();
await context.Database.EnsureCreatedAsync();
await context.Runners.AddAsync(new Runner
{
ChipId = "4329085723",
Firstname = "Firstname",
Lastname = "Lastname",
Gender = Gender.Mann,
YearOfBirth = 2000,
TimeAtDestination = new DateTime(2017, 10, 12, 12, 00, 00),
Category = new Category
{
Name = "The Name of the Category",
}
});
await context.SaveChangesAsync();
}
using (var context = new RunnerDbContext(options))
{
var repository = new RunnerRepository(context);
var result = repository.GetIfHasNoTimeWithCategory("4329085723");
Assert.Null(result);
}
using (var context = new RunnerDbContext(options))
await context.Database.EnsureDeletedAsync();
}
private static void GenerateSampleRunningTimes()
{
var optionsBuilder = new DbContextOptionsBuilder <RunnerDbContext>();
optionsBuilder.UseSqlServer("Data Source=(localdb)\\MSSQLLocalDB;Initial Catalog=MarathonManager;Integrated Security=True");
using (var context = new RunnerDbContext(optionsBuilder.Options))
using (var unitOfWork = new UnitOfWork(context, new CategoryRepository(context), new RunnerRepository(context), new Database(context), new EmptyChangesFinder(), new EmptyChangesLogger()))
{
var runners = unitOfWork.Runners.GetAll().ToList();
var random = new Random();
for (int i = 0; i < runners.Count; i++)
{
runners[i].Startnumber = i + 1;
runners[i].RunningTime = new TimeSpan(0, random.Next(15, 59), random.Next(0, 59));
}
unitOfWork.Complete();
}
}
public async Task GetIfHasNoTimeWithCategory_should_return_null_if_no_runner_with_given_chipId_is_found()
{
var databaseName = nameof(GetIfHasNoTimeWithCategory_should_return_null_if_no_runner_with_given_chipId_is_found);
var options = new DbContextOptionsBuilder <RunnerDbContext>()
.UseSqlServer(string.Format(TestConfiguration.ConnectionString, databaseName))
.Options;
using (var context = new RunnerDbContext(options))
{
var repository = new RunnerRepository(context);
await context.Database.EnsureDeletedAsync();
await context.Database.EnsureCreatedAsync();
var result = repository.GetIfHasNoTimeWithCategory("0123456789");
await context.Database.EnsureDeletedAsync();
Assert.Null(result);
}
}
private static void ImportRunners()
{
var path = string.Empty;
while (!File.Exists(path))
{
path = ReadPath("Runners");
}
var categories = ReadCategories();
var filereader = new StreamReader(path);
var json = filereader.ReadToEndClean();
var options = new DbContextOptionsBuilder <RunnerDbContext>()
.UseSqlServer(Configuration.GetConnectionString("Default"))
.Options;
using (var context = new RunnerDbContext(options))
{
var categoryRepository = new CategoryRepository(context);
var runnerRepository = new RunnerRepository(context);
var database = new Database(context);
using (var unitOfWork = new UnitOfWork(context, categoryRepository, runnerRepository, database))
{
var mapperConfiguration = GetMapperConfiguration(unitOfWork.Categories, categories.ToImmutableDictionary(c => c.ShortName, c => c.Name));
var mapper = new Mapper(mapperConfiguration);
var deserializer = new JsonDeserializer(mapper);
var runners = deserializer.Deserialize(json);
runnerRepository.AddRange(runners);
unitOfWork.Complete();
WriteLine($"{runners.Count()} Runners were successfully saved.");
}
}
}
private static void SaveData(IEnumerable <Runner> runners, IEnumerable <Category> categories)
{
var optionsBuilder = new DbContextOptionsBuilder <RunnerDbContext>();
optionsBuilder.UseSqlServer("Data Source=(localdb)\\MSSQLLocalDB;Initial Catalog=MarathonManager;Integrated Security=True");
using (var context = new RunnerDbContext(optionsBuilder.Options))
using (var unitOfWork = new UnitOfWork(context, new CategoryRepository(context), new RunnerRepository(context), new Database(context), new EmptyChangesFinder(), new EmptyChangesLogger()))
{
unitOfWork.Categories.AddRange(categories);
unitOfWork.Complete();
var categoriesFromDb = unitOfWork.Categories.GetAll().ToList();
var random = new Random();
foreach (var runner in runners)
{
runner.Category = categoriesFromDb[random.Next(0, categoriesFromDb.Count)];
}
unitOfWork.Runners.AddRange(runners);
unitOfWork.Complete();
}
}
public async Task CRUD_Operations_for_Runners_Async()
{
var options = new DbContextOptionsBuilder <RunnerDbContext>()
.UseInMemoryDatabase("CRUD_Operations_for_Runners")
.Options;
using (var context = new RunnerDbContext(options))
{
await context.Database.EnsureDeletedAsync();
await context.Database.EnsureCreatedAsync();
var categories = new[]
{
new Category {
Name = "Category1"
},
new Category {
Name = "Category2"
},
new Category {
Name = "Category3"
},
};
await context.Categories.AddRangeAsync(categories);
await context.SaveChangesAsync();
}
using (var context = new RunnerDbContext(options))
{
var categories = await context.Categories.ToListAsync();
var runners = new[]
{
new Runner {
Firstname = "Ein Vorname", Lastname = "Ein Nachname", Gender = Gender.Mann, YearOfBirth = 1980, Category = categories[0]
},
new Runner {
Firstname = "Ein anderer Vorname", Lastname = "Ein anderer Nachname", Gender = Gender.Frau, YearOfBirth = 1990, Category = categories[1]
},
new Runner {
Firstname = "Noch ein anderer Vorname", Lastname = "noch ein anderer Nachname", Gender = Gender.Mann, YearOfBirth = 2000, Category = categories[2]
}
};
await context.Runners.AddRangeAsync(runners);
await context.SaveChangesAsync();
}
using (var context = new RunnerDbContext(options))
{
var runners = await context.Runners.ToListAsync();
Assert.Equal(3, runners.Count);
Assert.Equal(1980, runners[0].YearOfBirth);
Assert.Equal("Ein anderer Vorname", runners[1].Firstname);
Assert.Equal(Gender.Mann, runners[2].Gender);
context.Runners.RemoveRange(runners);
await context.SaveChangesAsync();
}
using (var context = new RunnerDbContext(options))
{
var countRunners = await context.Runners.CountAsync();
Assert.Equal(0, countRunners);
}
}
public RunnerService(RunnerDbContext dbContext)
{
this.dbContext = dbContext;
}
public Database(RunnerDbContext context) => this.context = context ?? throw new System.ArgumentNullException(nameof(context));
public void CRUD_Operations_for_Categories()
{
var options = new DbContextOptionsBuilder <RunnerDbContext>()
.UseInMemoryDatabase("CRUD_Operations_for_Categories")
.Options;
using (var context = new RunnerDbContext(options))
{
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
var categories = new[]
{
new Category {
Name = "Category1"
},
new Category {
Name = "Category2"
},
new Category {
Name = "Category3"
},
};
context.Categories.AddRange(categories);
context.SaveChanges();
}
using (var context = new RunnerDbContext(options))
{
var categories = context.Categories.ToList();
Assert.Equal(3, categories.Count);
Assert.Equal("Category2", categories[1].Name);
Assert.Null(categories[1].Starttime);
categories[0].Name = "New Category Name Number 1";
categories[2].Name = "Whatever";
context.SaveChanges();
}
using (var context = new RunnerDbContext(options))
{
var categories = context.Categories.ToList();
Assert.Equal(3, categories.Count);
Assert.Equal("New Category Name Number 1", categories[0].Name);
Assert.Equal("Whatever", categories[2].Name);
context.Remove(categories[1]);
context.SaveChanges();
}
using (var context = new RunnerDbContext(options))
{
var categories = context.Categories.ToList();
Assert.Equal(2, categories.Count);
context.Categories.RemoveRange(categories);
context.SaveChanges();
}
using (var context = new RunnerDbContext(options))
{
var countCategories = context.Categories.Count();
Assert.Equal(0, countCategories);
}
}
