private void SetupMetricsProviderMember(Mock <IMetricsProvider> metricsProvider, Mock <IMetricsPolicy> metricsPolicy, string contextName,
                                                InterfaceMethodData interfaceMethodData, bool metricEnabled)
        {
            var(metricsCollectorIndicatorType, metricName, measurementUnitName, tags) =
                GetMetricsCollectorIndicatorInfo(interfaceMethodData);

            _output.WriteLine(
                $"Got metrics collector indicator info. ContextName:'{contextName}'. IndicatorType:{metricsCollectorIndicatorType}. MetricName:{metricName}. MeasurementUnitName:{measurementUnitName}. Tags:{tags}. Original method:{interfaceMethodData}");

            metricsPolicy.Setup(_ => _.IsEnabled(contextName, metricName))
            .Returns(metricEnabled).Verifiable();

            if (!metricEnabled)
            {
                return;
            }

            switch (metricsCollectorIndicatorType)
            {
            case MetricsCollectorIndicatorType.Counter:
                var counter = new Mock <ICounter>();
                metricsProvider.Setup(_ => _.CreateCounter(contextName, metricName, measurementUnitName, tags))
                .Returns(counter.Object).Verifiable();
                break;

            case MetricsCollectorIndicatorType.Gauge:
                var gauge = new Mock <IGauge>();
                metricsProvider.Setup(_ => _.CreateGauge(contextName, metricName, measurementUnitName, tags))
                .Returns(gauge.Object).Verifiable();
                break;

            case MetricsCollectorIndicatorType.HitPercentageGauge:
                var hitPercentageGauge = new Mock <IHitPercentageGauge>();
                metricsProvider.Setup(_ => _.CreateHitPercentageGauge(contextName, metricName, measurementUnitName, tags))
                .Returns(hitPercentageGauge.Object).Verifiable();
                break;

            case MetricsCollectorIndicatorType.Timer:
                var timer = new Mock <ITimer>();
                metricsProvider.Setup(_ => _.CreateTimer(contextName, metricName, measurementUnitName, tags))
                .Returns(timer.Object).Verifiable();
                break;

            case MetricsCollectorIndicatorType.Meter:
                var meter = new Mock <IMeter>();
                metricsProvider.Setup(_ => _.CreateMeter(contextName, metricName, measurementUnitName, tags))
                .Returns(meter.Object).Verifiable();
                break;

            case MetricsCollectorIndicatorType.Histogram:
                var histogram = new Mock <IHistogram>();
                metricsProvider.Setup(_ => _.CreateHistogram(contextName, metricName, measurementUnitName, tags))
                .Returns(histogram.Object).Verifiable();
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(metricsCollectorIndicatorType), metricsCollectorIndicatorType,
                                                      null);
            }
        }
示例#2
0
        private static InterfaceData GetInheritedInterfaceData(int index, ITestContext context)
        {
            var methods = InterfaceMethodData.GetPossibleVariations(context.Options).ToList()
                          .GetPossibleCombinations(context.Options.InterfaceMethodsCounts.Max()).First().Select(_ => _.Invoke(context))
                          .ToArray();

            return(new InterfaceData("ITestInheritedInterface" + index, "TestNamespaceForITestInheritedInterface" + index, Array.Empty <AttributeData>(), methods, Array.Empty <InterfaceData>(), false));
        }
                        measurementUnitName, Tags tags) GetMetricsCollectorIndicatorInfo(InterfaceMethodData interfaceMethodData)
        {
            var metricsCollectorIndicatorTypeString = interfaceMethodData.ReturnType.Name.TrimStart('I').Replace("<TInterfaceParam1, TInterfaceParam2>", "`2");

            if (!Enum.TryParse <MetricsCollectorIndicatorType>(metricsCollectorIndicatorTypeString, true,
                                                               out var metricsCollectorIndicatorType))
            {
                throw new Exception($"Illegal return type:'{interfaceMethodData.ReturnType}'");
            }

            string metricName;
            string measurementUnitName = null;
            var    metricsCollectorMethodAttributeData = interfaceMethodData.AttributeDataList
                                                         .OfType <MetricsCollectorMethodAttributeData>().FirstOrDefault();

            if (metricsCollectorMethodAttributeData == null)
            {
                metricName = interfaceMethodData.Name;
            }
            else
            {
                metricName          = metricsCollectorMethodAttributeData.IsMetricNameDefined ? metricsCollectorMethodAttributeData.MetricName : interfaceMethodData.Name;
                measurementUnitName = metricsCollectorMethodAttributeData.MeasurementUnitName;
            }

            Tags tags;

            if (!interfaceMethodData.Parameters.Any())
            {
                tags = Tags.Empty;
            }
            else if (interfaceMethodData.Parameters.Length == 1)
            {
                tags = new Tags(interfaceMethodData.Parameters[0].Name, interfaceMethodData.Parameters[0].Value.ToString());
            }
            else
            {
                tags = new Tags(interfaceMethodData.Parameters.Select(_ => _.Name).ToArray(),
                                interfaceMethodData.Parameters.Select(_ => _.Value?.ToString()).ToArray());
            }

            return(metricsCollectorIndicatorType, metricName, measurementUnitName, tags);
        }