public void FiltersDuplicatedCommandEvents()
{
var firstEventTime = DateTimeFactory.SomeWorkingHoursDateTime();
var commandEvent = new CommandEvent
{
CommandId = "Test",
TriggeredAt = firstEventTime
};
var commandEvent2 = new CommandEvent
{
CommandId = "Test",
TriggeredAt = firstEventTime + ConcurrentEventHeuristic.EventTimeDifference
};
var commandEvent3 = new CommandEvent
{
CommandId = "Test",
TriggeredAt =
firstEventTime + ConcurrentEventHeuristic.EventTimeDifference +
ConcurrentEventHeuristic.EventTimeDifference
};
var commandEvent4 = new CommandEvent
{
CommandId = "Test",
TriggeredAt = firstEventTime + ConcurrentEventHeuristic.EventTimeDifference +
ConcurrentEventHeuristic.EventTimeDifference.Add(
new TimeSpan(TimeSpan.TicksPerSecond))
};
Assert.AreEqual(Sets.NewHashSet <IDEEvent>(commandEvent), _uut.Map(commandEvent));
Assert.AreEqual(Sets.NewHashSet <IDEEvent>(), _uut.Map(commandEvent2));
Assert.AreEqual(Sets.NewHashSet <IDEEvent>(), _uut.Map(commandEvent3));
Assert.AreEqual(Sets.NewHashSet <IDEEvent>(commandEvent4), _uut.Map(commandEvent4));
}
public void ShouldReturnFalseForNonSimilarEventTimes()
{
var eventTime1 = DateTimeFactory.SomeWorkingHoursDateTime();
var eventTime2 = eventTime1.Add(ConcurrentEventHeuristic.EventTimeDifference + TimeSpan.FromTicks(1));
Assert.IsFalse(ConcurrentEventHeuristic.AreSimilar(eventTime1, eventTime2));
}
public void ShouldNotIgnoreOtherWindowEvents()
{
_uut.AddEventAfterBreakToStatistic = false;
var triggeredAt = DateTimeFactory.SomeWorkingHoursDateTime();
var someEvent = new WindowEvent
{
TriggeredAt = triggeredAt,
Action = WindowAction.Activate
};
var eventAfterBreak = new CommandEvent
{
TriggeredAt = triggeredAt + _uut.MinBreakTime
};
_uut.OnStreamStarts(new Developer());
_uut.OnEvent(someEvent);
_uut.OnEvent(eventAfterBreak);
_uut.OnStreamEnds();
var expectedStatistic = new Dictionary<string, Tuple<TimeSpan, int>>
{
{
EventMappingUtils.GetAbstractStringOf(someEvent),
new Tuple<TimeSpan, int>(_uut.MinBreakTime, 1)
}
};
CollectionAssert.AreEquivalent(expectedStatistic, _uut.Statistic);
}
public void ShouldAddMappingForTwoConcurrentCommandEvents()
{
var eventTime = DateTimeFactory.SomeWorkingHoursDateTime();
var commandEvent1 = new CommandEvent
{
CommandId = "Edit.Copy",
TriggeredAt = eventTime
};
var commandEvent2 = new CommandEvent
{
CommandId = "Copy",
TriggeredBy = EventTrigger.Click,
TriggeredAt = eventTime + ConcurrentEventHeuristic.EventTimeDifference
};
_uut.OnStreamStarts(TestFactory.SomeDeveloper());
_uut.OnEvent(commandEvent1);
_uut.OnEvent(commandEvent2);
_uut.OnStreamEnds();
var expectedPair = SortedCommandPair.NewSortedPair(commandEvent1.CommandId, commandEvent2.CommandId);
CollectionAssert.Contains(
_uut.Statistic,
new KeyValuePair <SortedCommandPair, int>(expectedPair, 1));
}
public void ShouldAddNextEventWhenEnabled()
{
_uut.AddEventAfterBreakToStatistic = true;
var triggeredAt = DateTimeFactory.SomeWorkingHoursDateTime();
var someEvent = new TestIDEEvent
{
TriggeredAt = triggeredAt
};
var eventAfterBreak = new CommandEvent
{
TriggeredAt = triggeredAt + _uut.MinBreakTime
};
_uut.OnStreamStarts(new Developer());
_uut.OnEvent(someEvent);
_uut.OnEvent(eventAfterBreak);
_uut.OnStreamEnds();
var expectedStatistic = new Dictionary<string, Tuple<TimeSpan, int>>
{
{
String.Format(
"{0}{1}{2}",
EventMappingUtils.GetAbstractStringOf(new TestIDEEvent()),
AverageBreakAfterEventsCalculator.EventAfterBreakSeparator,
EventMappingUtils.GetAbstractStringOf(new CommandEvent())),
new Tuple<TimeSpan, int>(_uut.MinBreakTime, 1)
}
};
CollectionAssert.AreEquivalent(expectedStatistic, _uut.Statistic);
}
public void HaveSimiliarEventTimeTest()
{
var eventTime1 = DateTimeFactory.SomeWorkingHoursDateTime();
var eventTime2 = eventTime1.Add(ConcurrentEventHeuristic.EventTimeDifference);
Assert.IsTrue(ConcurrentEventHeuristic.AreSimilar(eventTime1, eventTime2));
}
public void SetUp()
{
_testMergeStrategy = new TestMergeStrategy();
_uut = new ActivityWindowProcessor(_testMergeStrategy, WindowSpan);
_someDeveloper = TestFactory.SomeDeveloper();
_someDateTime = DateTimeFactory.SomeWorkingHoursDateTime();
}
public void TracksLastActivityOnDay()
{
var lastActionTriggeredAt = DateTimeFactory.SomeWorkingHoursDateTime();
_uut.AddEvent(TestEventFactory.SomeEvent(lastActionTriggeredAt.AddMinutes(-10)));
_uut.AddEvent(TestEventFactory.SomeEvent(lastActionTriggeredAt));
Assert.AreEqual(lastActionTriggeredAt, _uut.LastActivityAt);
}
public void ShouldDropEventAfterLongBreak()
{
var someDateTime = DateTimeFactory.SomeWorkingHoursDateTime();
var eventBeforeBreak = TestEventFactory.SomeEvent(someDateTime);
var eventAfterBreak = TestEventFactory.SomeEvent(someDateTime + _uut.LongBreak);
_uut.Map(eventBeforeBreak);
Assert.AreEqual(Sets.NewHashSet <IDEEvent>(), _uut.Map(eventAfterBreak));
}
private static ActivityEvent Event(Activity activity, int durationInMilliseconds)
{
return(new ActivityEvent
{
Activity = activity,
TriggeredAt = DateTimeFactory.SomeWorkingHoursDateTime(),
Duration = TimeSpan.FromMilliseconds(durationInMilliseconds)
});
}
private static Window Window(params ActivityEvent[] activityEvents)
{
var window = new Window(DateTimeFactory.SomeWorkingHoursDateTime(), TimeSpan.FromSeconds(5));
foreach (var activityEvent in activityEvents)
{
window.Add(activityEvent);
}
return(window);
}
public void ShouldNotInsertDroppedEventsIfASecondLongBreakOccurs()
{
var someDateTime = DateTimeFactory.SomeWorkingHoursDateTime();
var eventBeforeBreak = TestEventFactory.SomeEvent(someDateTime);
var droppedEvent = TestEventFactory.SomeEvent(someDateTime + _uut.LongBreak);
var eventAfterSecondLongBreak = TestEventFactory.SomeEvent(
someDateTime + _uut.LongBreak + _uut.LongBreak);
_uut.Map(eventBeforeBreak);
_uut.Map(droppedEvent);
CollectionAssert.DoesNotContain(_uut.Map(eventAfterSecondLongBreak), droppedEvent);
}
protected static Window Window(params Activity[] activities)
{
var window = new Window(DateTimeFactory.SomeWorkingHoursDateTime(), TimeSpan.FromSeconds(5));
foreach (var activityEvent in activities.Select(a => new ActivityEvent {
Activity = a
}))
{
window.Add(activityEvent);
}
return(window);
}
public void ShouldCombineResultsForMultipleDeveloperStreams()
{
_uut.MaxEventsBeforeBreak = 2;
var triggeredAt = DateTimeFactory.SomeWorkingHoursDateTime();
var firstEvent = new TestIDEEvent
{
TriggeredAt = triggeredAt
};
var secondEvent = new CommandEvent
{
TriggeredAt = triggeredAt
};
var lateEvent = new TestIDEEvent
{
TriggeredAt = triggeredAt + _uut.MinBreakTime
};
var listOfEvents = new List<IDEEvent>
{
firstEvent,
secondEvent,
lateEvent
};
_uut.OnStreamStarts(new Developer());
listOfEvents.ForEach(@event => _uut.OnEvent(@event));
_uut.OnStreamEnds();
_uut.OnStreamStarts(new Developer());
listOfEvents.ForEach(@event => _uut.OnEvent(@event));
_uut.OnStreamEnds();
var expectedStatistic = new Dictionary<string, Tuple<TimeSpan, int>>
{
{
String.Format(
"{0}{1}{2}",
EventMappingUtils.GetAbstractStringOf(new TestIDEEvent()),
AverageBreakAfterEventsCalculator.StatisticStringSeparator,
EventMappingUtils.GetAbstractStringOf(new CommandEvent())),
new Tuple<TimeSpan, int>(_uut.MinBreakTime, 2)
}
};
CollectionAssert.AreEquivalent(expectedStatistic, _uut.Statistic);
}
public void ShouldInsertDroppedEventsIfNoSecondLongBreakOccurs()
{
var someDateTime = DateTimeFactory.SomeWorkingHoursDateTime();
var eventBeforeBreak = TestEventFactory.SomeEvent(someDateTime);
var droppedEvent = TestEventFactory.SomeEvent(someDateTime + _uut.LongBreak);
var eventAfterBlockSpanWithoutLongBreak =
TestEventFactory.SomeEvent(
someDateTime + _uut.LongBreak + _uut.MaximumBlockSpan + TimeSpan.FromTicks(1));
_uut.Map(eventBeforeBreak);
_uut.Map(droppedEvent);
var actualSet = _uut.Map(eventAfterBlockSpanWithoutLongBreak);
var expectedSet = Sets.NewHashSet <IDEEvent>(droppedEvent, eventAfterBlockSpanWithoutLongBreak);
CollectionAssert.AreEquivalent(expectedSet, actualSet);
}
public void ShouldNotFilterIgnorableTextControlCommands()
{
var firstEventTime = DateTimeFactory.SomeWorkingHoursDateTime();
var commandEvent = new CommandEvent
{
CommandId = ConcurrentEventHeuristic.IgnorableTextControlCommands.First(),
TriggeredAt = firstEventTime
};
var commandEvent2 = new CommandEvent
{
CommandId = ConcurrentEventHeuristic.IgnorableTextControlCommands.First(),
TriggeredAt = firstEventTime + ConcurrentEventHeuristic.EventTimeDifference
};
CollectionAssert.AreEquivalent(Sets.NewHashSet(commandEvent), _uut.Map(commandEvent));
CollectionAssert.AreEquivalent(Sets.NewHashSet(commandEvent2), _uut.Map(commandEvent2));
}
public void ShouldAddDroppedEventBlocksToStatistic()
{
var someDateTime = DateTimeFactory.SomeWorkingHoursDateTime();
var eventBeforeBreak = TestEventFactory.SomeEvent(someDateTime);
var droppedEvent = TestEventFactory.SomeEvent(someDateTime + _uut.LongBreak);
var eventAfterSecondLongBreak = TestEventFactory.SomeEvent(
someDateTime + _uut.LongBreak + _uut.LongBreak);
_uut.Map(eventBeforeBreak);
_uut.Map(droppedEvent);
_uut.Map(eventAfterSecondLongBreak);
var expectedFilteredIsolatedBlocks = Lists.NewList(Lists.NewList <IDEEvent>(droppedEvent));
CollectionAssert.AreEquivalent(_uut.FilteredIsolatedBlocks, expectedFilteredIsolatedBlocks);
}
public void ShouldAddUnknownTriggerMappingsToSeparateStatistic()
{
var eventTime = DateTimeFactory.SomeWorkingHoursDateTime();
var commandEvent1 = new CommandEvent
{
CommandId = "Test1",
TriggeredAt = eventTime
};
var commandEvent2 = new CommandEvent
{
CommandId = "Test2",
TriggeredAt = eventTime + ConcurrentEventHeuristic.EventTimeDifference
};
var commandEvent3 = new CommandEvent
{
CommandId = commandEvent1.CommandId,
TriggeredAt = eventTime + ConcurrentEventHeuristic.EventTimeDifference +
TimeSpan.FromSeconds(1)
};
var commandEvent4 = new CommandEvent
{
CommandId = commandEvent2.CommandId,
TriggeredAt = eventTime + ConcurrentEventHeuristic.EventTimeDifference +
TimeSpan.FromSeconds(1) +
ConcurrentEventHeuristic.EventTimeDifference
};
_uut.OnStreamStarts(TestFactory.SomeDeveloper());
_uut.OnEvent(commandEvent1);
_uut.OnEvent(commandEvent2);
_uut.OnEvent(commandEvent3);
_uut.OnEvent(commandEvent4);
var expectedPair = SortedCommandPair.NewSortedPair(commandEvent1.CommandId, commandEvent2.CommandId);
CollectionAssert.AreEquivalent(
new Dictionary <SortedCommandPair, int>
{
{ expectedPair, 2 }
},
_uut.UnknownTriggerMappings);
CollectionAssert.IsEmpty(_uut.Statistic);
}
public static List <IDEEvent> GenerateEvents(long eventTimeDifferenceInTicks)
{
var eventList = TestEventFactory.SomeEvents(Random.Next(2, 10));
var lastEventTime = DateTimeFactory.SomeWorkingHoursDateTime();
eventList.ForEach(
ideEvent =>
{
lastEventTime = new DateTime(lastEventTime.Ticks + eventTimeDifferenceInTicks);
ideEvent.TriggeredAt = lastEventTime;
});
var lateEvent = TestEventFactory.SomeEvent();
lateEvent.TriggeredAt = new DateTime(lastEventTime.Ticks + eventTimeDifferenceInTicks + 1);
eventList.Add(lateEvent);
return(eventList);
}
public void ShouldNotFilterAnyOtherCommandEvents()
{
var firstEventTime = DateTimeFactory.SomeWorkingHoursDateTime();
var commandEvent1 = new CommandEvent
{
CommandId = "Test",
TriggeredAt =
firstEventTime + ConcurrentEventHeuristic.EventTimeDifference
};
var commandEvent2 = new CommandEvent
{
CommandId = "Test",
TriggeredAt = firstEventTime + ConcurrentEventHeuristic.EventTimeDifference.Add(
new TimeSpan(TimeSpan.TicksPerSecond))
};
Assert.AreEqual(Sets.NewHashSet <IDEEvent>(commandEvent1), _uut.Map(commandEvent1));
Assert.AreEqual(Sets.NewHashSet <IDEEvent>(commandEvent2), _uut.Map(commandEvent2));
}
public void ShouldNotUseMoreThanMaximumEventsBeforeBreakForStatistic()
{
_uut.MaxEventsBeforeBreak = 1;
var triggeredAt = DateTimeFactory.SomeWorkingHoursDateTime();
var firstEvent = new TestIDEEvent
{
TriggeredAt = triggeredAt
};
var secondEvent = new CommandEvent
{
TriggeredAt = triggeredAt
};
var lateEvent = new TestIDEEvent
{
TriggeredAt = triggeredAt + _uut.MinBreakTime
};
var listOfEvents = new List<IDEEvent>
{
firstEvent,
secondEvent,
lateEvent
};
_uut.OnStreamStarts(new Developer());
listOfEvents.ForEach(@event => _uut.OnEvent(@event));
_uut.OnStreamEnds();
var expectedStatistic = new Dictionary<string, Tuple<TimeSpan, int>>
{
{
EventMappingUtils.GetAbstractStringOf(new CommandEvent()),
new Tuple<TimeSpan, int>(_uut.MinBreakTime, 1)
}
};
CollectionAssert.AreEquivalent(expectedStatistic, _uut.Statistic);
}
public void ShouldNotMapEventsOnThemselves()
{
var eventTime = DateTimeFactory.SomeWorkingHoursDateTime();
const string sameId = "Test";
var commandEvent1 = new CommandEvent
{
CommandId = sameId,
TriggeredAt = eventTime
};
var commandEvent2 = new CommandEvent
{
CommandId = sameId,
TriggeredAt = eventTime + ConcurrentEventHeuristic.EventTimeDifference
};
_uut.OnStreamStarts(TestFactory.SomeDeveloper());
_uut.OnEvent(commandEvent1);
_uut.OnEvent(commandEvent2);
CollectionAssert.IsEmpty(_uut.Statistic);
}
public void ShouldIgnoreWindowMoveEvents()
{
_uut.AddEventAfterBreakToStatistic = true;
var triggeredAt = DateTimeFactory.SomeWorkingHoursDateTime();
var someEvent = new WindowEvent
{
TriggeredAt = triggeredAt,
Action = WindowAction.Move
};
var eventAfterBreak = new CommandEvent
{
TriggeredAt = triggeredAt + _uut.MinBreakTime
};
_uut.OnStreamStarts(new Developer());
_uut.OnEvent(someEvent);
_uut.OnEvent(eventAfterBreak);
_uut.OnStreamEnds();
CollectionAssert.IsEmpty(_uut.Statistic);
}
public void ShouldNotAddMappingForIgnorableTextControlCommands()
{
var eventTime = DateTimeFactory.SomeWorkingHoursDateTime();
var ignorableCommand1 = ConcurrentEventHeuristic.IgnorableTextControlCommands[0];
var ignorableCommand2 = ConcurrentEventHeuristic.IgnorableTextControlCommands[1];
var commandEvent1 = new CommandEvent
{
CommandId = ignorableCommand1,
TriggeredAt = eventTime
};
var commandEvent2 = new CommandEvent
{
CommandId = ignorableCommand2,
TriggeredAt = eventTime + ConcurrentEventHeuristic.EventTimeDifference
};
_uut.OnStreamStarts(TestFactory.SomeDeveloper());
_uut.OnEvent(commandEvent1);
_uut.OnEvent(commandEvent2);
CollectionAssert.IsEmpty(_uut.Statistic);
}
public void ShouldNotAddMappingForNonConcurrentCommandEvents()
{
var eventTime = DateTimeFactory.SomeWorkingHoursDateTime();
var commandEvent1 = new CommandEvent
{
CommandId = "Copy",
TriggeredBy = EventTrigger.Click,
TriggeredAt = eventTime
};
var commandEvent2 = new CommandEvent
{
CommandId = "Edit.Copy",
TriggeredAt =
eventTime + ConcurrentEventHeuristic.EventTimeDifference +
TimeSpan.FromTicks(TimeSpan.TicksPerSecond)
};
_uut.OnStreamStarts(TestFactory.SomeDeveloper());
_uut.OnEvent(commandEvent1);
_uut.OnEvent(commandEvent2);
CollectionAssert.IsEmpty(_uut.Statistic);
}
public void ShouldNotDropEventsWithoutPrecedingLongBreak()
{
var someEvent = TestEventFactory.SomeEvent(DateTimeFactory.SomeWorkingHoursDateTime());
Assert.AreEqual(Sets.NewHashSet <IDEEvent>(someEvent), _uut.Map(someEvent));
}
