private void SetupFileDataContextToReturnDataSource(FileDataSource source)
{
mockContext
.Setup(context => context.GetDataSource<FileDataSource>(It.Is<Guid>(id => id == source.Id)))
.Returns(source)
.Verifiable();
}
public virtual Task<SourceResultDataContract> UpsertFileDataSource(FileDataContract fileData, Stream stream)
{
return Task.Run(() =>
{
lock (UpsertFileDataSourceLock)
{
var hash = GetHash(stream);
var fileSource = Context.GetFileDataSource(fileData.SourceId, hash);
if (fileSource == null)
{
fileSource = new FileDataSource
{
OriginalFileName = fileData.OriginalFileName,
DateEdit = DateTime.Now,
InputStatus = SourceStatus.PendingExtraction,
ReferenceNotes = fileData.ReferenceNotes,
UserName = fileData.UserName,
HandlerName = fileData.HandlerName,
FileHash = hash,
MediaType = fileData.MediaType
};
fileSource = Context.AddDataSource(fileSource);
var newFileName = streamManager
.StageStream(
fileSource.Id,
fileData.OriginalFileName,
stream);
fileSource.CurrentFileName = newFileName;
}
if (fileSource.InputStatus != SourceStatus.PendingExtraction)
{
return DataContractError(fileSource.Id,
DataSourceServiceResources.FileSourceIsNotPendingExtraction);
}
fileSource.OriginalFileName = fileData.OriginalFileName ?? fileSource.OriginalFileName;
fileSource.HandlerName = fileData.HandlerName ?? fileSource.HandlerName;
fileSource.MediaType = fileData.MediaType ?? fileSource.MediaType;
fileSource.UserName = fileData.UserName;
fileSource.DateEdit = DateTime.Now;
fileSource.ReferenceNotes = fileData.ReferenceNotes ?? fileSource.ReferenceNotes;
Context.UpdateDataSource(fileSource);
return ValidateSource(fileSource.Id);
}
});
}
public void ValidateSourceMustReportEachMissingColumn()
{
//Arrange
var source = new FileDataSource
{
Id = newSourceId,
InputStatus = SourceStatus.PendingExtraction,
CurrentFileName = "CurrentFileName",
HandlerName = "HandlerName"
};
SetupFileDataContextToReturnDataSource(source);
CreateService();
var mockHandler = new Mock<IFileHandler>();
mockHandler
.Setup(handler => handler.MissingColumns(
It.Is<string>(s => s == "CurrentFileName"),
It.IsAny<Stream>()))
.Returns(new Dictionary<string, IEnumerable<string>>
{
{"col1", new[] {"match1a", "match1b"}},
{"col2", new[] {"match2a", "match2b"}},
{"col3", new[] {"match3a", "match3b"}},
{"col4", new[] {"match4a", "match4b"}},
})
.Verifiable();
mockStreamManager
.Setup(manager => manager.RetrieveData(It.IsAny<Guid>(), It.IsAny<string>()))
.Returns(Task.FromResult(new MemoryStream()))
.Verifiable();
mockHandlerFactory
.Setup(factory => factory.CreateHandler(It.Is<string>(s => s == "HandlerName")))
.Returns(mockHandler.Object)
.Verifiable();
mockContext
.Setup(context => context.UpdateDataSource(It.IsAny<FileDataSource>()))
.Returns(source);
mockService
.Setup(
service =>
service.ReportSourceError(It.IsAny<Guid>(), It.IsAny<SourceErrorType>(), It.IsAny<string>()))
.Callback(() => { })
.Verifiable();
//Act
var result = mockService.Object.ValidateSource(newSourceId);
//Assert
mockContext.Verify();
mockService.Verify();
mockHandlerFactory.Verify();
mockHandler.Verify();
mockStreamManager.Verify();
mockService
.Verify(
service =>
service.ReportSourceError(
It.Is<Guid>(guid => guid == newSourceId),
It.Is<SourceErrorType>(type => type == SourceErrorType.MissingFields),
It.IsAny<string>()), Times.Exactly(4));
Assert.AreEqual(4, result.ErrorMessages.Count);
Assert.AreEqual(newSourceId, result.SourceId);
Assert.IsFalse(result.Succeeded);
var message = string.Format(DataSourceServiceResources.MissingRowsMessage, "col1", "match1a,match1b");
Assert.AreEqual(message, result.ErrorMessages[0]);
message = string.Format(DataSourceServiceResources.MissingRowsMessage, "col2", "match2a,match2b");
Assert.AreEqual(message, result.ErrorMessages[1]);
message = string.Format(DataSourceServiceResources.MissingRowsMessage, "col3", "match3a,match3b");
Assert.AreEqual(message, result.ErrorMessages[2]);
message = string.Format(DataSourceServiceResources.MissingRowsMessage, "col4", "match4a,match4b");
Assert.AreEqual(message, result.ErrorMessages[3]);
}
public void ValidateSourceMustReportAnInvalidHandler()
{
//Arrange
var source = new FileDataSource
{
Id = newSourceId,
InputStatus = SourceStatus.PendingExtraction,
CurrentFileName = "CurrentFileName",
HandlerName = "HandlerName"
};
var message = string.Format(DataSourceServiceResources.InvalidHandlerMessage, "HandlerName");
SetupFileDataContextToReturnDataSource(source);
CreateService();
mockHandlerFactory
.Setup(factory => factory.CreateHandler(It.Is<string>(s => s == "HandlerName")))
.Returns((IFileHandler) null)
.Verifiable();
mockService
.Setup(service => service.ReportSourceError(
It.Is<Guid>(guid => guid == newSourceId),
It.Is<SourceErrorType>(type => type == SourceErrorType.FileTypeNotFound),
It.Is<string>(s => s == message)))
.Callback(() => { })
.Verifiable();
//Act
var result = mockService.Object.ValidateSource(newSourceId);
//Assert
mockService.Verify();
mockHandlerFactory.Verify();
mockStreamManager
.Verify(manager => manager.RetrieveData(It.IsAny<Guid>(), It.IsAny<string>()), Times.Never);
Assert.AreEqual(newSourceId, result.SourceId);
Assert.AreEqual(message, result.ErrorMessages[0]);
Assert.IsFalse(result.Succeeded);
}
public void UpsertFileDataSourceMustCancelfInsertingAndSourceIdNotNull()
{
//Arrange
var source = new FileDataSource { Id = newSourceId };
mockContext
.Setup(context => context.AddDataSource(It.IsAny<FileDataSource>()))
.Returns(source)
.Verifiable();
var uploadContract = new FileDataContract
{
SourceId = newSourceId,
OriginalFileName = "Original Name"
};
//Act
CreateService().UpsertFileDataSource(uploadContract,new MemoryStream());
//Assert
mockContext.Verify();
mockService
.Verify(service => service.CancelFileSourceExtraction(It.Is<Guid>(guid => guid == newSourceId)));
}
public void RevertCalculationMustSetTheStatusToPendingCalculation()
{
//Arrange
var source = new FileDataSource { Id = newSourceId, InputStatus = SourceStatus.Calculated };
SetupFileDataContextToReturnDataSource(source);
//Act
var result = CreateService().RevertCalculation(newSourceId);
//Assert
mockContext
.Verify(context => context.UpdateDataSource(
It.Is<FileDataSource>(ds=>
(ds.Id == newSourceId) &&
(ds.InputStatus == SourceStatus.PendingCalculation)
)), Times.Once);
Assert.AreEqual(newSourceId, result.SourceId);
Assert.AreEqual(0, result.ErrorMessages.Count);
Assert.IsTrue(result.Succeeded);
}
public void ExtractCompletedMustNotSendMailIfProfileIsNotFound()
{
//Arrange
var source = new FileDataSource { Id = newSourceId, InputStatus = SourceStatus.Extracting, UserName = "******" };
SetupFileDataContextToReturnDataSource(source);
mockContext
.Setup(context => context.GetUserProfile(It.IsAny<string>()))
.Returns((UserProfile)null)
.Verifiable();
//Act
var result = CreateService().ExtractCompleted(newSourceId);
//Assert
mockEmailManager.Verify(context => context.SendMail(It.IsAny<FileDataSource>(), It.Is<string>(s => s == EmailTemplate.ExtractComplete), It.IsAny<string[]>()), Times.Never);
var message = string.Format(DataSourceServiceResources.UserNameNotFound, source.UserName);
Assert.AreEqual(newSourceId, result.SourceId);
Assert.AreEqual(message, result.ErrorMessages[0]);
Assert.IsFalse(result.Succeeded);
}
public void ExtractDataMustNotUpdateIfInputStatusIsNotPendingExtraction()
{
//Arrange
var source = new FileDataSource { Id = newSourceId, InputStatus = SourceStatus.PendingCalculation };
SetupFileDataContextToReturnDataSource(source);
//Act
var result = CreateService().CancelFileSourceExtraction(newSourceId).Result;
//Assert
mockContext.Verify(context => context.UpdateDataSource(It.IsAny<FileDataSource>()), Times.Never);
mockContext.Verify(context => context.GetUserProfile(It.IsAny<string>()), Times.Never);
mockEmailManager.Verify(context => context.SendMail(It.IsAny<FileDataSource>(), It.IsAny<string>()), Times.Never);
Assert.AreEqual(newSourceId, result.SourceId);
Assert.AreEqual(DataSourceServiceResources.FileSourceIsNotPendingExtraction, result.ErrorMessages[0]);
Assert.IsFalse(result.Succeeded);
}
public void ExtractDataMustNotValidateIfInputstatusIsNotPendingExtraction()
{
//Arrange
var source = new FileDataSource { Id = newSourceId, InputStatus = SourceStatus.PendingCalculation };
SetupFileDataContextToReturnDataSource(source);
//Act
var result = CreateService().ExtractData(newSourceId).Result;
//Assert
mockContext.Verify(context => context.UpdateDataSource(It.IsAny<FileDataSource>()), Times.Never);
mockContext.Verify(context => context.SourceContainsErrors(It.IsAny<Guid>()), Times.Never);
mockStreamManager.Verify(
context => context.PrepareForExtraction(
It.IsAny<Guid>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
Assert.AreEqual(newSourceId, result.SourceId);
Assert.AreEqual(DataSourceServiceResources.FileSourceIsNotPendingExtraction, result.ErrorMessages[0]);
Assert.IsFalse(result.Succeeded);
}
public void UpsertFileDataMustNotUpdateReferenceNotesIfNull()
{
//Arrange
var source = new FileDataSource
{
Id = newSourceId,
InputStatus = SourceStatus.PendingExtraction,
HandlerName = "oldHandlerName",
OriginalFileName = "oldFileName",
ReferenceNotes ="oldReferenceNotes"
};
mockContext
.Setup(context => context.GetFileDataSource(It.IsAny<Guid>(), It.IsAny<string>()))
.Returns(source)
.Verifiable();
CreateService();
mockService
.Setup(service => service.ValidateSource(It.IsAny<Guid>()))
.Returns((SourceResultDataContract)null)
.Verifiable();
var contract = new FileDataContract
{
SourceId = newSourceId,
HandlerName = "newHandlerName",
OriginalFileName = "newFileName",
};
//Act
mockService.Object.UpsertFileDataSource(contract,new MemoryStream());
//Assert
mockService.Verify();
mockContext.Verify();
mockContext
.Verify(context => context.UpdateDataSource(It.Is<FileDataSource>(
dataSource =>
(dataSource.Id == newSourceId) &&
(dataSource.UserName == "testUserName") &&
(dataSource.OriginalFileName == "newFileName") &&
(dataSource.HandlerName == "newHandlerName") &&
(dataSource.ReferenceNotes == "oldReferenceNotes"))));
}
public void CancelFileSourceExtractionMustCallRemoveSource()
{
//Arrange
var source = new FileDataSource { Id = newSourceId, InputStatus = SourceStatus.PendingExtraction, CurrentFileName = "CurrentFileName" };
SetupFileDataContextToReturnDataSource(source);
//Act
var result = CreateService().CancelFileSourceExtraction(newSourceId).Result;
//Assert
mockContext.Verify(context => context.RemoveSource(It.Is<Guid>(guid => guid == newSourceId)), Times.Once);
mockStreamManager.Verify(context => context.RemoveStream(
It.Is<Guid>(guid => guid == newSourceId),
It.Is<string>(s => s == "CurrentFileName")), Times.Once);
Assert.AreEqual(newSourceId, result.SourceId);
Assert.AreEqual(0, result.ErrorMessages.Count);
Assert.IsTrue(result.Succeeded);
}
public void UpsertFileDataSourceMustReturnErrorIfFoundAndNotPendingExtraction()
{
//Arrange
var source = new FileDataSource { Id = newSourceId, InputStatus = SourceStatus.PendingCalculation };
mockContext
.Setup(context => context.GetFileDataSource(It.IsAny<Guid>(), It.IsAny<string>()))
.Returns(source)
.Verifiable();
//Act
var result = CreateService().CancelFileSourceExtraction(newSourceId).Result;
//Assert
mockContext.Verify(context => context.UpdateDataSource(It.IsAny<FileDataSource>()), Times.Never);
mockContext.Verify(context => context.AddDataSource(It.IsAny<FileDataSource>()), Times.Never);
mockStreamManager.Verify(context => context.StageStream(It.IsAny<Guid>(), It.IsAny<string>(),It.IsAny<Stream>()), Times.Never);
Assert.AreEqual(newSourceId, result.SourceId);
Assert.AreEqual(DataSourceServiceResources.FileSourceIsNotPendingExtraction, result.ErrorMessages[0]);
Assert.IsFalse(result.Succeeded);
}
public void UpsertFileDataSourceMustCallValidateIfUpdating()
{
//Arrange
var source = new FileDataSource { Id = newSourceId,InputStatus = SourceStatus.PendingExtraction};
mockContext
.Setup(context => context.GetFileDataSource(It.IsAny<Guid>(), It.IsAny<string>()))
.Returns(source)
.Verifiable();
var uploadContract = new FileDataContract
{
SourceId = newSourceId,
OriginalFileName = "Original Name"
};
var fileStream = new MemoryStream(new byte[] { 100 });
//Act
CreateService().UpsertFileDataSource(uploadContract, fileStream);
//Assert
mockService
.Verify(service => service.ValidateSource(It.Is<Guid>(guid => guid == newSourceId)));
}
public void UpsertFileDataSourceMustSetTheFileHashIfInserting()
{
//Arrange
var source = new FileDataSource { Id = newSourceId };
mockContext
.Setup(context => context.AddDataSource(It.IsAny<FileDataSource>()))
.Returns(source)
.Verifiable();
var uploadContract = new FileDataContract
{
SourceId = newSourceId,
OriginalFileName = "Original Name",
};
var fileStream = new MemoryStream(new byte[] {100});
//Act
CreateService().UpsertFileDataSource(uploadContract, fileStream);
//Assert
mockContext
.Verify(context => context.AddDataSource(
It.Is<FileDataSource>(
dataSource =>
(dataSource.OriginalFileName == "Original Name") &&
(dataSource.FileHash) == "<686ÏNffi¢]¢€¡†\\-(t")));
}
public void RevertCalculationMustNotRemoveCalculationsUnlessInputStatusIsCalculated()
{
//Arrange
var source = new FileDataSource { Id = newSourceId, InputStatus = SourceStatus.PendingCalculation };
SetupFileDataContextToReturnDataSource(source);
//Act
var result = CreateService().RevertCalculation(newSourceId);
//Assert
mockContext
.Verify(context => context.RemoveSourceCalculations(It.IsAny<Guid>()), Times.Never());
mockContext
.Verify(context => context.UpdateDataSource(It.IsAny<FileDataSource>()), Times.Never());
Assert.AreEqual(newSourceId, result.SourceId);
Assert.AreEqual(DataSourceServiceResources.FileSourceIsNotCalculated, result.ErrorMessages[0]);
Assert.IsFalse(result.Succeeded);
}
public void ExtractDataMustSetTheStatusToExtracting()
{
//Arrange
var source = new FileDataSource
{
Id = newSourceId,
InputStatus = SourceStatus.PendingExtraction,
HandlerName = "HandlerName",
CurrentFileName = "CurrentFileName"
};
SetupFileDataContextToReturnDataSource(source);
mockContext
.Setup(context => context.SourceContainsErrors(It.Is<Guid>(guid => guid == newSourceId)))
.Returns(false);
//Act
var result = CreateService().ExtractData(newSourceId).Result;
//Assert
mockContext.Verify(context => context.UpdateDataSource(It.Is<FileDataSource>(
dataSource =>
(dataSource.Id == newSourceId) &&
(dataSource.InputStatus == SourceStatus.Extracting))), Times.Once);
mockStreamManager.Verify(
context => context.PrepareForExtraction(
It.IsAny<Guid>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
Assert.AreEqual(newSourceId, result.SourceId);
Assert.AreEqual(0, result.ErrorMessages.Count);
Assert.IsTrue(result.Succeeded);
}
public void RevertCalculationMustCallRemoveSourceCalculations()
{
//Arrange
var source = new FileDataSource {Id = newSourceId, InputStatus = SourceStatus.Calculated};
SetupFileDataContextToReturnDataSource(source);
//Act
var result = CreateService().RevertCalculation(newSourceId);
//Assert
mockContext
.Verify(context => context.RemoveSourceCalculations(It.Is<Guid>(id=>id == newSourceId)), Times.Once);
mockContext
.Verify(context => context.UpdateDataSource(It.IsAny<FileDataSource>()), Times.Once);
Assert.AreEqual(newSourceId, result.SourceId);
Assert.AreEqual(0, result.ErrorMessages.Count);
Assert.IsTrue(result.Succeeded);
}
public void ValidateSourceMustReturnAnErrorIfTheInputStatusIsNotPendingCalculation()
{
//Arrange
var source = new FileDataSource {Id = newSourceId, InputStatus = SourceStatus.PendingCalculation};
SetupFileDataContextToReturnDataSource(source);
//Act
var result = CreateService().ValidateSource(newSourceId);
//Assert
mockStreamManager.Verify(manager => manager.RetrieveData(It.IsAny<Guid>(), It.IsAny<string>()), Times.Never);
mockHandlerFactory.Verify(factory => factory.CreateHandler(It.IsAny<string>()), Times.Never);
Assert.AreEqual(newSourceId, result.SourceId);
Assert.AreEqual(DataSourceServiceResources.FileSourceIsNotPendingExtraction, result.ErrorMessages[0]);
Assert.IsFalse(result.Succeeded);
}
public void ExtractCompletedMustUpdateStatusToPendingCalculation()
{
//Arrange
var source = new FileDataSource { Id = newSourceId, InputStatus = SourceStatus.Extracting,UserName = "******"};
SetupFileDataContextToReturnDataSource(source);
mockContext
.Setup(context => context.GetUserProfile(It.Is<string>(
s =>
s == "user name")))
.Returns(new UserProfile {Email = "test email"})
.Verifiable();
//Act
CreateService().ExtractCompleted(newSourceId);
//Assert
mockContext.Verify(context => context.UpdateDataSource(It.Is<FileDataSource>(
dataSource =>
(dataSource.Id == newSourceId) &&
(dataSource.InputStatus == SourceStatus.PendingCalculation))), Times.Once);
mockContext.Verify();
}
public void ValidateSourceMustRemovePreviousErrorsInSource()
{
//Arrange
var source = new FileDataSource
{
Id = newSourceId,
InputStatus = SourceStatus.PendingExtraction,
CurrentFileName = "CurrentFileName"
};
SetupFileDataContextToReturnDataSource(source);
CreateService();
mockContext
.Setup(context => context.UpdateDataSource(It.IsAny<FileDataSource>()))
.Returns(source);
mockService
.Setup(
service =>
service.ReportSourceError(It.IsAny<Guid>(), It.IsAny<SourceErrorType>(), It.IsAny<string>()))
.Callback(() => { });
//Act
mockService.Object.ValidateSource(newSourceId);
//Assert
mockContext
.Verify(context => context.RemoveSourceErrors(It.Is<Guid>(guid => guid == newSourceId)), Times.Once);
mockStreamManager
.Verify(manager => manager.RetrieveData(It.IsAny<Guid>(), It.IsAny<string>()),Times.Never);
}
public void ExtractCompletedMustSendAnEmailUsingTheProfileEmailAddress()
{
//Arrange
var source = new FileDataSource { Id = newSourceId, InputStatus = SourceStatus.Extracting, UserName = "******" };
SetupFileDataContextToReturnDataSource(source);
mockContext
.Setup(context => context.GetUserProfile(It.Is<string>(
s =>
s == "user name")))
.Returns(new UserProfile { Email = "test email" })
.Verifiable();
//Act
var result =CreateService().ExtractCompleted(newSourceId);
//Assert
mockContext.Verify(context => context.UpdateDataSource(It.Is<FileDataSource>(
dataSource =>
(dataSource.Id == newSourceId) &&
(dataSource.InputStatus == SourceStatus.PendingCalculation))), Times.Once);
mockContext.Verify();
mockEmailManager
.Verify(
context => context.SendMail(
It.Is<FileDataSource>(dataSource => dataSource.Id == newSourceId),
It.Is<string>(s => s == EmailTemplate.ExtractComplete),
It.Is<string[]>(strings => strings[0] == "test email")), Times.Once);
Assert.AreEqual(newSourceId, result.SourceId);
Assert.AreEqual(0, result.ErrorMessages.Count);
Assert.IsTrue(result.Succeeded);
}
public void UpsertFilesourceMustUpdateCurrentFileNameWithTheNewName()
{
//Arrange
var source = new FileDataSource { Id = newSourceId, InputStatus = SourceStatus.PendingExtraction };
mockStreamManager
.Setup(manager => manager.StageStream(
It.Is<Guid>(guid => guid == newSourceId),
It.Is<string>(s => s == "Original Name"),
It.IsAny<Stream>()))
.Returns("NewFileName")
.Verifiable();
mockContext
.Setup(context => context.AddDataSource(It.IsAny<FileDataSource>()))
.Returns(source);
var uploadContract = new FileDataContract
{
SourceId = newSourceId,
OriginalFileName = "Original Name"
};
//Act
CreateService().UpsertFileDataSource(uploadContract,new MemoryStream());
//Assert
mockService.Verify();
mockStreamManager.Verify();
mockContext.Verify(context => context.UpdateDataSource(It.Is<FileDataSource>(
dataSource =>
(dataSource.Id == newSourceId) &&
(dataSource.InputStatus == SourceStatus.PendingExtraction) &&
(dataSource.CurrentFileName == "NewFileName"))), Times.Once);
}
