public async Task HasDataGridAudits()
{
// Arrange
var kernel = IntegrationSetupFixture.CreateNewKernel();
kernel.Bind <IServicesMgr>().ToConstant(TestUtilities.GetKeplerServicesManager());
kernel.Bind <IHelper>().ToConstant(TestUtilities.GetMockHelper().Object);
var workspaceId = Config.WorkSpaceId;
var connectionFactory = TestUtilities.GetIntegrationConnectionFactory();
var hourRepository = new HourRepository(connectionFactory);
var hour = await hourRepository.ReadLatestCompletedHourAsync();
var dataGridCacheRepositoryMock = new Mock <IDataGridCacheRepository>();
dataGridCacheRepositoryMock.Setup(m => m.ReadUseDataGrid(workspaceId, It.IsAny <int>())).ReturnsAsync(false);
var factory =
new WorkspaceAuditServiceFactory(
new RelativityApplicationRepository(connectionFactory),
kernel.Get <IWorkspaceAuditServiceProvider <ISqlWorkspaceAuditService> >(),
kernel.Get <IWorkspaceAuditServiceProvider <IDataGridWorkspaceAuditService> >(),
new PdbSqlToggleProvider(connectionFactory),
TestUtilities.GetMockLogger().Object,
dataGridCacheRepositoryMock.Object);
// Act
var result = await factory.HasDataGridAudits(workspaceId, hour.Id);
// Assert
Assert.That(result, Is.True);
}
public async Task OneTimeSetup()
{
var hourRepo = new HourRepository(ConnectionFactorySetup.ConnectionFactory);
this.metricRepository = new MetricRepository(ConnectionFactorySetup.ConnectionFactory);
var serverRepository = new ServerRepository(ConnectionFactorySetup.ConnectionFactory);
this.server = await serverRepository.CreateAsync(new Server
{
ServerName = Environment.MachineName,
CreatedOn = DateTime.Now,
DeletedOn = null,
ServerTypeId = 3,
ServerIpAddress = "127.0.0.1",
IgnoreServer = false,
ResponsibleAgent = "",
ArtifactId = 1234,
});
hour = await hourRepo.CreateAsync(new Hour { HourTimeStamp = DateTime.Now.NormilizeToHour() });
metric = await this.metricRepository.CreateAsync(new Metric { HourId = hour.Id, MetricType = MetricType.WebUptime });
this.metricDataRepository = new MetricDataRepository(ConnectionFactorySetup.ConnectionFactory);
metricData = await this.metricDataRepository.CreateAsync(new MetricData { MetricId = metric.Id, Score = 100.0m });
metricData.Score = 75.0m;
metricData.Data = "asdf";
await this.metricDataRepository.UpdateAsync(metricData);
metricData = await this.metricDataRepository.ReadAsync(metricData.Id);
}
public async Task SetUp()
{
var connFactory = TestUtilities.GetIntegrationConnectionFactory();
this.searchAuditBatchRepository = new SearchAuditBatchRepository(connFactory);
var hourRepo = new HourRepository(connFactory);
hour = await hourRepo.CreateAsync(new Hour { HourTimeStamp = DateTime.UtcNow.NormilizeToHour() });
Assert.That(hour, Is.Not.Null, "Must have a valid hour for tests");
var serverRepo = new ServerRepository(connFactory);
server = (await serverRepo.ReadAllActiveAsync()).FirstOrDefault();
Assert.That(server, Is.Not.Null, "Must have a valid server for tests");
this.HourAuditSearchBatchId =
await this.searchAuditBatchRepository.CreateHourSearchAuditBatch(hour.Id, server.ServerId, 1);
await this.searchAuditBatchRepository.CreateBatches(new[] {
new SearchAuditBatch
{
HourSearchAuditBatchId = this.HourAuditSearchBatchId,
WorkspaceId = Config.WorkSpaceId,
BatchStart = 0,
BatchSize = 5000
}
});
this.searchAuditBatch = (await this.searchAuditBatchRepository.ReadBatchesByHourAndServer(hour.Id, server.ServerId)).FirstOrDefault();
}
public async Task OneTimeSetup()
{
connectionFactory = TestUtilities.GetIntegrationConnectionFactory();
userExperienceReportRepository = new UserExperienceReportRepository(connectionFactory);
var hourRepo = new HourRepository(connectionFactory);
hour = await hourRepo.CreateAsync(new Hour { HourTimeStamp = DateTime.Now });
var serverRepo = new ServerRepository(connectionFactory);
server = await serverRepo.CreateAsync(new Server
{
ServerName = Environment.MachineName,
CreatedOn = DateTime.Now,
DeletedOn = null,
ServerTypeId = 3,
ServerIpAddress = "127.0.0.1",
IgnoreServer = false,
ResponsibleAgent = "",
ArtifactId = 1234,
LastChecked = null,
UptimeMonitoringResourceHost = null,
UptimeMonitoringResourceUseHttps = null,
LastServerBackup = null,
AdminScriptsVersion = null,
});
}
public async Task SetUp()
{
connectionFactory = TestUtilities.GetIntegrationConnectionFactory();
var hourRepo = new HourRepository(connectionFactory);
var metricRepo = new MetricRepository(connectionFactory);
var hour = await hourRepo.CreateAsync(new Hour { HourTimeStamp = DateTime.Now });
var metric = await metricRepo.CreateAsync(new Metric { HourId = hour.Id, MetricType = MetricType.WebUptime });
var metricDataRepo = new MetricDataRepository(connectionFactory);
metricData = await metricDataRepo.CreateAsync(new MetricData { MetricId = metric.Id, Score = 100.0m });
var repo = new AuditAnalysisRepository(connectionFactory);
await repo.CreateAsync(Enumerable.Range(0, 4).Select(i =>
new AuditAnalysis
{
MetricDataId = metricData.Id,
TotalQueries = 123,
TotalLongRunningQueries = 234,
TotalComplexQueries = 345,
UserId = 456
}).ToList());
auditAnalyses = await repo.ReadByMetricData(metricData);
}
public async Task Setup()
{
this.hourRepository = new HourRepository(ConnectionFactorySetup.ConnectionFactory);
this.hour = await this.hourRepository.CreateAsync(new Hour { HourTimeStamp = DateTime.Now });
this.dataGridCacheRepository = new DataGridCacheRepository(ConnectionFactorySetup.ConnectionFactory);
}
public ActionResult List(
string createdDate,
string date,
string isArchived,
string modifiedDate,
int?projectId,
string projectName,
int?sprintId,
string sprintName,
int?storyId,
int?userId,
string userName)
{
var model = new HourListModel();
var criteria =
new HourDataCriteria
{
CreatedDate = CriteriaHelper.ToDateRangeCriteria(createdDate),
Date = CriteriaHelper.ToDateRangeCriteria(date),
IsArchived = CriteriaHelper.ToBoolean(isArchived),
ModifiedDate = CriteriaHelper.ToDateRangeCriteria(modifiedDate),
ProjectId = CriteriaHelper.ToArray(projectId),
ProjectName = projectName,
SprintId = sprintId,
StoryId = storyId,
UserId = userId,
UserName = userName
};
var hours = HourRepository.HourFetchInfoList(criteria);
model.Hours = hours;
return(this.View(model));
}
public static Hour HourAdd()
{
var hour = HourTestHelper.HourNew();
hour = HourRepository.HourSave(hour);
return(hour);
}
public void Hour_Fetch_Info_List()
{
HourTestHelper.HourAdd();
HourTestHelper.HourAdd();
var hours = HourRepository.HourFetchInfoList(new HourDataCriteria());
Assert.IsTrue(hours.Count() > 1, "Row returned should be greater than one");
}
public void Hour_Fetch()
{
var hour = HourTestHelper.HourNew();
hour = HourRepository.HourSave(hour);
hour = HourRepository.HourFetch(hour.HourId);
Assert.IsTrue(hour != null, "Row returned should not equal null");
}
public ActionResult Edit(int id)
{
var model = new HourFormModel();
var hour = HourRepository.HourFetch(id);
model.Title = "Hour Edit";
model.Hour = hour;
model.Story = StoryRepository.StoryFetch(hour.StoryId);
return(this.View(model));
}
public void Hour_Add()
{
var hour = HourTestHelper.HourNew();
Assert.IsTrue(hour.IsValid, "IsValid should be true");
hour = HourRepository.HourSave(hour);
Assert.IsTrue(hour.HourId != 0, "HourId should be a non-zero value");
HourRepository.HourFetch(hour.HourId);
}
public async Task AgentHistory_ReadByHourAsync_Success()
{
//Arrange
var hourRepo = new HourRepository(ConnectionFactorySetup.ConnectionFactory);
var hour = await hourRepo.CreateAsync(new Hour { HourTimeStamp = DateTime.UtcNow.NormilizeToHour() });
//Act
var result = await agentHistoryRepository.ReadByHourAsync(hour);
//Assert
Assert.That(result, Is.Not.Empty);
}
public static DataGridWorkspaceAuditService SetUpWorkspaceAuditService(IAuditLogObjectManagerFactory auditLogObjectManagerFactory)
{
var connectionFactory = TestUtilities.GetIntegrationConnectionFactory();
var loggerMock = TestUtilities.GetMockLogger();
var dataGridService = new DataGridService(auditLogObjectManagerFactory, new DataGridConditionBuilder(), new DataGridResponseAuditMapper(loggerMock.Object), loggerMock.Object);
var artifactRepository = new ArtifactRepository(connectionFactory);
var dataGridSettingsService = new DataGridSettingsService(artifactRepository, loggerMock.Object);
var hourRepository = new HourRepository(connectionFactory);
var dataGridWorkspaceAuditService = new DataGridWorkspaceAuditService(dataGridSettingsService, artifactRepository, dataGridService, hourRepository);
return(dataGridWorkspaceAuditService);
}
public static Hour HourNew()
{
var story = StoryTestHelper.StoryAdd();
var user = UserTestHelper.UserAdd();
var hour = HourRepository.HourNew();
hour.StoryId = story.StoryId;
hour.UserId = user.UserId;
hour.Notes = DataHelper.RandomString(50);
return(hour);
}
public void OneTimeSetup()
{
connectionFactory = TestUtilities.GetIntegrationConnectionFactory();
hourRepository = new HourRepository(this.connectionFactory);
this.metricRepository = new MetricRepository(this.connectionFactory);
this.serverRepository = new ServerRepository(this.connectionFactory);
this.metricDataRepository = new MetricDataRepository(this.connectionFactory);
this.categoryScoreRepository = new CategoryScoreRepository(this.connectionFactory);
this.categoryRepository = new CategoryRepository(this.connectionFactory);
this.metricService = new MetricService(this.serverRepository, this.metricRepository, this.metricDataRepository, this.categoryRepository, this.categoryScoreRepository);
}
public ActionResult Create(int storyId)
{
var model = new HourFormModel();
var hour = HourRepository.HourNew();
hour.StoryId = storyId;
model.Title = "Hour Create";
model.Hour = hour;
model.Story = StoryRepository.StoryFetch(storyId);
return(this.View(model));
}
public void Hour_Create()
{
var hour = HourRepository.HourNew();
Assert.IsTrue(hour.IsNew, "IsNew should be true");
Assert.IsTrue(hour.IsDirty, "IsDirty should be true");
Assert.IsFalse(hour.IsValid, "IsValid should be false");
Assert.IsTrue(hour.IsSelfDirty, "IsSelfDirty should be true");
Assert.IsFalse(hour.IsSelfValid, "IsSelfValid should be false");
// Assert.IsTrue(ValidationHelper.ContainsRule(hour, DbType.String, "Name"),
// "Name should be required");
}
public async Task OneTimeSetup()
{
var hourRepo = new HourRepository(ConnectionFactorySetup.ConnectionFactory);
hour = await hourRepo.CreateAsync(new Hour { HourTimeStamp = DateTime.Now });
categoryRepository = new CategoryRepository(ConnectionFactorySetup.ConnectionFactory);
category = await categoryRepository.CreateAsync(new Category { HourId = hour.Id, CategoryType = CategoryType.InfrastructurePerformance });
category = await categoryRepository.ReadAsync(category.Id);
category.CategoryType = CategoryType.Uptime;
await categoryRepository.UpdateAsync(category);
}
public async Task GetPastWeekUserExperienceMetricDataAsync()
{
var connectionFactory = TestUtilities.GetIntegrationConnectionFactory();
var serverRepository = new ServerRepository(connectionFactory);
var servers = await serverRepository.ReadAllActiveAsync();
var server = servers.First(s => s.ServerType == ServerType.Database);
var hourRepository = new HourRepository(connectionFactory);
var hour = await hourRepository.ReadNextHourWithoutRatings();
var result = await this.userExperienceSampleService.GetPastWeekUserExperienceMetricDataAsync(server.ServerId, hour);
Assert.Pass();
}
public async Task CalculateSample()
{
var connectionFactory = TestUtilities.GetIntegrationConnectionFactory();
var serverRepository = new ServerRepository(connectionFactory);
var servers = await serverRepository.ReadAllActiveAsync();
var server = servers.First(s => s.ServerType == ServerType.Database);
var hourRepository = new HourRepository(connectionFactory);
var hour = await hourRepository.ReadNextHourWithoutRatings() ?? await hourRepository.ReadLatestCompletedHourAsync();
var result = await this.userExperienceSampleService.CalculateSample(server.ServerId, hour.Id);
Assert.Pass();
}
public async Task OneTimeSetup()
{
var hourRepo = new HourRepository(ConnectionFactorySetup.ConnectionFactory);
hour = await hourRepo.CreateAsync(new Hour { HourTimeStamp = DateTime.Now });
metricRepository = new MetricRepository(ConnectionFactorySetup.ConnectionFactory);
metric = await metricRepository.CreateAsync(new Metric { HourId = hour.Id, MetricType = MetricType.AgentUptime });
metric = await metricRepository.ReadAsync(metric.Id);
metric.MetricType = MetricType.WebUptime;
await metricRepository.UpdateAsync(metric);
}
public ActionResult Delete(int id)
{
var model = new DeleteModel();
var hour = HourRepository.HourFetch(id);
model.Title = "Hour Delete";
model.Id = hour.HourId;
model.Name = "Hour";
model.Description = hour.Date.ToShortDateString();
model.ControllerName = "Hour";
model.BackUrl = Url.Action("Details", "Hour", new { id = hour.HourId });
return(this.View(model));
}
public async Task SetUp()
{
connectionFactory = TestUtilities.GetIntegrationConnectionFactory();
var processControlRepo = new ProcessControlRepository(connectionFactory);
repo = new PoisonWaitRepository(connectionFactory, processControlRepo);
var serverRepo = new ServerRepository(connectionFactory);
server = (await serverRepo.ReadAllActiveAsync()).FirstOrDefault();
var hourRepo = new HourRepository(connectionFactory);
hour = await hourRepo.ReadLastAsync();
}
public async Task OneTimeSetup()
{
var hourRepo = new HourRepository(ConnectionFactorySetup.ConnectionFactory);
var categoryRepo = new CategoryRepository(ConnectionFactorySetup.ConnectionFactory);
hour = await hourRepo.CreateAsync(new Hour { HourTimeStamp = DateTime.Now });
category = await categoryRepo.CreateAsync(new Category { HourId = hour.Id, CategoryType = CategoryType.Uptime });
categoryScoreRepository = new CategoryScoreRepository(ConnectionFactorySetup.ConnectionFactory);
categoryScore = await categoryScoreRepository.CreateAsync(new CategoryScore { CategoryId = category.Id, Score = 100.0m });
categoryScore.Score = 75.0m;
await categoryScoreRepository.UpdateAsync(categoryScore);
categoryScore = await categoryScoreRepository.ReadAsync(categoryScore.Id);
}
public ActionResult Details(int id)
{
var model = new StoryFormModel();
var story = StoryRepository.StoryFetch(id);
model.Title = string.Format("Story {0}", story.Description);
model.Story = story;
model.Notes = NoteRepository.NoteFetchInfoList(id, SourceType.Story);
model.Attachments = AttachmentRepository.AttachmentFetchInfoList(
model.Notes.Select(row => row.NoteId).Distinct().ToArray(), SourceType.Note);
model.Hours = HourRepository.HourFetchInfoList(story);
model.Statuses = StatusRepository.StatusFetchInfoList(story.ProjectId);
model.Actions.Add("Edit this story", Url.Action("Edit", new { id }), "primary");
model.Actions.Add("Add an hour", Url.Action("Create", "Hour", new { storyId = id }));
model.Actions.Add("Add an email", string.Empty);
model.Actions.Add("Add a note", Url.Action("Create", "Note", new { sourceId = id, sourceTypeId = (int)SourceType.Story }));
return(this.View(model));
}
public async Task SetUp()
{
var nowHour = DateTime.UtcNow.NormilizeToHour();
repo = new HourRepository(ConnectionFactorySetup.ConnectionFactory);
hour = await repo.CreateAsync(new Hour
{
HourTimeStamp = nowHour,
Score = 100.0m,
InSample = true
});
hour.Score = 75.0m;
await repo.UpdateAsync(hour);
hour = await repo.ReadAsync(hour.Id);
}
public async Task Setup()
{
var hourRepository = new HourRepository(ConnectionFactorySetup.ConnectionFactory);
this.repository = new IntegrationTestNewHourRepository(ConnectionFactorySetup.ConnectionFactory, hourRepository);
this.hourTestDataRepository = new HourTestDataRepository(ConnectionFactorySetup.ConnectionFactory, hourRepository);
this.testHour = new MockHour {
HourTimeStamp = DateTime.UtcNow.NormilizeToHour()
};
await this.hourTestDataRepository.CreateAsync(new List <MockHour> {
this.testHour
});
var hourToCreate = new Hour {
HourTimeStamp = DateTime.UtcNow.NormilizeToHour().AddHours(-4)
};
this.nonTestHour = await hourRepository.CreateAsync(hourToCreate);
}
public void Hour_Edit()
{
var hour = HourTestHelper.HourNew();
var notes = hour.Notes;
Assert.IsTrue(hour.IsValid, "IsValid should be true");
hour = HourRepository.HourSave(hour);
hour = HourRepository.HourFetch(hour.HourId);
hour.Notes = DataHelper.RandomString(20);
hour = HourRepository.HourSave(hour);
hour = HourRepository.HourFetch(hour.HourId);
Assert.IsTrue(hour.Notes != notes, "Name should have different value");
}
public void Hour_Delete()
{
var hour = HourTestHelper.HourNew();
Assert.IsTrue(hour.IsValid, "IsValid should be true");
hour = HourRepository.HourSave(hour);
hour = HourRepository.HourFetch(hour.HourId);
HourRepository.HourDelete(hour.HourId);
try
{
HourRepository.HourFetch(hour.HourId);
}
catch (Exception ex)
{
Assert.IsTrue(ex.GetBaseException() is InvalidOperationException);
}
}
