public void Initialise()
{
MockPersonRepository = new MockPersonRepository();
MockPersonRepository.Create(new Person {Address = null});
PersonWithNullAddress = MockPersonRepository.Get(p => p.Address == null).FirstOrDefault();
}
public async System.Threading.Tasks.Task ShouldCrashOnDemand()
{
var l = new DummyLogger();
var r = new MockPersonRepository();
var c = new PersonController(l, r);
await Assert.ThrowsAnyAsync <Exception>(() => c.Get("err"));
}
public async System.Threading.Tasks.Task ShouldNotCrashOnNullQuery()
{
var l = new DummyLogger();
var r = new MockPersonRepository();
var c = new PersonController(l, r);
Assert.Empty(await c.Get(null));
}
public async System.Threading.Tasks.Task ShouldNotReturnUnknownPeople()
{
var l = new DummyLogger();
var r = new MockPersonRepository();
var c = new PersonController(l, r);
Assert.Empty(await c.Get("XXX"));
}
public void TestUpdateAuthors()
{
var unitOfWorkProvider = CreateMockUnitOfWorkProvider();
var bookData = new BookData
{
Authors = new List <AuthorData>
{
new AuthorData {
Name = "Aaa Bbb"
},
new AuthorData {
Name = "Ccc Ddd"
}
}
};
var personRepository = new MockPersonRepository(unitOfWorkProvider)
{
CanFindAuthorByName = true
};
var projectRepository = new MockProjectRepository(unitOfWorkProvider)
{
ProjectOriginalAuthors = new List <ProjectOriginalAuthor>
{
new ProjectOriginalAuthor
{
OriginalAuthor = new OriginalAuthor {
FirstName = "Eee", LastName = "Fff", Id = 30
},
Sequence = 1
},
new ProjectOriginalAuthor
{
OriginalAuthor = new OriginalAuthor {
FirstName = "Aaa", LastName = "Bbb", Id = 10
},
Sequence = 2
}
}
};
var subtask = new UpdateAuthorsSubtask(projectRepository, personRepository);
subtask.UpdateAuthors(41, bookData);
Assert.AreEqual(1, projectRepository.CreatedObjects.Count);
Assert.AreEqual(1, projectRepository.UpdatedObjects.Count);
Assert.AreEqual(1, projectRepository.DeletedObjects.Count);
var createdItem = (ProjectOriginalAuthor)projectRepository.CreatedObjects.Single();
var updatedItem = (ProjectOriginalAuthor)projectRepository.UpdatedObjects.Single();
Assert.AreEqual(1, updatedItem.Sequence);
Assert.AreEqual(2, createdItem.Sequence);
}
public async System.Threading.Tasks.Task ShouldReturnKnownPeople()
{
var l = new DummyLogger();
var r = new MockPersonRepository();
var c = new PersonController(l, r);
var p = r.GetAll().First();
var fname = p.FirstName;
var lname = p.LastName;
Assert.NotEmpty(await c.Get(fname));
Assert.NotEmpty(await c.Get(lname));
}
public async Task ValidationFlow()
{
MockValidatorFactory.Setup(v => v.GetValidator(Request)).Throws(new ValidationException("testing error."));
var service = CreateService();
var result = await service.ProcessAsync();
MockValidatorFactory.Verify(v => v.GetValidator(Request), Times.Once);
MockPersonRepository.Verify(r => r.GetPersonAsync(Request.PersonID.Value), Times.Never);
Assert.IsTrue(result != null);
Assert.IsTrue(result.StatusCode == HttpStatusCode.BadRequest);
Assert.IsTrue(result.Response is ValidationErrorResponse response && !response.Successful);
}
public async Task EmptyValidator()
{
MockValidatorFactory.Setup(v => v.GetValidator(Request)).Returns <IValidator>(null);
var service = CreateService();
var result = await service.ProcessAsync();
MockValidatorFactory.Verify(v => v.GetValidator(Request), Times.Once);
MockPersonRepository.Verify(r => r.GetPersonAsync(Request.PersonID.Value), Times.Never);
Assert.IsTrue(result != null);
Assert.IsTrue(result.StatusCode == HttpStatusCode.InternalServerError);
Assert.IsTrue(result.Response is ErrorResponse response && !response.Successful);
}
public void Test_GetAllPersons()
{
// arrange
var colorMock = new Mock <IColorRepository>();
colorMock.Setup(c => c.Colors).Returns(Colors);
var pService = new MockPersonRepository(colorMock.Object);
int expectedPersons = 9;
// act
var persons = pService.GetPersons();
// assert
Assert.Equal(expectedPersons, persons.Count());
}
public void Test_GetPersonById()
{
// arrange
var colorMock = new Mock <IColorRepository>();
colorMock.Setup(c => c.Colors).Returns(Colors);
var pService = new MockPersonRepository(colorMock.Object);
int expectedId = 0;
// act
var person = pService.GetPersonById(0);
// assert
Assert.Equal(expectedId, person.Id);
}
public void Test_GetPersonsByColor()
{
// arrange
var colorMock = new Mock <IColorRepository>();
colorMock.Setup(c => c.Colors).Returns(Colors);
var pService = new MockPersonRepository(colorMock.Object);
int expectedId = 3;
// act
var persons = pService.GetPersonsByColor("grün");
int totalPersonsByColor = persons.Count();
// assert
Assert.Equal(expectedId, totalPersonsByColor);
}
public void Test_AddPersion()
{
// arrange
var person = new Person()
{
Id = 9, Name = "Mr. New", LastName = "Mann", ColorId = 1, City = "Erlangen", ZipCode = 91402
};
var colorMock = new Mock <IColorRepository>();
colorMock.Setup(c => c.Colors).Returns(Colors);
var pService = new MockPersonRepository(colorMock.Object);
int totaLPersonAfterAdd = 10;
// act
var persons = pService.AddPerson(person);
var personsCount = persons.Count();
// assert
Assert.Equal(totaLPersonAfterAdd, personsCount);
}
public async Task SuccessfulFlow()
{
const string name = "example";
const int age = int.MaxValue;
var repositoryResults = new PersonResult()
{
Name = name,
Age = age
};
MockValidatorFactory.Setup(v => v.GetValidator(Request)).Returns(new GetPersonRequestValidator());
MockPersonRepository.Setup(r => r.GetPersonAsync(Request.PersonID.Value)).ReturnsAsync(repositoryResults);
var service = CreateService();
var result = await service.ProcessAsync();
MockValidatorFactory.Verify(v => v.GetValidator(Request), Times.Once);
MockPersonRepository.Verify(r => r.GetPersonAsync(Request.PersonID.Value), Times.Once);
Assert.IsTrue(result != null);
Assert.IsTrue(result.StatusCode == HttpStatusCode.OK);
Assert.IsTrue(result.Response is GetPersonResponse response && response.Person != null && response.Successful);
}
public async Task ValidatorFailure()
{
var mockValidationResult = new Mock <ValidationResult>();
mockValidationResult.SetupGet(v => v.IsValid).Returns(false);
MockServiceValidationConverter.Setup(v => v.ConvertToDictionaryFormat(It.IsAny <ValidationResult>()))
.Returns(new Dictionary <string, List <string> > {
{ "testing", new List <string> {
"testing message."
} }
});
var mockValidator = new Mock <GetPersonRequestValidator>();
mockValidator.Setup(v => v.ValidateAsync(It.IsAny <ValidationContext <GetPersonRequest> >(), It.IsAny <CancellationToken>()))
.ReturnsAsync(mockValidationResult.Object);
MockValidatorFactory.Setup(v => v.GetValidator(Request)).Returns(mockValidator.Object);
var service = CreateService();
var result = await service.ProcessAsync();
MockValidatorFactory.Verify(v => v.GetValidator(Request), Times.Once);
mockValidator.Verify(v => v.ValidateAsync(It.IsAny <ValidationContext <GetPersonRequest> >(), It.IsAny <CancellationToken>()), Times.Once);
mockValidationResult.VerifyGet(v => v.IsValid, Times.Once);
MockServiceValidationConverter.Verify(v => v.ConvertToDictionaryFormat(It.IsAny <ValidationResult>()), Times.Once);
MockPersonRepository.Verify(r => r.GetPersonAsync(Request.PersonID.Value), Times.Never);
Assert.IsTrue(result != null);
Assert.IsTrue(result.StatusCode == HttpStatusCode.BadRequest);
Assert.IsTrue(result.Response is ValidationErrorResponse response &&
!response.Successful &&
response.ValidationErrors.ContainsKey("testing") &&
response.ValidationErrors["testing"][0] == "testing message.");
}
public void TestUpdateResponsiblePersons()
{
var unitOfWorkProvider = CreateMockUnitOfWorkProvider();
var bookData = new BookData
{
Responsibles = new List <ResponsibleData>
{
new ResponsibleData
{
NameText = "Aaa Bbb",
TypeText = "editor",
},
new ResponsibleData
{
NameText = "Aaa Bbb",
TypeText = "production",
},
new ResponsibleData
{
NameText = "Ccc Ddd",
TypeText = "editor",
},
}
};
var personRepository = new MockPersonRepository(unitOfWorkProvider)
{
CanFindAuthorByName = true
};
var projectRepository = new MockProjectRepository(unitOfWorkProvider)
{
ProjectResponsiblePersons = new List <ProjectResponsiblePerson>
{
new ProjectResponsiblePerson
{
ResponsiblePerson = new ResponsiblePerson {
FirstName = "Eee", LastName = "Fff", Id = 30
},
ResponsibleType = new ResponsibleType {
Text = "editor", Id = 10
},
Sequence = 1,
},
new ProjectResponsiblePerson
{
ResponsiblePerson = new ResponsiblePerson {
FirstName = "Aaa", LastName = "Bbb", Id = 31
},
ResponsibleType = new ResponsibleType {
Text = "editor", Id = 10
},
Sequence = 1,
}
}
};
var subtask = new UpdateResponsiblePersonSubtask(projectRepository, personRepository);
subtask.UpdateResponsiblePersonList(41, bookData);
Assert.AreEqual(2, projectRepository.CreatedObjects.Count);
Assert.AreEqual(1, projectRepository.UpdatedObjects.Count);
Assert.AreEqual(1, projectRepository.DeletedObjects.Count);
var createdItem2 = projectRepository.CreatedObjects.OfType <ProjectResponsiblePerson>().Single(x => x.ResponsiblePerson.FirstName == "Aaa");
var createdItem3 = projectRepository.CreatedObjects.OfType <ProjectResponsiblePerson>().Single(x => x.ResponsiblePerson.FirstName == "Ccc");
var updatedItem = projectRepository.UpdatedObjects.OfType <ProjectResponsiblePerson>().Single();
Assert.AreEqual(1, updatedItem.Sequence);
Assert.AreEqual(2, createdItem2.Sequence);
Assert.AreEqual(3, createdItem3.Sequence);
}
