public async Task ShouldWriteUpdatedData()
{
var model = UsageModel.Create(Guid.NewGuid());
//model.Dimensions.AppVersion = AssemblyVersionInformation.Version;
model.Dimensions.Lang = CultureInfo.InstalledUICulture.IetfLanguageTag;
model.Dimensions.CurrentLang = CultureInfo.CurrentCulture.IetfLanguageTag;
model.Measures.NumberOfClones = 1;
var service = CreateUsageService(model);
var target = new UsageTracker(
CreateServiceProvider(),
service,
CreatePackageSettings(),
new JoinableTaskContext(),
vsTelemetry: false);
await target.IncrementCounter(x => x.NumberOfClones);
await service.Received(1).WriteLocalData(Arg.Is <UsageData>(data =>
data.Reports.Count == 1 &&
data.Reports[0].Dimensions.Date.Date == DateTimeOffset.Now.Date &&
//data.Reports[0].Dimensions.AppVersion == AssemblyVersionInformation.Version &&
data.Reports[0].Dimensions.Lang == CultureInfo.InstalledUICulture.IetfLanguageTag &&
data.Reports[0].Dimensions.CurrentLang == CultureInfo.CurrentCulture.IetfLanguageTag &&
data.Reports[0].Measures.NumberOfClones == 2
));
}
async Task <UsageModel> GetCurrentReport(UsageData data)
{
var current = data.Reports.FirstOrDefault(x => x.Dimensions.Date.Date == DateTimeOffset.Now.Date);
if (current == null)
{
var guid = await service.GetUserGuid();
current = UsageModel.Create(guid);
data.Reports.Add(current);
}
current.Dimensions.Lang = CultureInfo.InstalledUICulture.IetfLanguageTag;
current.Dimensions.CurrentLang = CultureInfo.CurrentCulture.IetfLanguageTag;
current.Dimensions.AppVersion = AssemblyVersionInformation.Version;
current.Dimensions.VSVersion = vsservices.VSVersion;
if (connectionManager.Connections.Any(x => x.HostAddress.IsGitHubDotCom()))
{
current.Dimensions.IsGitHubUser = true;
}
if (connectionManager.Connections.Any(x => !x.HostAddress.IsGitHubDotCom()))
{
current.Dimensions.IsEnterpriseUser = true;
}
return(current);
}
public async Task FirstTickShouldIncrementLaunchCount()
{
var service = CreateUsageService(UsageModel.Create(Guid.NewGuid()));
var targetAndTick = CreateTargetAndGetTick(CreateServiceProvider(), service);
await targetAndTick.Item2();
await service.Received(1).WriteLocalData(Arg.Any <UsageData>());
}
public async Task TickShouldNotSendDataIfSameDay()
{
var serviceProvider = CreateServiceProvider();
var targetAndTick = CreateTargetAndGetTick(
serviceProvider,
CreateUsageService(UsageModel.Create(Guid.NewGuid())));
await targetAndTick.Item2();
var metricsService = serviceProvider.TryGetService <IMetricsService>();
await metricsService.DidNotReceive().PostUsage(Arg.Any <UsageModel>());
}
public async Task SubsequentTickShouldNotIncrementLaunchCount()
{
var service = CreateUsageService(UsageModel.Create(Guid.NewGuid()));
var targetAndTick = CreateTargetAndGetTick(CreateServiceProvider(), service);
await targetAndTick.Item2();
service.ClearReceivedCalls();
await targetAndTick.Item2();
await service.DidNotReceiveWithAnyArgs().WriteLocalData(null);
}
public async Task UpdatesMetricsWhenRepositoryClonedAsync(string cloneUrl, int numberOfCalls, string counterName)
{
var vsGitServices = Substitute.For <IVSGitServices>();
var usageTracker = Substitute.For <IUsageTracker>();
var cloneService = CreateRepositoryCloneService(vsGitServices: vsGitServices, usageTracker: usageTracker);
await cloneService.CloneRepository(cloneUrl, @"c:\dev\bar");
var model = UsageModel.Create(Guid.NewGuid());
await usageTracker.Received(numberOfCalls).IncrementCounter(
Arg.Is <Expression <Func <UsageModel.MeasuresModel, int> > >(x =>
((MemberExpression)x.Body).Member.Name == counterName));
}
public async Task UpdatesMetricsWhenDefaultClonePath(string targetPath, string defaultPath, int numberOfCalls, string counterName)
{
var vsGitServices = Substitute.For <IVSGitServices>();
vsGitServices.GetLocalClonePathFromGitProvider().Returns(defaultPath);
var usageTracker = Substitute.For <IUsageTracker>();
var cloneService = CreateRepositoryCloneService(usageTracker: usageTracker, vsGitServices: vsGitServices);
await cloneService.CloneRepository("https://github.com/foo/bar", targetPath);
var model = UsageModel.Create(Guid.NewGuid());
await usageTracker.Received(numberOfCalls).IncrementCounter(
Arg.Is <Expression <Func <UsageModel.MeasuresModel, int> > >(x =>
((MemberExpression)x.Body).Member.Name == counterName));
}
public async Task TickShouldSendDataIfDifferentDay()
{
var model = UsageModel.Create(Guid.NewGuid());
model.Dimensions.Date = DateTimeOffset.Now.AddDays(-2);
var serviceProvider = CreateServiceProvider();
var targetAndTick = CreateTargetAndGetTick(
serviceProvider,
CreateUsageService(model));
await targetAndTick.Item2();
var metricsService = serviceProvider.TryGetService <IMetricsService>();
await metricsService.Received(1).PostUsage(Arg.Any <UsageModel>());
}
public async Task ShouldDisposeTimerIfMetricsServiceNotFound()
{
var service = CreateUsageService(UsageModel.Create(Guid.NewGuid()));
var disposed = false;
var disposable = Disposable.Create(() => disposed = true);
service.StartTimer(null, new TimeSpan(), new TimeSpan()).ReturnsForAnyArgs(disposable);
var targetAndTick = CreateTargetAndGetTick(
CreateServiceProvider(hasMetricsService: false),
service);
await targetAndTick.Item2();
Assert.True(disposed);
}
public async Task UpdatesMetricsWhenRepositoryClonedAsync()
{
var serviceProvider = Substitutes.ServiceProvider;
var operatingSystem = serviceProvider.GetOperatingSystem();
var vsGitServices = serviceProvider.GetVSGitServices();
var usageTracker = Substitute.For <IUsageTracker>();
var cloneService = new RepositoryCloneService(operatingSystem, vsGitServices, usageTracker);
await cloneService.CloneRepository("https://github.com/foo/bar", "bar", @"c:\dev");
var model = UsageModel.Create(Guid.NewGuid());
await usageTracker.Received().IncrementCounter(
Arg.Is <Expression <Func <UsageModel.MeasuresModel, int> > >(x =>
((MemberExpression)x.Body).Member.Name == nameof(model.Measures.NumberOfClones)));
}
public async Task UpdatesMetricsWhenRepositoryClonedAsync(string cloneUrl, int numberOfCalls, string counterName)
{
var serviceProvider = Substitutes.ServiceProvider;
var operatingSystem = serviceProvider.GetOperatingSystem();
var vsGitServices = serviceProvider.GetVSGitServices();
var graphqlFactory = Substitute.For <IGraphQLClientFactory>();
var usageTracker = Substitute.For <IUsageTracker>();
var cloneService = new RepositoryCloneService(operatingSystem, vsGitServices, graphqlFactory, usageTracker);
await cloneService.CloneRepository(cloneUrl, @"c:\dev\bar");
var model = UsageModel.Create(Guid.NewGuid());
await usageTracker.Received(numberOfCalls).IncrementCounter(
Arg.Is <Expression <Func <UsageModel.MeasuresModel, int> > >(x =>
((MemberExpression)x.Body).Member.Name == counterName));
}
async Task Send()
{
var uri = new Uri("http://localhost:40000");
var server = new MetricsServer.Server(uri.Host, uri.Port);
server.Start();
var client = new HttpClient();
client.DefaultRequestHeaders
.Accept
.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var request = new HttpRequestMessage(HttpMethod.Post, new Uri(uri, "/api/usage/visualstudio"));
var model = UsageModel.Create(Guid.NewGuid());
model.Dimensions.AppVersion = "9.9.9";
model.Dimensions.Lang = "en-us";
model.Dimensions.VSVersion = "14";
model.Measures.NumberOfStartups = 1;
var data = new UsageData();
data.Reports = new List <UsageModel> {
model
};
request.Content = SerializeRequest(model);
HttpResponseMessage response = null;
try
{
response = await client.SendAsync(request);
}
catch (Exception ex)
{
Debugger.Break();
}
var ret = await response.Content.ReadAsStringAsync();
Console.WriteLine(response.ToString());
Console.WriteLine(ret);
server.Stop();
}
public async Task ShouldIncrementCounter()
{
var model = UsageModel.Create(Guid.NewGuid());
model.Measures.NumberOfClones = 4;
var usageService = CreateUsageService(model);
var target = new UsageTracker(
CreateServiceProvider(),
usageService,
CreatePackageSettings());
await target.IncrementCounter(x => x.NumberOfClones);
UsageData result = usageService.ReceivedCalls().First(x => x.GetMethodInfo().Name == "WriteLocalData").GetArguments()[0] as UsageData;
Assert.AreEqual(5, result.Reports[0].Measures.NumberOfClones);
}
public async Task UpdatesMetricsWhenDefaultClonePath(string targetPath, string defaultPath, int numberOfCalls, string counterName)
{
var serviceProvider = Substitutes.ServiceProvider;
var operatingSystem = serviceProvider.GetOperatingSystem();
var vsGitServices = serviceProvider.GetVSGitServices();
var teamExplorerServices = Substitute.For <ITeamExplorerServices>();
vsGitServices.GetLocalClonePathFromGitProvider().Returns(defaultPath);
var graphqlFactory = Substitute.For <IGraphQLClientFactory>();
var usageTracker = Substitute.For <IUsageTracker>();
var cloneService = new RepositoryCloneService(operatingSystem, vsGitServices, teamExplorerServices,
graphqlFactory, usageTracker);
await cloneService.CloneRepository("https://github.com/foo/bar", targetPath);
var model = UsageModel.Create(Guid.NewGuid());
await usageTracker.Received(numberOfCalls).IncrementCounter(
Arg.Is <Expression <Func <UsageModel.MeasuresModel, int> > >(x =>
((MemberExpression)x.Body).Member.Name == counterName));
}
async Task <UsageModel> GetCurrentReport(UsageData data)
{
var current = data.Reports.FirstOrDefault(x => x.Dimensions.Date.Date == DateTimeOffset.Now.Date);
if (current == null)
{
var guid = await service.GetUserGuid();
current = UsageModel.Create(guid);
data.Reports.Add(current);
}
current.Dimensions.Lang = CultureInfo.InstalledUICulture.IetfLanguageTag;
current.Dimensions.CurrentLang = CultureInfo.CurrentCulture.IetfLanguageTag;
current.Dimensions.CurrentUILang = CultureInfo.CurrentUICulture.IetfLanguageTag;
current.Dimensions.AppVersion = ExtensionInformation.Version;
current.Dimensions.VSVersion = vsservices.VSVersion;
current.Dimensions.IsGitHubUser = IsGitHubUser;
current.Dimensions.IsEnterpriseUser = IsEnterpriseUser;
return(current);
}
public async Task InvalidAppVersion()
{
var request = new HttpRequestMessage(HttpMethod.Post, new Uri(uri, "/api/usage/visualstudio"));
var data = new UsageData();
data.Reports = new List <UsageModel> {
UsageModel.Create(Guid.NewGuid())
};
var model = data.Reports[0];
model.Dimensions.AppVersion = "nope";
model.Dimensions.Lang = "en-us";
model.Dimensions.VSVersion = "14";
model.Measures.NumberOfStartups = 1;
request.Content = GitHub.Services.MetricsService.SerializeRequest(model);
HttpResponseMessage response = null;
Assert.DoesNotThrowAsync(async() => response = await client.SendAsync(request));
var ret = await response.Content.ReadAsStringAsync();
Assert.AreEqual(HttpStatusCode.InternalServerError, response.StatusCode);
}
