public async void ShouldReturnOKObjectResultWithClan()
{
//Arrange
var expectedClans = new Clan[]
{
new Clan {
Name = "Test Clan 1"
},
new Clan {
Name = "Test Clan 2"
},
new Clan {
Name = "Test Clan 3"
}
};
ClanServiceMock
.Setup(x => x.ReadAllAsync())
.ReturnsAsync(expectedClans);
//Act
var result = await ControllerUnderTest.ReadAllAsync();
//Assert
var okResult = Assert.IsType <OkObjectResult>(result);
Assert.Same(expectedClans, okResult.Value);
}
public async void ShouldDeleteAndReturnTheDeletedNinja()
{
//Arrange
var clanName = "Some clan name";
var ninjaKey = "SomeNinjaKey";
var expectedNinja = new Ninja();
ClanServiceMock
.Setup(x => x.IsClanExistsAsync(clanName))
.ReturnsAsync(true);
NinjaRepositoryMock
.Setup(x => x.ReadOneAsync(clanName, ninjaKey))
.ReturnsAsync(expectedNinja)
.Verifiable();
NinjaRepositoryMock
.Setup(x => x.DeleteAsync(clanName, ninjaKey))
.ReturnsAsync(expectedNinja)
.Verifiable();
//Act
var result = await ServiceUnderTest.DeleteAsync(clanName, ninjaKey);
//Assert
Assert.Same(expectedNinja, result);
NinjaRepositoryMock.Verify(x => x.ReadOneAsync(clanName, ninjaKey), Times.Once);
NinjaRepositoryMock.Verify(x => x.DeleteAsync(clanName, ninjaKey), Times.Once);
}
public async void ShouldCreateAndReturnTheCreatedNinja()
{
//Arrange
var clanName = "Some clan name";
var expectedNinja = new Ninja {
Name = "Test Ninja 1", Clan = new Clan {
Name = clanName
}
};
ClanServiceMock
.Setup(x => x.IsClanExistsAsync(expectedNinja.Clan.Name))
.ReturnsAsync(true)
.Verifiable();
NinjaRepositoryMock
.Setup(x => x.CreateAsync(expectedNinja))
.ReturnsAsync(expectedNinja)
.Verifiable();
//Act
var result = await ServiceUnderTest.CreateAsync(expectedNinja);
//Assert
Assert.Same(expectedNinja, result);
ClanServiceMock.Verify(x => x.IsClanExistsAsync(clanName), Times.Once);
NinjaRepositoryMock.Verify(x => x.CreateAsync(expectedNinja), Times.Once);
}
public async void Should_throw_a_ClanNotFoundException_when_clan_does_not_exist()
{
// Arrange
const string ninjaKey = "SomeKey";
const string clanKey = "Some clan";
var unexistingNinja = new Ninja {
Key = ninjaKey, Clan = new Clan {
Name = clanKey
}
};
NinjaRepositoryMock
.Setup(x => x.UpdateAsync(unexistingNinja))
.Verifiable();
ClanServiceMock
.Setup(x => x.IsClanExistsAsync(clanKey))
.ReturnsAsync(false);
// Act & Assert
await Assert.ThrowsAsync <ClanNotFoundException>(() => ServiceUnderTest.UpdateAsync(unexistingNinja));
// Make sure UpdateAsync is never called
NinjaRepositoryMock
.Verify(x => x.UpdateAsync(unexistingNinja), Times.Never);
}
public async void Should_throw_NinjaNotFoundException_when_ninja_does_not_exist()
{
// Arrange
const string ninjaKey = "SomeKey";
const string clanKey = "Some clan";
var unexistingNinja = new Ninja {
Key = ninjaKey, Clan = new Clan {
Name = clanKey
}
};
NinjaRepositoryMock
.Setup(x => x.UpdateAsync(unexistingNinja))
.Verifiable();
NinjaRepositoryMock
.Setup(x => x.ReadOneAsync(clanKey, ninjaKey))
.ReturnsAsync(default(Ninja))
.Verifiable();
ClanServiceMock
.Setup(x => x.IsClanExistsAsync(clanKey))
.ReturnsAsync(true);
// Act & Assert
await Assert.ThrowsAsync <NinjaNotFoundException>(() => ServiceUnderTest.UpdateAsync(unexistingNinja));
// Make sure UpdateAsync is never hit
NinjaRepositoryMock
.Verify(x => x.UpdateAsync(unexistingNinja), Times.Never);
// Make sure we read the ninja from the repository before attempting an update.
NinjaRepositoryMock
.Verify(x => x.ReadOneAsync(clanKey, ninjaKey), Times.Once);
}
public async void Should_update_and_return_the_updated_Ninja()
{
// Arrange
const string ninjaKey = "Some key";
const string clanKey = "Some clan";
var expectedNinja = new Ninja
{
Key = ninjaKey,
Clan = new Clan {
Name = clanKey
}
};
NinjaRepositoryMock
.Setup(x => x.ReadOneAsync(clanKey, ninjaKey))
.ReturnsAsync(expectedNinja);
NinjaRepositoryMock
.Setup(x => x.UpdateAsync(expectedNinja))
.ReturnsAsync(expectedNinja)
.Verifiable();
ClanServiceMock
.Setup(x => x.IsClanExistsAsync(clanKey))
.ReturnsAsync(true);
// Act
var result = await ServiceUnderTest.UpdateAsync(expectedNinja);
// Assert
Assert.Same(expectedNinja, result);
NinjaRepositoryMock.Verify(x => x.UpdateAsync(expectedNinja), Times.Once);
}
public async void Should_create_and_return_the_created_Ninja()
{
// Arrange
const string clanName = "Some clan name";
var expectedNinja = new Ninja {
Clan = new Clan {
Name = clanName
}
};
NinjaRepositoryMock
.Setup(x => x.CreateAsync(expectedNinja))
.ReturnsAsync(expectedNinja)
.Verifiable();
ClanServiceMock
.Setup(x => x.IsClanExistsAsync(clanName))
.ReturnsAsync(true);
// Act
var result = await ServiceUnderTest.CreateAsync(expectedNinja);
// Assert
Assert.Same(expectedNinja, result);
NinjaRepositoryMock.Verify(x => x.CreateAsync(expectedNinja), Times.Once);
}
public async void ShouldThrowClanNotFoundExceptionWhenClanDoesNotExist()
{
//Arrange
var unexistingClanName = "Some clan name";
NinjaRepositoryMock
.Setup(x => x.ReadAllClanAsync(unexistingClanName))
.Verifiable();
ClanServiceMock
.Setup(x => x.IsClanExistsAsync(unexistingClanName))
.ReturnsAsync(false)
.Verifiable();
//Act & Assert
await Assert.ThrowsAsync <ClanNotFoundException>(() => ServiceUnderTest.ReadAllClanAsync(unexistingClanName));
NinjaRepositoryMock.Verify(x => x.ReadAllClanAsync(unexistingClanName), Times.Never);
ClanServiceMock.Verify(x => x.IsClanExistsAsync(unexistingClanName), Times.Once);
}
public async void ShouldThrowNinjaNotFoundExceptionWhenNinjaDoesNotExist()
{
//Arrange
var clanName = "Some clan name";
var ninjaKey = "SomeNinjaKey";
NinjaRepositoryMock
.Setup(x => x.ReadOneAsync(clanName, ninjaKey))
.ThrowsAsync(new NinjaNotFoundException(clanName, ninjaKey))
.Verifiable();
ClanServiceMock
.Setup(x => x.IsClanExistsAsync(clanName))
.ReturnsAsync(true)
.Verifiable();
//Act & Assert
await Assert.ThrowsAsync <NinjaNotFoundException>(() => ServiceUnderTest.ReadOneAsync(clanName, ninjaKey));
NinjaRepositoryMock.Verify(x => x.ReadOneAsync(clanName, ninjaKey), Times.Once);
ClanServiceMock.Verify(x => x.IsClanExistsAsync(clanName), Times.Once);
}
public async void Should_throw_a_ClanNotFoundException_when_clan_does_not_exist()
{
const string clanName = "Some clan name";
var expectedNinja = new Ninja {
Clan = new Clan {
Name = clanName
}
};
NinjaRepositoryMock
.Setup(x => x.CreateAsync(expectedNinja))
.ReturnsAsync(expectedNinja)
.Verifiable();
ClanServiceMock
.Setup(x => x.IsClanExistsAsync(clanName))
.ReturnsAsync(false);
// Act & Assert
await Assert.ThrowsAsync <ClanNotFoundException>(() => ServiceUnderTest.CreateAsync(expectedNinja));
// Make sure CreateAsync is never called
NinjaRepositoryMock.Verify(x => x.CreateAsync(expectedNinja), Times.Never);
}
public async void ShouldReturnAllNinjasInClan()
{
//Arrange
var clanName = "Some clan name";
var expectedNinjas = new Ninja[]
{
new Ninja {
Name = "Test Ninja 1"
},
new Ninja {
Name = "Test Ninja 2"
},
new Ninja {
Name = "Test Ninja 3"
}
};
NinjaRepositoryMock
.Setup(x => x.ReadAllClanAsync(clanName))
.ReturnsAsync(expectedNinjas)
.Verifiable();
ClanServiceMock
.Setup(x => x.IsClanExistsAsync(clanName))
.ReturnsAsync(true)
.Verifiable();
//Act
var result = await ServiceUnderTest.ReadAllClanAsync(clanName);
//Assert
Assert.Same(expectedNinjas, result);
NinjaRepositoryMock
.Verify(x => x.ReadAllClanAsync(clanName), Times.Once);
ClanServiceMock
.Verify(x => x.IsClanExistsAsync(clanName), Times.Once);
}
public async void ShouldThrowClanNotFoundExceptionWhenClanDoesNotExist()
{
//Arrange
var clanName = "Some clan name";
var expectedNinja = new Ninja {
Name = "Test Ninja 1", Clan = new Clan {
Name = clanName
}
};
ClanServiceMock
.Setup(x => x.IsClanExistsAsync(expectedNinja.Clan.Name))
.ReturnsAsync(false)
.Verifiable();
NinjaRepositoryMock
.Setup(x => x.CreateAsync(expectedNinja))
.Verifiable();
//Act & Assert
await Assert.ThrowsAsync <ClanNotFoundException>(() => ServiceUnderTest.CreateAsync(expectedNinja));
ClanServiceMock.Verify(x => x.IsClanExistsAsync(clanName), Times.Once);
NinjaRepositoryMock.Verify(x => x.CreateAsync(expectedNinja), Times.Never);
}
