public async Task GetById_PersonWithIdInRepository_ReturnsSuccessWithPerson()
{
//Arrange
const int Id = 0;
Person expected = PersonGenerator.Generate();
expected.Id = Id;
Mock <IPersonRepository> repository = new Mock <IPersonRepository>();
repository.Setup(r => r.GetAsync(Id))
.Returns(Task.FromResult(expected));
PersonController controller = new PersonController(repository.Object);
//Act
IActionResult result = await controller.Get(Id);
//Assert
ObjectResult resultWithValue = Assert.IsType <ObjectResult>(result);
Person actual = Assert.IsType <Person>(resultWithValue.Value);
Assert.Equal(expected, actual, PersonEqualityComparer.Default);
}
public async Task Put_NoPeopleInRepository_ReturnsNotFound()
{
Mock <IPersonRepository> repository = new Mock <IPersonRepository>();
PersonController controller = new PersonController(repository.Object);
Person person = PersonGenerator.Generate();
//Act
IActionResult result = await controller.Put(0, person);
//Assert
Assert.IsType <NotFoundResult>(result);
}
public async Task GetAllAsync_MultiplePeopleInContext_ReturnsMultipleItems()
{
//Arrange
IEnumerable <Person> expected = PersonGenerator.Generate(10);
PersonContext personContext = await CreatePersonContextWithPeople(expected);
PersonRepository personRepository = new PersonRepository(personContext);
//Act
IEnumerable <Person> actual = await personRepository.GetAllAsync();
//Assert
Assert.Equal(expected, actual);
}
public async Task RemoveAsync_PersonExistsInContext_RemovesFromContext()
{
//Arrange
Person original = PersonGenerator.Generate();
PersonContext personContext = await CreatePersonContextWithPeople(original);
PersonRepository personRepository = new PersonRepository(personContext);
//Act
Person entity = await personRepository.RemoveAsync(original.Id);
//Assert
Assert.NotNull(entity);
Assert.Empty(personContext.People);
}
public async Task Get_MultiplePeopleInRepository_ReturnsAllItems()
{
//Arrange
IEnumerable <Person> people = PersonGenerator.Generate(5);
Mock <IPersonRepository> repository = new Mock <IPersonRepository>();
repository.Setup(r => r.GetAllAsync()).Returns(Task.FromResult(people));
PersonController controller = new PersonController(repository.Object);
//Act
IEnumerable <Person> result = await controller.Get();
//Assert
Assert.Equal(people, result);
}
public async Task Get_SinglePersonInRepository_ReturnsSinglePerson()
{
//Arrange
Mock <IPersonRepository> repository = new Mock <IPersonRepository>();
repository.Setup(r => r.GetAllAsync())
.Returns(Task.FromResult <IEnumerable <Person> >(new [] { PersonGenerator.Generate() }));
PersonController controller = new PersonController(repository.Object);
//Act
IEnumerable <Person> result = await controller.Get();
//Assert
Assert.Single(result);
}
public async Task Delete_ValidIdMatchingPersonInRepository_ReturnsOk()
{
Person person = PersonGenerator.Generate();
Mock <IPersonRepository> repository = new Mock <IPersonRepository>();
repository.Setup(r => r.RemoveAsync(It.IsAny <int>())).Returns(Task.FromResult(person));
PersonController controller = new PersonController(repository.Object);
//Act
IActionResult result = await controller.Delete(0);
//Assert
Assert.IsType <OkResult>(result);
}
public async Task Put_ValidPersonWithExistingInRepository_ReturnsOk()
{
Person person = PersonGenerator.Generate();
Mock <IPersonRepository> repository = new Mock <IPersonRepository>();
repository.Setup(r => r.GetAsync(It.IsAny <int>())).Returns(Task.FromResult(person));
PersonController controller = new PersonController(repository.Object);
//Act
IActionResult result = await controller.Put(0, person);
//Assert
Assert.IsType <OkResult>(result);
}
public async Task Post_PersonWithFullName_ReturnsCreatedAtResult()
{
//Arrange
Person expected = PersonGenerator.Generate();
Mock <IPersonRepository> repository = new Mock <IPersonRepository>();
PersonController controller = new PersonController(repository.Object);
//Act
IActionResult result = await controller.Post(expected);
//Assert
CreatedAtActionResult createdAtActionResult = Assert.IsType <CreatedAtActionResult>(result);
Assert.Null(createdAtActionResult.ControllerName);
Assert.Equal(nameof(PersonController.Get), createdAtActionResult.ActionName);
}
public async Task GetAsync_IdExistsInContext_ReturnsPerson()
{
//Arrange
const int ExpectedId = 1;
Person expected = PersonGenerator.Generate();
PersonContext personContext = await CreatePersonContextWithPeople(expected);
PersonRepository personRepository = new PersonRepository(personContext);
//Act
Person actual = await personRepository.GetAsync(ExpectedId);
//Assert
Assert.Equal(expected, actual, PersonEqualityComparer.Default);
}
public async Task RemoveAsync_PersonNotInContext_ReturnsNullAndNoEntriesRemoved()
{
//Arrange
Person original = PersonGenerator.Generate();
Person entryToRemove = PersonGenerator.Generate();
PersonContext personContext = await CreatePersonContextWithPeople(original);
PersonRepository personRepository = new PersonRepository(personContext);
//Act
Person entity = await personRepository.RemoveAsync(entryToRemove.Id);
//Assert
Assert.Null(entity);
Assert.NotEmpty(personContext.People);
}
public async Task AddAsync_NewPersonWithNoExistingPeople_ReturnsIdAndAddsToContext()
{
//Arrange
Person expected = PersonGenerator.Generate();
PersonContext personContext = CreatePersonContext();
PersonRepository personRepository = new PersonRepository(personContext);
//Act
int result = await personRepository.AddAsync(expected);
//Assert
Assert.Equal(expected.Id, result);
Person actual = personContext.People.Find(result);
Assert.Equal(expected, actual, PersonEqualityComparer.Default);
}
public async Task GetAllAsync_OnePersonInContext_ReturnsSingleItem()
{
//Arrange
Person expected = PersonGenerator.Generate();
PersonContext personContext = await CreatePersonContextWithPeople(expected);
PersonRepository personRepository = new PersonRepository(personContext);
//Act
IEnumerable <Person> result = await personRepository.GetAllAsync();
//Assert
Person actual = Assert.Single(result);
Assert.Equal(expected, actual, PersonEqualityComparer.Default);
}
public async Task AddAsync_ExistingPersonWithIdAddingDuplicate_DuplicateNotAddedAndReturnsExistingId()
{
//Arrange
const int Id = 1;
Person expected = PersonGenerator.Generate();
PersonContext personContext = await CreatePersonContextWithPeople(expected);
PersonRepository personRepository = new PersonRepository(personContext);
//Act
int result = await personRepository.AddAsync(expected);
//Assert
Assert.Equal(Id, result);
Person actual = Assert.Single(personContext.People);
Assert.Equal(expected, actual, PersonEqualityComparer.Default);
}
static void Main(string[] args)
{
{
// Zadanie 2
Delegata d = new Delegata(Method);
d(2, 2);
Console.WriteLine("Wartość właściwości metod: {0}", d.Method);
d += Method2;
Console.WriteLine("Usunięcie Method, wyświetlenie Method2:");
d -= Method;
d(1, 2);
Console.WriteLine(d.Method);
PersonGenerator pg = new PersonGenerator();
pg.Zdarzenie += Wyswietl;
pg.Generate();
}
Console.ReadKey();
}
public async Task UpdateAsync_IdExistsInContext_OriginalUpdated()
{
//Arrange
Person original = PersonGenerator.Generate();
PersonContext personContext = await CreatePersonContextWithPeople(original);
PersonRepository personRepository = new PersonRepository(personContext);
//Act
Person updated = new Person
{
Id = original.Id,
FirstName = original.FirstName,
LastName = "Perkins"
};
await personRepository.UpdateAsync(updated);
//Assert
Person actual = Assert.Single(personContext.People, p => p.Id == original.Id);
Assert.Equal(updated, actual, PersonEqualityComparer.Default);
}