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);
}
