public void Execute_IntegrationTest_SQLite()
{
string filePath = Path.Combine(AppContext.BaseDirectory, Path.GetRandomFileName() + ".dbtest");
using (SQLiteDbContext dbContext = new SQLiteDbContext(filePath))
{
dbContext.Initialise();
dbContext.BeginTransaction();
IProjectValidator projectValidator = new ProjectValidator();
IProjectRequestAggregateValidator validator = new ProjectRequestAggregateValidator();
ISetLogFileUnprocessedCommand setLogFileUnprocessedCommand = Substitute.For <ISetLogFileUnprocessedCommand>();
ICreateProjectRequestAggregateCommand createProjectRequestAggregateCommand = new CreateProjectRequestAggregateCommand(dbContext, validator, new LogFileRepository(dbContext), setLogFileUnprocessedCommand);
// create the project first so we have one
ProjectModel project = DataHelper.CreateProjectModel();
DataHelper.InsertProjectModel(dbContext, project);
// create the request aggregate
ProjectRequestAggregateModel projectRequestAggregate = DataHelper.CreateProjectRequestAggregateModel();
projectRequestAggregate.ProjectId = project.Id;
createProjectRequestAggregateCommand.Execute(projectRequestAggregate);
Assert.Greater(projectRequestAggregate.Id, 0);
int rowCount = dbContext.ExecuteScalar <int>("SELECT COUNT(*) FROM ProjectRequestAggregates");
Assert.Greater(rowCount, 0);
ProjectRequestAggregateModel savedModel = dbContext.Query <ProjectRequestAggregateModel>("SELECT * FROM ProjectRequestAggregates WHERE Id = @Id", new { Id = projectRequestAggregate.Id }).Single();
Assert.AreEqual(projectRequestAggregate.RegularExpression, savedModel.RegularExpression);
Assert.AreEqual(projectRequestAggregate.AggregateTarget, savedModel.AggregateTarget);
}
}
public void GetById_Integration_ReturnsData()
{
string filePath = Path.Combine(AppContext.BaseDirectory, Path.GetRandomFileName() + ".dbtest");
using (SQLiteDbContext dbContext = new SQLiteDbContext(filePath))
{
dbContext.Initialise();
dbContext.BeginTransaction();
IProjectRequestAggregateRepository projectRequestAggregateRepo = new ProjectRequestAggregateRepository(dbContext);
ICreateProjectCommand createProjectCommand = new CreateProjectCommand(dbContext, new ProjectValidator());
ISetLogFileUnprocessedCommand setLogFileUnprocessedCommand = Substitute.For <ISetLogFileUnprocessedCommand>();
ICreateProjectRequestAggregateCommand createProjectRequestAggregateCommand = new CreateProjectRequestAggregateCommand(dbContext, new ProjectRequestAggregateValidator(), new LogFileRepository(dbContext), setLogFileUnprocessedCommand);
IDeleteProjectRequestAggregateCommand deleteProjectRequestAggregateCommand = new DeleteProjectRequestAggregateCommand(dbContext, projectRequestAggregateRepo, new LogFileRepository(dbContext), setLogFileUnprocessedCommand);
// create the project
ProjectModel projectA = DataHelper.CreateProjectModel();
createProjectCommand.Execute(projectA);
// create the request aggregate record for ProjectA
ProjectRequestAggregateModel projectRequestAggregate = DataHelper.CreateProjectRequestAggregateModel();
projectRequestAggregate.ProjectId = projectA.Id;
createProjectRequestAggregateCommand.Execute(projectRequestAggregate);
int id = projectRequestAggregate.Id;
Assert.Greater(id, 0);
// fetch the record
ProjectRequestAggregateModel result = projectRequestAggregateRepo.GetById(id);
Assert.IsNotNull(result);
Assert.AreEqual(projectRequestAggregate.Id, id);
Assert.AreEqual(projectRequestAggregate.RegularExpression, result.RegularExpression);
Assert.AreEqual(projectRequestAggregate.AggregateTarget, result.AggregateTarget);
}
}
public void Execute_ValidationSucceeds_JobsRegisteredForLogFiles()
{
int id = new Random().Next(1, 1000);
ProjectRequestAggregateModel model = DataHelper.CreateProjectRequestAggregateModel();
_projectRequestAggregateRepo.GetById(id).Returns(model);
LogFileModel log1 = DataHelper.CreateLogFileModel(model.ProjectId);
log1.Id = 1;
LogFileModel log2 = DataHelper.CreateLogFileModel(model.ProjectId);
log2.Id = 2;
LogFileModel log3 = DataHelper.CreateLogFileModel(model.ProjectId);
log3.Id = 3;
_logFileRepo.GetByProject(model.ProjectId).Returns(new LogFileModel[] { log1, log2, log3 });
// execute
_deleteProjectRequestAggregateCommand.Execute(id);
// assert
_logFileRepo.Received(1).GetByProject(model.ProjectId);
_setLogFileUnprocessedCommand.Received(1).Execute(log1.Id);
_setLogFileUnprocessedCommand.Received(1).Execute(log2.Id);
_setLogFileUnprocessedCommand.Received(1).Execute(log3.Id);
}
public dynamic Save()
{
ProjectAggregateViewModel viewModel = this.Bind <ProjectAggregateViewModel>();
ProjectRequestAggregateModel model = new ProjectRequestAggregateModel();
model.ProjectId = viewModel.ProjectId;
model.AggregateTarget = viewModel.AggregateTarget;
model.RegularExpression = viewModel.RegularExpression;
SaveResultModel result = null;
_dbContext.BeginTransaction();
try
{
_createProjectRequestAggregateCommand.Execute(model);
_dbContext.Commit();
result = new SaveResultModel(model.Id.ToString(), true, Enumerable.Empty <string>().ToArray());
}
catch (ValidationException vex)
{
result = new SaveResultModel(String.Empty, false, vex.ValidationErrors);
_dbContext.Rollback();
}
return(this.Response.AsJson(result));
}
public ProjectRequestAggregateModel Execute(ProjectRequestAggregateModel projectRequestAggregate)
{
// validate
ValidationResult result = _projectRequestAggregateValidator.Validate(projectRequestAggregate);
if (!result.Success)
{
throw new ValidationException(result.Messages);
}
// insert new record
string sql = @"INSERT INTO ProjectRequestAggregates (ProjectId, RegularExpression, AggregateTarget, CreateDate) VALUES (@ProjectId, @RegularExpression, @AggregateTarget, @CreateDate)";
_dbContext.ExecuteNonQuery(sql, projectRequestAggregate);
// update the id
sql = @"select last_insert_rowid()";
projectRequestAggregate.Id = _dbContext.ExecuteScalar <int>(sql);
// register jobs so all log files are reprocessed
IEnumerable <LogFileModel> logFiles = _logFileRepo.GetByProject(projectRequestAggregate.ProjectId);
foreach (LogFileModel logFile in logFiles)
{
_setLogFileUnprocessedCommand.Execute(logFile.Id);
}
return(projectRequestAggregate);
}
public void Execute_ValidationSucceeds_JobsRegisteredForLogFiles()
{
ProjectRequestAggregateModel model = DataHelper.CreateProjectRequestAggregateModel();
_projectRequestAggregateValidator.Validate(model).Returns(new ValidationResult());
LogFileModel log1 = DataHelper.CreateLogFileModel(model.ProjectId);
log1.Id = 1;
LogFileModel log2 = DataHelper.CreateLogFileModel(model.ProjectId);
log2.Id = 2;
LogFileModel log3 = DataHelper.CreateLogFileModel(model.ProjectId);
log3.Id = 3;
_logFileRepo.GetByProject(model.ProjectId).Returns(new LogFileModel[] { log1, log2, log3 });
// execute
_createProjectRequestAggregateCommand.Execute(model);
// assert
_logFileRepo.Received(1).GetByProject(model.ProjectId);
_setLogFileUnprocessedCommand.Received(1).Execute(log1.Id);
_setLogFileUnprocessedCommand.Received(1).Execute(log2.Id);
_setLogFileUnprocessedCommand.Received(1).Execute(log3.Id);
}
public void Validate_AllFieldsValid_ReturnsSuccess()
{
ProjectRequestAggregateModel model = DataHelper.CreateProjectRequestAggregateModel();
ValidationResult result = _projectRequestAggregateValidator.Validate(model);
Assert.IsTrue(result.Success);
Assert.AreEqual(0, result.Messages.Count);
}
public static ProjectRequestAggregateModel CreateProjectRequestAggregateModel()
{
Random r = new Random();
ProjectRequestAggregateModel model = new ProjectRequestAggregateModel();
model.Id = r.Next(1, 1000);
model.ProjectId = r.Next(1, 1000);
model.AggregateTarget = Path.GetRandomFileName();
model.RegularExpression = Path.GetRandomFileName();
return(model);
}
public void Execute_ValidationSucceeds_RecordInserted()
{
ProjectRequestAggregateModel model = DataHelper.CreateProjectRequestAggregateModel();
_projectRequestAggregateValidator.Validate(model).Returns(new ValidationResult());
// execute
_createProjectRequestAggregateCommand.Execute(model);
// assert
_dbContext.Received(1).ExecuteNonQuery(Arg.Any <string>(), Arg.Any <object>());
}
public void Validate_InvalidAggregateTarget_ReturnsFailure(string aggregateTarget)
{
ProjectRequestAggregateModel model = DataHelper.CreateProjectRequestAggregateModel();
model.AggregateTarget = aggregateTarget;
ValidationResult result = _projectRequestAggregateValidator.Validate(model);
Assert.IsFalse(result.Success);
Assert.AreEqual(1, result.Messages.Count);
Assert.IsTrue(result.Messages[0].Contains("Aggregate target"));
}
public void Validate_InvalidRegularExpression_ReturnsFailure(string regularExpression)
{
ProjectRequestAggregateModel model = DataHelper.CreateProjectRequestAggregateModel();
model.RegularExpression = regularExpression;
ValidationResult result = _projectRequestAggregateValidator.Validate(model);
Assert.IsFalse(result.Success);
Assert.AreEqual(1, result.Messages.Count);
Assert.IsTrue(result.Messages[0].Contains("Regular expression"));
}
public void GetAggregatedUriStem_MatchFound_ReturnsAggregateTarget(string originalUriStem, string regEx)
{
ProjectRequestAggregateModel aggregateModel = DataHelper.CreateProjectRequestAggregateModel();
aggregateModel.RegularExpression = regEx;
ProjectRequestAggregateModel[] requestAggregates = { aggregateModel };
string result = _requestAggregationService.GetAggregatedUriStem(originalUriStem, requestAggregates);
Assert.AreEqual(aggregateModel.AggregateTarget, result);
}
public void Validate_InvalidProjectId_ReturnsFailure(int projectId)
{
ProjectRequestAggregateModel model = DataHelper.CreateProjectRequestAggregateModel();
model.ProjectId = projectId;
ValidationResult result = _projectRequestAggregateValidator.Validate(model);
Assert.IsFalse(result.Success);
Assert.AreEqual(1, result.Messages.Count);
Assert.IsTrue(result.Messages[0].Contains("Project id"));
}
public void Execute_ValidationSucceeds_RecordInserted()
{
int id = new Random().Next(1, 1000);
ProjectRequestAggregateModel model = DataHelper.CreateProjectRequestAggregateModel();
_projectRequestAggregateRepo.GetById(id).Returns(model);
// execute
_deleteProjectRequestAggregateCommand.Execute(id);
// assert
_projectRequestAggregateRepo.Received(1).GetById(id);
_dbContext.Received(1).ExecuteNonQuery(Arg.Any <string>(), Arg.Any <object>());
}
public void Execute_ValidationFails_ThrowsException()
{
ProjectRequestAggregateModel model = DataHelper.CreateProjectRequestAggregateModel();
_projectRequestAggregateValidator.Validate(model).Returns(new ValidationResult("error"));
// execute
TestDelegate del = () => _createProjectRequestAggregateCommand.Execute(model);
// assert
Assert.Throws <ValidationException>(del);
// we shouldn't have even tried to do the insert
_dbContext.DidNotReceive().ExecuteNonQuery(Arg.Any <string>(), Arg.Any <object>());
}
public void Execute_RecordDoesNotExist_ThrowsException()
{
int id = new Random().Next(1, 1000);
ProjectRequestAggregateModel model = null;
_projectRequestAggregateRepo.GetById(id).Returns(model);
// execute
TestDelegate del = () => _deleteProjectRequestAggregateCommand.Execute(id);
// assert
Assert.Throws <InvalidOperationException>(del);
// we shouldn't have even tried to do the delete
_dbContext.DidNotReceive().ExecuteNonQuery(Arg.Any <string>(), Arg.Any <object>());
}
public void GetByProject_Integration_ReturnsData()
{
string filePath = Path.Combine(AppContext.BaseDirectory, Path.GetRandomFileName() + ".dbtest");
using (SQLiteDbContext dbContext = new SQLiteDbContext(filePath))
{
dbContext.Initialise();
dbContext.BeginTransaction();
IProjectRequestAggregateRepository projectRequestAggregateRepo = new ProjectRequestAggregateRepository(dbContext);
ISetLogFileUnprocessedCommand setLogFileUnprocessedCommand = Substitute.For <ISetLogFileUnprocessedCommand>();
ICreateProjectRequestAggregateCommand projectRequestAggregateCommand = new CreateProjectRequestAggregateCommand(dbContext, new ProjectRequestAggregateValidator(), new LogFileRepository(dbContext), setLogFileUnprocessedCommand);
// create the projects
ProjectModel projectA = DataHelper.CreateProjectModel();
DataHelper.InsertProjectModel(dbContext, projectA);
ProjectModel projectZ = DataHelper.CreateProjectModel();
DataHelper.InsertProjectModel(dbContext, projectZ);
// create the request aggregate records for ProjectA
int numRecords = new Random().Next(5, 10);
for (var i = 0; i < numRecords; i++)
{
ProjectRequestAggregateModel projectRequestAggregate = DataHelper.CreateProjectRequestAggregateModel();
projectRequestAggregate.ProjectId = projectA.Id;
projectRequestAggregateCommand.Execute(projectRequestAggregate);
}
// create the log file records for ProjectB that should be excluded by the query
for (var i = 0; i < 5; i++)
{
ProjectRequestAggregateModel projectRequestAggregate = DataHelper.CreateProjectRequestAggregateModel();
projectRequestAggregate.ProjectId = projectZ.Id;
projectRequestAggregateCommand.Execute(projectRequestAggregate);
}
IEnumerable <ProjectRequestAggregateModel> result = projectRequestAggregateRepo.GetByProject(projectA.Id);
Assert.IsNotNull(result);
Assert.AreEqual(numRecords, result.Count());
}
}
public ValidationResult Validate(ProjectRequestAggregateModel model)
{
ValidationResult result = new ValidationResult();
if (model.ProjectId <= 0)
{
result.Messages.Add("Project id must be a valid number");
}
if (String.IsNullOrWhiteSpace(model.AggregateTarget))
{
result.Messages.Add("Aggregate target cannot be empty");
}
if (String.IsNullOrWhiteSpace(model.RegularExpression))
{
result.Messages.Add("Regular expression cannot be empty");
}
return(result);
}
public void Execute(int id)
{
// load the record up
ProjectRequestAggregateModel projectRequestAggregate = _projectRequestAggregateRepo.GetById(id);
if (projectRequestAggregate == null)
{
throw new InvalidOperationException(String.Format("No project aggregate request found with id {0}", id));
}
// insert new record
string sql = @"DELETE FROM ProjectRequestAggregates WHERE Id = @Id";
_dbContext.ExecuteNonQuery(sql, new { Id = id });
// register jobs so all log files are reprocessed
IEnumerable <LogFileModel> logFiles = _logFileRepo.GetByProject(projectRequestAggregate.ProjectId);
foreach (LogFileModel logFile in logFiles)
{
_setLogFileUnprocessedCommand.Execute(logFile.Id);
}
}
public void Aggregates_ValidProjectId_GetsAggregatesFromDatabase()
{
int projectId = new Random().Next(1, 1000);
// setup
var currentUser = new UserIdentity()
{
Id = Guid.NewGuid(), UserName = "******"
};
var browser = new Browser((bootstrapper) =>
bootstrapper.Module(new ProjectModule(_dbContext, _projectValidator, _createProjectCommand, _deleteProjectCommand, _projectRepo, _logFileRepo, _requestRepo, _projectRequestAggregateRepo))
.RequestStartup((container, pipelines, context) => {
context.CurrentUser = currentUser;
})
);
ProjectRequestAggregateModel pra1 = DataHelper.CreateProjectRequestAggregateModel();
ProjectRequestAggregateModel pra2 = DataHelper.CreateProjectRequestAggregateModel();
ProjectRequestAggregateModel pra3 = DataHelper.CreateProjectRequestAggregateModel();
_projectRequestAggregateRepo.GetByProject(projectId).Returns(new ProjectRequestAggregateModel[] { pra1, pra2, pra3 });
// execute
var url = Actions.Project.Aggregates(projectId);
var response = browser.Post(url, (with) =>
{
with.HttpRequest();
with.FormsAuth(currentUser.Id, new Nancy.Authentication.Forms.FormsAuthenticationConfiguration());
});
// assert
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
_projectRequestAggregateRepo.Received(1).GetByProject(projectId);
IEnumerable <ProjectRequestAggregateModel> result = JsonConvert.DeserializeObject <IEnumerable <ProjectRequestAggregateModel> >(response.Body.AsString());
Assert.AreEqual(3, result.Count());
}
public void Execute_IntegrationTest_SQLite()
{
string filePath = Path.Combine(AppContext.BaseDirectory, Path.GetRandomFileName() + ".dbtest");
using (SQLiteDbContext dbContext = new SQLiteDbContext(filePath))
{
dbContext.Initialise();
dbContext.BeginTransaction();
IProjectRequestAggregateRepository projectRequestAggregateRepo = new ProjectRequestAggregateRepository(dbContext);
ISetLogFileUnprocessedCommand setLogFileUnprocessedCommand = Substitute.For <ISetLogFileUnprocessedCommand>();
ICreateProjectRequestAggregateCommand createProjectRequestAggregateCommand = new CreateProjectRequestAggregateCommand(dbContext, new ProjectRequestAggregateValidator(), new LogFileRepository(dbContext), setLogFileUnprocessedCommand);
IDeleteProjectRequestAggregateCommand deleteProjectRequestAggregateCommand = new DeleteProjectRequestAggregateCommand(dbContext, projectRequestAggregateRepo, new LogFileRepository(dbContext), setLogFileUnprocessedCommand);
// create the project first so we have one
ProjectModel project = DataHelper.CreateProjectModel();
DataHelper.InsertProjectModel(dbContext, project);
// create the request aggregate
ProjectRequestAggregateModel projectRequestAggregate = DataHelper.CreateProjectRequestAggregateModel();
projectRequestAggregate.ProjectId = project.Id;
createProjectRequestAggregateCommand.Execute(projectRequestAggregate);
int id = projectRequestAggregate.Id;
Assert.Greater(id, 0);
// fetch the record to make sure it exists
ProjectRequestAggregateModel record = projectRequestAggregateRepo.GetById(id);
Assert.IsNotNull(record);
// delete the request aggregate
deleteProjectRequestAggregateCommand.Execute(id);
record = projectRequestAggregateRepo.GetById(id);
Assert.IsNull(record);
}
}
