public void NuGetTelemetryService_EmitProjectInformation(NuGetProjectType projectType) { // Arrange var telemetrySession = new Mock <ITelemetrySession>(); TelemetryEvent lastTelemetryEvent = null; telemetrySession .Setup(x => x.PostEvent(It.IsAny <TelemetryEvent>())) .Callback <TelemetryEvent>(x => lastTelemetryEvent = x); var projectInformation = new ProjectTelemetryEvent( "3.5.0-beta2", "15e9591f-9391-4ddf-a246-ca9e0351277d", projectType, true, @"C:\path\to\project.csproj"); var target = new NuGetVSTelemetryService(telemetrySession.Object); // Act target.EmitTelemetryEvent(projectInformation); // Assert telemetrySession.Verify(x => x.PostEvent(It.IsAny <TelemetryEvent>()), Times.Once); Assert.NotNull(lastTelemetryEvent); Assert.Equal("ProjectInformation", lastTelemetryEvent.Name); Assert.Equal(4, lastTelemetryEvent.Count); var nuGetVersion = lastTelemetryEvent["NuGetVersion"]; Assert.NotNull(nuGetVersion); Assert.IsType <string>(nuGetVersion); Assert.Equal(projectInformation.NuGetVersion, nuGetVersion); var projectId = lastTelemetryEvent["ProjectId"]; Assert.NotNull(projectId); Assert.IsType <string>(projectId); Assert.Equal(projectInformation.ProjectId.ToString(), projectId); var actualProjectType = lastTelemetryEvent["NuGetProjectType"]; Assert.NotNull(actualProjectType); Assert.IsType <NuGetProjectType>(actualProjectType); Assert.Equal(projectInformation.NuGetProjectType, actualProjectType); var isPRUpgradable = lastTelemetryEvent["IsPRUpgradable"]; Assert.NotNull(isPRUpgradable); Assert.IsType <bool>(isPRUpgradable); Assert.Equal(projectInformation.IsProjectPRUpgradable, isPRUpgradable); var projectFilePath = lastTelemetryEvent .GetPiiData() .Where(kv => kv.Key == ProjectTelemetryEvent.ProjectFilePath) .First() .Value; Assert.IsType <string>(projectFilePath); Assert.True(!string.IsNullOrEmpty((string)projectFilePath)); }
public void SearchSelectionTelemetryEvent_VulnerableAndDeprecationInfo_Succeeds(bool isPackageVulnerable, bool isPackageDeprecated, bool hasDeprecationAlternative) { // Assert params Assert.False(isPackageDeprecated == false && hasDeprecationAlternative == true); // Arrange var telemetrySession = new Mock <ITelemetrySession>(); TelemetryEvent lastTelemetryEvent = null; _ = telemetrySession .Setup(x => x.PostEvent(It.IsAny <TelemetryEvent>())) .Callback <TelemetryEvent>(x => lastTelemetryEvent = x); var service = new NuGetVSTelemetryService(telemetrySession.Object); var evt = new SearchSelectionTelemetryEvent( parentId: It.IsAny <Guid>(), recommendedCount: It.IsAny <int>(), itemIndex: It.IsAny <int>(), packageId: "testpackage", packageVersion: new NuGetVersion(1, 0, 0), isPackageVulnerable: isPackageVulnerable, isPackageDeprecated: isPackageDeprecated, hasDeprecationAlternativePackage: hasDeprecationAlternative); // Act service.EmitTelemetryEvent(evt); // Assert Assert.NotNull(lastTelemetryEvent); Assert.Equal(isPackageDeprecated, lastTelemetryEvent["IsPackageDeprecated"]); Assert.Equal(isPackageVulnerable, lastTelemetryEvent["IsPackageVulnerable"]); Assert.Equal(hasDeprecationAlternative, lastTelemetryEvent["HasDeprecationAlternativePackage"]); }
public void ActionsTelemetryService_EmitActionStepsEvent(string stepName) { // Arrange var telemetrySession = new Mock <ITelemetrySession>(); TelemetryEvent lastTelemetryEvent = null; telemetrySession .Setup(x => x.PostEvent(It.IsAny <TelemetryEvent>())) .Callback <TelemetryEvent>(x => lastTelemetryEvent = x); var duration = 1.12; var service = new NuGetVSTelemetryService(telemetrySession.Object); var parentId = Guid.NewGuid().ToString(); // Act service.EmitTelemetryEvent(new ActionTelemetryStepEvent(parentId, stepName, duration)); // Assert Assert.NotNull(lastTelemetryEvent); Assert.Equal(ActionTelemetryStepEvent.NugetActionStepsEventName, lastTelemetryEvent.Name); Assert.Equal(3, lastTelemetryEvent.Count); Assert.Equal(parentId, lastTelemetryEvent["ParentId"].ToString()); Assert.Equal(stepName, lastTelemetryEvent["SubStepName"].ToString()); Assert.Equal(duration, (double)lastTelemetryEvent["Duration"]); }
public void ActionsTelemetryService_EmitActionEvent_OperationNoOp(NuGetOperationType operationType) { // Arrange var telemetrySession = new Mock <ITelemetrySession>(); TelemetryEvent lastTelemetryEvent = null; telemetrySession .Setup(x => x.PostEvent(It.IsAny <TelemetryEvent>())) .Callback <TelemetryEvent>(x => lastTelemetryEvent = x); var operationId = Guid.NewGuid().ToString(); var actionTelemetryData = new VSActionsTelemetryEvent( operationId, projectIds: new[] { Guid.NewGuid().ToString() }, operationType: operationType, source: OperationSource.PMC, startTime: DateTimeOffset.Now.AddSeconds(-1), status: NuGetOperationStatus.NoOp, packageCount: 1, endTime: DateTimeOffset.Now, duration: .40); var service = new NuGetVSTelemetryService(telemetrySession.Object); // Act service.EmitTelemetryEvent(actionTelemetryData); // Assert VerifyTelemetryEventData(operationId, actionTelemetryData, lastTelemetryEvent); }
/// <summary> /// Initialization of the package; this method is called right after the package is sited, so this is the place /// where you can put all the initialization code that rely on services provided by VisualStudio. /// </summary> /// <param name="cancellationToken">A cancellation token to monitor for initialization cancellation, which can occur when VS is shutting down.</param> /// <param name="progress">A provider for progress updates.</param> /// <returns>A task representing the async work of package initialization, or an already completed task if there is none. Do not return null from this method.</returns> protected override Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress) { // When initialized asynchronously, the current thread may be a background thread at this point. // Do any initialization that requires the UI thread after switching to the UI thread NuGetVSTelemetryService.Initialize(); return(Task.CompletedTask); }
public void RestoreTelemetryService_EmitRestoreEvent_OperationSucceed(bool forceRestore, RestoreOperationSource source, NuGetOperationStatus status, ExplicitRestoreReason explicitRestoreReason) { // Arrange var telemetrySession = new Mock <ITelemetrySession>(); TelemetryEvent lastTelemetryEvent = null; telemetrySession .Setup(x => x.PostEvent(It.IsAny <TelemetryEvent>())) .Callback <TelemetryEvent>(x => lastTelemetryEvent = x); var noopProjectsCount = 0; if (status == NuGetOperationStatus.NoOp) { noopProjectsCount = 1; } var operationId = Guid.NewGuid().ToString(); var restoreTelemetryData = new RestoreTelemetryEvent( operationId, projectIds: new[] { Guid.NewGuid().ToString() }, forceRestore: forceRestore, source: source, startTime: DateTimeOffset.Now.AddSeconds(-3), status: status, packageCount: 2, noOpProjectsCount: noopProjectsCount, upToDateProjectsCount: 5, unknownProjectsCount: 0, projectJsonProjectsCount: 0, packageReferenceProjectsCount: 0, legacyPackageReferenceProjectsCount: 0, cpsPackageReferenceProjectsCount: 0, dotnetCliToolProjectsCount: 0, packagesConfigProjectsCount: 1, endTime: DateTimeOffset.Now, duration: 2.10, additionalTrackingData: new Dictionary <string, object>() { { nameof(RestoreTelemetryEvent.IsSolutionLoadRestore), true }, { nameof(ExplicitRestoreReason), explicitRestoreReason } }, new IntervalTracker("Activity"), isPackageSourceMappingEnabled: false, httpFeedsCount: 1, localFeedsCount: 2, hasNuGetOrg: true, hasVSOfflineFeed: false); var service = new NuGetVSTelemetryService(telemetrySession.Object); // Act service.EmitTelemetryEvent(restoreTelemetryData); // Assert VerifyTelemetryEventData(operationId, restoreTelemetryData, lastTelemetryEvent); }
public void NuGetTelemetryService_EmitProjectInformation(NuGetProjectType projectType) { // Arrange var telemetrySession = new Mock <ITelemetrySession>(); TelemetryEvent lastTelemetryEvent = null; telemetrySession .Setup(x => x.PostEvent(It.IsAny <TelemetryEvent>())) .Callback <TelemetryEvent>(x => lastTelemetryEvent = x); var projectInformation = new ProjectTelemetryEvent( "3.5.0-beta2", "15e9591f-9391-4ddf-a246-ca9e0351277d", projectType, 3, true); var target = new NuGetVSTelemetryService(telemetrySession.Object); // Act target.EmitTelemetryEvent(projectInformation); // Assert telemetrySession.Verify(x => x.PostEvent(It.IsAny <TelemetryEvent>()), Times.Once); Assert.NotNull(lastTelemetryEvent); Assert.Equal("ProjectInformation", lastTelemetryEvent.Name); Assert.Equal(5, lastTelemetryEvent.Count); var nuGetVersion = lastTelemetryEvent["NuGetVersion"]; Assert.NotNull(nuGetVersion); Assert.IsType <string>(nuGetVersion); Assert.Equal(projectInformation.NuGetVersion, nuGetVersion); var projectId = lastTelemetryEvent["ProjectId"]; Assert.NotNull(projectId); Assert.IsType <string>(projectId); Assert.Equal(projectInformation.ProjectId.ToString(), projectId); var actualProjectType = lastTelemetryEvent["NuGetProjectType"]; Assert.NotNull(actualProjectType); Assert.IsType <NuGetProjectType>(actualProjectType); Assert.Equal(projectInformation.NuGetProjectType, actualProjectType); var installedPackageCount = lastTelemetryEvent["InstalledPackageCount"]; Assert.NotNull(installedPackageCount); Assert.IsType <int>(installedPackageCount); Assert.Equal(projectInformation.InstalledPackageCount, installedPackageCount); var isPRUpgradable = lastTelemetryEvent["IsPRUpgradable"]; Assert.NotNull(isPRUpgradable); Assert.IsType <bool>(isPRUpgradable); Assert.Equal(projectInformation.IsProjectPRUpgradable, isPRUpgradable); }
public void RestoreTelemetryService_EmitRestoreEvent_IntervalsAreCaptured() { // Arrange var first = "first"; var second = "second"; var telemetrySession = new Mock <ITelemetrySession>(); TelemetryEvent lastTelemetryEvent = null; telemetrySession .Setup(x => x.PostEvent(It.IsAny <TelemetryEvent>())) .Callback <TelemetryEvent>(x => lastTelemetryEvent = x); var tracker = new IntervalTracker("Activity"); using (tracker.Start(first)) { } using (tracker.Start(second)) { } var operationId = Guid.NewGuid().ToString(); var restoreTelemetryData = new RestoreTelemetryEvent( operationId, projectIds: new[] { Guid.NewGuid().ToString() }, forceRestore: false, source: RestoreOperationSource.OnBuild, startTime: DateTimeOffset.Now.AddSeconds(-3), status: NuGetOperationStatus.Succeeded, packageCount: 1, noOpProjectsCount: 0, upToDateProjectsCount: 0, endTime: DateTimeOffset.Now, duration: 2.10, isSolutionLoadRestore: true, tracker ); var service = new NuGetVSTelemetryService(telemetrySession.Object); // Act service.EmitTelemetryEvent(restoreTelemetryData); // Assert Assert.NotNull(lastTelemetryEvent); Assert.Equal(RestoreTelemetryEvent.RestoreActionEventName, lastTelemetryEvent.Name); Assert.Equal(15, lastTelemetryEvent.Count); Assert.Equal(restoreTelemetryData.OperationSource.ToString(), lastTelemetryEvent["OperationSource"].ToString()); Assert.Equal(restoreTelemetryData.NoOpProjectsCount, (int)lastTelemetryEvent["NoOpProjectsCount"]); Assert.Equal(restoreTelemetryData[first], lastTelemetryEvent[first]); Assert.Equal(restoreTelemetryData[second], lastTelemetryEvent[second]); }
public void RestoreTelemetryService_EmitRestoreEvent_OperationSucceed(bool forceRestore, RestoreOperationSource source, NuGetOperationStatus status) { // Arrange var telemetrySession = new Mock <ITelemetrySession>(); TelemetryEvent lastTelemetryEvent = null; telemetrySession .Setup(x => x.PostEvent(It.IsAny <TelemetryEvent>())) .Callback <TelemetryEvent>(x => lastTelemetryEvent = x); var noopProjectsCount = 0; if (status == NuGetOperationStatus.NoOp) { noopProjectsCount = 1; } var operationId = Guid.NewGuid().ToString(); var restoreTelemetryData = new RestoreTelemetryEvent( operationId, projectIds: new[] { Guid.NewGuid().ToString() }, forceRestore: forceRestore, source: source, startTime: DateTimeOffset.Now.AddSeconds(-3), status: status, packageCount: 2, noOpProjectsCount: noopProjectsCount, upToDateProjectsCount: 5, unknownProjectsCount: 0, projectJsonProjectsCount: 0, packageReferenceProjectsCount: 0, legacyPackageReferenceProjectsCount: 0, cpsPackageReferenceProjectsCount: 0, dotnetCliToolProjectsCount: 0, packagesConfigProjectsCount: 1, endTime: DateTimeOffset.Now, duration: 2.10, isSolutionLoadRestore: true, new IntervalTracker("Activity")); var service = new NuGetVSTelemetryService(telemetrySession.Object); // Act service.EmitTelemetryEvent(restoreTelemetryData); // Assert VerifyTelemetryEventData(operationId, restoreTelemetryData, lastTelemetryEvent); }
protected override async Task InitializeAsync( CancellationToken cancellationToken, IProgress <ServiceProgressData> progress) { NuGetVSTelemetryService.Initialize(); _handler = await SolutionRestoreBuildHandler.InitializeAsync(this); await SolutionRestoreCommand.InitializeAsync(this); // Set up brokered services - Do not reference NuGet.VisualStudio.Internals.Contract explicitly to avoid an unnecessary assembly load IBrokeredServiceContainer brokeredServiceContainer = await this.GetServiceAsync <SVsBrokeredServiceContainer, IBrokeredServiceContainer>(); brokeredServiceContainer.Proffer(BrokeredServicesUtility.DeprecatedSolutionService, factory: BrokeredServicesUtility.GetNuGetSolutionServicesFactory()); brokeredServiceContainer.Proffer(BrokeredServicesUtility.SolutionService, factory: BrokeredServicesUtility.GetNuGetSolutionServicesFactory()); await base.InitializeAsync(cancellationToken, progress); }
private async Task EnsureInitializeAsync() { try { // If already initialized, need not be on the UI thread if (_initialized) { await EnsureNuGetAndVsProjectAdapterCacheAsync(); return; } // Ensure all initialization finished when needed, it still runs as async and prevents _initialized set true too early. // Setting '_initialized = true' too early caused random timing bug. await _semaphoreLock.ExecuteAsync(async() => { if (_initialized) { return; } NuGetVSTelemetryService.Initialize(); await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); await InitializeAsync(); var dte = await _asyncServiceProvider.GetDTEAsync(); if (dte.Solution.IsOpen) { await OnSolutionExistsAndFullyLoadedAsync(); } _initialized = true; }); } catch (Exception e) { // ignore errors Debug.Fail(e.ToString()); _logger.LogError(e.ToString()); } }
public void EmitCpsBulkFileRestoreCoordinationEvent_Succeeds() { // Arrange var telemetrySession = new Mock <ITelemetrySession>(); TelemetryEvent lastTelemetryEvent = null; _ = telemetrySession .Setup(x => x.PostEvent(It.IsAny <TelemetryEvent>())) .Callback <TelemetryEvent>(x => lastTelemetryEvent = x); var service = new NuGetVSTelemetryService(telemetrySession.Object); var evt = new CpsBulkFileRestoreCoordinationEvent(); // Act service.EmitTelemetryEvent(evt); // Assert Assert.NotNull(lastTelemetryEvent); Assert.Equal(evt.Name, lastTelemetryEvent.Name); }
public void RestoreTelemetryService_EmitRestoreEvent_OperationSucceed(RestoreOperationSource source, NuGetOperationStatus status) { // Arrange var telemetrySession = new Mock <ITelemetrySession>(); TelemetryEvent lastTelemetryEvent = null; telemetrySession .Setup(x => x.PostEvent(It.IsAny <TelemetryEvent>())) .Callback <TelemetryEvent>(x => lastTelemetryEvent = x); var noopProjectsCount = 0; if (status == NuGetOperationStatus.NoOp) { noopProjectsCount = 1; } var stausMessage = status == NuGetOperationStatus.Failed ? "Operation Failed" : string.Empty; var operationId = Guid.NewGuid().ToString(); var restoreTelemetryData = new RestoreTelemetryEvent( operationId, projectIds: new[] { Guid.NewGuid().ToString() }, source: source, startTime: DateTimeOffset.Now.AddSeconds(-3), status: status, packageCount: 2, noOpProjectsCount: noopProjectsCount, endTime: DateTimeOffset.Now, duration: 2.10, new IntervalTracker()); var service = new NuGetVSTelemetryService(telemetrySession.Object); // Act service.EmitTelemetryEvent(restoreTelemetryData); // Assert VerifyTelemetryEventData(operationId, restoreTelemetryData, lastTelemetryEvent); }
public void HyperlinkClicked_RoundTrip_Succeeds(HyperlinkType hyperlinkTab, ContractsItemFilter currentTab, bool isSolutionView, string searchQuery) { // Arrange var telemetrySession = new Mock <ITelemetrySession>(); TelemetryEvent lastTelemetryEvent = null; _ = telemetrySession .Setup(x => x.PostEvent(It.IsAny <TelemetryEvent>())) .Callback <TelemetryEvent>(x => lastTelemetryEvent = x); var service = new NuGetVSTelemetryService(telemetrySession.Object); var evt = new HyperlinkClickedTelemetryEvent(hyperlinkTab, currentTab, isSolutionView, searchQuery); // Act service.EmitTelemetryEvent(evt); // Assert Assert.NotNull(lastTelemetryEvent); Assert.Equal(hyperlinkTab, lastTelemetryEvent[HyperlinkClickedTelemetryEvent.HyperLinkTypePropertyName]); Assert.Equal(currentTab, lastTelemetryEvent[HyperlinkClickedTelemetryEvent.CurrentTabPropertyName]); Assert.Equal(isSolutionView, lastTelemetryEvent[HyperlinkClickedTelemetryEvent.IsSolutionViewPropertyName]); Assert.Equal(searchQuery, lastTelemetryEvent.GetPiiData().Where(x => x.Key == HyperlinkClickedTelemetryEvent.AlternativePackageIdPropertyName).Select(x => x.Value).First()); }
public async Task CreateInstallAction_OnInstallingProject_EmitsPkgWasTransitiveTelemetryAndTabAndIsSolutionPropertiesAsync(ContractsItemFilter activeTab, bool isSolutionLevel, string packageIdToInstall, bool?expectedPkgWasTransitive) { // Arrange var telemetrySession = new Mock <ITelemetrySession>(); TelemetryEvent lastTelemetryEvent = null; telemetrySession .Setup(x => x.PostEvent(It.IsAny <TelemetryEvent>())) .Callback <TelemetryEvent>(x => lastTelemetryEvent = x); var telemetryService = new NuGetVSTelemetryService(telemetrySession.Object); TelemetryActivity.NuGetTelemetryService = telemetryService; var sourceProvider = new Mock <ISourceRepositoryProvider>(); var settings = new Mock <ISettings>(); var nugetPM = new NuGetPackageManager(sourceProvider.Object, settings.Object, @"\packagesFolder"); var lockService = new NuGetLockService(ThreadHelper.JoinableTaskContext); var uiEngine = new UIActionEngine(sourceProvider.Object, nugetPM, lockService); var installedAndTransitive = new InstalledAndTransitivePackages( new[] { new PackageReferenceContextInfo(new PackageIdentity("installedA", NuGetVersion.Parse("1.0.0")), NuGetFramework.Parse("net472")), new PackageReferenceContextInfo(new PackageIdentity("installedB", NuGetVersion.Parse("1.0.0")), NuGetFramework.Parse("net472")) }, new[] { new TransitivePackageReferenceContextInfo(new PackageIdentity("transitiveA", NuGetVersion.Parse("1.0.0")), NuGetFramework.Parse("net472")) }); var prjMgrSvc = new Mock <INuGetProjectManagerService>(); prjMgrSvc .Setup(mgr => mgr.GetInstalledAndTransitivePackagesAsync(It.IsAny <IReadOnlyCollection <string> >(), It.IsAny <CancellationToken>())) .Returns(new ValueTask <IInstalledAndTransitivePackages>(installedAndTransitive)); var dictMetadata = new Dictionary <string, object> { [NuGetProjectMetadataKeys.UniqueName] = "a", [NuGetProjectMetadataKeys.ProjectId] = "a" }; ProjectMetadataContextInfo metadataCtxtInfo = ProjectMetadataContextInfo.Create(dictMetadata); prjMgrSvc .Setup(mgr => mgr.GetMetadataAsync(It.IsAny <string>(), It.IsAny <CancellationToken>())) .Returns(new ValueTask <IProjectMetadataContextInfo>(metadataCtxtInfo)); var uiService = new Mock <INuGetUI>(); var uiContext = new Mock <INuGetUIContext>(); var projectContext = new Mock <INuGetProjectContext>(); var serviceBroker = new Mock <IServiceBroker>(); _ = serviceBroker.Setup(sb => sb.GetProxyAsync <INuGetProjectManagerService>( It.Is <ServiceRpcDescriptor>(s => s == NuGetServices.ProjectManagerService), It.IsAny <ServiceActivationOptions>(), It.IsAny <CancellationToken>())) .Returns(new ValueTask <INuGetProjectManagerService>(prjMgrSvc.Object)); uiContext.Setup(ctx => ctx.ServiceBroker).Returns(serviceBroker.Object); uiService.Setup(ui => ui.UIContext).Returns(uiContext.Object); uiService.Setup(ui => ui.ProjectContext).Returns(projectContext.Object); uiService.Setup(ui => ui.Settings).Returns(settings.Object); uiService.Setup(ui => ui.Projects).Returns(new[] { new ProjectContextInfo("a", ProjectModel.ProjectStyle.PackageReference, NuGetProjectKind.PackageReference) }); var action = UserAction.CreateInstallAction(packageIdToInstall, NuGetVersion.Parse("1.0.0"), isSolutionLevel, activeTab); // Act await uiEngine.PerformInstallOrUninstallAsync(uiService.Object, action, CancellationToken.None); // Assert Assert.NotNull(lastTelemetryEvent); // expect failed action because we mocked just enough objects to emit telemetry Assert.Equal(NuGetOperationStatus.Failed, lastTelemetryEvent[nameof(ActionEventBase.Status)]); Assert.Equal(NuGetOperationType.Install, lastTelemetryEvent[nameof(ActionsTelemetryEvent.OperationType)]); Assert.Equal(isSolutionLevel, lastTelemetryEvent[nameof(VSActionsTelemetryEvent.IsSolutionLevel)]); Assert.Equal(activeTab, lastTelemetryEvent[nameof(VSActionsTelemetryEvent.Tab)]); Assert.Equal(expectedPkgWasTransitive, lastTelemetryEvent[nameof(VSActionsTelemetryEvent.PackageToInstallWasTransitive)]); }
public void NuGetTelemetryService_EmitsPMUIRefreshEvent(RefreshOperationSource expectedRefreshSource, RefreshOperationStatus expectedRefreshStatus) { // Arrange var telemetrySession = new Mock <ITelemetrySession>(); TelemetryEvent lastTelemetryEvent = null; telemetrySession .Setup(x => x.PostEvent(It.IsAny <TelemetryEvent>())) .Callback <TelemetryEvent>(x => lastTelemetryEvent = x); var expectedGuid = Guid.NewGuid(); var expectedIsSolutionLevel = true; var expectedTab = "All"; var expectedTimeSinceLastRefresh = TimeSpan.FromSeconds(1); var refreshEvent = new PackageManagerUIRefreshEvent(expectedGuid, expectedIsSolutionLevel, expectedRefreshSource, expectedRefreshStatus, expectedTab, expectedTimeSinceLastRefresh); var target = new NuGetVSTelemetryService(telemetrySession.Object); // Act target.EmitTelemetryEvent(refreshEvent); // Assert telemetrySession.Verify(x => x.PostEvent(It.IsAny <TelemetryEvent>()), Times.Once); Assert.NotNull(lastTelemetryEvent); Assert.Equal("PMUIRefresh", lastTelemetryEvent.Name); Assert.Equal(6, lastTelemetryEvent.Count); var parentIdGuid = lastTelemetryEvent["ParentId"]; Assert.NotNull(parentIdGuid); Assert.IsType <string>(parentIdGuid); Assert.Equal(expectedGuid.ToString(), parentIdGuid); var solutionLevel = lastTelemetryEvent["IsSolutionLevel"]; Assert.NotNull(solutionLevel); Assert.IsType <bool>(solutionLevel); Assert.Equal(expectedIsSolutionLevel, solutionLevel); var refreshSource = lastTelemetryEvent["RefreshSource"]; Assert.NotNull(refreshSource); Assert.IsType <RefreshOperationSource>(refreshSource); Assert.Equal(expectedRefreshSource, refreshSource); var refreshStatus = lastTelemetryEvent["RefreshStatus"]; Assert.NotNull(refreshStatus); Assert.IsType <RefreshOperationStatus>(refreshStatus); Assert.Equal(expectedRefreshStatus, refreshStatus); var tab = lastTelemetryEvent["Tab"]; Assert.NotNull(tab); Assert.IsType <string>(tab); Assert.Equal(expectedTab, tab); var timeSinceLastRefresh = lastTelemetryEvent["TimeSinceLastRefresh"]; Assert.NotNull(timeSinceLastRefresh); Assert.IsType <double>(timeSinceLastRefresh); Assert.Equal(expectedTimeSinceLastRefresh.TotalMilliseconds, timeSinceLastRefresh); }
public void RestoreTelemetryService_EmitRestoreEvent_IntervalsAreCaptured(string _packageSourceMapping) { // Arrange var first = "first"; var second = "second"; var telemetrySession = new Mock <ITelemetrySession>(); TelemetryEvent lastTelemetryEvent = null; telemetrySession .Setup(x => x.PostEvent(It.IsAny <TelemetryEvent>())) .Callback <TelemetryEvent>(x => lastTelemetryEvent = x); var tracker = new IntervalTracker("Activity"); using (tracker.Start(first)) { } using (tracker.Start(second)) { } var operationId = Guid.NewGuid().ToString(); var packageSourceMapping = string.IsNullOrEmpty(_packageSourceMapping) ? null : PackageSourceMappingUtility.GetpackageSourceMapping(_packageSourceMapping); bool isPackageSourceMappingEnabled = packageSourceMapping?.IsEnabled ?? false; var restoreTelemetryData = new RestoreTelemetryEvent( operationId, projectIds: new[] { Guid.NewGuid().ToString() }, forceRestore: false, source: RestoreOperationSource.OnBuild, startTime: DateTimeOffset.Now.AddSeconds(-3), status: NuGetOperationStatus.Succeeded, packageCount: 1, noOpProjectsCount: 0, upToDateProjectsCount: 0, unknownProjectsCount: 0, projectJsonProjectsCount: 0, packageReferenceProjectsCount: 1, legacyPackageReferenceProjectsCount: 0, cpsPackageReferenceProjectsCount: 1, dotnetCliToolProjectsCount: 0, packagesConfigProjectsCount: 0, endTime: DateTimeOffset.Now, duration: 2.10, additionalTrackingData: new Dictionary <string, object>() { { nameof(RestoreTelemetryEvent.IsSolutionLoadRestore), true } }, tracker, isPackageSourceMappingEnabled: isPackageSourceMappingEnabled); var service = new NuGetVSTelemetryService(telemetrySession.Object); // Act service.EmitTelemetryEvent(restoreTelemetryData); // Assert Assert.NotNull(lastTelemetryEvent); Assert.Equal(RestoreTelemetryEvent.RestoreActionEventName, lastTelemetryEvent.Name); Assert.Equal(23, lastTelemetryEvent.Count); Assert.Equal(restoreTelemetryData.OperationSource.ToString(), lastTelemetryEvent["OperationSource"].ToString()); Assert.Equal(restoreTelemetryData.NoOpProjectsCount, (int)lastTelemetryEvent["NoOpProjectsCount"]); Assert.Equal(restoreTelemetryData[first], lastTelemetryEvent[first]); Assert.Equal(restoreTelemetryData[second], lastTelemetryEvent[second]); }
public void AddUiActionEngineTelemetryProperties_AddsVulnerabilityInfo_Succeeds() { // Arrange var telemetrySession = new Mock <ITelemetrySession>(); TelemetryEvent lastTelemetryEvent = null; telemetrySession .Setup(x => x.PostEvent(It.IsAny <TelemetryEvent>())) .Callback <TelemetryEvent>(x => lastTelemetryEvent = x); var operationId = Guid.NewGuid().ToString(); var actionTelemetryData = new VSActionsTelemetryEvent( operationId, projectIds: new[] { Guid.NewGuid().ToString() }, operationType: NuGetOperationType.Install, source: OperationSource.PMC, startTime: DateTimeOffset.Now.AddSeconds(-1), status: NuGetOperationStatus.NoOp, packageCount: 1, endTime: DateTimeOffset.Now, duration: .40, isPackageSourceMappingEnabled: false); UIActionEngine.AddUiActionEngineTelemetryProperties( actionTelemetryEvent: actionTelemetryData, continueAfterPreview: true, acceptedLicense: true, userAction: UserAction.CreateInstallAction("mypackageId", new NuGetVersion(1, 0, 0)), selectedIndex: 0, recommendedCount: 0, recommendPackages: false, recommenderVersion: null, topLevelVulnerablePackagesCount: 3, topLevelVulnerablePackagesMaxSeverities: new List <int> { 1, 1, 3 }, // each package has its own max severity existingPackages: null, addedPackages: null, removedPackages: null, updatedPackagesOld: null, updatedPackagesNew: null, targetFrameworks: null); // Act var service = new NuGetVSTelemetryService(telemetrySession.Object); service.EmitTelemetryEvent(actionTelemetryData); // Assert Assert.NotNull(lastTelemetryEvent); Assert.NotNull(lastTelemetryEvent.ComplexData["TopLevelVulnerablePackagesMaxSeverities"] as List <int>); var pkgSeverities = lastTelemetryEvent.ComplexData["TopLevelVulnerablePackagesMaxSeverities"] as List <int>; Assert.Equal(lastTelemetryEvent["TopLevelVulnerablePackagesCount"], pkgSeverities.Count()); Assert.Collection(pkgSeverities, item => Assert.Equal(1, item), item => Assert.Equal(1, item), item => Assert.Equal(3, item)); Assert.Equal(3, pkgSeverities.Count()); }
public void HyperlinkClicked_CorrelatesSearchSelectionAndAction_Succeeds() { // Arrange var telemetrySession = new Mock <ITelemetrySession>(); TelemetryEvent lastTelemetryEvent = null; _ = telemetrySession .Setup(x => x.PostEvent(It.IsAny <TelemetryEvent>())) .Callback <TelemetryEvent>(x => lastTelemetryEvent = x); var service = new NuGetVSTelemetryService(telemetrySession.Object); var testPackageId = "testPackage.id"; var testPackageVersion = new NuGetVersion(1, 0, 0); var evtHyperlink = new HyperlinkClickedTelemetryEvent( HyperlinkType.DeprecationAlternativeDetails, ContractsItemFilter.All, isSolutionView: false, testPackageId); var evtSearch = new SearchSelectionTelemetryEvent( parentId: It.IsAny <Guid>(), recommendedCount: It.IsAny <int>(), itemIndex: It.IsAny <int>(), packageId: testPackageId, packageVersion: testPackageVersion, isPackageVulnerable: It.IsAny <bool>(), isPackageDeprecated: true, hasDeprecationAlternativePackage: true); var evtActions = new VSActionsTelemetryEvent( operationId: It.IsAny <string>(), projectIds: new[] { Guid.NewGuid().ToString() }, operationType: NuGetOperationType.Install, source: OperationSource.PMC, startTime: DateTimeOffset.Now.AddSeconds(-1), status: NuGetOperationStatus.NoOp, packageCount: 1, endTime: DateTimeOffset.Now, duration: .40, isPackageSourceMappingEnabled: false); // Simulate UIActionEngine.AddUiActionEngineTelemetryProperties() var pkgAdded = new TelemetryEvent(eventName: null); pkgAdded.AddPiiData("id", VSTelemetryServiceUtility.NormalizePackageId(testPackageId)); pkgAdded.AddPiiData("version", testPackageVersion.ToNormalizedString()); var packages = new List <TelemetryEvent> { pkgAdded }; evtActions.ComplexData["AddedPackages"] = packages; // Act service.EmitTelemetryEvent(evtHyperlink); var hyperlinkEmitted = lastTelemetryEvent; service.EmitTelemetryEvent(evtSearch); var searchEmitted = lastTelemetryEvent; service.EmitTelemetryEvent(evtActions); var actionEmitted = lastTelemetryEvent; // Assert var packageIdHyperlink = hyperlinkEmitted.GetPiiData().First(x => x.Key == HyperlinkClickedTelemetryEvent.AlternativePackageIdPropertyName).Value; var packageIdSearch = searchEmitted.GetPiiData().First(x => x.Key == "PackageId").Value; var packageIdsAction = (IEnumerable <TelemetryEvent>)actionEmitted.ComplexData["AddedPackages"]; var packageIds = packageIdsAction.Select(x => x.GetPiiData().First(x => x.Key == "id").Value); Assert.Equal(packageIdHyperlink, packageIdSearch); Assert.Contains(packageIdHyperlink, packageIds); }