public async Task CanCreateUpdateRemoveAsync()
{
await ResetAsync();
await _repository.RemoveAllAsync();
await _client.RefreshAsync();
Assert.Equal(0, await _repository.CountAsync());
var stack = StackData.GenerateStack(projectId: TestConstants.ProjectId, organizationId: TestConstants.OrganizationId);
Assert.Null(stack.Id);
await _repository.AddAsync(stack);
Assert.NotNull(stack.Id);
await _client.RefreshAsync();
stack = await _repository.GetByIdAsync(stack.Id);
Assert.NotNull(stack);
stack.Description = "New Description";
await _repository.SaveAsync(stack);
await _repository.RemoveAsync(stack.Id);
}
private WebHookDataContext GetWebHookDataContext(Version version)
{
var json = File.ReadAllText(Path.GetFullPath(@"..\..\ErrorData\1477.expected.json"));
var settings = new JsonSerializerSettings {
MissingMemberHandling = MissingMemberHandling.Ignore,
ContractResolver = new ExtensionContractResolver()
};
var ev = JsonConvert.DeserializeObject <PersistentEvent>(json, settings);
ev.OrganizationId = TestConstants.OrganizationId;
ev.ProjectId = TestConstants.ProjectId;
ev.StackId = TestConstants.StackId;
var context = new WebHookDataContext(version, ev, OrganizationData.GenerateSampleOrganization(), ProjectData.GenerateSampleProject());
context.Stack = StackData.GenerateStack(id: TestConstants.StackId, organizationId: TestConstants.OrganizationId, projectId: TestConstants.ProjectId, title: _formattingPluginManager.GetStackTitle(ev), signatureHash: "722e7afd4dca4a3c91f4d94fec89dfdc");
context.Stack.Tags = new TagSet {
"Test"
};
context.Stack.FirstOccurrence = context.Stack.LastOccurrence = ev.Date.DateTime;
return(context);
}
public async Task CanGetByFixedAsync()
{
var stack = await _repository.AddAsync(StackData.GenerateStack(id: TestConstants.StackId, projectId: TestConstants.ProjectId, organizationId: TestConstants.OrganizationId));
await RefreshDataAsync();
var results = await _repository.GetByFilterAsync(null, "fixed:true", null, null, DateTime.MinValue, DateTime.MaxValue);
Assert.NotNull(results);
Assert.Equal(0, results.Total);
results = await _repository.GetByFilterAsync(null, "fixed:false", null, null, DateTime.MinValue, DateTime.MaxValue);
Assert.NotNull(results);
Assert.Equal(1, results.Total);
Assert.False(results.Documents.Single().IsRegressed);
Assert.Null(results.Documents.Single().DateFixed);
stack.MarkFixed();
await _repository.SaveAsync(stack);
await RefreshDataAsync();
results = await _repository.GetByFilterAsync(null, "fixed:true", null, null, DateTime.MinValue, DateTime.MaxValue);
Assert.NotNull(results);
Assert.Equal(1, results.Total);
Assert.False(results.Documents.Single().IsRegressed);
Assert.NotNull(results.Documents.Single().DateFixed);
results = await _repository.GetByFilterAsync(null, "fixed:false", null, null, DateTime.MinValue, DateTime.MaxValue);
Assert.NotNull(results);
Assert.Equal(0, results.Total);
}
public async Task GetStacksForCleanupAsync()
{
var openStack10DaysOldWithReference = StackData.GenerateStack(id: TestConstants.StackId3, utcLastOccurrence: SystemClock.UtcNow.SubtractDays(10), status: StackStatus.Open);
openStack10DaysOldWithReference.References.Add("test");
await _repository.AddAsync(new List <Stack> {
StackData.GenerateStack(id: TestConstants.StackId, utcLastOccurrence: SystemClock.UtcNow.SubtractDays(5), status: StackStatus.Open),
StackData.GenerateStack(id: TestConstants.StackId2, utcLastOccurrence: SystemClock.UtcNow.SubtractDays(10), status: StackStatus.Open),
openStack10DaysOldWithReference,
StackData.GenerateStack(id: TestConstants.StackId4, utcLastOccurrence: SystemClock.UtcNow.SubtractDays(10), status: StackStatus.Fixed)
}, o => o.ImmediateConsistency());
var stacks = await _repository.GetStacksForCleanupAsync(TestConstants.OrganizationId, SystemClock.UtcNow.SubtractDays(8));
Assert.NotNull(stacks);
Assert.Equal(1, stacks.Total);
Assert.Equal(1, stacks.Documents.Count);
Assert.Equal(TestConstants.StackId2, stacks.Documents.Single().Id);
stacks = await _repository.GetStacksForCleanupAsync(TestConstants.OrganizationId, SystemClock.UtcNow.SubtractDays(1));
Assert.NotNull(stacks);
Assert.Equal(2, stacks.Total);
Assert.Equal(2, stacks.Documents.Count);
Assert.NotNull(stacks.Documents.SingleOrDefault(s => String.Equals(s.Id, TestConstants.StackId)));
Assert.NotNull(stacks.Documents.SingleOrDefault(s => String.Equals(s.Id, TestConstants.StackId2)));
}
public async Task CanGetByFixedAsync()
{
var stack = await _repository.AddAsync(StackData.GenerateStack(projectId: TestConstants.ProjectId, organizationId: TestConstants.OrganizationId), o => o.ImmediateConsistency());
var results = await _repository.FindAsync(q => q.FilterExpression("fixed:true"));
Assert.NotNull(results);
Assert.Equal(0, results.Total);
results = await _repository.FindAsync(q => q.FilterExpression("fixed:false"));
Assert.NotNull(results);
Assert.Equal(1, results.Total);
Assert.False(results.Documents.Single().Status == Core.Models.StackStatus.Regressed);
Assert.Null(results.Documents.Single().DateFixed);
stack.MarkFixed();
await _repository.SaveAsync(stack, o => o.ImmediateConsistency());
results = await _repository.FindAsync(q => q.FilterExpression("fixed:true"));
Assert.NotNull(results);
Assert.Equal(1, results.Total);
Assert.False(results.Documents.Single().Status == Core.Models.StackStatus.Regressed);
Assert.NotNull(results.Documents.Single().DateFixed);
results = await _repository.FindAsync(q => q.FilterExpression("fixed:false"));
Assert.NotNull(results);
Assert.Equal(0, results.Total);
}
private WebHookDataContext GetWebHookDataContext(Version version)
{
string json = File.ReadAllText(Path.GetFullPath(Path.Combine("..", "..", "..", "ErrorData", "1477.expected.json")));
var settings = GetService <JsonSerializerSettings>();
settings.Formatting = Formatting.Indented;
var ev = JsonConvert.DeserializeObject <PersistentEvent>(json, settings);
ev.OrganizationId = TestConstants.OrganizationId;
ev.ProjectId = TestConstants.ProjectId;
ev.StackId = TestConstants.StackId;
ev.Id = TestConstants.EventId;
var context = new WebHookDataContext(version, ev, OrganizationData.GenerateSampleOrganization(GetService <BillingManager>(), GetService <BillingPlans>()), ProjectData.GenerateSampleProject())
{
Stack = StackData.GenerateStack(id: TestConstants.StackId, organizationId: TestConstants.OrganizationId, projectId: TestConstants.ProjectId, title: _formatter.GetStackTitle(ev), signatureHash: "722e7afd4dca4a3c91f4d94fec89dfdc")
};
context.Stack.Tags = new TagSet {
"Test"
};
context.Stack.FirstOccurrence = context.Stack.LastOccurrence = ev.Date.UtcDateTime;
return(context);
}
public async Task WillSetStackDuplicateSignature()
{
var stack = StackData.GenerateStack();
stack.DuplicateSignature = null;
stack = await _repository.AddAsync(stack, o => o.ImmediateConsistency());
Assert.NotEmpty(stack.ProjectId);
Assert.NotEmpty(stack.SignatureHash);
Assert.Null(stack.DuplicateSignature);
var migration = GetService <SetStackDuplicateSignature>();
var context = new MigrationContext(GetService <ILock>(), _logger, CancellationToken.None);
await migration.RunAsync(context);
string expectedDuplicateSignature = $"{stack.ProjectId}:{stack.SignatureHash}";
var actualStack = await _repository.GetByIdAsync(stack.Id);
Assert.NotEmpty(actualStack.ProjectId);
Assert.NotEmpty(actualStack.SignatureHash);
Assert.Equal($"{actualStack.ProjectId}:{actualStack.SignatureHash}", actualStack.DuplicateSignature);
var results = await _repository.FindAsync(q => q.ElasticFilter(Query <Stack> .Term(s => s.DuplicateSignature, expectedDuplicateSignature)));
Assert.Single(results.Documents);
}
public async Task WillMergeToStackWithMostEvents()
{
var utcNow = SystemClock.UtcNow;
var originalStack = StackData.GenerateStack();
originalStack.Id = ObjectId.GenerateNewId().ToString();
originalStack.TotalOccurrences = 10;
var biggerStack = originalStack.DeepClone();
biggerStack.Id = ObjectId.GenerateNewId().ToString();
biggerStack.Status = StackStatus.Fixed;
biggerStack.TotalOccurrences = 100;
biggerStack.LastOccurrence = originalStack.LastOccurrence.AddMinutes(1);
biggerStack.SnoozeUntilUtc = originalStack.SnoozeUntilUtc = null;
biggerStack.DateFixed = biggerStack.LastOccurrence.AddMinutes(1);
biggerStack.Tags.Add("stack2");
biggerStack.References.Add("stack2");
biggerStack.OccurrencesAreCritical = true;
originalStack = await _stackRepository.AddAsync(originalStack, o => o.ImmediateConsistency());
biggerStack = await _stackRepository.AddAsync(biggerStack, o => o.ImmediateConsistency());
await _eventRepository.AddAsync(EventData.GenerateEvents(count: 10, stackId: originalStack.Id), o => o.ImmediateConsistency());
await _eventRepository.AddAsync(EventData.GenerateEvents(count: 100, stackId: biggerStack.Id), o => o.ImmediateConsistency());
var results = await _stackRepository.FindAsync(q => q.ElasticFilter(Query <Stack> .Term(s => s.DuplicateSignature, originalStack.DuplicateSignature)));
Assert.Equal(2, results.Total);
var migration = GetService <FixDuplicateStacks>();
var context = new MigrationContext(GetService <ILock>(), _logger, CancellationToken.None);
await migration.RunAsync(context);
await RefreshDataAsync();
results = await _stackRepository.FindAsync(q => q.ElasticFilter(Query <Stack> .Term(s => s.DuplicateSignature, originalStack.DuplicateSignature)));
Assert.Single(results.Documents);
var updatedOriginalStack = await _stackRepository.GetByIdAsync(originalStack.Id, o => o.IncludeSoftDeletes());
Assert.True(updatedOriginalStack.IsDeleted);
var updatedBiggerStack = await _stackRepository.GetByIdAsync(biggerStack.Id, o => o.IncludeSoftDeletes());
Assert.False(updatedBiggerStack.IsDeleted);
Assert.Equal(originalStack.CreatedUtc, updatedBiggerStack.CreatedUtc);
Assert.Equal(110, updatedBiggerStack.TotalOccurrences);
Assert.Equal(StackStatus.Fixed, updatedBiggerStack.Status);
Assert.Equal(biggerStack.LastOccurrence, updatedBiggerStack.LastOccurrence);
Assert.Null(updatedBiggerStack.SnoozeUntilUtc);
Assert.Equal(biggerStack.DateFixed, updatedBiggerStack.DateFixed);
Assert.Equal(originalStack.Tags.Count + 1, updatedBiggerStack.Tags.Count);
Assert.Contains("stack2", updatedBiggerStack.Tags);
Assert.Equal(originalStack.References.Count + 1, updatedBiggerStack.References.Count);
Assert.Contains("stack2", updatedBiggerStack.References);
Assert.True(updatedBiggerStack.OccurrencesAreCritical);
}
protected void CreateData()
{
var baseDate = DateTime.Now;
var occurrenceDateStart = baseDate.AddMinutes(-30);
var occurrenceDateMid = baseDate;
var occurrenceDateEnd = baseDate.AddMinutes(30);
_stackRepository.Add(StackData.GenerateStack(id: TestConstants.StackId, organizationId: TestConstants.OrganizationId, projectId: TestConstants.ProjectId));
var occurrenceDates = new List <DateTime> {
occurrenceDateStart,
occurrenceDateEnd,
baseDate.AddMinutes(-10),
baseDate.AddMinutes(-20),
occurrenceDateMid,
occurrenceDateMid,
occurrenceDateMid,
baseDate.AddMinutes(20),
baseDate.AddMinutes(10),
baseDate.AddSeconds(1),
occurrenceDateEnd,
occurrenceDateStart
};
foreach (var date in occurrenceDates)
{
var ev = _repository.Add(EventData.GenerateEvent(projectId: TestConstants.ProjectId, organizationId: TestConstants.OrganizationId, stackId: TestConstants.StackId, occurrenceDate: date));
_ids.Add(Tuple.Create(ev.Id, date));
}
}
private async Task CreateDataAsync()
{
var baseDate = SystemClock.UtcNow.SubtractHours(1);
var occurrenceDateStart = baseDate.AddMinutes(-30);
var occurrenceDateMid = baseDate;
var occurrenceDateEnd = baseDate.AddMinutes(30);
await _stackRepository.AddAsync(StackData.GenerateStack(id: TestConstants.StackId, organizationId: TestConstants.OrganizationId, projectId: TestConstants.ProjectId));
var occurrenceDates = new List <DateTime> {
occurrenceDateStart,
occurrenceDateEnd,
baseDate.AddMinutes(-10),
baseDate.AddMinutes(-20),
occurrenceDateMid,
occurrenceDateMid,
occurrenceDateMid,
baseDate.AddMinutes(20),
baseDate.AddMinutes(10),
baseDate.AddSeconds(1),
occurrenceDateEnd,
occurrenceDateStart
};
foreach (var date in occurrenceDates)
{
var ev = await _repository.AddAsync(EventData.GenerateEvent(projectId: TestConstants.ProjectId, organizationId: TestConstants.OrganizationId, stackId: TestConstants.StackId, occurrenceDate: date));
_ids.Add(Tuple.Create(ev.Id, date));
}
await RefreshDataAsync();
}
public async Task IncrementUsageConcurrently()
{
var stack = await _stackRepository.AddAsync(StackData.GenerateStack(id: TestConstants.StackId, projectId: TestConstants.ProjectId, organizationId: TestConstants.OrganizationId));
var stack2 = await _stackRepository.AddAsync(StackData.GenerateStack(id: TestConstants.StackId2, projectId: TestConstants.ProjectId, organizationId: TestConstants.OrganizationId));
DateTime?minOccurrenceDate = null, maxOccurrenceDate = null;
var tasks = new List <Task>();
for (int i = 0; i < 10; i++)
{
tasks.Add(IncrementUsageBatch());
}
await Task.WhenAll(tasks);
// Assert stack state has no change after increment usage
stack = await _stackRepository.GetByIdAsync(TestConstants.StackId);
Assert.Equal(0, stack.TotalOccurrences);
Assert.True(stack.FirstOccurrence <= SystemClock.UtcNow);
Assert.True(stack.LastOccurrence <= SystemClock.UtcNow);
// Assert state in cache has been changed after increment usage
Assert.Equal(minOccurrenceDate, await _cache.GetUnixTimeMillisecondsAsync(_stackService.GetStackOccurrenceMinDateCacheKey(stack.Id)));
Assert.Equal(maxOccurrenceDate, await _cache.GetUnixTimeMillisecondsAsync(_stackService.GetStackOccurrenceMaxDateCacheKey(stack.Id)));
Assert.Equal(100, await _cache.GetAsync <long>(_stackService.GetStackOccurrenceCountCacheKey(stack.Id), 0));
stack2 = await _stackRepository.GetByIdAsync(TestConstants.StackId2);
Assert.Equal(0, stack2.TotalOccurrences);
Assert.True(stack2.FirstOccurrence <= SystemClock.UtcNow);
Assert.True(stack2.LastOccurrence <= SystemClock.UtcNow);
// Assert state in cache has been changed after increment usage
Assert.Equal(minOccurrenceDate, await _cache.GetUnixTimeMillisecondsAsync(_stackService.GetStackOccurrenceMinDateCacheKey(stack2.Id)));
Assert.Equal(maxOccurrenceDate, await _cache.GetUnixTimeMillisecondsAsync(_stackService.GetStackOccurrenceMaxDateCacheKey(stack2.Id)));
Assert.Equal(200, await _cache.GetAsync <long>(_stackService.GetStackOccurrenceCountCacheKey(stack2.Id), 0));
var occurrenceSet = await _cache.GetListAsync <(string OrganizationId, string ProjectId, string StackId)>(_stackService.GetStackOccurrenceSetCacheKey());
Assert.Equal(2, occurrenceSet.Value.Count);
async Task IncrementUsageBatch()
{
for (int i = 0; i < 10; i++)
{
var utcNow = SystemClock.UtcNow.Floor(TimeSpan.FromMilliseconds(1));
if (!minOccurrenceDate.HasValue)
{
minOccurrenceDate = utcNow;
}
maxOccurrenceDate = utcNow;
await _stackService.IncrementStackUsageAsync(TestConstants.OrganizationId, TestConstants.ProjectId, stack.Id, utcNow, utcNow, 1);
await _stackService.IncrementStackUsageAsync(TestConstants.OrganizationId, TestConstants.ProjectId, stack2.Id, utcNow, utcNow, 2);
}
}
}
public async Task WillNotMergeDuplicatedDeletedStacks()
{
var originalStack = StackData.GenerateStack();
var duplicateStack = originalStack.DeepClone();
duplicateStack.Id = ObjectId.GenerateNewId().ToString();
duplicateStack.CreatedUtc = originalStack.CreatedUtc.AddMinutes(1);
duplicateStack.Status = StackStatus.Fixed;
duplicateStack.LastOccurrence = originalStack.LastOccurrence.AddMinutes(1);
duplicateStack.SnoozeUntilUtc = originalStack.SnoozeUntilUtc = null;
duplicateStack.DateFixed = duplicateStack.LastOccurrence.AddMinutes(1);
duplicateStack.UpdatedUtc = originalStack.UpdatedUtc.SubtractMinutes(1);
duplicateStack.Tags.Add("stack2");
duplicateStack.References.Add("stack2");
duplicateStack.OccurrencesAreCritical = true;
duplicateStack.IsDeleted = true;
await _stackRepository.AddAsync(new[] { originalStack, duplicateStack }, o => o.ImmediateConsistency());
var results = await _stackRepository.FindAsync(q => q.ElasticFilter(Query <Stack> .Term(s => s.DuplicateSignature, originalStack.DuplicateSignature)));
Assert.Single(results.Documents);
var migration = GetService <FixDuplicateStacks>();
var context = new MigrationContext(GetService <ILock>(), _logger, CancellationToken.None);
await migration.RunAsync(context);
await RefreshDataAsync();
results = await _stackRepository.FindAsync(q => q.ElasticFilter(Query <Stack> .Term(s => s.DuplicateSignature, originalStack.DuplicateSignature)));
Assert.Single(results.Documents);
var updatedOriginalStack = await _stackRepository.GetByIdAsync(originalStack.Id, o => o.IncludeSoftDeletes());
Assert.False(updatedOriginalStack.IsDeleted);
var updatedDuplicateStack = await _stackRepository.GetByIdAsync(duplicateStack.Id, o => o.IncludeSoftDeletes());
Assert.True(updatedDuplicateStack.IsDeleted);
Assert.Equal(originalStack.CreatedUtc, updatedOriginalStack.CreatedUtc);
Assert.Equal(originalStack.Status, updatedOriginalStack.Status);
Assert.Equal(originalStack.LastOccurrence, updatedOriginalStack.LastOccurrence);
Assert.Equal(originalStack.SnoozeUntilUtc, updatedOriginalStack.SnoozeUntilUtc);
Assert.Equal(originalStack.DateFixed, updatedOriginalStack.DateFixed);
Assert.Equal(originalStack.UpdatedUtc, updatedOriginalStack.UpdatedUtc);
Assert.Equal(originalStack.Tags.Count, updatedOriginalStack.Tags.Count);
Assert.DoesNotContain("stack2", updatedOriginalStack.Tags);
Assert.Equal(originalStack.References.Count, updatedOriginalStack.References.Count);
Assert.DoesNotContain("stack2", updatedOriginalStack.References);
Assert.False(updatedOriginalStack.OccurrencesAreCritical);
}
public async Task IncrementUsage_OnlyChangeCache()
{
var stack = await _stackRepository.AddAsync(StackData.GenerateStack(id: TestConstants.StackId, projectId: TestConstants.ProjectId, organizationId: TestConstants.OrganizationId), o => o.ImmediateConsistency());
// Assert stack state in elasticsearch before increment usage
Assert.Equal(0, stack.TotalOccurrences);
Assert.True(stack.FirstOccurrence <= SystemClock.UtcNow);
Assert.True(stack.LastOccurrence <= SystemClock.UtcNow);
// Assert state in cache before increment usage
Assert.Equal(DateTime.MinValue, await _cache.GetUnixTimeMillisecondsAsync(_stackService.GetStackOccurrenceMinDateCacheKey(stack.Id)));
Assert.Equal(DateTime.MinValue, await _cache.GetUnixTimeMillisecondsAsync(_stackService.GetStackOccurrenceMaxDateCacheKey(stack.Id)));
Assert.Equal(0, await _cache.GetAsync <long>(_stackService.GetStackOccurrenceCountCacheKey(stack.Id), 0));
var occurrenceSet = await _cache.GetListAsync <(string OrganizationId, string ProjectId, string StackId)>(_stackService.GetStackOccurrenceSetCacheKey());
Assert.True(occurrenceSet.IsNull || !occurrenceSet.HasValue || occurrenceSet.Value.Count == 0);
var firstUtcNow = SystemClock.UtcNow.Floor(TimeSpan.FromMilliseconds(1));
await RefreshDataAsync();
await _stackService.IncrementStackUsageAsync(TestConstants.OrganizationId, TestConstants.ProjectId, stack.Id, firstUtcNow, firstUtcNow, 1);
// Assert stack state has no change after increment usage
stack = await _stackRepository.GetByIdAsync(TestConstants.StackId);
Assert.Equal(0, stack.TotalOccurrences);
Assert.True(stack.FirstOccurrence <= SystemClock.UtcNow);
Assert.True(stack.LastOccurrence <= SystemClock.UtcNow);
// Assert state in cache has been changed after increment usage
Assert.Equal(firstUtcNow, await _cache.GetUnixTimeMillisecondsAsync(_stackService.GetStackOccurrenceMinDateCacheKey(stack.Id)));
Assert.Equal(firstUtcNow, await _cache.GetUnixTimeMillisecondsAsync(_stackService.GetStackOccurrenceMaxDateCacheKey(stack.Id)));
Assert.Equal(1, await _cache.GetAsync <long>(_stackService.GetStackOccurrenceCountCacheKey(stack.Id), 0));
occurrenceSet = await _cache.GetListAsync <(string OrganizationId, string ProjectId, string StackId)>(_stackService.GetStackOccurrenceSetCacheKey());
Assert.Single(occurrenceSet.Value);
var secondUtcNow = SystemClock.UtcNow.Floor(TimeSpan.FromMilliseconds(1));
await RefreshDataAsync();
await _stackService.IncrementStackUsageAsync(TestConstants.OrganizationId, TestConstants.ProjectId, stack.Id, secondUtcNow, secondUtcNow, 2);
// Assert state in cache has been changed after increment usage again
Assert.Equal(firstUtcNow, await _cache.GetUnixTimeMillisecondsAsync(_stackService.GetStackOccurrenceMinDateCacheKey(stack.Id)));
Assert.Equal(secondUtcNow, await _cache.GetUnixTimeMillisecondsAsync(_stackService.GetStackOccurrenceMaxDateCacheKey(stack.Id)));
Assert.Equal(3, await _cache.GetAsync <long>(_stackService.GetStackOccurrenceCountCacheKey(stack.Id), 0));
occurrenceSet = await _cache.GetListAsync <(string OrganizationId, string ProjectId, string StackId)>(_stackService.GetStackOccurrenceSetCacheKey());
Assert.Single(occurrenceSet.Value);
}
public async Task CanMarkAsRegressedAsync()
{
var stack = await _repository.AddAsync(StackData.GenerateStack(projectId: TestConstants.ProjectId, organizationId: TestConstants.OrganizationId, dateFixed: SystemClock.UtcNow.SubtractMonths(1)), o => o.ImmediateConsistency());
Assert.NotNull(stack);
Assert.False(stack.Status == Core.Models.StackStatus.Regressed);
Assert.NotNull(stack.DateFixed);
await _repository.MarkAsRegressedAsync(stack.Id);
stack = await _repository.GetByIdAsync(stack.Id);
Assert.NotNull(stack);
Assert.True(stack.Status == Core.Models.StackStatus.Regressed);
Assert.NotNull(stack.DateFixed);
}
public async Task IncrementEventCounterTestAsync()
{
await RemoveDataAsync();
await _repository.AddAsync(StackData.GenerateStack(id: TestConstants.StackId, projectId: TestConstants.ProjectId, organizationId: TestConstants.OrganizationId));
await _client.RefreshAsync();
var stack = await _repository.GetByIdAsync(TestConstants.StackId);
Assert.NotNull(stack);
Assert.Equal(0, stack.TotalOccurrences);
Assert.Equal(DateTime.MinValue, stack.FirstOccurrence);
Assert.Equal(DateTime.MinValue, stack.LastOccurrence);
var utcNow = DateTime.UtcNow;
await _repository.IncrementEventCounterAsync(TestConstants.OrganizationId, TestConstants.ProjectId, TestConstants.StackId, utcNow, utcNow, 1);
await _client.RefreshAsync();
stack = await _repository.GetByIdAsync(TestConstants.StackId);
Assert.Equal(1, stack.TotalOccurrences);
Assert.Equal(utcNow, stack.FirstOccurrence);
Assert.Equal(utcNow, stack.LastOccurrence);
await _repository.IncrementEventCounterAsync(TestConstants.OrganizationId, TestConstants.ProjectId, TestConstants.StackId, utcNow.SubtractDays(1), utcNow.SubtractDays(1), 1);
await _client.RefreshAsync();
stack = await _repository.GetByIdAsync(TestConstants.StackId);
Assert.Equal(2, stack.TotalOccurrences);
Assert.Equal(utcNow.SubtractDays(1), stack.FirstOccurrence);
Assert.Equal(utcNow, stack.LastOccurrence);
await _repository.IncrementEventCounterAsync(TestConstants.OrganizationId, TestConstants.ProjectId, TestConstants.StackId, utcNow.AddDays(1), utcNow.AddDays(1), 1);
await _client.RefreshAsync();
stack = await _repository.GetByIdAsync(TestConstants.StackId);
Assert.Equal(3, stack.TotalOccurrences);
Assert.Equal(utcNow.SubtractDays(1), stack.FirstOccurrence);
Assert.Equal(utcNow.AddDays(1), stack.LastOccurrence);
}
public async Task CanMarkAsRegressedAsync()
{
await _repository.AddAsync(StackData.GenerateStack(id: TestConstants.StackId, projectId: TestConstants.ProjectId, organizationId: TestConstants.OrganizationId, dateFixed: SystemClock.UtcNow.SubtractMonths(1)));
var stack = await _repository.GetByIdAsync(TestConstants.StackId);
Assert.NotNull(stack);
Assert.False(stack.IsRegressed);
Assert.NotNull(stack.DateFixed);
await RefreshDataAsync();
await _repository.MarkAsRegressedAsync(TestConstants.StackId);
stack = await _repository.GetByIdAsync(TestConstants.StackId);
Assert.NotNull(stack);
Assert.True(stack.IsRegressed);
Assert.NotNull(stack.DateFixed);
}
public async Task CanSaveStackUsage()
{
var stack = await _stackRepository.AddAsync(StackData.GenerateStack(id: TestConstants.StackId, projectId: TestConstants.ProjectId, organizationId: TestConstants.OrganizationId));
var utcNow = SystemClock.UtcNow.Floor(TimeSpan.FromMilliseconds(1));
DateTime minOccurrenceDate = utcNow.AddMinutes(-1), maxOccurrenceDate = utcNow;
await _stackService.IncrementStackUsageAsync(TestConstants.OrganizationId, TestConstants.ProjectId, stack.Id, minOccurrenceDate, maxOccurrenceDate, 10);
await _stackService.SaveStackUsagesAsync(false);
// Assert state in cache after save stack usage
Assert.Equal(0, await _cache.GetAsync <long>(_stackService.GetStackOccurrenceCountCacheKey(stack.Id), 0));
// Assert stack state after save stack usage
stack = await _stackRepository.GetByIdAsync(TestConstants.StackId);
Assert.Equal(10, stack.TotalOccurrences);
Assert.Equal(minOccurrenceDate, stack.FirstOccurrence);
Assert.Equal(maxOccurrenceDate, stack.LastOccurrence);
}
public async Task CanGetByStackHashAsync()
{
long count = _cache.Count;
long hits = _cache.Hits;
long misses = _cache.Misses;
var stack = await _repository.AddAsync(StackData.GenerateStack(id: TestConstants.StackId, projectId: TestConstants.ProjectId, organizationId: TestConstants.OrganizationId, dateFixed: SystemClock.UtcNow.SubtractMonths(1)), o => o.Cache());
Assert.NotNull(stack?.Id);
Assert.Equal(count + 2, _cache.Count);
Assert.Equal(hits, _cache.Hits);
Assert.Equal(misses, _cache.Misses);
var result = await _repository.GetStackBySignatureHashAsync(stack.ProjectId, stack.SignatureHash);
Assert.Equal(stack.ToJson(), result.ToJson());
Assert.Equal(count + 2, _cache.Count);
Assert.Equal(hits + 1, _cache.Hits);
Assert.Equal(misses, _cache.Misses);
}
public void MarkAsRegressedTest()
{
RemoveData();
_repository.Add(StackData.GenerateStack(id: TestConstants.StackId, projectId: TestConstants.ProjectId, organizationId: TestConstants.OrganizationId, dateFixed: DateTime.Now.SubtractMonths(1)));
_client.Refresh();
var stack = _repository.GetById(TestConstants.StackId);
Assert.NotNull(stack);
Assert.False(stack.IsRegressed);
Assert.NotNull(stack.DateFixed);
_repository.MarkAsRegressed(TestConstants.StackId);
_client.Refresh();
stack = _repository.GetById(TestConstants.StackId);
Assert.NotNull(stack);
Assert.True(stack.IsRegressed);
Assert.Null(stack.DateFixed);
}
public void CanCreateUpdateRemove()
{
_repository.RemoveAll();
Assert.Equal(0, _repository.Count());
var stack = StackData.GenerateStack(projectId: TestConstants.ProjectId, organizationId: TestConstants.OrganizationId);
Assert.Null(stack.Id);
_repository.Add(stack);
Assert.NotNull(stack.Id);
_client.Refresh();
stack = _repository.GetById(stack.Id);
Assert.NotNull(stack);
stack.Description = "New Description";
_repository.Save(stack);
_repository.Remove(stack.Id);
}
public async Task CanIncrementEventCounterAsync()
{
var stack = await _repository.AddAsync(StackData.GenerateStack(projectId: TestConstants.ProjectId, organizationId: TestConstants.OrganizationId), o => o.ImmediateConsistency());
Assert.NotNull(stack);
Assert.Equal(0, stack.TotalOccurrences);
Assert.True(stack.FirstOccurrence <= SystemClock.UtcNow);
Assert.True(stack.LastOccurrence <= SystemClock.UtcNow);
Assert.NotEqual(DateTime.MinValue, stack.CreatedUtc);
Assert.NotEqual(DateTime.MinValue, stack.UpdatedUtc);
Assert.Equal(stack.CreatedUtc, stack.UpdatedUtc);
var updatedUtc = stack.UpdatedUtc;
var utcNow = SystemClock.UtcNow;
await _repository.IncrementEventCounterAsync(TestConstants.OrganizationId, TestConstants.ProjectId, stack.Id, utcNow, utcNow, 1);
stack = await _repository.GetByIdAsync(stack.Id);
Assert.Equal(1, stack.TotalOccurrences);
Assert.Equal(utcNow, stack.FirstOccurrence);
Assert.Equal(utcNow, stack.LastOccurrence);
Assert.Equal(updatedUtc, stack.CreatedUtc);
Assert.True(updatedUtc.IsBefore(stack.UpdatedUtc), $"Previous {updatedUtc}, Current: {stack.UpdatedUtc}");
await _repository.IncrementEventCounterAsync(TestConstants.OrganizationId, TestConstants.ProjectId, stack.Id, utcNow.SubtractDays(1), utcNow.SubtractDays(1), 1);
stack = await _repository.GetByIdAsync(stack.Id);
Assert.Equal(2, stack.TotalOccurrences);
Assert.Equal(utcNow.SubtractDays(1), stack.FirstOccurrence);
Assert.Equal(utcNow, stack.LastOccurrence);
await _repository.IncrementEventCounterAsync(TestConstants.OrganizationId, TestConstants.ProjectId, stack.Id, utcNow.AddDays(1), utcNow.AddDays(1), 1);
stack = await _repository.GetByIdAsync(stack.Id);
Assert.Equal(3, stack.TotalOccurrences);
Assert.Equal(utcNow.SubtractDays(1), stack.FirstOccurrence);
Assert.Equal(utcNow.AddDays(1), stack.LastOccurrence);
}
public void IncrementEventCounterTest()
{
RemoveData();
_repository.Add(StackData.GenerateStack(id: TestConstants.StackId, projectId: TestConstants.ProjectId, organizationId: TestConstants.OrganizationId));
_client.Refresh();
var stack = _repository.GetById(TestConstants.StackId);
Assert.NotNull(stack);
Assert.Equal(0, stack.TotalOccurrences);
Assert.Equal(DateTime.MinValue, stack.FirstOccurrence);
Assert.Equal(DateTime.MinValue, stack.LastOccurrence);
var utcNow = DateTime.UtcNow;
_repository.IncrementEventCounter(TestConstants.OrganizationId, TestConstants.StackId, utcNow);
_client.Refresh();
stack = _repository.GetById(TestConstants.StackId);
Assert.Equal(1, stack.TotalOccurrences);
Assert.Equal(utcNow, stack.FirstOccurrence);
Assert.Equal(utcNow, stack.LastOccurrence);
_repository.IncrementEventCounter(TestConstants.OrganizationId, TestConstants.StackId, utcNow.SubtractDays(1));
_client.Refresh();
stack = _repository.GetById(TestConstants.StackId);
Assert.Equal(2, stack.TotalOccurrences);
Assert.Equal(utcNow.SubtractDays(1), stack.FirstOccurrence);
Assert.Equal(utcNow, stack.LastOccurrence);
_repository.IncrementEventCounter(TestConstants.OrganizationId, TestConstants.StackId, utcNow.AddDays(1));
_client.Refresh();
stack = _repository.GetById(TestConstants.StackId);
Assert.Equal(3, stack.TotalOccurrences);
Assert.Equal(utcNow.SubtractDays(1), stack.FirstOccurrence);
Assert.Equal(utcNow.AddDays(1), stack.LastOccurrence);
}
