function initTemplateSrv(values: any, multi = false) {
  const templateSrv = new TemplateSrv();
  templateSrv.init([
    new CustomVariable(
      {
        name: 'test',
        current: {
          value: values,
        },
        multi: multi,
      },
      {}
    ),
  ]);
  return templateSrv;
}

 getEc2InstanceAttribute(region, attributeName, filters) {
   return this.doMetricQueryRequest('ec2_instance_attribute', {
     region: this.templateSrv.replace(this.getActualRegion(region)),
     attributeName: this.templateSrv.replace(attributeName),
     filters: filters,
   });
 }

 getResourceARNs(region, resourceType, tags) {
   return this.doMetricQueryRequest('resource_arns', {
     region: this.templateSrv.replace(this.getActualRegion(region)),
     resourceType: this.templateSrv.replace(resourceType),
     tags: tags,
   });
 }

    }).map(target => {
      const item = target.azureLogAnalytics;

      const querystringBuilder = new LogAnalyticsQuerystringBuilder(
        this.templateSrv.replace(item.query, options.scopedVars, this.interpolateVariable),
        options,
        'TimeGenerated'
      );
      const generated = querystringBuilder.generate();

      const workspace = this.templateSrv.replace(item.workspace, options.scopedVars);

      const url = `${this.baseUrl}/${workspace}/query?${generated.uriString}`;

      return {
        refId: target.refId,
        intervalMs: options.intervalMs,
        maxDataPoints: options.maxDataPoints,
        datasourceId: this.id,
        url: url,
        query: generated.rawQuery,
        format: target.format,
        resultFormat: item.resultFormat,
      };
    });

 getDimensionValues(region, namespace, metricName, dimensionKey, filterDimensions) {
   return this.doMetricQueryRequest('dimension_values', {
     region: this.templateSrv.replace(this.getActualRegion(region)),
     namespace: this.templateSrv.replace(namespace),
     metricName: this.templateSrv.replace(metricName),
     dimensionKey: this.templateSrv.replace(dimensionKey),
     dimensions: this.convertDimensionFormat(filterDimensions, {}),
   });
 }

 targetContainsTemplate(target) {
   return (
     this.templateSrv.variableExists(target.region) ||
     this.templateSrv.variableExists(target.namespace) ||
     this.templateSrv.variableExists(target.metricName) ||
     _.find(target.dimensions, (v, k) => {
       return this.templateSrv.variableExists(k) || this.templateSrv.variableExists(v);
     })
   );
 }

  init(dashboard: DashboardModel) {
    this.dashboard = dashboard;
    this.dashboard.events.on('time-range-updated', this.onTimeRangeUpdated.bind(this));
    this.dashboard.events.on('template-variable-value-updated', this.updateUrlParamsWithCurrentVariables.bind(this));

    // create working class models representing variables
    this.variables = dashboard.templating.list = dashboard.templating.list.map(this.createVariableFromModel.bind(this));
    this.templateSrv.init(this.variables, this.timeSrv.timeRange());

    // init variables
    for (const variable of this.variables) {
      variable.initLock = this.$q.defer();
    }

    const queryParams = this.$location.search();
    return this.$q
      .all(
        this.variables.map(variable => {
          return this.processVariable(variable, queryParams);
        })
      )
      .then(() => {
        this.templateSrv.updateIndex();
      });
  }

 .map(t => {
   return {
     refId: t.refId,
     intervalMs: options.intervalMs,
     datasourceId: this.id,
     metricType: this.templateSrv.replace(t.metricType, options.scopedVars || {}),
     crossSeriesReducer: this.templateSrv.replace(t.crossSeriesReducer || 'REDUCE_MEAN', options.scopedVars || {}),
     perSeriesAligner: this.templateSrv.replace(t.perSeriesAligner, options.scopedVars || {}),
     alignmentPeriod: this.templateSrv.replace(t.alignmentPeriod, options.scopedVars || {}),
     groupBys: this.interpolateGroupBys(t.groupBys, options.scopedVars),
     view: t.view || 'FULL',
     filters: this.interpolateFilters(t.filters, options.scopedVars),
     aliasBy: this.templateSrv.replace(t.aliasBy, options.scopedVars || {}),
     type: 'timeSeriesQuery',
   };
 });

  annotationQuery(options) {
    const annotation = options.annotation;
    const statistics = _.map(annotation.statistics, s => {
      return this.templateSrv.replace(s);
    });
    const defaultPeriod = annotation.prefixMatching ? '' : '300';
    let period = annotation.period || defaultPeriod;
    period = parseInt(period, 10);
    const parameters = {
      prefixMatching: annotation.prefixMatching,
      region: this.templateSrv.replace(this.getActualRegion(annotation.region)),
      namespace: this.templateSrv.replace(annotation.namespace),
      metricName: this.templateSrv.replace(annotation.metricName),
      dimensions: this.convertDimensionFormat(annotation.dimensions, {}),
      statistics: statistics,
      period: period,
      actionPrefix: annotation.actionPrefix || '',
      alarmNamePrefix: annotation.alarmNamePrefix || '',
    };

    return this.awsRequest('/api/tsdb/query', {
      from: options.range.from.valueOf().toString(),
      to: options.range.to.valueOf().toString(),
      queries: [
        _.extend(
          {
            refId: 'annotationQuery',
            intervalMs: 1, // dummy
            maxDataPoints: 1, // dummy
            datasourceId: this.instanceSettings.id,
            type: 'annotationQuery',
          },
          parameters
        ),
      ],
    }).then(r => {
      return _.map(r.results['annotationQuery'].tables[0].rows, v => {
        return {
          annotation: annotation,
          time: Date.parse(v[0]),
          title: v[1],
          tags: [v[2]],
          text: v[3],
        };
      });
    });
  }