public void TestSearch1()
{
var settings = new DataSource(TextLogFileAcceptanceTest.File2Mb)
{
Id = DataSourceId.CreateNew()
};
using (var logFile = new TextLogFile(_taskScheduler, TextLogFileAcceptanceTest.File2Mb))
using (var dataSource = new SingleDataSource(_taskScheduler, settings, logFile, TimeSpan.Zero))
{
var model = new SingleDataSourceViewModel(dataSource, new Mock <IActionCenter>().Object);
logFile.Property(x => x.EndOfSourceReached).ShouldEventually().BeTrue();
model.Property(x =>
{
x.Update();
return(x.TotalCount);
}).ShouldEventually().Be(16114);
//model.Update();
//model.TotalCount.Should().Be(16114);
model.SearchTerm = "RPC #12";
var search = dataSource.Search;
search.Property(x => x.Count).ShouldEventually().Be(334);
model.Update();
model.SearchResultCount.Should().Be(334);
model.CurrentSearchResultIndex.Should().Be(0);
}
}
public void TestSetDataSourcesOneLessSource()
{
var logFile1 = new InMemoryLogFile();
var source1 = new SingleDataSource(_taskScheduler,
new DataSource {
Id = DataSourceId.CreateNew()
},
logFile1,
TimeSpan.Zero);
var logFile2 = new InMemoryLogFile();
var source2 = new SingleDataSource(_taskScheduler,
new DataSource {
Id = DataSourceId.CreateNew()
},
logFile2,
TimeSpan.Zero);
_merged.SetDataSources(new [] { source1, source2 });
_merged.OriginalSources.Should().BeEquivalentTo(new object[] { source1, source2 });
source1.ParentId.Should().Be(_merged.Id);
source2.ParentId.Should().Be(_merged.Id);
_merged.SetDataSources(new [] { source2 });
_merged.OriginalSources.Should().BeEquivalentTo(new object[] { source2 });
source1.ParentId.Should().Be(DataSourceId.Empty);
source2.ParentId.Should().Be(_merged.Id);
}
public void TestActivate1()
{
_quickFilters.Add();
var model = new QuickFiltersSidePanelViewModel(_settings, _quickFilters);
model.QuickInfo.Should().BeNull();
var dataSource = new SingleDataSource(_logFileFactory, _scheduler,
new DataSource("daw")
{
Id = DataSourceId.CreateNew()
});
model.CurrentDataSource = new SingleDataSourceViewModel(dataSource, _actionCenter.Object);
model.QuickFilters.ElementAt(0).IsActive = true;
model.QuickInfo.Should().Be("1 active");
model.AddQuickFilter();
model.QuickFilters.ElementAt(1).IsActive = true;
model.QuickInfo.Should().Be("2 active");
model.QuickFilters.ElementAt(0).IsActive = false;
model.QuickFilters.ElementAt(1).IsActive = false;
model.QuickInfo.Should().BeNull();
}
public void TestRemove2()
{
var filter1 = _quickFilters.Add();
var dataSource = new SingleDataSource(_logFileFactory, _scheduler,
new DataSource("daw")
{
Id = DataSourceId.CreateNew()
});
dataSource.ActivateQuickFilter(filter1.Id);
var model = new QuickFiltersSidePanelViewModel(_settings, _quickFilters)
{
CurrentDataSource = new SingleDataSourceViewModel(dataSource, _actionCenter.Object)
};
var filter1Model = model.QuickFilters.First();
filter1Model.IsActive = false;
var changed = 0;
model.OnFiltersChanged += () => ++ changed;
filter1Model.RemoveCommand.Execute(null);
model.QuickFilters.Should().BeEmpty("because we've just removed the only quick filter");
changed.Should().Be(0, "because removing an inactive quick-filter should never fire the OnFiltersChanged event");
}
public void TestDispose1()
{
LogFileProxy permanentLogFile;
LogFileSearchProxy permanentSearch;
LogFileProxy permanentFindAllLogFile;
LogFileSearchProxy permanentFindAllSearch;
SingleDataSource source;
using (source = new SingleDataSource(_logFileFactory, _scheduler, new DataSource(@"E:\somelogfile.txt")
{
Id = DataSourceId.CreateNew()
}))
{
permanentLogFile = (LogFileProxy)source.FilteredLogFile;
permanentLogFile.IsDisposed.Should().BeFalse();
permanentSearch = (LogFileSearchProxy)source.Search;
permanentSearch.IsDisposed.Should().BeFalse();
permanentFindAllLogFile = (LogFileProxy)source.FindAllLogFile;
permanentFindAllLogFile.IsDisposed.Should().BeFalse();
permanentFindAllSearch = (LogFileSearchProxy)source.FindAllSearch;
permanentFindAllSearch.IsDisposed.Should().BeFalse();
}
source.IsDisposed.Should().BeTrue();
permanentLogFile.IsDisposed.Should().BeTrue();
permanentSearch.IsDisposed.Should().BeTrue();
permanentFindAllLogFile.IsDisposed.Should().BeTrue();
permanentFindAllSearch.IsDisposed.Should().BeTrue();
}
public void TestAddChild1()
{
var model = new MergedDataSourceViewModel(_dataSources.AddGroup(), _actionCenter.Object);
SingleDataSource source = _dataSources.AddDataSource("foo");
var sourceViewModel = new SingleDataSourceViewModel(source, _actionCenter.Object);
model.AddChild(sourceViewModel);
model.Observable.Should().Equal(sourceViewModel);
sourceViewModel.Parent.Should().BeSameAs(model);
}
public void SetUp()
{
_scheduler = new DefaultTaskScheduler();
_logFileFactory = new PluginLogFileFactory(_scheduler);
_settings = new DataSource(TextLogFileAcceptanceTest.File20Mb)
{
Id = DataSourceId.CreateNew()
};
_dataSource = new SingleDataSource(_logFileFactory, _scheduler, _settings, TimeSpan.FromMilliseconds(100));
}
public void TestInsertChild1()
{
var dataSource = _dataSources.AddGroup();
var model = new MergedDataSourceViewModel(dataSource, _actionCenter.Object);
SingleDataSource source = _dataSources.AddDataSource("foo");
var sourceViewModel = new SingleDataSourceViewModel(source, _actionCenter.Object);
model.Insert(0, sourceViewModel);
sourceViewModel.CharacterCode.Should().Be("A", "because the merged data source is responsible for providing unique character codes");
}
public void TestRemove1()
{
var settings = new DataSource("foo")
{
Id = DataSourceId.CreateNew()
};
var dataSource = new SingleDataSource(_logFileFactory, _taskScheduler, settings);
_merged.Add(dataSource);
_merged.Remove(dataSource);
dataSource.Settings.ParentId.Should().Be(DataSourceId.Empty);
}
public void TestAddFile()
{
SingleDataSource source = _dataSources.AddFile(@"E:\Code\test.log");
source.Should().NotBeNull();
source.FullFileName.Should().Be(@"E:\Code\test.log");
source.FollowTail.Should().BeFalse();
source.Id.Should().NotBe(Guid.Empty, "Because a newly added data source should have a unique id");
_settings.Count.Should().Be(1);
_settings[0].File.Should().Be(@"E:\Code\test.log");
}
public void TestRemove()
{
SingleDataSource source1 = _dataSources.AddFile(@"E:\Code\test1.log");
SingleDataSource source2 = _dataSources.AddFile(@"E:\Code\test2.log");
_dataSources.Remove(source1);
_settings.Count.Should().Be(1);
_settings[0].File.Should().Be(@"E:\Code\test2.log");
_dataSources.Remove(source2);
_settings.Should().BeEmpty();
}
public void TestAdd1()
{
var settings = new DataSource("foo")
{
Id = DataSourceId.CreateNew()
};
var dataSource = new SingleDataSource(_logFileFactory, _taskScheduler, settings);
_merged.Add(dataSource);
settings.ParentId.Should()
.Be(_settings.Id, "Because the parent-child relationship should've been declared via ParentId");
}
public void TestDispose2()
{
SingleDataSource source = new SingleDataSource(_logFileFactory, _scheduler,
new DataSource(@"E:\somelogfile.txt")
{
Id = DataSourceId.CreateNew()
});
_scheduler.PeriodicTaskCount.Should().BeGreaterThan(0);
source.Dispose();
_scheduler.PeriodicTaskCount.Should().Be(0, "because all tasks should've been removed");
}
public void TestWrite2([Values(true, false)] bool isSingleLine)
{
_settings.IsSingleLine = isSingleLine;
using (var dataSource = new SingleDataSource(_scheduler, _settings, _logFile, TimeSpan.Zero))
{
_writer.Write("Hello World\r\n");
_writer.Flush();
_scheduler.Run(2);
dataSource.FilteredLogFile.Count.Should().Be(1);
dataSource.FilteredLogFile.GetLine(0).Should().Be(new LogLine(0, 0, "Hello World", LevelFlags.Other));
}
}
public void TestConstruction4([Values(true, false)] bool showElapsedTime)
{
using (var source = new SingleDataSource(_scheduler, new DataSource
{
Id = DataSourceId.CreateNew(),
File = @"C:\temp\foo.txt",
ShowElapsedTime = showElapsedTime
}, new Mock <ILogFile>().Object, TimeSpan.Zero))
{
var model = new SingleDataSourceViewModel(source, _actionCenter.Object);
model.ShowElapsedTime.Should().Be(showElapsedTime);
}
}
public void TestConstruction4([Values(true, false)] bool showElapsedTime)
{
var settings = new DataSource(@"E:\somelogfile.txt")
{
Id = DataSourceId.CreateNew(),
ShowElapsedTime = showElapsedTime
};
using (var source = new SingleDataSource(_logFileFactory, _scheduler, settings))
{
source.ShowElapsedTime.Should().Be(showElapsedTime);
}
}
public void TestAdd2()
{
var settings = new DataSource("foo")
{
Id = DataSourceId.CreateNew()
};
var dataSource = new SingleDataSource(_logFileFactory, _taskScheduler, settings);
_merged.Add(dataSource);
_merged.UnfilteredLogFile.Should().NotBeNull();
_merged.UnfilteredLogFile.Should().BeOfType <MergedLogFile>();
((MergedLogFile)_merged.UnfilteredLogFile).Sources.Should().Equal(new object[] { dataSource.OriginalLogFile });
}
public void TestConstruction1()
{
using (var source = new SingleDataSource(_logFileFactory, _scheduler, new DataSource(@"E:\somelogfile.txt")
{
Id = DataSourceId.CreateNew()
}))
{
source.FullFileName.Should().Be(@"E:\somelogfile.txt");
source.LevelFilter.Should().Be(LevelFlags.All);
source.SearchTerm.Should().BeNull();
source.FollowTail.Should().BeFalse();
}
}
public void SetUp()
{
_quickFilter = new QuickFilter(new Core.Settings.QuickFilter());
_dataSource = new SingleDataSource(_logFileFactory, _scheduler, _dataSourceSettings = new DataSource("nothing")
{
Id = DataSourceId.CreateNew()
});
_model = new QuickFilterViewModel(_quickFilter, x => { })
{
CurrentDataSource = _dataSource
};
_changes = new List <string>();
_model.PropertyChanged += (sender, args) => _changes.Add(args.PropertyName);
}
public void TestAdd()
{
var model = new QuickFiltersSidePanelViewModel(_settings, _quickFilters);
var dataSource = new SingleDataSource(_logFileFactory, _scheduler,
new DataSource("sw")
{
Id = DataSourceId.CreateNew()
});
model.CurrentDataSource = new SingleDataSourceViewModel(dataSource, _actionCenter.Object);
var filter = model.AddQuickFilter();
filter.CurrentDataSource.Should().BeSameAs(dataSource);
}
public void TestIsSingleLine()
{
var settings = CreateDataSource();
using (var dataSource = new SingleDataSource(_scheduler, settings, _logFile.Object, TimeSpan.Zero))
{
dataSource.IsSingleLine.Should().BeFalse();
dataSource.IsSingleLine = true;
settings.IsSingleLine.Should().BeTrue("because the data source should modify the settings object when changed");
dataSource.IsSingleLine = false;
settings.IsSingleLine.Should().BeFalse("because the data source should modify the settings object when changed");
}
}
public void TestSearch1()
{
using (var dataSource = new SingleDataSource(_scheduler, CreateDataSource(), _logFile.Object, TimeSpan.Zero))
{
_entries.Add(new LogLine(0, 0, "Hello foobar world!", LevelFlags.None));
_listeners.OnRead(1);
_scheduler.RunOnce();
dataSource.SearchTerm = "foobar";
_scheduler.Run(10);
dataSource.Search.Count.Should().Be(1);
var matches = dataSource.Search.Matches.ToList();
matches.Should().Equal(new LogMatch(0, new LogLineMatch(6, 6)));
}
}
public void TestMultiline()
{
var settings = new DataSource("foo")
{
Id = DataSourceId.CreateNew()
};
var dataSource = new SingleDataSource(_logFileFactory, _taskScheduler, settings);
ILogFile logFile1 = _merged.UnfilteredLogFile;
_merged.Add(dataSource);
ILogFile logFile2 = _merged.UnfilteredLogFile;
logFile2.Should().NotBeSameAs(logFile1);
((AbstractLogFile)logFile1).IsDisposed.Should().BeTrue();
}
public void TestConstruction2()
{
using (
var source = new SingleDataSource(_scheduler,
new DataSource {
Id = DataSourceId.CreateNew(), File = @"C:\temp\foo.txt", SearchTerm = "foobar"
},
new Mock <ILogFile>().Object, TimeSpan.Zero))
{
source.SearchTerm.Should().Be("foobar");
var model = new SingleDataSourceViewModel(source, _actionCenter.Object);
model.SearchTerm.Should().Be("foobar");
}
}
public void TestDispose2()
{
var settings = new DataSource("foo")
{
Id = DataSourceId.CreateNew()
};
var dataSource = new SingleDataSource(_logFileFactory, _taskScheduler, settings);
_merged.Add(dataSource);
_merged.Remove(dataSource);
dataSource.Dispose();
_merged.Dispose();
_taskScheduler.PeriodicTaskCount.Should().Be(0, "because all tasks should've been removed");
}
public void TestConstruction2()
{
var settings = new DataSource(@"E:\somelogfile.txt")
{
Id = DataSourceId.CreateNew(),
SelectedLogLines = new HashSet <LogLineIndex> {
1, 2
}
};
using (var source = new SingleDataSource(_logFileFactory, _scheduler, settings))
{
source.SelectedLogLines.Should().BeEquivalentTo(new LogLineIndex[] { 1, 2 });
}
}
public void TestLevelPrecedence()
{
var settings = new DataSource(@"TestData\DifferentLevels.txt")
{
Id = DataSourceId.CreateNew()
};
using (var dataSource = new SingleDataSource(_logFileFactory, _scheduler, settings))
{
dataSource.FilteredLogFile.Property(x =>
{
_scheduler.RunOnce();
return(x.Count >= 6);
}).ShouldEventually().BeTrue();
dataSource.FilteredLogFile.Count.Should().Be(6, "because the file consists of 6 lines");
LogLine[] lines = dataSource.FilteredLogFile.GetSection(new LogFileSection(0, 6));
lines[0].Message.Should().Be("DEBUG ERROR WARN FATAL INFO");
lines[0].Level.Should().Be(LevelFlags.Debug, "Because DEBUG is the first level to appear in the line");
lines[1].Message.Should().Be("INFO DEBUG ERROR WARN FATAL");
lines[1].Level.Should().Be(LevelFlags.Info, "Because INFO is the first level to appear in the line");
lines[2].Message.Should().Be("WARN ERROR FATAL INFO DEBUG");
lines[2].Level.Should().Be(LevelFlags.Warning, "Because WARN is the first level to appear in the line");
lines[3].Message.Should().Be("ERROR INFO DEBUG FATAL WARN");
lines[3].Level.Should().Be(LevelFlags.Error, "Because ERROR is the first level to appear in the line");
lines[4].Message.Should().Be("FATAL ERROR INFO WARN DEBUG");
lines[4].Level.Should().Be(LevelFlags.Fatal, "Because FATAL is the first level to appear in the line");
lines[5].Message.Should().Be("fatal error info warn debug");
lines[5].Level.Should()
.Be(LevelFlags.Fatal,
"Because this line belongs to the previous log entry and thus is marked as fatal as well");
lines[5].LogEntryIndex.Should().Be(lines[4].LogEntryIndex);
_scheduler.RunOnce();
dataSource.DebugCount.Should().Be(1);
dataSource.InfoCount.Should().Be(1);
dataSource.WarningCount.Should().Be(1);
dataSource.ErrorCount.Should().Be(1);
dataSource.FatalCount.Should().Be(1);
dataSource.NoLevelCount.Should().Be(0);
}
}
public void TestSetQuickFilterChain1()
{
var settings = new DataSource(@"E:\Code\SharpTail\SharpTail.Test\TestData\20Mb.test")
{
Id = DataSourceId.CreateNew()
};
using (var dataSource = new SingleDataSource(_logFileFactory, _scheduler, settings))
{
var model = new SingleDataSourceViewModel(dataSource, _actionCenter.Object);
var chain = new[] { new SubstringFilter("foobar", true) };
model.QuickFilterChain = chain;
model.QuickFilterChain.Should().BeSameAs(chain);
dataSource.QuickFilterChain.Should().BeSameAs(chain);
}
}
public void TestRemoveCommand1()
{
using (
var source =
new SingleDataSource(_logFileFactory, _scheduler,
new DataSource(@"E:\Code\SharpTail\SharpTail.Test\TestData\20Mb.test")
{
Id = DataSourceId.CreateNew()
}))
{
var model = new SingleDataSourceViewModel(source, _actionCenter.Object);
model.RemoveCommand.Should().NotBeNull();
model.RemoveCommand.CanExecute(null).Should().BeTrue();
new Action(() => model.RemoveCommand.Execute(null)).ShouldNotThrow();
}
}
public void TestChangeShowDeltaTimes([Values(true, false)] bool showDeltaTimes)
{
var settings = new DataSource(@"E:\somelogfile.txt")
{
Id = DataSourceId.CreateNew()
};
using (var source = new SingleDataSource(_logFileFactory, _scheduler, settings))
{
source.ShowDeltaTimes = showDeltaTimes;
settings.ShowDeltaTimes.Should().Be(showDeltaTimes);
source.ShowDeltaTimes = !showDeltaTimes;
settings.ShowDeltaTimes.Should().Be(!showDeltaTimes);
}
}
