Chore: Removes observableTester (#29369)

b904e0c6 · Hugo Häggmark · GitHub · 465735a7 · b904e0c6 · 465735a7
Commit b904e0c6 authored Nov 26, 2020 by Hugo Häggmark Committed by GitHub Nov 26, 2020
10 changed files
--- a/packages/grafana-data/src/utils/index.ts
+++ b/packages/grafana-data/src/utils/index.ts
@@ -17,4 +17,3 @@ export { locationUtil } from './location';
 export { urlUtil, UrlQueryMap, UrlQueryValue } from './url';
 export { DataLinkBuiltInVars, mapInternalLinkToExplore } from './dataLinks';
 export { DocsId } from './docs';
-export { observableTester } from './tests/observableTester';
--- a/packages/grafana-data/src/utils/tests/observableTester.ts
+++ b/packages/grafana-data/src/utils/tests/observableTester.ts
-import { Observable } from 'rxjs';
-interface ObservableTester<T> {
-  observable: Observable<T>;
-  done: {
-    (...args: any[]): any;
-    fail(error?: string | { message: string }): any;
-  };
-}
-interface SubscribeAndExpectOnNext<T> extends ObservableTester<T> {
-  expect: (value: T) => void;
-}
-interface SubscribeAndExpectOnNextAndComplete<T> extends ObservableTester<T> {
-  expectOnNext: (value: T) => void;
-  expectOnComplete: () => void;
-}
-interface SubscribeAndExpectOnComplete<T> extends ObservableTester<T> {
-  expect: () => void;
-}
-interface SubscribeAndExpectOnError<T> extends ObservableTester<T> {
-  expect: (err: any) => void;
-}
-export const observableTester = () => {
-  const subscribeAndExpectOnNext = <T>({ observable, expect, done }: SubscribeAndExpectOnNext<T>): void => {
-    observable.subscribe({
-      next: value => {
-        try {
-          expect(value);
-        } catch (err) {
-          done.fail(err);
-        }
-      },
-      error: err => done.fail(err),
-      complete: () => done(),
-    });
-  };
-  const subscribeAndExpectOnComplete = <T>({ observable, expect, done }: SubscribeAndExpectOnComplete<T>): void => {
-    observable.subscribe({
-      next: () => {},
-      error: err => done.fail(err),
-      complete: () => {
-        try {
-          expect();
-          done();
-        } catch (err) {
-          done.fail(err);
-        }
-      },
-    });
-  };
-  const subscribeAndExpectOnNextAndComplete = <T>({
-    observable,
-    expectOnComplete,
-    expectOnNext,
-    done,
-  }: SubscribeAndExpectOnNextAndComplete<T>): void => {
-    observable.subscribe({
-      next: (value: T) => {
-        try {
-          expectOnNext(value);
-          done();
-        } catch (err) {
-          done.fail(err);
-        }
-      },
-      error: err => done.fail(err),
-      complete: () => {
-        try {
-          expectOnComplete();
-          done();
-        } catch (err) {
-          done.fail(err);
-        }
-      },
-    });
-  };
-  const subscribeAndExpectOnError = <T>({ observable, expect, done }: SubscribeAndExpectOnError<T>): void => {
-    observable.subscribe({
-      next: () => {},
-      error: err => {
-        try {
-          expect(err);
-          done();
-        } catch (err) {
-          done.fail(err);
-        }
-      },
-      complete: () => {
-        done();
-      },
-    });
-  };
-  return {
-    subscribeAndExpectOnNext,
-    subscribeAndExpectOnComplete,
-    subscribeAndExpectOnNextAndComplete,
-    subscribeAndExpectOnError,
-  };
-};
--- a/public/app/features/variables/query/operators.test.ts
+++ b/public/app/features/variables/query/operators.test.ts
 import { of } from 'rxjs';
 import { queryBuilder } from '../shared/testing/builders';
-import { FieldType, observableTester, toDataFrame } from '@grafana/data';
+import { FieldType, toDataFrame } from '@grafana/data';
 import { initialQueryVariableModelState, updateVariableOptions, updateVariableTags } from './reducer';
 import { toVariablePayload } from '../state/types';
 import { VariableRefresh } from '../types';
@@ -14,24 +14,22 @@ import {
 } from './operators';
 describe('operators', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
  describe('validateVariableSelection', () => {
    describe('when called', () => {
-      it('then the correct observable should be created', done => {
+      it('then the correct observable should be created', async () => {
        const variable = queryBuilder()
          .withId('query')
          .build();
        const dispatch = jest.fn().mockResolvedValue({});
-        const observable = of(undefined).pipe(
+        const observable = of(undefined).pipe(validateVariableSelection({ variable, dispatch }));
-          validateVariableSelection({ variable, dispatch, searchFilter: 'A search filter' })
-        );
-        observableTester().subscribeAndExpectOnNext({
+        await expect(observable).toEmitValuesWith(received => {
-          observable,
+          expect(received[0]).toEqual({});
-          expect: value => {
-            expect(value).toEqual({});
          expect(dispatch).toHaveBeenCalledTimes(1);
-          },
-          done,
        });
      });
    });
@@ -39,7 +37,7 @@ describe('operators', () => {
  describe('updateTagsState', () => {
    describe('when called with a variable that uses Tags', () => {
-      it('then the correct observable should be created', done => {
+      it('then the correct observable should be created', async () => {
        const variable = queryBuilder()
          .withId('query')
          .withTags(true)
@@ -47,22 +45,17 @@ describe('operators', () => {
        const dispatch = jest.fn().mockResolvedValue({});
        const observable = of([{ text: 'A text' }]).pipe(updateTagsState({ variable, dispatch }));
-        observableTester().subscribeAndExpectOnNext({
+        await expect(observable).toEmitValuesWith(received => {
-          observable,
+          const value = received[0];
-          expect: value => {
          expect(value).toEqual(undefined);
          expect(dispatch).toHaveBeenCalledTimes(1);
-            expect(dispatch).toHaveBeenCalledWith(
+          expect(dispatch).toHaveBeenCalledWith(updateVariableTags(toVariablePayload(variable, [{ text: 'A text' }])));
-              updateVariableTags(toVariablePayload(variable, [{ text: 'A text' }]))
-            );
-          },
-          done,
        });
      });
    });
    describe('when called with a variable that does not use Tags', () => {
-      it('then the correct observable should be created', done => {
+      it('then the correct observable should be created', async () => {
        const variable = queryBuilder()
          .withId('query')
          .withTags(false)
@@ -70,13 +63,10 @@ describe('operators', () => {
        const dispatch = jest.fn().mockResolvedValue({});
        const observable = of([{ text: 'A text' }]).pipe(updateTagsState({ variable, dispatch }));
-        observableTester().subscribeAndExpectOnNext({
+        await expect(observable).toEmitValuesWith(received => {
-          observable,
+          const value = received[0];
-          expect: value => {
          expect(value).toEqual(undefined);
          expect(dispatch).not.toHaveBeenCalled();
-          },
-          done,
        });
      });
    });
@@ -84,7 +74,7 @@ describe('operators', () => {
  describe('runUpdateTagsRequest', () => {
    describe('when called with a datasource with metricFindQuery and variable that uses Tags and refreshes on time range changes', () => {
-      it('then the correct observable should be created', done => {
+      it('then the correct observable should be created', async () => {
        const variable = queryBuilder()
          .withId('query')
          .withTags(true)
@@ -98,9 +88,8 @@ describe('operators', () => {
        const searchFilter = 'A search filter';
        const observable = of(undefined).pipe(runUpdateTagsRequest({ variable, datasource, searchFilter }, timeSrv));
-        observableTester().subscribeAndExpectOnNext({
+        await expect(observable).toEmitValuesWith(received => {
-          observable,
+          const value = received[0];
-          expect: value => {
          const { index, global, ...rest } = initialQueryVariableModelState;
          expect(value).toEqual([{ text: 'A text' }]);
          expect(timeSrv.timeRange).toHaveBeenCalledTimes(1);
@@ -117,14 +106,12 @@ describe('operators', () => {
              refresh: VariableRefresh.onTimeRangeChanged,
            },
          });
-          },
-          done,
        });
      });
    });
    describe('when called with a datasource without metricFindQuery and variable that uses Tags and refreshes on time range changes', () => {
-      it('then the correct observable should be created', done => {
+      it('then the correct observable should be created', async () => {
        const variable = queryBuilder()
          .withId('query')
          .withTags(true)
@@ -138,19 +125,16 @@ describe('operators', () => {
        const searchFilter = 'A search filter';
        const observable = of(undefined).pipe(runUpdateTagsRequest({ variable, datasource, searchFilter }, timeSrv));
-        observableTester().subscribeAndExpectOnNext({
+        await expect(observable).toEmitValuesWith(received => {
-          observable,
+          const value = received[0];
-          expect: value => {
          expect(value).toEqual([]);
          expect(timeSrv.timeRange).not.toHaveBeenCalled();
-          },
-          done,
        });
      });
    });
    describe('when called with a datasource with metricFindQuery and variable that does not use Tags but refreshes on time range changes', () => {
-      it('then the correct observable should be created', done => {
+      it('then the correct observable should be created', async () => {
        const variable = queryBuilder()
          .withId('query')
          .withTags(false)
@@ -163,14 +147,11 @@ describe('operators', () => {
        const searchFilter = 'A search filter';
        const observable = of(undefined).pipe(runUpdateTagsRequest({ variable, datasource, searchFilter }, timeSrv));
-        observableTester().subscribeAndExpectOnNext({
+        await expect(observable).toEmitValuesWith(received => {
-          observable,
+          const value = received[0];
-          expect: value => {
          expect(value).toEqual([]);
          expect(timeSrv.timeRange).not.toHaveBeenCalled();
          expect(datasource.metricFindQuery).not.toHaveBeenCalled();
-          },
-          done,
        });
      });
    });
@@ -178,7 +159,7 @@ describe('operators', () => {
  describe('updateOptionsState', () => {
    describe('when called', () => {
-      it('then the correct observable should be created', done => {
+      it('then the correct observable should be created', async () => {
        const variable = queryBuilder()
          .withId('query')
          .build();
@@ -187,9 +168,8 @@ describe('operators', () => {
        const observable = of([{ text: 'A' }]).pipe(updateOptionsState({ variable, dispatch, getTemplatedRegexFunc }));
-        observableTester().subscribeAndExpectOnNext({
+        await expect(observable).toEmitValuesWith(received => {
-          observable,
+          const value = received[0];
-          expect: value => {
          expect(value).toEqual(undefined);
          expect(getTemplatedRegexFunc).toHaveBeenCalledTimes(1);
          expect(dispatch).toHaveBeenCalledTimes(1);
@@ -200,8 +180,6 @@ describe('operators', () => {
              data: { results: [{ text: 'A' }], templatedRegex: 'getTemplatedRegexFunc result' },
            })
          );
-          },
-          done,
        });
      });
    });
@@ -278,23 +256,20 @@ describe('operators', () => {
        ],
      },
    ].map(scenario => {
-      it(`when called with series:${JSON.stringify(scenario.series, null, 0)}`, done => {
+      it(`when called with series:${JSON.stringify(scenario.series, null, 0)}`, async () => {
        const { series, expected } = scenario;
        const panelData: any = { series };
        const observable = of(panelData).pipe(toMetricFindValues());
-        observableTester().subscribeAndExpectOnNext({
+        await expect(observable).toEmitValuesWith(received => {
-          observable,
+          const value = received[0];
-          expect: value => {
          expect(value).toEqual(expected);
-          },
-          done,
        });
      });
    });
    describe('when called without metric find values and string fields', () => {
-      it('then the observable throws', done => {
+      it('then the observable throws', async () => {
        const frameWithTimeField = toDataFrame({
          fields: [{ name: 'time', type: FieldType.time, values: [1, 2, 3] }],
        });
@@ -302,12 +277,9 @@ describe('operators', () => {
        const panelData: any = { series: [frameWithTimeField] };
        const observable = of(panelData).pipe(toMetricFindValues());
-        observableTester().subscribeAndExpectOnError({
+        await expect(observable).toEmitValuesWith(received => {
-          observable,
+          const value = received[0];
-          expect: value => {
          expect(value).toEqual(new Error("Couldn't find any field of type string in the results."));
-          },
-          done,
        });
      });
    });

--- a/public/app/features/variables/query/queryRunners.test.ts
+++ b/public/app/features/variables/query/queryRunners.test.ts
 import { QueryRunners } from './queryRunners';
-import { DefaultTimeRange, observableTester, VariableSupportType } from '@grafana/data';
+import { DefaultTimeRange, VariableSupportType } from '@grafana/data';
 import { VariableRefresh } from '../types';
 import { of } from 'rxjs';
@@ -41,17 +41,14 @@ describe('QueryRunners', () => {
      });
      const observable = runner.runRequest(runnerArgs, request);
-      it('then it should return correct observable', done => {
+      it('then it should return correct observable', async () => {
-        observableTester().subscribeAndExpectOnNext({
+        await expect(observable).toEmitValuesWith(received => {
-          observable,
+          const value = received[0];
-          expect: values => {
+          expect(value).toEqual({
-            expect(values).toEqual({
            series: [{ text: 'A', value: 'A' }],
            state: 'Done',
            timeRange: { from: {}, raw: { from: '6h', to: 'now' }, to: {} },
          });
-          },
-          done,
        });
      });
@@ -86,17 +83,14 @@ describe('QueryRunners', () => {
      });
      const observable = runner.runRequest(runnerArgs, request);
-      it('then it should return correct observable', done => {
+      it('then it should return correct observable', async () => {
-        observableTester().subscribeAndExpectOnNext({
+        await expect(observable).toEmitValuesWith(received => {
-          observable,
+          const values = received[0];
-          expect: values => {
          expect(values).toEqual({
            series: [{ text: 'A', value: 'A' }],
            state: 'Done',
            timeRange: { from: {}, raw: { from: '6h', to: 'now' }, to: {} },
          });
-          },
-          done,
        });
      });
@@ -161,13 +155,10 @@ describe('QueryRunners', () => {
      });
      const observable = runner.runRequest(runnerArgs, request);
-      it('then it should return correct observable', done => {
+      it('then it should return correct observable', async () => {
-        observableTester().subscribeAndExpectOnNext({
+        await expect(observable).toEmitValuesWith(received => {
-          observable,
+          const value = received[0];
-          expect: value => {
          expect(value).toEqual({});
-          },
-          done,
        });
      });
@@ -183,13 +174,10 @@ describe('QueryRunners', () => {
      });
      const observable = runner.runRequest(runnerArgs, request);
-      it('then it should return correct observable', done => {
+      it('then it should return correct observable', async () => {
-        observableTester().subscribeAndExpectOnNext({
+        await expect(observable).toEmitValuesWith(received => {
-          observable,
+          const value = received[0];
-          expect: value => {
          expect(value).toEqual({});
-          },
-          done,
        });
      });
@@ -234,13 +222,10 @@ describe('QueryRunners', () => {
      const { runner, request, runnerArgs, runRequest, datasource } = getCustomTestContext();
      const observable = runner.runRequest(runnerArgs, request);
-      it('then it should return correct observable', done => {
+      it('then it should return correct observable', async () => {
-        observableTester().subscribeAndExpectOnNext({
+        await expect(observable).toEmitValuesWith(received => {
-          observable,
+          const value = received[0];
-          expect: value => {
          expect(value).toEqual({});
-          },
-          done,
        });
      });
@@ -285,13 +270,10 @@ describe('QueryRunners', () => {
      const { runner, request, runnerArgs, runRequest, datasource } = getDatasourceTestContext();
      const observable = runner.runRequest(runnerArgs, request);
-      it('then it should return correct observable', done => {
+      it('then it should return correct observable', async () => {
-        observableTester().subscribeAndExpectOnNext({
+        await expect(observable).toEmitValuesWith(received => {
-          observable,
+          const value = received[0];
-          expect: value => {
          expect(value).toEqual({});
-          },
-          done,
        });
      });

--- a/public/app/plugins/datasource/cloud-monitoring/specs/datasource.test.ts
+++ b/public/app/plugins/datasource/cloud-monitoring/specs/datasource.test.ts
 import { of, throwError } from 'rxjs';
-import { DataSourceInstanceSettings, observableTester, toUtc } from '@grafana/data';
+import { DataSourceInstanceSettings, toUtc } from '@grafana/data';
 import CloudMonitoringDataSource from '../datasource';
 import { metricDescriptors } from './testData';
@@ -84,7 +84,7 @@ describe('CloudMonitoringDataSource', () => {
  describe('When performing query', () => {
    describe('and no time series data is returned', () => {
-      it('should return a list of datapoints', done => {
+      it('should return a list of datapoints', async () => {
        const options = {
          range: {
            from: toUtc('2017-08-22T20:00:00Z'),
@@ -116,12 +116,9 @@ describe('CloudMonitoringDataSource', () => {
        const { ds } = getTestcontext({ response });
-        observableTester().subscribeAndExpectOnNext({
+        await expect(ds.query(options as any)).toEmitValuesWith(received => {
-          expect: results => {
+          const results = received[0];
          expect(results.data.length).toBe(0);
-          },
-          observable: ds.query(options as any),
-          done,
        });
      });
    });

--- a/public/app/plugins/datasource/cloudwatch/datasource.test.ts
+++ b/public/app/plugins/datasource/cloudwatch/datasource.test.ts
 import { of } from 'rxjs';
 import { setBackendSrv } from '@grafana/runtime';
-import { dateTime, DefaultTimeRange, observableTester } from '@grafana/data';
+import { dateTime, DefaultTimeRange } from '@grafana/data';
 import { TemplateSrv } from '../../../features/templating/template_srv';
 import { CloudWatchDatasource } from './datasource';
 describe('datasource', () => {
  describe('query', () => {
-    it('should return error if log query and log groups is not specified', done => {
+    it('should return error if log query and log groups is not specified', async () => {
      const { datasource } = setup();
+      const observable = datasource.query({
-      observableTester().subscribeAndExpectOnNext({
-        observable: datasource.query({
        targets: [
          {
            queryMode: 'Logs' as 'Logs',
          },
        ],
-        } as any),
+      } as any);
-        expect: response => {
+      await expect(observable).toEmitValuesWith(received => {
+        const response = received[0];
        expect(response.error?.message).toBe('Log group is required');
-        },
-        done,
      });
    });
-    it('should return empty response if queries are hidden', done => {
+    it('should return empty response if queries are hidden', async () => {
      const { datasource } = setup();
+      const observable = datasource.query({
-      observableTester().subscribeAndExpectOnNext({
-        observable: datasource.query({
        targets: [
          {
            queryMode: 'Logs' as 'Logs',
            hide: true,
          },
        ],
-        } as any),
+      } as any);
-        expect: response => {
+      await expect(observable).toEmitValuesWith(received => {
+        const response = received[0];
        expect(response.data).toEqual([]);
-        },
-        done,
      });
    });
  });
  describe('performTimeSeriesQuery', () => {
-    it('should return the same length of data as result', done => {
+    it('should return the same length of data as result', async () => {
      const { datasource } = setup({
        data: {
          results: {
@@ -58,8 +54,7 @@ describe('datasource', () => {
      const buildCloudwatchConsoleUrlMock = jest.spyOn(datasource, 'buildCloudwatchConsoleUrl');
      buildCloudwatchConsoleUrlMock.mockImplementation(() => '');
-      observableTester().subscribeAndExpectOnNext({
+      const observable = datasource.performTimeSeriesQuery(
-        observable: datasource.performTimeSeriesQuery(
        {
          queries: [
            { datasourceId: 1, refId: 'a' },
@@ -67,11 +62,11 @@ describe('datasource', () => {
          ],
        } as any,
        { from: dateTime(), to: dateTime() } as any
-        ),
+      );
-        expect: response => {
+      await expect(observable).toEmitValuesWith(received => {
+        const response = received[0];
        expect(response.data.length).toEqual(2);
-        },
-        done,
      });
    });
  });

--- a/public/app/plugins/datasource/cloudwatch/specs/datasource.test.ts
+++ b/public/app/plugins/datasource/cloudwatch/specs/datasource.test.ts
@@ -6,9 +6,7 @@ import {
  DataSourceInstanceSettings,
  dateMath,
  getFrameDisplayName,
-  observableTester,
 } from '@grafana/data';
-import { FetchResponse } from '@grafana/runtime';
 import * as redux from 'app/store/store';
 import '../datasource';
@@ -22,6 +20,7 @@ import { getTemplateSrvDependencies } from 'test/helpers/getTemplateSrvDependenc
 import { CustomVariableModel, initialVariableModelState, VariableHide } from '../../../../features/variables/types';
 import * as rxjsUtils from '../utils/rxjs/increasingInterval';
+import { createFetchResponse } from 'test/helpers/createFetchResponse';
 jest.mock('rxjs/operators', () => {
  const operators = jest.requireActual('rxjs/operators');
@@ -358,12 +357,10 @@ describe('CloudWatchDatasource', () => {
      },
    };
-    it('should generate the correct query', done => {
+    it('should generate the correct query', async () => {
      const { ds, fetchMock } = getTestContext({ response });
-      observableTester().subscribeAndExpectOnComplete({
+      await expect(ds.query(query)).toEmitValuesWith(() => {
-        observable: ds.query(query),
-        expect: () => {
        expect(fetchMock.mock.calls[0][0].data.queries).toMatchObject(
          expect.arrayContaining([
            expect.objectContaining({
@@ -375,12 +372,10 @@ describe('CloudWatchDatasource', () => {
            }),
          ])
        );
-        },
-        done,
      });
    });
-    it('should generate the correct query with interval variable', done => {
+    it('should generate the correct query with interval variable', async () => {
      const period: CustomVariableModel = {
        ...initialVariableModelState,
        id: 'period',
@@ -418,12 +413,8 @@ describe('CloudWatchDatasource', () => {
      const { ds, fetchMock } = getTestContext({ response, templateSrv });
-      observableTester().subscribeAndExpectOnComplete({
+      await expect(ds.query(query)).toEmitValuesWith(() => {
-        observable: ds.query(query),
-        expect: () => {
        expect(fetchMock.mock.calls[0][0].data.queries[0].period).toEqual('600');
-        },
-        done,
      });
    });
@@ -451,39 +442,33 @@ describe('CloudWatchDatasource', () => {
      expect(ds.query.bind(ds, query)).toThrow(/Invalid extended statistics/);
    });
-    it('should return series list', done => {
+    it('should return series list', async () => {
      const { ds } = getTestContext({ response });
-      observableTester().subscribeAndExpectOnNext({
+      await expect(ds.query(query)).toEmitValuesWith(received => {
-        observable: ds.query(query),
+        const result = received[0];
-        expect: result => {
        expect(getFrameDisplayName(result.data[0])).toBe(response.results.A.series[0].name);
        expect(result.data[0].fields[1].values.buffer[0]).toBe(response.results.A.series[0].points[0][0]);
-        },
-        done,
      });
    });
    describe('a correct cloudwatch url should be built for each time series in the response', () => {
-      it('should be built correctly if theres one search expressions returned in meta for a given query row', done => {
+      it('should be built correctly if theres one search expressions returned in meta for a given query row', async () => {
        const { ds } = getTestContext({ response });
        response.results['A'].meta.gmdMeta = [{ Expression: `REMOVE_EMPTY(SEARCH('some expression'))`, Period: '300' }];
-        observableTester().subscribeAndExpectOnNext({
+        await expect(ds.query(query)).toEmitValuesWith(received => {
-          observable: ds.query(query),
+          const result = received[0];
-          expect: result => {
          expect(getFrameDisplayName(result.data[0])).toBe(response.results.A.series[0].name);
          expect(result.data[0].fields[1].config.links[0].title).toBe('View in CloudWatch console');
          expect(decodeURIComponent(result.data[0].fields[1].config.links[0].url)).toContain(
            `region=us-east-1#metricsV2:graph={"view":"timeSeries","stacked":false,"title":"A","start":"2016-12-31T15:00:00.000Z","end":"2016-12-31T16:00:00.000Z","region":"us-east-1","metrics":[{"expression":"REMOVE_EMPTY(SEARCH(\'some expression\'))"}]}`
          );
-          },
-          done,
        });
      });
-      it('should be built correctly if theres two search expressions returned in meta for a given query row', done => {
+      it('should be built correctly if theres two search expressions returned in meta for a given query row', async () => {
        const { ds } = getTestContext({ response });
        response.results['A'].meta.gmdMeta = [
@@ -491,49 +476,40 @@ describe('CloudWatchDatasource', () => {
          { Expression: `REMOVE_EMPTY(SEARCH('second expression'))` },
        ];
-        observableTester().subscribeAndExpectOnNext({
+        await expect(ds.query(query)).toEmitValuesWith(received => {
-          observable: ds.query(query),
+          const result = received[0];
-          expect: result => {
          expect(getFrameDisplayName(result.data[0])).toBe(response.results.A.series[0].name);
          expect(result.data[0].fields[1].config.links[0].title).toBe('View in CloudWatch console');
          expect(decodeURIComponent(result.data[0].fields[0].config.links[0].url)).toContain(
            `region=us-east-1#metricsV2:graph={"view":"timeSeries","stacked":false,"title":"A","start":"2016-12-31T15:00:00.000Z","end":"2016-12-31T16:00:00.000Z","region":"us-east-1","metrics":[{"expression":"REMOVE_EMPTY(SEARCH(\'first expression\'))"},{"expression":"REMOVE_EMPTY(SEARCH(\'second expression\'))"}]}`
          );
-          },
-          done,
        });
      });
-      it('should be built correctly if the query is a metric stat query', done => {
+      it('should be built correctly if the query is a metric stat query', async () => {
        const { ds } = getTestContext({ response });
        response.results['A'].meta.gmdMeta = [{ Period: '300' }];
-        observableTester().subscribeAndExpectOnNext({
+        await expect(ds.query(query)).toEmitValuesWith(received => {
-          observable: ds.query(query),
+          const result = received[0];
-          expect: result => {
          expect(getFrameDisplayName(result.data[0])).toBe(response.results.A.series[0].name);
          expect(result.data[0].fields[1].config.links[0].title).toBe('View in CloudWatch console');
          expect(decodeURIComponent(result.data[0].fields[0].config.links[0].url)).toContain(
            `region=us-east-1#metricsV2:graph={\"view\":\"timeSeries\",\"stacked\":false,\"title\":\"A\",\"start\":\"2016-12-31T15:00:00.000Z\",\"end\":\"2016-12-31T16:00:00.000Z\",\"region\":\"us-east-1\",\"metrics\":[[\"AWS/EC2\",\"CPUUtilization\",\"InstanceId\",\"i-12345678\",{\"stat\":\"Average\",\"period\":\"300\"}]]}`
          );
-          },
-          done,
        });
      });
-      it('should not be added at all if query is a math expression', done => {
+      it('should not be added at all if query is a math expression', async () => {
        const { ds } = getTestContext({ response });
        query.targets[0].expression = 'a * 2';
        response.results['A'].meta.searchExpressions = [];
-        observableTester().subscribeAndExpectOnNext({
+        await expect(ds.query(query)).toEmitValuesWith(received => {
-          observable: ds.query(query),
+          const result = received[0];
-          expect: result => {
          expect(result.data[0].fields[1].config.links).toBeUndefined();
-          },
-          done,
        });
      });
    });
@@ -602,19 +578,15 @@ describe('CloudWatchDatasource', () => {
        } as any);
      });
-      it('should display one alert error message per region+datasource combination', done => {
+      it('should display one alert error message per region+datasource combination', async () => {
        const { ds } = getTestContext({ response: backendErrorResponse, throws: true });
        const memoizedDebounceSpy = jest.spyOn(ds, 'debouncedAlert');
-        observableTester().subscribeAndExpectOnError({
+        await expect(ds.query(query)).toEmitValuesWith(received => {
-          observable: ds.query(query),
-          expect: err => {
          expect(memoizedDebounceSpy).toHaveBeenCalledWith('TestDatasource', 'us-east-1');
          expect(memoizedDebounceSpy).toHaveBeenCalledWith('TestDatasource', 'us-east-2');
          expect(memoizedDebounceSpy).toHaveBeenCalledWith('TestDatasource', 'eu-north-1');
          expect(memoizedDebounceSpy).toBeCalledTimes(3);
-          },
-          done,
        });
      });
    });
@@ -666,7 +638,7 @@ describe('CloudWatchDatasource', () => {
      expect(ds.getActualRegion('some-fake-region-1')).toBe('some-fake-region-1');
    });
-    it('should query for the datasource region if empty or "default"', done => {
+    it('should query for the datasource region if empty or "default"', async () => {
      const { ds, instanceSettings } = getTestContext();
      const performTimeSeriesQueryMock = jest.spyOn(ds, 'performTimeSeriesQuery').mockReturnValue(of({}));
@@ -689,14 +661,10 @@ describe('CloudWatchDatasource', () => {
        ],
      };
-      observableTester().subscribeAndExpectOnComplete({
+      await expect(ds.query(query)).toEmitValuesWith(() => {
-        observable: ds.query(query),
-        expect: () => {
        expect(performTimeSeriesQueryMock.mock.calls[0][0].queries[0].region).toBe(
          instanceSettings.jsonData.defaultRegion
        );
-        },
-        done,
      });
    });
  });
@@ -809,16 +777,13 @@ describe('CloudWatchDatasource', () => {
      },
    };
-    it('should return series list', done => {
+    it('should return series list', async () => {
      const { ds } = getTestContext({ response });
-      observableTester().subscribeAndExpectOnNext({
+      await expect(ds.query(query)).toEmitValuesWith(received => {
-        observable: ds.query(query),
+        const result = received[0];
-        expect: result => {
        expect(getFrameDisplayName(result.data[0])).toBe(response.results.A.series[0].name);
        expect(result.data[0].fields[1].values.buffer[0]).toBe(response.results.A.series[0].points[0][0]);
-        },
-        done,
      });
    });
  });
@@ -892,7 +857,7 @@ describe('CloudWatchDatasource', () => {
      templateSrv.init(variables);
    });
-    it('should generate the correct query for single template variable', done => {
+    it('should generate the correct query for single template variable', async () => {
      const { ds, fetchMock } = getTestContext({ templateSrv });
      const query: any = {
        range: defaultTimeRange,
@@ -913,16 +878,12 @@ describe('CloudWatchDatasource', () => {
        ],
      };
-      observableTester().subscribeAndExpectOnComplete({
+      await expect(ds.query(query)).toEmitValuesWith(() => {
-        observable: ds.query(query),
-        expect: () => {
        expect(fetchMock.mock.calls[0][0].data.queries[0].dimensions['dim2']).toStrictEqual(['var2-foo']);
-        },
-        done,
      });
    });
-    it('should generate the correct query in the case of one multilple template variables', done => {
+    it('should generate the correct query in the case of one multilple template variables', async () => {
      const { ds, fetchMock } = getTestContext({ templateSrv });
      const query: any = {
        range: defaultTimeRange,
@@ -949,18 +910,14 @@ describe('CloudWatchDatasource', () => {
        },
      };
-      observableTester().subscribeAndExpectOnComplete({
+      await expect(ds.query(query)).toEmitValuesWith(() => {
-        observable: ds.query(query),
-        expect: () => {
        expect(fetchMock.mock.calls[0][0].data.queries[0].dimensions['dim1']).toStrictEqual(['var1-foo']);
        expect(fetchMock.mock.calls[0][0].data.queries[0].dimensions['dim2']).toStrictEqual(['var2-foo']);
        expect(fetchMock.mock.calls[0][0].data.queries[0].dimensions['dim3']).toStrictEqual(['var3-foo', 'var3-baz']);
-        },
-        done,
      });
    });
-    it('should generate the correct query in the case of multilple multi template variables', done => {
+    it('should generate the correct query in the case of multilple multi template variables', async () => {
      const { ds, fetchMock } = getTestContext({ templateSrv });
      const query: any = {
        range: defaultTimeRange,
@@ -983,18 +940,14 @@ describe('CloudWatchDatasource', () => {
        ],
      };
-      observableTester().subscribeAndExpectOnComplete({
+      await expect(ds.query(query)).toEmitValuesWith(() => {
-        observable: ds.query(query),
-        expect: () => {
        expect(fetchMock.mock.calls[0][0].data.queries[0].dimensions['dim1']).toStrictEqual(['var1-foo']);
        expect(fetchMock.mock.calls[0][0].data.queries[0].dimensions['dim3']).toStrictEqual(['var3-foo', 'var3-baz']);
        expect(fetchMock.mock.calls[0][0].data.queries[0].dimensions['dim4']).toStrictEqual(['var4-foo', 'var4-baz']);
-        },
-        done,
      });
    });
-    it('should generate the correct query for multilple template variables, lack scopedVars', done => {
+    it('should generate the correct query for multilple template variables, lack scopedVars', async () => {
      const { ds, fetchMock } = getTestContext({ templateSrv });
      const query: any = {
        range: defaultTimeRange,
@@ -1020,14 +973,10 @@ describe('CloudWatchDatasource', () => {
        },
      };
-      observableTester().subscribeAndExpectOnComplete({
+      await expect(ds.query(query)).toEmitValuesWith(() => {
-        observable: ds.query(query),
-        expect: () => {
        expect(fetchMock.mock.calls[0][0].data.queries[0].dimensions['dim1']).toStrictEqual(['var1-foo']);
        expect(fetchMock.mock.calls[0][0].data.queries[0].dimensions['dim2']).toStrictEqual(['var2-foo']);
        expect(fetchMock.mock.calls[0][0].data.queries[0].dimensions['dim3']).toStrictEqual(['var3-foo', 'var3-baz']);
-        },
-        done,
      });
    });
  });
@@ -1213,17 +1162,3 @@ function genMockFrames(numResponses: number): DataFrame[] {
  return mockFrames;
 }
-function createFetchResponse<T>(data: T): FetchResponse<T> {
-  return {
-    data,
-    status: 200,
-    url: 'http://localhost:3000/api/query',
-    config: { url: 'http://localhost:3000/api/query' },
-    type: 'basic',
-    statusText: 'Ok',
-    redirected: false,
-    headers: ({} as unknown) as Headers,
-    ok: true,
-  };
-}
--- a/public/app/plugins/datasource/loki/datasource.test.ts
+++ b/public/app/plugins/datasource/loki/datasource.test.ts
@@ -11,6 +11,7 @@ import { backendSrv } from 'app/core/services/backend_srv';
 import { CustomVariableModel } from '../../../features/variables/types';
 import { initialCustomVariableModelState } from '../../../features/variables/custom/reducer';
 import { makeMockLokiDatasource } from './mocks';
+import { createFetchResponse } from 'test/helpers/createFetchResponse';
 jest.mock('@grafana/runtime', () => ({
  // @ts-ignore
@@ -593,17 +594,3 @@ function makeMetadataAndVersionsMocks() {
  }
  return mocks;
 }
-function createFetchResponse<T>(data: T): FetchResponse<T> {
-  return {
-    data,
-    status: 200,
-    url: 'http://localhost:3000/api/query',
-    config: { url: 'http://localhost:3000/api/query' },
-    type: 'basic',
-    statusText: 'Ok',
-    redirected: false,
-    headers: ({} as unknown) as Headers,
-    ok: true,
-  };
-}
--- a/public/app/plugins/datasource/mssql/specs/datasource.test.ts
+++ b/public/app/plugins/datasource/mssql/specs/datasource.test.ts
@@ -6,7 +6,7 @@ import { TimeSrvStub } from 'test/specs/helpers';
 import { TemplateSrv } from 'app/features/templating/template_srv';
 import { backendSrv } from 'app/core/services/backend_srv';
 import { initialCustomVariableModelState } from '../../../../features/variables/custom/reducer';
-import { FetchResponse } from '@grafana/runtime'; // will use the version in __mocks__
+import { createFetchResponse } from 'test/helpers/createFetchResponse';
 jest.mock('@grafana/runtime', () => ({
  ...((jest.requireActual('@grafana/runtime') as unknown) as object),
@@ -334,17 +334,3 @@ describe('MSSQLDatasource', () => {
    });
  });
 });
-function createFetchResponse<T>(data: T): FetchResponse<T> {
-  return {
-    data,
-    status: 200,
-    url: 'http://localhost:3000/api/query',
-    config: { url: 'http://localhost:3000/api/query' },
-    type: 'basic',
-    statusText: 'Ok',
-    redirected: false,
-    headers: ({} as unknown) as Headers,
-    ok: true,
-  };
-}
--- a/public/test/helpers/createFetchResponse.ts
+++ b/public/test/helpers/createFetchResponse.ts
@@ -4,8 +4,8 @@ export function createFetchResponse<T>(data: T): FetchResponse<T> {
  return {
    data,
    status: 200,
-    url: 'http://localhost:3000/api/query',
+    url: 'http://localhost:3000/api/tsdb/query',
-    config: { url: 'http://localhost:3000/api/query' },
+    config: { url: 'http://localhost:3000/api/tsdb/query' },
    type: 'basic',
    statusText: 'Ok',
    redirected: false,