private TypeScriptAnalyzer CreateTestSubject(
IEslintBridgeAnalyzer eslintBridgeAnalyzer = null,
ITsConfigProvider tsConfigProvider = null,
IRulesProvider rulesProvider = null,
IAnalysisStatusNotifier statusNotifier = null,
ITelemetryManager telemetryManager = null,
ILogger logger = null)
{
statusNotifier ??= Mock.Of <IAnalysisStatusNotifier>();
rulesProvider ??= Mock.Of <IRulesProvider>();
logger ??= Mock.Of <ILogger>();
tsConfigProvider ??= SetupTsConfigProvider();
eslintBridgeAnalyzer ??= Mock.Of <IEslintBridgeAnalyzer>();
telemetryManager ??= Mock.Of <ITelemetryManager>();
var rulesProviderFactory = new Mock <IRulesProviderFactory>();
rulesProviderFactory.Setup(x => x.Create("typescript")).Returns(rulesProvider);
var eslintBridgeClient = Mock.Of <ITypeScriptEslintBridgeClient>();
var eslintBridgeAnalyzerFactory = new Mock <IEslintBridgeAnalyzerFactory>();
eslintBridgeAnalyzerFactory
.Setup(x => x.Create(rulesProvider, eslintBridgeClient))
.Returns(eslintBridgeAnalyzer);
return(new TypeScriptAnalyzer(eslintBridgeClient,
rulesProviderFactory.Object,
tsConfigProvider,
statusNotifier,
eslintBridgeAnalyzerFactory.Object,
telemetryManager,
logger));
}
public CLangAnalyzer(ITelemetryManager telemetryManager, ISonarLintSettings settings, ICFamilyRulesConfigProvider cFamilyRulesConfigProvider, ILogger logger)
{
this.telemetryManager = telemetryManager;
this.settings = settings;
this.cFamilyRulesConfigProvider = cFamilyRulesConfigProvider;
this.logger = logger;
}
private JavaScriptAnalyzer CreateTestSubject(
IEslintBridgeAnalyzer eslintBridgeAnalyzer = null,
IRulesProvider rulesProvider = null,
ITelemetryManager telemetryManager = null,
IAnalysisStatusNotifier statusNotifier = null)
{
telemetryManager ??= Mock.Of <ITelemetryManager>();
statusNotifier ??= Mock.Of <IAnalysisStatusNotifier>();
rulesProvider ??= Mock.Of <IRulesProvider>();
var rulesProviderFactory = new Mock <IRulesProviderFactory>();
rulesProviderFactory.Setup(x => x.Create("javascript")).Returns(rulesProvider);
var eslintBridgeClient = Mock.Of <IJavaScriptEslintBridgeClient>();
var eslintBridgeAnalyzerFactory = new Mock <IEslintBridgeAnalyzerFactory>();
eslintBridgeAnalyzerFactory
.Setup(x => x.Create(rulesProvider, eslintBridgeClient))
.Returns(eslintBridgeAnalyzer);
return(new JavaScriptAnalyzer(eslintBridgeClient,
rulesProviderFactory.Object,
telemetryManager,
statusNotifier,
eslintBridgeAnalyzerFactory.Object));
}
public OpenInIDERequestHandler(
IIDEWindowService ideWindowService,
IToolWindowService toolWindowService,
IOpenInIDEStateValidator ideStateValidator,
ISonarQubeService sonarQubeService,
IHotspotToIssueVisualizationConverter converter,
ILocationNavigator navigator,
IHotspotsStore hotspotsStore,
IOpenInIDEFailureInfoBar failureInfoBar,
IIssueSelectionService issueSelectionService,
ITelemetryManager telemetryManager,
ILogger logger)
{
// MEF-created so the arguments should never be null
this.ideWindowService = ideWindowService;
this.toolWindowService = toolWindowService;
this.ideStateValidator = ideStateValidator;
this.sonarQubeService = sonarQubeService;
this.converter = converter;
this.navigator = navigator;
this.hotspotsStore = hotspotsStore;
this.failureInfoBar = failureInfoBar;
this.issueSelectionService = issueSelectionService;
this.telemetryManager = telemetryManager;
this.logger = logger;
}
private async System.Threading.Tasks.Task InitOnUIThreadAsync()
{
Debug.Assert(ThreadHelper.CheckAccess(), "Expecting to be on the UI thread");
var logger = await this.GetMefServiceAsync <ILogger>();
// HACK: the telemetry manager has to be imported on the UI thread because
// of a complicated chain of transitive dependencies:
// TelemetryManager -> IActiveSolutionBoundTracker -> IBindingConfiguration -> IHost.
// The host expects to be initialized on the UI thread.
// The ui and non-ui parts of the host should be split into separate classes.
try
{
logger.WriteLine(Resources.Strings.Telemetry_Initializing);
telemetryManager = await this.GetMefServiceAsync <ITelemetryManager>();
logger.WriteLine(Resources.Strings.Telemetry_InitializationComplete);
if (await IsSolutionFullyOpenedAsync())
{
telemetryManager.Update();
}
}
catch (Exception ex) when(!ErrorHandler.IsCriticalException(ex))
{
// Suppress non-critical exceptions
logger.WriteLine(Resources.Strings.Telemetry_ERROR, ex.Message);
}
}
public /* public for test */ InstanceDiscoveryManager(
IHttpManager httpManager,
ITelemetryManager telemetryManager,
bool shouldClearCaches,
IUserMetadataProvider userMetadataProvider = null,
Uri userProvidedInstanceDiscoveryUri = null,
IKnownMetadataProvider knownMetadataProvider = null,
INetworkCacheMetadataProvider networkCacheMetadataProvider = null,
INetworkMetadataProvider networkMetadataProvider = null)
{
_httpManager = httpManager ?? throw new ArgumentNullException(nameof(httpManager));
_telemetryManager = telemetryManager ?? throw new ArgumentNullException(nameof(telemetryManager));
_userMetadataProvider = userMetadataProvider;
_knownMetadataProvider = knownMetadataProvider ?? new KnownMetadataProvider();
_networkCacheMetadataProvider = networkCacheMetadataProvider ?? new NetworkCacheMetadataProvider();
_networkMetadataProvider = networkMetadataProvider ??
new NetworkMetadataProvider(
_httpManager,
_telemetryManager,
_networkCacheMetadataProvider,
userProvidedInstanceDiscoveryUri);
if (shouldClearCaches)
{
_networkCacheMetadataProvider.Clear();
}
}
private JavaScriptAnalyzer CreateTestSubject(
IEslintBridgeProcess eslintBridgeProcess,
IEslintBridgeClientFactory eslintBridgeClientFactory = null,
IActiveJavaScriptRulesProvider activeRulesProvider = null,
IEslintBridgeIssueConverter issueConverter = null,
ITelemetryManager telemetryManager = null,
IAnalysisStatusNotifier statusNotifier = null,
IActiveSolutionTracker activeSolutionTracker = null,
IAnalysisConfigMonitor analysisConfigMonitor = null,
ILogger logger = null)
{
issueConverter ??= Mock.Of <IEslintBridgeIssueConverter>();
logger ??= Mock.Of <ILogger>();
telemetryManager ??= Mock.Of <ITelemetryManager>();
statusNotifier ??= Mock.Of <IAnalysisStatusNotifier>();
activeRulesProvider ??= Mock.Of <IActiveJavaScriptRulesProvider>();
activeSolutionTracker ??= Mock.Of <IActiveSolutionTracker>();
analysisConfigMonitor ??= Mock.Of <IAnalysisConfigMonitor>();
return(new JavaScriptAnalyzer(eslintBridgeClientFactory,
eslintBridgeProcess,
activeRulesProvider,
issueConverter,
telemetryManager,
statusNotifier,
activeSolutionTracker,
analysisConfigMonitor,
logger));
}
private static TaintIssuesControlViewModel CreateTestSubject(
IAnalysisIssueVisualization[] issueVizs = null,
ILocationNavigator locationNavigator = null,
Mock <ITaintStore> store = null,
IActiveDocumentTracker activeDocumentTracker = null,
IActiveDocumentLocator activeDocumentLocator = null,
ITelemetryManager telemetryManager = null,
IShowInBrowserService showInBrowserService = null,
IIssueSelectionService selectionService = null)
{
issueVizs ??= Array.Empty <IAnalysisIssueVisualization>();
store ??= new Mock <ITaintStore>();
store.Setup(x => x.GetAll()).Returns(issueVizs);
activeDocumentTracker ??= Mock.Of <IActiveDocumentTracker>();
activeDocumentLocator ??= Mock.Of <IActiveDocumentLocator>();
showInBrowserService ??= Mock.Of <IShowInBrowserService>();
locationNavigator ??= Mock.Of <ILocationNavigator>();
telemetryManager ??= Mock.Of <ITelemetryManager>();
selectionService ??= Mock.Of <IIssueSelectionService>();
return(new TaintIssuesControlViewModel(store.Object,
locationNavigator,
activeDocumentTracker,
activeDocumentLocator,
showInBrowserService,
telemetryManager,
selectionService));
}
public TestProvider(IEditorContext editorContext, ITestAdapterRepository testAdapterRepository, IOptions options, ITelemetryManager telemetryManager)
{
_editorContext = editorContext;
_testAdapterRepository = testAdapterRepository;
_options = options;
_telemetryManager = telemetryManager;
}
protected override void Initialize()
{
base.Initialize();
this.telemetryManager = this.GetMefService <ITelemetryManager>();
Debug.Assert(this.telemetryManager != null, "Cannot find the telemetry manager.");
}
static TelemetryHelper()
{
Provider = new AppInsightsTelemetryProvider(ConfigHelper.ApplicationInsightsKey);
TelemetryManager = new TelemetryManager(
Provider,
CreateGlobalProperties());
}
public AxoTestRunner(IEditorContext editorContext, IStorageController storageController, IOptions options, ITelemetryManager telemetryManager, ITestAdapterRepository testAdapterRepository)
{
_editorContext = editorContext;
_storageController = storageController;
_options = options;
_telemetryManager = telemetryManager;
_testAdapterRepository = testAdapterRepository;
}
public TelemetryHelper(
ITelemetryManager telemetryManager,
EventBase eventBase)
{
_telemetryManager = telemetryManager;
_eventToEnd = eventBase;
_telemetryManager?.StartEvent(eventBase);
}
public AadInstanceDiscovery(IHttpManager httpManager, ITelemetryManager telemetryManager, bool shouldClearCache = true)
{
_httpManager = httpManager;
_telemetryManager = telemetryManager;
if (shouldClearCache)
{
_cache.Clear();
}
}
public CacheSessionManager(
ITokenCacheInternal tokenCacheInternal,
AuthenticationRequestParameters requestParams,
ITelemetryManager telemetryManager)
{
TokenCacheInternal = tokenCacheInternal;
_requestParams = requestParams ?? throw new ArgumentNullException(nameof(requestParams));
_telemetryManager = telemetryManager ?? throw new ArgumentNullException(nameof(telemetryManager));
}
public NetworkMetadataProvider(
IHttpManager httpManager,
ITelemetryManager telemetryManager,
INetworkCacheMetadataProvider networkCacheMetadataProvider)
{
_httpManager = httpManager;
_telemetryManager = telemetryManager;
_networkCacheMetadataProvider = networkCacheMetadataProvider;
}
public CoverageProvider(ITestProvider testProvider, ITestRunner testRunner, ITelemetryManager telemetryManager, IEditorContext editorContext)
{
_testRunner = testRunner;
_telemetryManager = telemetryManager;
_testRunner.TestsFinished += OnTestsFinished;
_editorContext = editorContext;
_editorContext.SolutionClosing += OnSolutionClosing;
}
public CLangAnalyzer(ITelemetryManager telemetryManager, ISonarLintSettings settings, ICFamilyRulesConfigProvider cFamilyRulesConfigProvider, [Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider, IAnalysisStatusNotifier analysisStatusNotifier, ILogger logger, ICFamilyIssueToAnalysisIssueConverter issueConverter)
{
this.telemetryManager = telemetryManager;
this.settings = settings;
this.cFamilyRulesConfigProvider = cFamilyRulesConfigProvider;
this.analysisStatusNotifier = analysisStatusNotifier;
this.logger = logger;
this.issueConverter = issueConverter;
this.dte = serviceProvider.GetService <DTE>();
}
public void TestInitialize()
{
TestCommon.ResetStateAndInitMsal();
_cache = new TokenCache();
_telemetryManager = new TelemetryManager(_myReceiver);
new AadInstanceDiscovery(null, _telemetryManager, true);
new ValidatedAuthoritiesCache(true);
CreateSecureString();
}
private readonly Uri _userProvidedInstanceDiscoveryUri; // can be null
public NetworkMetadataProvider(
IHttpManager httpManager,
ITelemetryManager telemetryManager,
INetworkCacheMetadataProvider networkCacheMetadataProvider,
Uri userProvidedInstanceDiscoveryUri = null)
{
_httpManager = httpManager ?? throw new ArgumentNullException(nameof(httpManager));
_telemetryManager = telemetryManager ?? throw new ArgumentNullException(nameof(telemetryManager));
_networkCacheMetadataProvider = networkCacheMetadataProvider ?? throw new ArgumentNullException(nameof(networkCacheMetadataProvider));
_userProvidedInstanceDiscoveryUri = userProvidedInstanceDiscoveryUri; // can be null
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (!disposing)
{
return;
}
(telemetryManager as IDisposable)?.Dispose();
telemetryManager = null;
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (!disposing)
{
return;
}
this.telemetryManager?.Dispose();
this.telemetryManager = null;
}
public JavaScriptAnalyzer(IJavaScriptEslintBridgeClient eslintBridgeClient,
IRulesProviderFactory rulesProviderFactory,
ITelemetryManager telemetryManager,
IAnalysisStatusNotifier analysisStatusNotifier,
IEslintBridgeAnalyzerFactory eslintBridgeAnalyzerFactory)
{
this.telemetryManager = telemetryManager;
this.analysisStatusNotifier = analysisStatusNotifier;
var rulesProvider = rulesProviderFactory.Create("javascript");
eslintBridgeAnalyzer = eslintBridgeAnalyzerFactory.Create(rulesProvider, eslintBridgeClient);
}
public InstanceDiscoveryManager(
IHttpManager httpManager,
ITelemetryManager telemetryManager,
bool /* for test */ shouldClearCaches,
InstanceDiscoveryResponse userProviderInstanceDiscoveryResponse) :
this(
httpManager,
telemetryManager,
shouldClearCaches,
userProviderInstanceDiscoveryResponse != null ? new UserMetadataProvider(userProviderInstanceDiscoveryResponse) : null,
null, null, null)
{
}
public static IAssessmentContext GetEnvironmentContext(
ITelemetryManager telemetryManager,
ParsedUsageReport usageReport)
{
return(new AssessmentContext(
usageReport: usageReport,
subscriptionNames: null,
subscriptionIds: null,
resourceGroupNames: null,
accessToken: null,
armBaseUri: null,
resourceCachePath: null,
configManager: GetConfigManager(),
telemetryManager: telemetryManager));
}
public static IAssessmentContext GetEnvironmentContext(
ITelemetryManager telemetryManager,
string accessToken,
string armBaseUri,
string subscriptionId = null)
{
return(new AssessmentContext(
usageReport: null,
subscriptionNames: null,
subscriptionIds: subscriptionId == null ? null : new[] { subscriptionId },
resourceGroupNames: null,
accessToken: accessToken,
armBaseUri: armBaseUri,
resourceCachePath: null,
configManager: GetConfigManager(),
telemetryManager: telemetryManager));
}
public TypeScriptAnalyzer(ITypeScriptEslintBridgeClient eslintBridgeClient,
IRulesProviderFactory rulesProviderFactory,
ITsConfigProvider tsConfigProvider,
IAnalysisStatusNotifier analysisStatusNotifier,
IEslintBridgeAnalyzerFactory eslintBridgeAnalyzerFactory,
ITelemetryManager telemetryManager,
ILogger logger)
{
this.tsConfigProvider = tsConfigProvider;
this.analysisStatusNotifier = analysisStatusNotifier;
this.telemetryManager = telemetryManager;
this.logger = logger;
var rulesProvider = rulesProviderFactory.Create("typescript");
eslintBridgeAnalyzer = eslintBridgeAnalyzerFactory.Create(rulesProvider, eslintBridgeClient);
}
internal PublicClientApplication(
IHttpManager httpManager,
IStorageManager storageManager,
IBrowserFactory browserFactory,
IGuidService guidService,
ITelemetryManager telemetryManager,
EnvironmentMetadata environmentMetadata,
MsalClientConfiguration msalClientConfiguration)
{
_platformProxy = PlatformProxyFactory.GetPlatformProxy();
_httpManager = httpManager ?? new HttpManager(new HttpClientFactory(), msalClientConfiguration);
_storageManager = storageManager ?? _platformProxy.CreateStorageManager();
_browserFactory = browserFactory ?? _platformProxy.CreateBrowserFactory();
_guidService = guidService ?? new GuidService();
_telemetryManager = telemetryManager ?? new TelemetryManager(msalClientConfiguration);
_environmentMetadata = environmentMetadata ?? new EnvironmentMetadata();
_msalClientConfiguration = msalClientConfiguration;
}
private OtherOptionsDialogPageTestable CreateTestSubject(ITelemetryManager telemetryManager)
{
var testSubject = new OtherOptionsDialogPageTestable();
// The telemetry manager is a MEF component, so the page obtains it by
// using the "Site" property as service provider to get the IComponentModel MEF service.
// The MEF service then returns the telemetry manager.
Mock <ISite> mockSite = new Mock <ISite>();
Mock <IComponentModel> mockMefHost = new Mock <IComponentModel>();
mockMefHost.Setup(m => m.GetExtensions <ITelemetryManager>()).Returns(new[] { telemetryManager });
mockSite.As <IServiceProvider>().Setup(m => m.GetService(It.Is <Type>(t => t == typeof(SComponentModel)))).Returns(mockMefHost.Object);
mockSite.Object.GetMefService <ITelemetryManager>().Should().NotBeNull(); // sanity check of the test setup
testSubject.Site = mockSite.Object;
return(testSubject);
}
public JavaScriptAnalyzer(IEslintBridgeClientFactory eslintBridgeClientFactory,
IEslintBridgeProcess eslintBridgeProcess,
IJavaScriptRuleKeyMapper keyMapper,
IJavaScriptRuleDefinitionsProvider ruleDefinitionsProvider,
IActiveJavaScriptRulesProvider activeRulesProvider,
ITelemetryManager telemetryManager,
IAnalysisStatusNotifier analysisStatusNotifier,
IActiveSolutionTracker activeSolutionTracker,
IAnalysisConfigMonitor analysisConfigMonitor,
ILogger logger)
: this(eslintBridgeClientFactory, eslintBridgeProcess, activeRulesProvider,
new EslintBridgeIssueConverter(keyMapper.GetSonarRuleKey,
ruleDefinitionsProvider.GetDefinitions),
telemetryManager,
analysisStatusNotifier,
activeSolutionTracker,
analysisConfigMonitor,
logger)
{
}
public static void Init(ITelemetryManager platform)
{
_platformTelemetryManager = platform;
}
