private void AssertAppendToCurrentLog(params IDEEvent[] events)
{
_logHandler(TestEventFactory.SomeEvent()); // send another event to flush buffer
WaitForLogAppend();
CollectionAssert.AreEqual(events, _loggedEvents);
}
private static TestIDEEvent CreateSomeEventAfter(IDEEvent startupEvent)
{
var subsequentEvent = TestEventFactory.SomeEvent();
SetTriggeredAtToAfter(subsequentEvent, startupEvent);
return(subsequentEvent);
}
public void LogReplicatorCallsAppendEntriesPassingEncodedLog()
{
// Arrange
var encodedLog = BitConverter.GetBytes(100);
AppendEntriesRequest request = null;
var service = Substitute.For <IRaftService>();
service.When(x => x.AppendEntries(Arg.Any <AppendEntriesRequest>()))
.Do(x => request = x.Arg <AppendEntriesRequest>());
var peers = new List <PeerNode> {
new PeerNode()
};
var handler = new LogReplicator(peers);
var @event = TestEventFactory.GetCommandEvent(1L, encodedLog);
// Act
handler.Handle(@event);
// Assert
request.Should().NotBeNull();
request.Entries.Should().HaveCount(1);
request.Entries[0].Should().Equal(encodedLog);
}
public void ExportsErrorEventIfAnonymizerFails()
{
var original = TestEventFactory.SomeEvent();
_logManager.Add(SomeDate, original);
Mock.Get(_anonymizer).Setup(a => a.Anonymize(It.IsAny <IDEEvent>())).Returns <IDEEvent>(
e =>
{
if (!(e is ErrorEvent))
{
throw new NullReferenceException();
}
return(e);
});
WhenEverythingIsExported();
var ee = new ErrorEvent
{
Content = "An error occured during anonymization of KaVE.Commons.TestUtils.Model.Events.TestIDEEvent.",
StackTrace = new string[0],
TriggeredAt = original.TriggeredAt,
TerminatedAt = original.TerminatedAt,
Duration = original.Duration,
IDESessionUUID = original.IDESessionUUID,
ActiveDocument = original.ActiveDocument,
ActiveWindow = original.ActiveWindow,
Id = original.Id,
KaVEVersion = original.KaVEVersion,
TriggeredBy = original.TriggeredBy
};
AssertPublishedEvents(ee);
}
public void LogEncoderDoesAddLogEntryToLogRegisterWithIndexTermAndCommandTypeSet()
{
// Arrange
var @event = TestEventFactory.GetCommandEvent();
var expectedLogEntry = new LogEntry
{
Term = 3L,
Index = 7L,
CommandType = @event.Command.GetType().AssemblyQualifiedName,
Command = @event.Command
};
var nodeData = new NodeData
{
CurrentTerm = expectedLogEntry.Term,
CommitIndex = expectedLogEntry.Index - 1
};
var raftNode = Substitute.For <INode>();
raftNode.Data.Returns(nodeData);
var handler = new LogEncoder(raftNode);
// Act
handler.OnNext(@event, 1, false);
// Assert
@event.LogEntry.Should().NotBeNull();
@event.LogEntry.Term.Should().Be(expectedLogEntry.Term);
@event.LogEntry.Index.Should().Be(expectedLogEntry.Index);
@event.LogEntry.CommandType.Should().Be(expectedLogEntry.CommandType);
@event.LogEntry.Command.Should().Be(expectedLogEntry.Command);
}
public void CountsEvents()
{
_uut.AddEvent(TestEventFactory.SomeEvent());
_uut.AddEvent(TestEventFactory.SomeEvent());
_uut.AddEvent(TestEventFactory.SomeEvent());
Assert.AreEqual(3, _uut.NumberOfEvents);
}
public void ExportsMoreThan65535Events()
{
var manyEvents = TestEventFactory.SomeEvents(65536);
_logManager.Add(SomeDate, manyEvents);
WhenEverythingIsExported();
}
public void LogsEvent()
{
var someEvent = TestEventFactory.SomeEvent();
WhenLoggerReceives(someEvent);
AssertAppendToCurrentLog(someEvent);
}
public void DoesntFormatSelectionsForOtherEvents()
{
var someEvent = TestEventFactory.SomeEvent();
var view = new EventViewModel(someEvent);
Assert.IsNull(view.XamlSelectionsRepresentation);
}
public void GetTriggeredAtThrowsIfNotSet()
{
var ideEvent = TestEventFactory.SomeEvent();
ideEvent.TriggeredAt = null;
ideEvent.GetTriggeredAt();
}
public void DoesntDisplayContextForOtherEvents()
{
var someEvent = TestEventFactory.SomeEvent();
var view = new EventViewModel(someEvent);
Assert.IsNull(view.XamlContextRepresentation);
}
public void GetsTriggeredAtIfSet()
{
var someDateTime = new DateTimeOffset();
var ideEvent = TestEventFactory.SomeEvent();
ideEvent.TriggeredAt = someDateTime;
Assert.AreEqual(someDateTime, ideEvent.GetTriggeredAt());
}
public void CountsBreakIfTwoSubsequentEventsAreFarApart()
{
var someTriggeredAt = new DateTime(2015, 05, 12, 13, 14, 15);
_uut.AddEvent(TestEventFactory.SomeEvent(someTriggeredAt));
_uut.AddEvent(TestEventFactory.SomeEvent(someTriggeredAt + BreakThreshold.Times(2)));
Assert.AreEqual(1, _uut.NumberOfBreaks);
}
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));
}
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 override void ProcessAnyEvent(IDEEvent @event)
{
base.ProcessAnyEvent(@event);
var newEvent = TestEventFactory.SomeEvent();
newEvent.IDESessionUUID = @event.IDESessionUUID;
ReplaceCurrentEventWith(newEvent);
}
public override void ProcessAnyEvent(IDEEvent @event)
{
base.ProcessAnyEvent(@event);
var newEvent = TestEventFactory.SomeEvent();
newEvent.IDESessionUUID = @event.IDESessionUUID;
Insert(newEvent);
}
public void ShouldReadEventsFromLog()
{
var expected = TestEventFactory.SomeEvents(3);
GivenLogContainsEvents(expected);
var actuals = WhenEventViewModelsAreLoaded().Select(evm => evm.Event);
CollectionAssert.AreEqual(expected, actuals);
}
public void PublishesProfileEvent()
{
var logEntries = TestEventFactory.SomeEvents(25);
_logManager.Add(SomeDate, logEntries);
var numberOfEvents = WhenEverythingIsExported();
AssertPublishedEvents(logEntries);
Assert.AreEqual(25, numberOfEvents);
}
public void ExportsAnonymizedEvents()
{
_logManager.Add(SomeDate, TestEventFactory.SomeEvents(3));
IDEEvent anonymousEvent = TestEventFactory.SomeEvent();
Mock.Get(_anonymizer).Setup(a => a.Anonymize(It.IsAny <IDEEvent>())).Returns(anonymousEvent);
WhenEverythingIsExported();
AssertPublishedEvents(anonymousEvent, anonymousEvent, anonymousEvent);
}
public void CountsNoBreaksIfOnlySmallGapsBetweenEvents()
{
var someTriggeredAt = new DateTime(2015, 05, 12, 13, 14, 15);
_uut.AddEvent(TestEventFactory.SomeEvent(someTriggeredAt));
_uut.AddEvent(TestEventFactory.SomeEvent(someTriggeredAt.AddMinutes(1)));
_uut.AddEvent(TestEventFactory.SomeEvent(someTriggeredAt.AddMinutes(5)));
_uut.AddEvent(TestEventFactory.SomeEvent(someTriggeredAt.AddMinutes(7)));
_uut.AddEvent(TestEventFactory.SomeEvent(someTriggeredAt.AddMinutes(10)));
Assert.AreEqual(0, _uut.NumberOfBreaks);
}
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);
}
// RS9 TODO: this tests regularly fails during the build... what's going on here?
public void ShouldFlushOnShutdown()
{
var anEvent = TestEventFactory.SomeEvent();
var shutdownEvent = new IDEStateEvent {
IDELifecyclePhase = IDELifecyclePhase.Shutdown
};
WhenLoggerReceives(anEvent);
_uut.Shutdown(shutdownEvent);
CollectionAssert.AreEqual(new IDEEvent[] { anEvent, shutdownEvent }, _loggedEvents);
}
public void ReturnsFalseIfStreamContainsOnlyUserProfileEvent()
{
var events = new List <IDEEvent>
{
TestEventFactory.Some <UserProfileEvent>()
};
var stream = new MemoryStream();
var actual = _uut.WriteEventsToZipStream(events, stream, () => { });
Assert.IsFalse(actual);
}
public void InsertsStartupIfFirstEventIsSomethingElse()
{
var someEvent = TestEventFactory.SomeEvent();
someEvent.TriggeredAt = new DateTime(2015, 1, 23, 14, 7, 12);
var missingStartupEvent = CreateStartupEvent();
missingStartupEvent.TriggeredAt = someEvent.GetTriggeredAt().AddMilliseconds(-1);
AssertTransformation(Stream(someEvent), Stream(missingStartupEvent, someEvent));
}
public void ShouldAddNewEventsIfLogEntryIsAppended()
{
var expected = TestEventFactory.SomeEvents(3);
GivenLogContainsEvents(expected.Take(2).ToList());
WhenEventViewModelsAreLoaded();
_mockLog.Raise(l => l.EntryAppended += null, expected[2]);
var actual = _uut.Events.Select(evt => evt.Event);
Assert.AreEqual(expected, actual);
}
public void CountsMultipleBreaks()
{
var someTriggeredAt = new DateTime(2015, 05, 12, 13, 14, 15);
_uut.AddEvent(TestEventFactory.SomeEvent(someTriggeredAt));
_uut.AddEvent(TestEventFactory.SomeEvent(someTriggeredAt + BreakThreshold.Times(2)));
_uut.AddEvent(
TestEventFactory.SomeEvent(someTriggeredAt + BreakThreshold.Times(2) + TimeSpan.FromMinutes(1)));
_uut.AddEvent(
TestEventFactory.SomeEvent(someTriggeredAt + BreakThreshold.Times(4) + TimeSpan.FromMinutes(5)));
Assert.AreEqual(2, _uut.NumberOfBreaks);
}
public void PublishesOnlyOlderEvents()
{
var dateTime = DateTime.Now;
var newerEvent = TestEventFactory.SomeEvent(dateTime);
var olderEvent = TestEventFactory.SomeEvent(dateTime.AddMinutes(-2));
_logManager.Add(SomeDate, newerEvent, olderEvent);
var numberOfEvents = _sut.Export(dateTime.AddMinutes(-1), _publisher);
Assert.AreSame(_userProfileEvent, _publishedUpe);
AssertPublishedEvents(olderEvent);
Assert.AreEqual(1, numberOfEvents);
}
public void ShouldNotInvokeEventSelectionEventIfNoEventsWereSelectedPreviously()
{
var sessions = new[] { Fix.SomeLog(TestEventFactory.SomeEvents(4)) };
WhenViewModelIsRefreshedWithSessions(sessions);
_uut.SelectedSessions = new[] { _uut.Sessions.First() };
var eventInvoked = false;
_uut.SingleSelectedSession.OnPropertyChanged(m => m.SelectedEvents, selection => eventInvoked = true);
WhenViewModelIsRefreshedWithSessions(sessions);
Assert.IsFalse(eventInvoked);
}
public void PublishesEvents()
{
var log1Entries = TestEventFactory.SomeEvents(25);
_logManager.Add(SomeDate, log1Entries);
var log2Entries = TestEventFactory.SomeEvents(5);
_logManager.Add(SomeDate.AddDays(-1), log2Entries);
var numberOfEvents = WhenEverythingIsExported();
AssertPublishedEvents(log1Entries.Union(log2Entries));
Assert.AreEqual(30, numberOfEvents);
}
