public async Task MutantService_IsMutantAsync_ValidDnaAlreadySaved_Succeeds()
{
//Arrange
Mock <MutantService> serviceMock = GetMutantServiceMock();
MutantService service = serviceMock.Object;
Human human = new Human()
{
Dna = new string[] { "AAA", "CCC", "TTT" }
};
Dna savedDna = new Dna()
{
Id = Guid.NewGuid(),
ChainString = "AAA,CCC,TTT",
IsMutant = true
};
serviceMock.Setup(x => x.IsDnaValid(It.IsAny <string[]>())).Returns(true).Verifiable();
_memoryCacheServiceMock.Setup(x => x.GetAsync(It.IsAny <string>(), It.IsAny <Func <Task <Dna> > >())).ReturnsAsync(savedDna).Verifiable();
serviceMock.Setup(x => x.VerifyIsMutant(It.IsAny <string[]>())).Returns(true).Verifiable();
//Action
bool result = await service.IsMutantAsync(human);
//Asserts
Assert.IsTrue(result);
serviceMock.Verify(x => x.IsDnaValid(It.IsAny <string[]>()), Times.Once);
_memoryCacheServiceMock.Verify(x => x.GetAsync(It.IsAny <string>(), It.IsAny <Func <Task <Dna> > >()), Times.Once);
serviceMock.Verify(x => x.VerifyIsMutant(It.IsAny <string[]>()), Times.Never);
}
public async Task StatsMutantTests_HumanAndMutantEquals_Ratio1()
{
//arrange
fakeRepository.Setup(x => x.Where("isMutant = true"))
.Returns(Task.FromResult <IEnumerable <Mutant> >(new List <Mutant>()
{
new Mutant {
isMutant = true
}
}));
fakeRepository.Setup(x => x.Where("isMutant = false"))
.Returns(Task.FromResult <IEnumerable <Mutant> >(new List <Mutant>()
{
new Mutant {
isMutant = true
}
}));
var mutantservice = new MutantService(fakeRepository.Object);
//act
var result = await mutantservice.StatsMutant();
//assert
Assert.Equal(1, result.ratio);
}
public async Task MutantService_IsMutantAsync_ValidDnaNonSaved_Succeeds()
{
//Arrange
Mock <MutantService> serviceMock = GetMutantServiceMock();
MutantService service = serviceMock.Object;
Human human = new Human()
{
Dna = new string[] { "AAA", "CCC", "TTT" }
};
serviceMock.Setup(x => x.IsDnaValid(It.IsAny <string[]>())).Returns(true).Verifiable();
_memoryCacheServiceMock.Setup(x => x.GetAsync(It.IsAny <string>(), It.IsAny <Func <Task <Dna> > >())).ReturnsAsync((Dna)null).Verifiable();
serviceMock.Setup(x => x.VerifyIsMutant(It.IsAny <string[]>())).Returns(true).Verifiable();
_dnaServiceMock.Setup(x => x.SaveAsync(It.IsAny <ICollection <Dna> >())).Verifiable();
//Action
bool result = await service.IsMutantAsync(human);
//Asserts
Assert.IsTrue(result);
serviceMock.Verify(x => x.IsDnaValid(It.IsAny <string[]>()), Times.Once);
_memoryCacheServiceMock.Verify(x => x.GetAsync(It.IsAny <string>(), It.IsAny <Func <Task <Dna> > >()), Times.Once);
serviceMock.Verify(x => x.VerifyIsMutant(It.IsAny <string[]>()), Times.Once);
_dnaServiceMock.Verify(x => x.SaveAsync(It.IsAny <ICollection <Dna> >()), Times.Once);
}
public void MutantService_IsMutantAsync_ParameterHumanInNull_Fails()
{
//Arrange
MutantService service = GetMutantService();
//Action && Asserts
Assert.ThrowsExceptionAsync <ArgumentNullException>(() => service.IsMutantAsync(null));
}
public void MutantService_VerifyIsMutant_WrongParameters_Fails()
{
//Arrange
MutantService service = GetMutantService();
//Action && Asserts
Assert.ThrowsException <ArgumentException>(() => service.VerifyIsMutant(null));
Assert.ThrowsException <ArgumentException>(() => service.VerifyIsMutant(new string[] { }));
}
public void MutantService_IsDnaValid_OneInvalidLetterAtTheEnd_Fails()
{
//Arrange
MutantService service = GetMutantService();
string[] dna = { "AGT", "ATC", "CCW" }; //==> W is invalid
//Action & Asserts
Assert.ThrowsException <DnaInvalidException>(() => service.IsDnaValid(dna));
}
public void MutantService_IsDnaValid_DnaNxM_Fails()
{
//Arrange
MutantService service = GetMutantService();
string[] dna = { "AGA", "AT", "CCT" };
//Action & Asserts
Assert.ThrowsException <DnaInvalidException>(() => service.IsDnaValid(dna));
}
public void MutantService_IsDnaValid_DnaInNull_Fails()
{
//Arrange
MutantService service = GetMutantService();
string[] dna = null;
//Action & Asserts
Assert.ThrowsException <DnaInvalidException>(() => service.IsDnaValid(dna));
}
public void MutantService_IsDnaValid_OneInvalidWhiteSpaceInTheMiddle_Fails()
{
//Arrange
MutantService service = GetMutantService();
string[] dna = { "AGT", "A C", "CCW" }; //==> " " is invalid
//Action & Asserts
Assert.ThrowsException <DnaInvalidException>(() => service.IsDnaValid(dna));
}
public async Task MutantServiceTests_EntityDNANull_Exception()
{
//arrange
var mutantservice = new MutantService(fakeRepository.Object);
//act
var handleTask = mutantservice.ValidateIsMutant(null);
//assert
var result = await Assert.ThrowsAsync <Exception>(async() => await handleTask);
}
public void MutantService_IsMutantAsync_IsDnaValidThrowsException_Fails()
{
//Arrange
Mock <MutantService> serviceMock = GetMutantServiceMock();
MutantService service = serviceMock.Object;
serviceMock.Setup(x => x.IsDnaValid(It.IsAny <string[]>())).Throws <DnaInvalidException>().Verifiable();
//Action && Asserts
Assert.ThrowsExceptionAsync <DnaInvalidException>(() => service.IsMutantAsync(new Human()));
serviceMock.Verify(x => x.IsDnaValid(It.IsAny <string[]>()), Times.Once);
}
public void MutantService_IsDnaValid_ValidDna4x4_Succeeds()
{
//Arrange
MutantService service = GetMutantService();
string[] dna = { "AGTA", "ATCA", "ACCA", "TGAC" };
//Action
bool result = service.IsDnaValid(dna);
//Asserts
Assert.IsTrue(result);
}
public MutantServiceTest()
{
mockLogger = new Mock <ILogger <MutantService> >();
mockDnaValidator = new Mock <IDnaValidator>();
mockDataRepository = new Mock <IDataRepository <Dna> >();
mockStatsRepository = new Mock <IStatsRepository>();
mockMemoryCache = new Mock <IMemoryCache>();
mutantService = new MutantService(
mockLogger.Object,
mockDnaValidator.Object,
mockDataRepository.Object,
mockStatsRepository.Object,
mockMemoryCache.Object
);
}
public async Task MutantService_IsMutantAsync_InvalidDna_Succeeds()
{
//Arrange
Mock <MutantService> serviceMock = GetMutantServiceMock();
MutantService service = serviceMock.Object;
serviceMock.Setup(x => x.IsDnaValid(It.IsAny <string[]>())).Returns(false).Verifiable();
_memoryCacheServiceMock.Setup(x => x.GetAsync(It.IsAny <string>(), It.IsAny <Func <Task <Dna> > >())).ReturnsAsync(new Dna()).Verifiable();
//Action
bool result = await service.IsMutantAsync(new Human());
//Asserts
Assert.IsFalse(result);
serviceMock.Verify(x => x.IsDnaValid(It.IsAny <string[]>()), Times.Once);
_memoryCacheServiceMock.Verify(x => x.GetAsync(It.IsAny <string>(), It.IsAny <Func <Task <Dna> > >()), Times.Never);
}
public void MutantService_VerifyIsMutant_DnaNoMutant5x5_Succeeds()
{
//Arrange
MutantService service = GetMutantService();
string[] dna =
{
"AACCT",
"ACTGC",
"CCTGG",
"GATCC",
"TTCGA",
};
//Action
bool result = service.VerifyIsMutant(dna);
//Asserts
Assert.IsFalse(result);
}
public void MutantService_VerifyIsMutant_DnaMutant5x5DiagonalLeft_Succeeds()
{
//Arrange
MutantService service = GetMutantService();
string[] dna =
{
"AACCT",
"ACTGT",
"CCATG",
"GATCC",
"TTCGA",
};
//Action
bool result = service.VerifyIsMutant(dna);
//Asserts
Assert.IsTrue(result);
}
public void MutantService_IsDnaValid_ValidDna5x5_Succeeds()
{
//Arrange
MutantService service = GetMutantService();
string[] dna =
{
"AGATT",
"TATGC",
"CCAGT",
"AACGT",
"CCGGT"
};
//Action
bool result = service.IsDnaValid(dna);
//Asserts
Assert.IsTrue(result);
}
public void MutantService_VerifyIsMutant_DnaMutant5x5LowerLetters_Succeeds()
{
//Arrange
MutantService service = GetMutantService();
string[] dna =
{
"AACCT",
"ACTGC",
"ccccG",
"GATCC",
"TTCGA",
};
//Action
bool result = service.VerifyIsMutant(dna);
//Asserts
Assert.IsTrue(result);
}
public async Task MutantServiceTests_Successful()
{
//arrange
var mutan = new Mutant()
{
isMutant = true
};
fakeRepository.Setup(x => x.AddAsync(It.IsAny <Mutant>())).ReturnsAsync(mutan);
var mutantservice = new MutantService(fakeRepository.Object);
string[] dna = { "ATGCGA", "CAGTGC", "TTATGT", "AGAAGG", "CCCCTA", "TCACTG" };
var mutant = new Mutant {
dna = dna
};
var ismutantExcpected = true;
//act
var ismutantActual = await mutantservice.ValidateIsMutant(mutant);
//assert
Assert.Equal(ismutantExcpected, ismutantActual.isMutant);
}
