private static void Main(string[] args)
{
// Using Repository Pattern
using (IRepository <Employee> empRepository = new SQLRepository <Employee>())
{
empRepository.Add(new Employee {
Id = 1, Name = "John"
});
empRepository.Commit();
// Variance => made IReadOnlyRepository() => Covariance
DumpPeople(empRepository);
Employee employee = empRepository.FindById(1);
// Variance => made IWriteOnlyRepository() => Contravariance - accepts child class in IRepository<Employee>
AddManagers(empRepository);
// Manager is child class of Employee - Contravariance - accepts child class in IRepository<Employee>
empRepository.Add(new Manager {
Id = 10, Name = "person"
});
}
// Example 2
// T and TKey implementation of RepositoryWithKey
// Can NOT use ints since T must be of IEntity type
// IRepositoryWithKey<int, Person> repoWithKey = new RepositoryWithKey<int, Person>();
IRepositoryWithKey <EntityImplementation, Employee> repoWithKeyEmployee =
new RepositoryWithKey <EntityImplementation, Employee>();
repoWithKeyEmployee.AddItem(new EntityImplementation(1), new Employee {
Name = "John"
});
repoWithKeyEmployee.AddItem(new EntityImplementation(2), new Employee {
Name = "Steve"
});
repoWithKeyEmployee.AddItem(new EntityImplementation(3), new Employee {
Name = "Bob"
});
Console.WriteLine(repoWithKeyEmployee.GetItem(new EntityImplementation(2)).Name);
// Manager should also work
IRepositoryWithKey <EntityImplementation, Manager> repoWithKeyManager =
new RepositoryWithKey <EntityImplementation, Manager>();
repoWithKeyManager.AddItem(new EntityImplementation(1), new Manager {
Name = "Lisa"
});
Console.WriteLine(repoWithKeyEmployee.GetItem(new EntityImplementation(1)).Name);
}
public void GetWhere()
{
//Act
var options = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "Testing_InMemoryDatabase5")
.Options;
IQueryable <Quiz> responseGetWhere = null;
Quiz reponseFirstOfWhere = null;
var quiz = new Quiz
{
EmailCreator = "*****@*****.**",
Naam = "Quiz 1"
};
//Arrange
using (var context = new DataContext(options))
{
var repository = new SQLRepository <Quiz>(context);
repository.Add(quiz);
repository.SaveChanges();
responseGetWhere = repository.GetWhere(x => x.EmailCreator == "*****@*****.**");
reponseFirstOfWhere = responseGetWhere.FirstOrDefault();
}
//Assert
using (var context = new DataContext(options))
{
Assert.IsNotNull(responseGetWhere);
Assert.IsNotEmpty(reponseFirstOfWhere.Id.ToString());
Assert.That(quiz.EmailCreator, Is.EqualTo(reponseFirstOfWhere.EmailCreator));
Assert.That(quiz.Naam, Is.EqualTo(reponseFirstOfWhere.Naam));
}
}
public void FirstOrDefault()
{
//Act
var options = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "Testing_InMemoryDatabase2")
.Options;
int rows = 0;
Quiz responseAdd = null;
Quiz responseFirstOrDefault = null;
var quiz = new Quiz
{
EmailCreator = "*****@*****.**",
Naam = "Quiz 1"
};
//Arrange
using (var context = new DataContext(options))
{
var repository = new SQLRepository <Quiz>(context);
responseAdd = repository.Add(quiz);
rows = repository.SaveChanges();
responseFirstOrDefault = repository.FirstOrDefault(x => x.Id == 1);
}
//Assert
using (var context = new DataContext(options))
{
Assert.IsNotNull(responseFirstOrDefault.Id);
Assert.IsNotEmpty(responseFirstOrDefault.Id.ToString());
Assert.That(quiz.Naam, Is.EqualTo(responseFirstOrDefault.Naam));
Assert.That(quiz.EmailCreator, Is.EqualTo(responseFirstOrDefault.EmailCreator));
}
}
public void CreateRonde()
{
//Act
var options = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "Testing_InMemoryDatabase1")
.Options;
int rows = 0;
Ronde responseRonde = null;
var ronde = new Ronde
{
Naam = "Ronde "
};
//Arrange
using (var context = new DataContext(options))
{
var repository = new SQLRepository <Ronde>(context);
responseRonde = repository.Add(ronde);
rows = repository.SaveChanges();
}
//Assert
using (var context = new DataContext(options))
{
Assert.AreEqual(1, rows);
Assert.IsNotNull(responseRonde.Id);
Assert.IsNotEmpty(responseRonde.Id.ToString());
Assert.That(ronde.Naam, Is.EqualTo(responseRonde.Naam));
Assert.AreEqual(1, context.Ronden.Count());
}
}
public void GetByID()
{
//Act
var options = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "Testing_InMemoryDatabase4")
.Options;
Team responseGetById = null;
var team = new Team
{
Naam = "Quiz 1",
EmailCreator = "*****@*****.**",
Email = "*****@*****.**"
};
//Arrange
using (var context = new DataContext(options))
{
var repository = new SQLRepository <Team>(context);
repository.Add(team);
repository.SaveChanges();
responseGetById = repository.GetById(1);
}
//Assert
using (var context = new DataContext(options))
{
Assert.IsNotNull(responseGetById);
Assert.IsNotEmpty(responseGetById.Id.ToString());
Assert.That(team.EmailCreator, Is.EqualTo(responseGetById.EmailCreator));
Assert.That(team.Naam, Is.EqualTo(responseGetById.Naam));
Assert.That(team.Email, Is.EqualTo(responseGetById.Email));
}
}
public void GetByID()
{
//Act
var options = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "Testing_InMemoryDatabase4")
.Options;
Ronde responseGetById = null;
var ronde = new Ronde
{
Naam = "Ronde 1"
};
//Arrange
using (var context = new DataContext(options))
{
var repository = new SQLRepository <Ronde>(context);
repository.Add(ronde);
repository.SaveChanges();
responseGetById = repository.GetById(1);
}
//Assert
using (var context = new DataContext(options))
{
Assert.IsNotNull(responseGetById);
Assert.IsNotEmpty(responseGetById.Id.ToString());
Assert.That(ronde.Naam, Is.EqualTo(responseGetById.Naam));
}
}
public async Task AddAMovieToTheDatabase()
{
var options = new DbContextOptionsBuilder <MoviesContext>()
.UseInMemoryDatabase(databaseName: "MRADdMovie")
.Options;
addMovies(options);
using (var context = new MoviesContext(options))
{
SQLRepository controller = new SQLRepository(context);
Movie movieToAdd = new Movie
{
Title = "Movie to add to Mem DB 23",
LengthInMinutes = 134,
Rating = 7.9,
ReleaseYear = 2003,
MainGenre = "Action",
SubGenre1 = "Comedy",
SubGenre2 = "Adventure"
};
await controller.Add(movieToAdd);
int inventoryCount = controller.GetInventoryTotal();
Assert.Equal(23, inventoryCount);
}
}
public void FirstOrDefault()
{
//Act
var options = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "Testing_InMemoryDatabase2")
.Options;
int rows = 0;
Ronde responseAdd = null;
Ronde responseFirstOrDefault = null;
var ronde = new Ronde
{
Naam = "Ronde 1"
};
//Arrange
using (var context = new DataContext(options))
{
var repository = new SQLRepository <Ronde>(context);
responseAdd = repository.Add(ronde);
rows = repository.SaveChanges();
responseFirstOrDefault = repository.FirstOrDefault(x => x.Id == 1);
}
//Assert
using (var context = new DataContext(options))
{
Assert.IsNotNull(responseFirstOrDefault.Id);
Assert.IsNotEmpty(responseFirstOrDefault.Id.ToString());
Assert.That(ronde.Naam, Is.EqualTo(responseFirstOrDefault.Naam));
}
}
public void Remove()
{
//Act
var options = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "Testing_InMemoryDatabase6")
.Options;
bool reponseRemove;
int countBeforeDelete = 0;
int countAfterDelete = 0;
var ronde = new Ronde
{
Naam = "Quiz 1"
};
//Arrange
using (var context = new DataContext(options))
{
var repository = new SQLRepository <Ronde>(context);
var responseAdd = repository.Add(ronde);
repository.SaveChanges();
countBeforeDelete = repository.GetAll().Count();
reponseRemove = repository.Remove(responseAdd.Id);
repository.SaveChanges();
countAfterDelete = repository.GetAll().Count();
}
//Assert
using (var context = new DataContext(options))
{
Assert.That(1, Is.EqualTo(countBeforeDelete));
Assert.That(0, Is.EqualTo(countAfterDelete));
Assert.That(true, Is.EqualTo(reponseRemove));
}
}
public void GetWhere()
{
//Act
var options = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "Testing_InMemoryDatabase5")
.Options;
IQueryable <Ronde> responseGetWhere = null;
Ronde reponseFirstOfWhere = null;
var ronde = new Ronde
{
Naam = "Ronde 1"
};
//Arrange
using (var context = new DataContext(options))
{
var repository = new SQLRepository <Ronde>(context);
repository.Add(ronde);
repository.SaveChanges();
responseGetWhere = repository.GetWhere(x => x.Naam == "Ronde 1");
reponseFirstOfWhere = responseGetWhere.FirstOrDefault();
}
//Assert
using (var context = new DataContext(options))
{
Assert.IsNotNull(responseGetWhere);
Assert.IsNotEmpty(reponseFirstOfWhere.Id.ToString());
Assert.That(ronde.Naam, Is.EqualTo(reponseFirstOfWhere.Naam));
}
}
public bool Post(BillViewModel billVm)
{
Bill b = _repo.ModelBinder.ViewModelToEntity(billVm);
_repo.Add(b);
_repo.SaveChanges();
return(true);
}
public async Task GetLatestHorrorMovies()
{
var options = new DbContextOptionsBuilder <MoviesContext>()
.UseInMemoryDatabase(databaseName: "MRGetLatestHorrorMovies")
.Options;
addMovies(options);
using (var context = new MoviesContext(options))
{
SQLRepository controller = new SQLRepository(context);
Movie horrorMovie1 = new Movie
{
Id = 23,
Title = "In Memory DB Movie 23",
LengthInMinutes = 121,
Rating = 8.1,
ReleaseYear = 2013,
MainGenre = "Horror",
SubGenre1 = "Action",
SubGenre2 = "Adventure"
};
Movie horrorMovie2 = new Movie
{
Id = 24,
Title = "In Memory DB Movie 24",
LengthInMinutes = 121,
Rating = 8.1,
ReleaseYear = 2013,
MainGenre = "Horror",
SubGenre1 = "Action",
SubGenre2 = "Adventure"
};
await controller.Add(horrorMovie1);
await controller.Add(horrorMovie2);
List <Movie> actual = controller.GetLatestHorrorMovies(2);
Assert.Equal(2, actual.Count);
Assert.Equal("In Memory DB Movie 23", actual[0].Title);
}
}
public void Update()
{
//Act
var options = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "Testing_InMemoryDatabase7")
.Options;
Vraag responseVraagUpdated = null;
var vraag = new Vraag
{
MaxScoreVraag = 10,
TypeVraagId = 1,
VraagStelling = "Dit is de stelling van de vraag",
JsonCorrecteAntwoord = "JsonCorrecteAntwoord",
JsonMogelijkeAntwoorden = "JsonMogelijkeAntwoorden"
};
var updateVraag = new Vraag
{
Id = 1,
MaxScoreVraag = 15,
TypeVraagId = 2,
VraagStelling = "Dit is de stelling van een andere vraag",
JsonCorrecteAntwoord = "JsonCorrecteAntwoord2",
JsonMogelijkeAntwoorden = "JsonMogelijkeAntwoorden2"
};
//Arrange
using (var context = new DataContext(options))
{
var repository = new SQLRepository <Vraag>(context);
var responseAdd = repository.Add(vraag);
repository.SaveChanges();
}
using (var context = new DataContext(options))
{
var repository = new SQLRepository <Vraag>(context);
responseVraagUpdated = repository.Update(updateVraag);
repository.SaveChanges();
}
//Assert
using (var context = new DataContext(options))
{
Assert.That(updateVraag.Id, Is.EqualTo(responseVraagUpdated.Id));
Assert.That(updateVraag.JsonCorrecteAntwoord, Is.EqualTo(responseVraagUpdated.JsonCorrecteAntwoord));
Assert.That(updateVraag.JsonMogelijkeAntwoorden, Is.EqualTo(responseVraagUpdated.JsonMogelijkeAntwoorden));
Assert.That(updateVraag.MaxScoreVraag, Is.EqualTo(responseVraagUpdated.MaxScoreVraag));
Assert.That(updateVraag.TypeVraagId, Is.EqualTo(responseVraagUpdated.TypeVraagId));
Assert.That(updateVraag.VraagStelling, Is.EqualTo(responseVraagUpdated.VraagStelling));
}
}
public void Update()
{
//Act
var options = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "Testing_InMemoryDatabase7")
.Options;
IngevoerdAntwoord responseAntwoordUpdated = null;
var antwoord = new IngevoerdAntwoord
{
GescoordeScore = 6,
JsonAntwoord = "JsonAntwoord",
TeamId = 1
};
var updateAntwoord = new IngevoerdAntwoord
{
Id = 1,
GescoordeScore = 3,
JsonAntwoord = "JsonAntwoordUpdate",
TeamId = 1
};
//Arrange
using (var context = new DataContext(options))
{
var repository = new SQLRepository <IngevoerdAntwoord>(context);
var responseAdd = repository.Add(antwoord);
repository.SaveChanges();
}
using (var context = new DataContext(options))
{
var repository = new SQLRepository <IngevoerdAntwoord>(context);
responseAntwoordUpdated = repository.Update(updateAntwoord);
repository.SaveChanges();
}
//Assert
using (var context = new DataContext(options))
{
Assert.That(updateAntwoord.GescoordeScore, Is.EqualTo(responseAntwoordUpdated.GescoordeScore));
Assert.That(updateAntwoord.JsonAntwoord, Is.EqualTo(responseAntwoordUpdated.JsonAntwoord));
Assert.That(updateAntwoord.TeamId, Is.EqualTo(responseAntwoordUpdated.TeamId));
}
}
public void Update()
{
//Act
var options = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "Testing_InMemoryDatabase7")
.Options;
Team responseQuizUpdated = null;
var team = new Team
{
Naam = "Quiz 1",
EmailCreator = "*****@*****.**",
Email = "*****@*****.**"
};
var updateTeam = new Team
{
Id = 1,
EmailCreator = "*****@*****.**",
Naam = "Quiz 1",
Email = "*****@*****.**"
};
//Arrange
using (var context = new DataContext(options))
{
var repository = new SQLRepository <Team>(context);
var responseAdd = repository.Add(team);
repository.SaveChanges();
}
using (var context = new DataContext(options))
{
var repository = new SQLRepository <Team>(context);
responseQuizUpdated = repository.Update(updateTeam);
repository.SaveChanges();
}
//Assert
using (var context = new DataContext(options))
{
Assert.That(updateTeam.EmailCreator, Is.EqualTo(responseQuizUpdated.EmailCreator));
Assert.That(updateTeam.Naam, Is.EqualTo(responseQuizUpdated.Naam));
Assert.That(updateTeam.Email, Is.EqualTo(responseQuizUpdated.Email));
}
}
public void GetAll()
{
//Act
var options = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "Testing_InMemoryDatabase3")
.Options;
int count = 0;
IEnumerable <Vraag> responseGetAll = null;
Vraag firstResponse = null;
var vraag = new Vraag
{
MaxScoreVraag = 10,
TypeVraagId = 1,
VraagStelling = "Dit is de stelling van de vraag",
JsonCorrecteAntwoord = "JsonCorrecteAntwoord",
JsonMogelijkeAntwoorden = "JsonMogelijkeAntwoorden"
};
//Arrange
using (var context = new DataContext(options))
{
var repository = new SQLRepository <Vraag>(context);
repository.Add(vraag);
repository.SaveChanges();
responseGetAll = repository.GetAll();
count = responseGetAll.Count();
firstResponse = responseGetAll.FirstOrDefault();
}
//Assert
using (var context = new DataContext(options))
{
Assert.That(1, Is.EqualTo(count));
Assert.IsNotNull(firstResponse.Id);
Assert.IsNotEmpty(firstResponse.Id.ToString());
Assert.That(vraag.JsonCorrecteAntwoord, Is.EqualTo(firstResponse.JsonCorrecteAntwoord));
Assert.That(vraag.JsonMogelijkeAntwoorden, Is.EqualTo(firstResponse.JsonMogelijkeAntwoorden));
Assert.That(vraag.MaxScoreVraag, Is.EqualTo(firstResponse.MaxScoreVraag));
Assert.That(vraag.TypeVraagId, Is.EqualTo(firstResponse.TypeVraagId));
Assert.That(vraag.VraagStelling, Is.EqualTo(firstResponse.VraagStelling));
}
}
public void CreateTeam()
{
//Act
var options = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "Testing_InMemoryDatabase1")
.Options;
int rows = 0;
Vraag responseVraag = null;
var vraag = new Vraag
{
MaxScoreVraag = 10,
TypeVraagId = 1,
VraagStelling = "Dit is de stelling van de vraag",
JsonCorrecteAntwoord = "JsonCorrecteAntwoord",
JsonMogelijkeAntwoorden = "JsonMogelijkeAntwoorden"
};
//Arrange
using (var context = new DataContext(options))
{
var repository = new SQLRepository <Vraag>(context);
responseVraag = repository.Add(vraag);
rows = repository.SaveChanges();
}
//Assert
using (var context = new DataContext(options))
{
Assert.AreEqual(1, rows);
Assert.IsNotNull(responseVraag.Id);
Assert.IsNotEmpty(responseVraag.Id.ToString());
Assert.That(vraag.JsonCorrecteAntwoord, Is.EqualTo(responseVraag.JsonCorrecteAntwoord));
Assert.That(vraag.JsonMogelijkeAntwoorden, Is.EqualTo(responseVraag.JsonMogelijkeAntwoorden));
Assert.That(vraag.MaxScoreVraag, Is.EqualTo(responseVraag.MaxScoreVraag));
Assert.That(vraag.TypeVraagId, Is.EqualTo(responseVraag.TypeVraagId));
Assert.That(vraag.VraagStelling, Is.EqualTo(responseVraag.VraagStelling));
Assert.AreEqual(1, context.Vragen.Count());
}
}
public void GetAll()
{
//Act
var options = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "Testing_InMemoryDatabase3")
.Options;
int count = 0;
IEnumerable <IngevoerdAntwoord> responseGetAll = null;
IngevoerdAntwoord firstResponse = null;
var antwoord = new IngevoerdAntwoord
{
GescoordeScore = 5,
JsonAntwoord = "JsonAntwoord",
TeamId = 1
};
//Arrange
using (var context = new DataContext(options))
{
var repository = new SQLRepository <IngevoerdAntwoord>(context);
repository.Add(antwoord);
repository.SaveChanges();
responseGetAll = repository.GetAll();
count = responseGetAll.Count();
firstResponse = responseGetAll.FirstOrDefault();
}
//Assert
using (var context = new DataContext(options))
{
Assert.That(1, Is.EqualTo(count));
Assert.IsNotNull(firstResponse.Id);
Assert.IsNotEmpty(firstResponse.Id.ToString());
Assert.That(antwoord.GescoordeScore, Is.EqualTo(firstResponse.GescoordeScore));
Assert.That(antwoord.JsonAntwoord, Is.EqualTo(firstResponse.JsonAntwoord));
Assert.That(antwoord.TeamId, Is.EqualTo(firstResponse.TeamId));
}
}
public void Remove()
{
//Act
var options = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "Testing_InMemoryDatabase6")
.Options;
bool reponseRemove;
int countBeforeDelete = 0;
int countAfterDelete = 0;
var antwoord = new IngevoerdAntwoord
{
GescoordeScore = 6,
JsonAntwoord = "JsonAntwoord",
TeamId = 1
};
//Arrange
using (var context = new DataContext(options))
{
var repository = new SQLRepository <IngevoerdAntwoord>(context);
var responseAdd = repository.Add(antwoord);
repository.SaveChanges();
countBeforeDelete = repository.GetAll().Count();
reponseRemove = repository.Remove(responseAdd.Id);
repository.SaveChanges();
countAfterDelete = repository.GetAll().Count();
}
//Assert
using (var context = new DataContext(options))
{
Assert.That(1, Is.EqualTo(countBeforeDelete));
Assert.That(0, Is.EqualTo(countAfterDelete));
Assert.That(true, Is.EqualTo(reponseRemove));
}
}
public void Update()
{
//Act
var options = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "Testing_InMemoryDatabase7")
.Options;
Ronde responseRondeUpdated = null;
var ronde = new Ronde
{
Naam = "Ronde 1"
};
var updateRonde = new Ronde
{
Id = 1,
Naam = "Ronde 1"
};
//Arrange
using (var context = new DataContext(options))
{
var repository = new SQLRepository <Ronde>(context);
var responseAdd = repository.Add(ronde);
repository.SaveChanges();
}
using (var context = new DataContext(options))
{
var repository = new SQLRepository <Ronde>(context);
responseRondeUpdated = repository.Update(updateRonde);
repository.SaveChanges();
}
//Assert
using (var context = new DataContext(options))
{
Assert.That(updateRonde.Naam, Is.EqualTo(responseRondeUpdated.Naam));
}
}
public void GetAll()
{
//Act
var options = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "Testing_InMemoryDatabase3")
.Options;
int count = 0;
IEnumerable <Team> responseGetAll = null;
Team firstResponse = null;
var team = new Team
{
Naam = "Quiz 1",
EmailCreator = "*****@*****.**",
Email = "*****@*****.**"
};
//Arrange
using (var context = new DataContext(options))
{
var repository = new SQLRepository <Team>(context);
repository.Add(team);
repository.SaveChanges();
responseGetAll = repository.GetAll();
count = responseGetAll.Count();
firstResponse = responseGetAll.FirstOrDefault();
}
//Assert
using (var context = new DataContext(options))
{
Assert.That(1, Is.EqualTo(count));
Assert.IsNotNull(firstResponse.Id);
Assert.IsNotEmpty(firstResponse.Id.ToString());
Assert.That(team.EmailCreator, Is.EqualTo(firstResponse.EmailCreator));
Assert.That(team.Naam, Is.EqualTo(firstResponse.Naam));
Assert.That(team.Email, Is.EqualTo(firstResponse.Email));
}
}
public void GetWhere()
{
//Act
var options = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "Testing_InMemoryDatabase5")
.Options;
IQueryable <Vraag> responseGetWhere = null;
Vraag reponseFirstOfWhere = null;
var vraag = new Vraag
{
MaxScoreVraag = 10,
TypeVraagId = 1,
VraagStelling = "Dit is de stelling van de vraag",
JsonCorrecteAntwoord = "JsonCorrecteAntwoord",
JsonMogelijkeAntwoorden = "JsonMogelijkeAntwoorden"
};
//Arrange
using (var context = new DataContext(options))
{
var repository = new SQLRepository <Vraag>(context);
repository.Add(vraag);
repository.SaveChanges();
responseGetWhere = repository.GetWhere(x => x.VraagStelling == "Dit is de stelling van de vraag");
reponseFirstOfWhere = responseGetWhere.FirstOrDefault();
}
//Assert
using (var context = new DataContext(options))
{
Assert.IsNotNull(responseGetWhere);
Assert.IsNotEmpty(reponseFirstOfWhere.Id.ToString());
Assert.That(vraag.JsonCorrecteAntwoord, Is.EqualTo(reponseFirstOfWhere.JsonCorrecteAntwoord));
Assert.That(vraag.JsonMogelijkeAntwoorden, Is.EqualTo(reponseFirstOfWhere.JsonMogelijkeAntwoorden));
Assert.That(vraag.MaxScoreVraag, Is.EqualTo(reponseFirstOfWhere.MaxScoreVraag));
Assert.That(vraag.TypeVraagId, Is.EqualTo(reponseFirstOfWhere.TypeVraagId));
Assert.That(vraag.VraagStelling, Is.EqualTo(reponseFirstOfWhere.VraagStelling));
}
}
public void Remove()
{
//Act
var options = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "Testing_InMemoryDatabase6")
.Options;
bool reponseRemove;
int countBeforeDelete = 0;
int countAfterDelete = 0;
var vraag = new Vraag
{
MaxScoreVraag = 10,
TypeVraagId = 1,
VraagStelling = "Dit is de stelling van de vraag",
JsonCorrecteAntwoord = "JsonCorrecteAntwoord",
JsonMogelijkeAntwoorden = "JsonMogelijkeAntwoorden"
};
//Arrange
using (var context = new DataContext(options))
{
var repository = new SQLRepository <Vraag>(context);
var responseAdd = repository.Add(vraag);
repository.SaveChanges();
countBeforeDelete = repository.GetAll().Count();
reponseRemove = repository.Remove(responseAdd.Id);
repository.SaveChanges();
countAfterDelete = repository.GetAll().Count();
}
//Assert
using (var context = new DataContext(options))
{
Assert.That(1, Is.EqualTo(countBeforeDelete));
Assert.That(0, Is.EqualTo(countAfterDelete));
Assert.That(true, Is.EqualTo(reponseRemove));
}
}
public void GetWhere()
{
//Act
var options = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "Testing_InMemoryDatabase5")
.Options;
IQueryable <IngevoerdAntwoord> responseGetWhere = null;
IngevoerdAntwoord reponseFirstOfWhere = null;
var antwoord = new IngevoerdAntwoord
{
GescoordeScore = 6,
JsonAntwoord = "JsonAntwoord",
TeamId = 1
};
//Arrange
using (var context = new DataContext(options))
{
var repository = new SQLRepository <IngevoerdAntwoord>(context);
repository.Add(antwoord);
repository.SaveChanges();
responseGetWhere = repository.GetWhere(x => x.GescoordeScore > 5);
reponseFirstOfWhere = responseGetWhere.FirstOrDefault();
}
//Assert
using (var context = new DataContext(options))
{
Assert.IsNotNull(responseGetWhere);
Assert.IsNotEmpty(reponseFirstOfWhere.Id.ToString());
Assert.That(antwoord.GescoordeScore, Is.EqualTo(reponseFirstOfWhere.GescoordeScore));
Assert.That(antwoord.JsonAntwoord, Is.EqualTo(reponseFirstOfWhere.JsonAntwoord));
Assert.That(antwoord.TeamId, Is.EqualTo(reponseFirstOfWhere.TeamId));
}
}
public void GetAll()
{
//Act
var options = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "Testing_InMemoryDatabase3")
.Options;
int count = 0;
IEnumerable <Ronde> responseGetAll = null;
Ronde firstResponse = null;
var ronde = new Ronde
{
Naam = "Ronde 1"
};
//Arrange
using (var context = new DataContext(options))
{
var repository = new SQLRepository <Ronde>(context);
repository.Add(ronde);
repository.SaveChanges();
responseGetAll = repository.GetAll();
count = responseGetAll.Count();
firstResponse = responseGetAll.FirstOrDefault();
}
//Assert
using (var context = new DataContext(options))
{
Assert.That(1, Is.EqualTo(count));
Assert.IsNotNull(firstResponse.Id);
Assert.IsNotEmpty(firstResponse.Id.ToString());
Assert.That(ronde.Naam, Is.EqualTo(firstResponse.Naam));
}
}
public void CreateAntwoord()
{
//Act
var options = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "Testing_InMemoryDatabase1")
.Options;
int rows = 0;
IngevoerdAntwoord responseAdd = null;
var antwoord = new IngevoerdAntwoord
{
GescoordeScore = 5,
JsonAntwoord = "JsonAntwoord",
TeamId = 1
};
//Arrange
using (var context = new DataContext(options))
{
var repository = new SQLRepository <IngevoerdAntwoord>(context);
responseAdd = repository.Add(antwoord);
rows = repository.SaveChanges();
}
//Assert
using (var context = new DataContext(options))
{
Assert.AreEqual(1, rows);
Assert.IsNotNull(responseAdd.Id);
Assert.IsNotEmpty(responseAdd.Id.ToString());
Assert.That(antwoord.GescoordeScore, Is.EqualTo(responseAdd.GescoordeScore));
Assert.That(antwoord.JsonAntwoord, Is.EqualTo(responseAdd.JsonAntwoord));
Assert.That(antwoord.TeamId, Is.EqualTo(responseAdd.TeamId));
Assert.AreEqual(1, context.IngevoerdAntwoorden.Count());
}
}
