public void Get_ValidLocations_ReturnAsGeoHashPath()
{
var trackingRepository = new Mock <ITrackingRepository>();
trackingRepository.Setup(tp => tp.Get())
.Returns(
new List <Tracking>
{
new Tracking {
Location = new Location(53.125, 18.011111)
},
new Tracking {
Location = new Location(53.125, 18.011111)
},
new Tracking {
Location = new Location(53.125, 18.011111)
}
});
ITrackingService trackingService = new TrackingService(null, trackingRepository.Object);
var result = trackingService.GetPathAsGeoHash();
Assert.That(result, Is.EqualTo("u3ky1z5793cb,u3ky1z5793cb,u3ky1z5793cb"));
}
private void ConnectOrReconnect()
{
try
{
// Close active connections (if restarting)
apiClient.DisconnectHeadTrackingProxy();
apiClient.DisconnectControllerProxy();
apiClient.DisconnectBroadcastProxy();
controllerService?.Dispose();
// Give it some time to clean up
Thread.Sleep(10);
// Connect to the services
headTrackingService = new TrackingService(apiClient.ConnectHeadTrackingProxy());
controllerService = new ControllerService(apiClient.ConnectToControllerProxy());
broadcastProxy = apiClient.ConnectToBroadcaster();
broadcastProxy.HapticPulseReceived += OnHapticFeedbackReceived;
headTrackingService.ChangeStatus(IsControllingHeadTracking);
}
catch (Exception x)
{
MessageBox.Show(x.ToString(), "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public void Setup()
{
_customerDetailsRepository = new Mock <ICustomerDetailsRepository>();
_ordersRepository = new Mock <IOrdersRepository>();
_objectUnderTest = new TrackingService(_customerDetailsRepository.Object, _ordersRepository.Object, Mock.Of <ILogger <TrackingService> >());
}
public void CollectStats()
{
var dataMock = new DataServiceMock();
var timeMock = new MockedTimeSource();
var authService = new VitaAuthService(dataMock);
var trackService = new TrackingService(timeMock);
ITrackingReport report = null;
trackService.Reports.Subscribe(x => report = x);
ITrackingSession session = SessionTrackingScenarioOne(timeMock, trackService);
trackService.PublishReports();
Assert.IsNotNull(report);
Assert.AreEqual(report.Topics.Count(), 3);
Assert.IsTrue(report.Topics.All(x => x.ImpressionCount == 1));
Assert.AreEqual(report.Topics[0].Url, "person");
Assert.AreEqual(report.Topics[0].TopicDetail, "S");
Assert.AreEqual(report.Topics[0].ImpressionTimeSpan, TimeSpan.FromSeconds(20 + 12 + 0));
Assert.AreEqual(report.Topics[1].ImpressionTimeSpan, TimeSpan.FromSeconds(20 + 60 + 60));
Assert.AreEqual(report.Topics[2].ImpressionTimeSpan, TimeSpan.FromSeconds(2 + 18 + 42));
}
public void UpdateCoach_GetLatestLogs_IsEventSaved()
{
//mocking repos
var fakeCoachRep = new FakeCoachRepository();
var newCoach = fakeCoachRep.InsertCoach(new Coach());
var fakeLogRep = new FakeTrackingLogEventRepository();
//systems under test ( tracking side)
var trackingService = new TrackingService(fakeLogRep);
var trackingController = new TrackingController(trackingService);
_fixture.InitTrackingController(trackingController);
//system under test ( main app side)
var trackingLogsService = new TrackingLogsService(_fixture.Configuration, _fixture.FakeHttpService);
var coachService = new CoachService(fakeCoachRep, trackingLogsService);
//testing and assertions
var updateCoachResponse = coachService.UpdateCoach(newCoach);
updateCoachResponse.Should().Match <ServiceResponse <Coach> >(response => response.IsSuccess);
var logListResponse = trackingLogsService.GetLatestLogs();
logListResponse.Should().Match <ServiceResponse <List <TrackingLogEvent> > >(response => response.IsSuccess);
logListResponse.ResponseDTO.Should()
.Contain(eventLog => eventLog.EventTypeId == TrackingLogEventType.CoachUpdated);
}
private TrackingService CreateTrackingService()
{
var userId = Guid.Parse(User.Identity.GetUserId());
var service = new TrackingService(userId);
return(service);
}
public void SaveEvent_IsDataMatching(int?coachId, string eventDate, TrackingLogEventType eventTypeId,
string updatePageUrl, string userIpAddress)
{
var trackingLogEventRepositoryMock = new Mock <ITrackingLogEventRepository>();
var trackingLogEvent = new TrackingLogEvent()
{
CoachId = coachId,
EventDate = DateTime.Parse(eventDate),
EventTypeId = eventTypeId,
UpdatePageUrl = updatePageUrl,
UserIPAddress = userIpAddress,
};
trackingLogEventRepositoryMock.Setup(repository => repository.InsertEvent(trackingLogEvent))
.Returns(trackingLogEvent);
var sut = new TrackingService(trackingLogEventRepositoryMock.Object);
sut.SaveEvent(trackingLogEvent).Should().Match <ServiceResponse <TrackingLogEvent> >(response =>
response.ResponseDTO.CoachId == coachId &&
response.ResponseDTO.EventDate == trackingLogEvent.EventDate &&
response.ResponseDTO.EventTypeId == eventTypeId &&
response.ResponseDTO.UpdatePageUrl == updatePageUrl &&
response.ResponseDTO.UserIPAddress == userIpAddress
);
}
internal ViewButtons(Control hostControl)
{
Verify.Argument.IsNotNull(hostControl, "hostControl");
_host = hostControl;
_buttonHover = new TrackingService <ViewButton>((e) => _host.Invalidate());
_buttonPress = new TrackingService <ViewButton>((e) => _host.Invalidate());
}
// GET: Tracking
public ActionResult FollowUp()
{
var userId = Guid.Parse(User.Identity.GetUserId());
var service = new TrackingService(userId);
var model = service.GetTrackingQuestions();
return(View(model));
}
public ClanCommandHandler(IClanRepository clanRepository,
IRankRepository rankRepository,
TrackingService trackingService)
{
_clanRepository = clanRepository;
_trackingService = trackingService;
_rankRepository = rankRepository;
}
/// <summary>Create <see cref="ViewHostTabs"/>.</summary>
internal ViewHostTabs(ViewHost viewHost, AnchorStyles side)
{
Verify.Argument.IsNotNull(viewHost, "viewHost");
_viewHost = viewHost;
_viewHost.ActiveViewChanged += OnActiveViewChanged;
SetStyle(
ControlStyles.ContainerControl |
ControlStyles.Selectable |
ControlStyles.SupportsTransparentBackColor,
false);
SetStyle(
ControlStyles.UserPaint |
ControlStyles.ResizeRedraw |
ControlStyles.AllPaintingInWmPaint |
ControlStyles.OptimizedDoubleBuffer,
true);
_side = side;
_tabs = new List <ViewHostTab>();
foreach (var view in viewHost.Views)
{
_tabs.Add(new ViewHostTab(this, view));
}
if (_tabs.Count != 0)
{
int length = 0;
foreach (var tab in _tabs)
{
tab.ResetLength(GraphicsUtility.MeasurementGraphics);
length += tab.Length;
}
_length = length;
}
_tabHover = new TrackingService <ViewHostTab>(OnTabHoverChanged);
_areaHover = new TrackingService <object>(OnAreaHoverChanged);
_areaMouseDown = -1;
if (viewHost.IsDocumentWell)
{
var tabHeight = Renderer.TabHeight;
var tabFooterHeight = Renderer.TabFooterHeight;
_leftButtons = new ViewButtons(this)
{
Height = tabHeight + tabFooterHeight,
};
_leftButtons.ButtonClick += OnViewButtonClick;
_rightButtons = new ViewButtons(this)
{
Height = tabHeight + tabFooterHeight,
};
_rightButtons.SetAvailableButtons(ViewButtonType.TabsMenu);
_rightButtons.ButtonClick += OnViewButtonClick;
}
_floatId = -1;
}
public DataModule(HttpService httpService, EmbedService embedService, TrackingService trackingService, ImageService imageService, DBContextFactory dbFactory, Config config, MathService mathService) : base(mathService)
{
HttpService = httpService;
EmbedService = embedService;
TrackingService = trackingService;
ImageService = imageService;
DBFactory = dbFactory;
Config = config;
}
public void WorkflowRuntimeServicesAreAdded()
{
_container.AddComponent("explodingtracking.service", typeof(ExplodingTrackingService));
WorkflowRuntime runtime = _container.Resolve <WorkflowRuntime>();
TrackingService instance = runtime.GetService <TrackingService>();
Assert.IsInstanceOfType(typeof(ExplodingTrackingService), instance, "Type based off of WorkflowRuntimeService should be added to workflowruntime");
}
public LevelState(GameModel gameModel, LevelModel levelModel, GameConfig gameConfig, TrackingService trackingService)
{
_gameModel = gameModel;
_levelModel = levelModel;
_gameConfig = gameConfig;
_trackingService = trackingService;
SetNextLevel(_gameModel.GetLastFinishedLevel() + 1);
}
public StatsModule(EmbedService embedService, Config config, TrackingService trackingService, MathService mathService, ImageService imageService, DBContextFactory dbFactory) : base(mathService)
{
EmbedService = embedService;
Config = config;
TrackingService = trackingService;
MathService = mathService;
ImageService = imageService;
DBFactory = dbFactory;
}
public GameModeStatQueryHandler(
IPlayerRepository playerRepository,
TrackingService trackingService,
IRankRepository rankRepository)
{
_playerRepository = playerRepository;
_trackingService = trackingService;
_rankRepository = rankRepository;
}
internal RTTrackingProfile GetProfile(TrackingService service, Activity workflow, Guid instanceId)
{
TrackingProfile profile = service.GetProfile(instanceId);
if (profile == null)
{
return(null);
}
return(new RTTrackingProfile(profile, workflow, service.GetType()));
}
public ReadModelHandler(
IMatchEventRepository eventRepository,
IVersionRepository versionRepository,
T innerHandler,
TrackingService trackingService = null)
{
_eventRepository = eventRepository;
_versionRepository = versionRepository;
_innerHandler = innerHandler;
_trackingService = trackingService;
}
/// <summary>Initializes a new instance of the <see cref="ViewDockSide"/> class.</summary>
/// <param name="grid">Host grid.</param>
/// <param name="side">Align side.</param>
public ViewDockSide(ViewDockGrid grid, AnchorStyles side)
{
Verify.Argument.IsNotNull(grid, nameof(grid));
switch (side)
{
case AnchorStyles.Left:
case AnchorStyles.Right:
_orientation = Orientation.Vertical;
break;
case AnchorStyles.Top:
case AnchorStyles.Bottom:
_orientation = Orientation.Horizontal;
break;
default:
throw new ArgumentException(
"Unknown AnchorStyles value: {0}".UseAsFormat(side),
"side");
}
_grid = grid;
_side = side;
_dockedHosts = new List <ViewHost>();
_tabs = new List <ViewDockSideTab>();
_tabHover = new TrackingService <ViewDockSideTab>(OnTabHoverChanged);
_tabPress = new TrackingService <ViewDockSideTab>(OnTabPressChanged);
_autoShowTimer = new Timer()
{
Interval = 500
};
_autoHideTimer = new Timer()
{
Interval = 500
};
_autoShowTimer.Tick += OnAutoShowTimerTick;
_autoHideTimer.Tick += OnAutoHideTimerTick;
SetStyle(
ControlStyles.ContainerControl |
ControlStyles.Selectable |
ControlStyles.SupportsTransparentBackColor,
false);
SetStyle(
ControlStyles.UserPaint |
ControlStyles.ResizeRedraw |
ControlStyles.AllPaintingInWmPaint |
ControlStyles.OptimizedDoubleBuffer,
true);
MinimumSize = new Size(1, 1);
}
public void GetLogs_IsSuccess()
{
var trackingLogEventRepositoryMock = new Mock <ITrackingLogEventRepository>();
var trackingLogEventList = new List <TrackingLogEvent>();
trackingLogEventRepositoryMock.Setup(repository => repository.GetEvents()).Returns(trackingLogEventList);
var sut = new TrackingService(trackingLogEventRepositoryMock.Object);
sut.GetLogs().Should().Match <ServiceResponse <List <TrackingLogEvent> > >(response => response.IsSuccess);
}
async void TrackUser()
{
UserLocationInfo = await TrackingService.GetLocationInfoAsync();
SyncInProcess = false;
if (UserLocationInfo != null)
{
GpsPosition = "(" + UserLocationInfo.Location.Latitude + ", " + UserLocationInfo.Location.Longitude + ")";
Languages = string.Join(", ", UserLocationInfo.Languages.ToArray());
}
}
public void Get_EmptyFile_ShouldThrowsApplicationException()
{
// Arrange
IFileReader fileReader = new FakeEmptyFile();
ITrackingService trackingService = new TrackingService(fileReader);
// Act
Action act = () => trackingService.Get();
// Assert
Assert.Throws <ApplicationException>(act);
}
public void Get_FileEmpty_ShouldThrowApplicationException()
{
// Arrange
IFileReader fileReader = new FakeEmptyFileReader();
ITrackingService trackingService = new TrackingService(fileReader);
// Act
Action act = () => trackingService.Get();
// Assert
act.Should().Throw <ApplicationException>();
}
public TrackingService AuthenticateWithDespatchBay(TrackingService Service)
{
// Create the service of type Shipping service
Service.RequestEncoding = System.Text.Encoding.UTF8;
Uri uri = new Uri(Service.Url);
ICredentials credentials = SetAuthType(uri);
// Apply the credentials to the service
Service.Credentials = credentials;
return(Service);
}
public void Get_InvalidFile_ShouldThrowsFormatException()
{
// Arrange
IFileReader fileReader = new FakeInvalidFile();
ITrackingService trackingService = new TrackingService(fileReader);
// Act
Action act = () => trackingService.Get();
// Assert
Assert.Throws <FormatException>(act);
}
public BlameFilePanel(Repository repository, BlameFile blameFile)
{
Verify.Argument.IsNotNull(repository, "repository");
Verify.Argument.IsNotNull(blameFile, "blameFile");
_repository = repository;
_blameFile = blameFile;
_lineHover = new TrackingService(e => Invalidate(GetLineBounds(e.Index)));
_selStart = -1;
_selEnd = -1;
_selOrigin = -1;
}
public void Get_InvalidJson_ShouldThrowFormatException()
{
// Arrange
IFileReader fileReader = new FakeInvalidFileReader();
ITrackingService trackingService = new TrackingService(fileReader);
// Act
Action act = () => trackingService.Get();
// Assert
act.Should().Throw <FormatException>();
}
public void SaveEvent_IsSuccess()
{
var trackingLogEventRepositoryMock = new Mock <ITrackingLogEventRepository>();
var trackingLogEvent = new TrackingLogEvent();
trackingLogEventRepositoryMock.Setup(repository => repository.InsertEvent(trackingLogEvent))
.Returns(trackingLogEvent);
var sut = new TrackingService(trackingLogEventRepositoryMock.Object);
sut.SaveEvent(trackingLogEvent).Should().Match <ServiceResponse>(response => response.IsSuccess);
}
public void Get_EmptyFile_ThrowApplicationException()
{
// Arrange
IFileReader fileReader = new FakeEmptyFile();
TrackingService trackingService = new TrackingService(fileReader);
// Act
TestDelegate act = () => trackingService.Get();
// Assets
Assert.Throws <ApplicationException>(act);
}
public BlameFilePanel(Repository repository, BlameFile blameFile)
{
Verify.Argument.IsNotNull(repository, nameof(repository));
Verify.Argument.IsNotNull(blameFile, nameof(blameFile));
_repository = repository;
BlameFile = blameFile;
_lineHover = new TrackingService(e => Invalidate(GetLineBounds(e.Index)));
_selStart = -1;
_selEnd = -1;
_selOrigin = -1;
}
public void Get_ValidFile_ShouldReturnsLocation()
{
// Arrange
IFileReader fileReader = new FakeValidFile();
ITrackingService trackingService = new TrackingService(fileReader);
// Act
var result = trackingService.Get();
// Assert
Assert.Equal(52.05, result.Latitude);
Assert.Equal(18.95, result.Longitude);
}
public TextWithHyperlinks(string text, HyperlinkExtractor extractor = null)
{
_text = text;
_sf = (StringFormat)(StringFormat.GenericTypographic.Clone());
_sf.FormatFlags = StringFormatFlags.FitBlackBox | StringFormatFlags.MeasureTrailingSpaces;
if(extractor == null) extractor = new HyperlinkExtractor();
_glyphs = extractor.ExtractHyperlinks(text)
.Select(h => new HyperlinkGlyph(h))
.ToArray();
_sf.SetMeasurableCharacterRanges(
_glyphs.Select(l => new CharacterRange(l.Start, l.Length)).ToArray());
_hoveredLink = new TrackingService<HyperlinkGlyph>();
_hoveredLink.Changed += OnHoveredLinkChanged;
}
/// <summary>Create <see cref="FileDiffPanel"/>.</summary>
public FileDiffPanel(Repository repository, DiffFile diffFile, DiffType diffType)
{
Verify.Argument.IsNotNull(diffFile, "diffFile");
_repository = repository;
_diffType = diffType;
_diffFile = diffFile;
if(_diffFile.HunkCount != 0)
{
_digits = GetDecimalDigits(_diffFile.MaxLineNum);
_columnWidth = _lineHeaderWidth = _digits * CellSize.Width;
_lineHeaderWidth *= _diffFile[0].ColumnCount;
}
else
{
_digits = 0;
_columnWidth = 0;
_lineHeaderWidth = 0;
}
_lineHover = new TrackingService(OnLineHoverChanged);
_selStart = -1;
_selEnd = -1;
_selOrigin = -1;
}
public UntrackedFilesPanel(Status status, IEnumerable<string> paths)
{
Verify.Argument.IsNotNull(status, "status");
lock(status.SyncRoot)
{
var items = new List<FileItem>(status.UnstagedUntrackedCount);
foreach(var file in status.UnstagedFiles)
{
if(file.Status == FileStatus.Added)
{
bool found;
if(paths != null)
{
found = false;
foreach(var path in paths)
{
if(file.RelativePath.StartsWith(path))
{
found = true;
break;
}
}
}
else
{
found = true;
}
if(found)
{
items.Add(new FileItem(file));
}
}
}
_items = items.ToArray();
}
_fileHover = new TrackingService<FileItem>();
_fileHover.Changed += OnFileHoverChanged;
}
public RevisionHeaderContent()
{
_elements = new IRevisionHeaderElement[]
{
new HashElement(this),
new ParentsElement(this),
new AuthorElement(this),
new CommitterElement(this),
new CommitDateElement(this),
new SubjectElement(this),
new BodyElement(this),
new ReferencesElement(this),
};
foreach(var e in _elements)
{
e.InvalidateRequired +=
(sender, eargs) => OnSizeChanged();
e.CursorChangeRequired +=
(sender, eargs) => Cursor = eargs.Cursor;
}
_cursor = Cursors.Default;
_sizes = new Dictionary<Element, Size>(_elements.Length);
_hoverElement = new TrackingService(OnHoverChanged);
}
/// <summary>Create <see cref="CustomListBox"/>.</summary>
public CustomListBox()
{
_items = new CustomListBoxItemsCollection(this, null);
_items.Changing += OnItemsChanging;
_items.Changed += OnItemsChanged;
_columns = new CustomListBoxColumnsCollection(this);
_columns.Changed += OnColumnsChanged;
_selectedItems = new CustomListBoxSelectedItemsCollection(this);
_selectedItems.Changed += OnSelectedItemsChanged;
_itemPlainList = new List<CustomListBoxItem>();
_processOverlay = new ProcessOverlay(this);
_processOverlay.Renderer = Style.OverlayRenderer;
_itemHover = new TrackingService<CustomListBoxItem>(OnItemHoverChanged);
_itemFocus = new TrackingService<CustomListBoxItem>(OnItemFocusChanged);
_headerHover = new TrackingService<CustomListBoxColumn>(OnHeaderHoverChanged);
_headerDragHelper = new DragHelper();
_showRootTreeLines = true;
_allowColumnReorder = true;
_integralScroll = true;
_lastClickedItemIndex = -1;
_draggedHeaderIndex = -1;
_columnHeaderHeight = DEFAULT_ITEM_HEIGHT;
_itemHeight = DEFAULT_ITEM_HEIGHT;
_renderer = Style.ListBoxRenderer;
BackColor = Renderer.BackColor;
ForeColor = Renderer.ForeColor;
_tooltip = new ToolTip()
{
InitialDelay = 350,
};
}
/// <summary>Create <see cref="ChangedFilesPanel"/>.</summary>
public ChangedFilesPanel()
{
_fileHover = new TrackingService<FileItem>(OnFileHoverChanged);
_filterHover = new TrackingService<ChangesCountByType>(OnStatusFilterHoverChanged);
_statusFilter = StatusFilterAll;
_changesByType = new[]
{
new ChangesCountByType(StatusFilterAll),
new ChangesCountByType(FileStatus.Added),
new ChangesCountByType(FileStatus.Removed),
new ChangesCountByType(FileStatus.Modified),
new ChangesCountByType(FileStatus.Renamed),
new ChangesCountByType(FileStatus.Copied),
new ChangesCountByType(FileStatus.Unmerged),
new ChangesCountByType(FileStatus.ModeChanged),
};
}
