Fetch ddg action and reducer

packages/jaeger-ui/src/actions/deep-dependency-graph.tsx

@@ -0,0 +1,32 @@
+// Copyright (c) 2017 Uber Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import _identity from 'lodash/identity';
+import { createActions } from 'redux-actions';
+
+import { TDdgAddStylePayload, TDdgClearStylePayload } from '../model/ddg/types';
+import generateActionTypes from '../utils/generate-action-types';
+
+export const actionTypes = generateActionTypes('@jaeger-ui/DEEP-DEPENDENCY-GRAPH', [
+  'ADD_STYLE_STATE',
+  'CLEAR_STYLE_STATE',
+]);
+
+const addStyleState: (kwarg: TDdgAddStylePayload) => TDdgAddStylePayload = _identity;
+const clearStyleState: (kwarg: TDdgClearStylePayload) => TDdgClearStylePayload = _identity;
+
+export const actions = createActions<TDdgAddStylePayload | TDdgClearStylePayload>({
+  [actionTypes.ADD_STYLE_STATE]: addStyleState,
+  [actionTypes.CLEAR_STYLE_STATE]: clearStyleState,
+});

packages/jaeger-ui/src/actions/jaeger-api.js

@@ -47,6 +47,12 @@ export const fetchServiceOperations = createAction(
   serviceName => ({ serviceName })
 );
 
+export const fetchDeepDependencyGraph = createAction(
+  '@JAEGER_API/FETCH_DEEP_DEPENDENCY_GRAPH',
+  query => JaegerAPI.fetchDeepDependencyGraph(query),
+  query => ({ query })
+);
+
 export const fetchDependencies = createAction('@JAEGER_API/FETCH_DEPENDENCIES', () =>
   JaegerAPI.fetchDependencies()
 );

packages/jaeger-ui/src/actions/jaeger-api.test.js

@@ -27,90 +27,117 @@ import isPromise from 'is-promise';
 import * as jaegerApiActions from './jaeger-api';
 import JaegerAPI from '../api/jaeger';
 
-it('@JAEGER_API/FETCH_TRACE should fetch the trace by id', () => {
-  const api = JaegerAPI;
+describe('actions/jaeger-api', () => {
+  const query = { param: 'value' };
   const id = 'my-trace-id';
-  const mock = sinon.mock(api);
-
-  mock.expects('fetchTrace').withExactArgs(id);
-  jaegerApiActions.fetchTrace(id);
-  expect(() => mock.verify()).not.toThrow();
-
-  mock.restore();
-});
-
-it('@JAEGER_API/FETCH_TRACE should return the promise', () => {
-  const api = JaegerAPI;
-  const id = 'my-trace-id';
-  const mock = sinon.mock(api);
-
-  const { payload } = jaegerApiActions.fetchTrace(id);
-  expect(isPromise(payload)).toBeTruthy();
-
-  mock.restore();
-});
-
-it('@JAEGER_API/FETCH_TRACE should attach the id as meta', () => {
-  const api = JaegerAPI;
-  const id = 'my-trace-id';
-  const mock = sinon.mock(api);
-
-  const { meta } = jaegerApiActions.fetchTrace(id);
-  expect(meta.id).toBe(id);
-
-  mock.restore();
-});
-
-it('@JAEGER_API/SEARCH_TRACES should fetch the trace by id', () => {
-  const api = JaegerAPI;
-  const query = { service: 's', limit: 1 };
-  const mock = sinon.mock(api);
-
-  mock.expects('searchTraces').withExactArgs(query);
-  jaegerApiActions.searchTraces(query);
-  expect(() => mock.verify()).not.toThrow();
-
-  mock.restore();
-});
-
-it('@JAEGER_API/SEARCH_TRACES should return the promise', () => {
-  const api = JaegerAPI;
-  const query = { myQuery: 'whatever' };
-  const mock = sinon.mock(api);
-
-  const { payload } = jaegerApiActions.searchTraces(query);
-  expect(isPromise(payload)).toBeTruthy();
-
-  mock.restore();
-});
-
-it('@JAEGER_API/SEARCH_TRACES should attach the query as meta', () => {
-  const api = JaegerAPI;
-  const query = { myQuery: 'whatever' };
-  const mock = sinon.mock(api);
-
-  const { meta } = jaegerApiActions.searchTraces(query);
-  expect(meta.query).toEqual(query);
-
-  mock.restore();
-});
-
-it('@JAEGER_API/FETCH_SERVICES should return a promise', () => {
-  const api = JaegerAPI;
-  const mock = sinon.mock(api);
-  const { payload } = jaegerApiActions.fetchServices();
-  expect(isPromise(payload)).toBeTruthy();
-  mock.restore();
-});
-
-it('@JAEGER_API/FETCH_SERVICE_OPERATIONS should call the JaegerAPI', () => {
-  const api = JaegerAPI;
-  const mock = sinon.mock(api);
-  const called = mock
-    .expects('fetchServiceOperations')
-    .once()
-    .withExactArgs('service');
-  jaegerApiActions.fetchServiceOperations('service');
-  expect(called.verify()).toBeTruthy();
-  mock.restore();
+  const ids = [id, id];
+  let mock;
+
+  beforeEach(() => {
+    mock = sinon.mock(JaegerAPI);
+  });
+
+  afterEach(() => {
+    mock.restore();
+  });
+
+  it('@JAEGER_API/FETCH_TRACE should fetch the trace by id', () => {
+    mock.expects('fetchTrace').withExactArgs(id);
+    jaegerApiActions.fetchTrace(id);
+    expect(() => mock.verify()).not.toThrow();
+  });
+
+  it('@JAEGER_API/FETCH_TRACE should return the promise', () => {
+    const { payload } = jaegerApiActions.fetchTrace(id);
+    expect(isPromise(payload)).toBeTruthy();
+  });
+
+  it('@JAEGER_API/FETCH_TRACE should attach the id as meta', () => {
+    const { meta } = jaegerApiActions.fetchTrace(id);
+    expect(meta.id).toBe(id);
+  });
+
+  it('@JAEGER_API/FETCH_MULTIPLE_TRACES should fetch traces by ids', () => {
+    mock.expects('searchTraces').withExactArgs(sinon.match.has('traceID', ids));
+    jaegerApiActions.fetchMultipleTraces(ids);
+    expect(() => mock.verify()).not.toThrow();
+  });
+
+  it('@JAEGER_API/FETCH_MULTIPLE_TRACES should return the promise', () => {
+    const { payload } = jaegerApiActions.fetchMultipleTraces(ids);
+    expect(isPromise(payload)).toBeTruthy();
+  });
+
+  it('@JAEGER_API/FETCH_MULTIPLE_TRACES should attach the ids as meta', () => {
+    const { meta } = jaegerApiActions.fetchMultipleTraces(ids);
+    expect(meta.ids).toBe(ids);
+  });
+
+  it('@JAEGER_API/ARCHIVE_TRACE should archive the trace by id', () => {
+    mock.expects('archiveTrace').withExactArgs(id);
+    jaegerApiActions.archiveTrace(id);
+    expect(() => mock.verify()).not.toThrow();
+  });
+
+  it('@JAEGER_API/ARCHIVE_TRACE should return the promise', () => {
+    const { payload } = jaegerApiActions.archiveTrace(id);
+    expect(isPromise(payload)).toBeTruthy();
+  });
+
+  it('@JAEGER_API/ARCHIVE_TRACE should attach the id as meta', () => {
+    const { meta } = jaegerApiActions.archiveTrace(id);
+    expect(meta.id).toBe(id);
+  });
+
+  it('@JAEGER_API/SEARCH_TRACES should fetch the trace by id', () => {
+    mock.expects('searchTraces').withExactArgs(query);
+    jaegerApiActions.searchTraces(query);
+    expect(() => mock.verify()).not.toThrow();
+  });
+
+  it('@JAEGER_API/SEARCH_TRACES should return the promise', () => {
+    const { payload } = jaegerApiActions.searchTraces(query);
+    expect(isPromise(payload)).toBeTruthy();
+  });
+
+  it('@JAEGER_API/SEARCH_TRACES should attach the query as meta', () => {
+    const { meta } = jaegerApiActions.searchTraces(query);
+    expect(meta.query).toEqual(query);
+  });
+
+  it('@JAEGER_API/FETCH_SERVICES should return a promise', () => {
+    const { payload } = jaegerApiActions.fetchServices();
+    expect(isPromise(payload)).toBeTruthy();
+  });
+
+  it('@JAEGER_API/FETCH_SERVICE_OPERATIONS should call the JaegerAPI', () => {
+    const called = mock
+      .expects('fetchServiceOperations')
+      .once()
+      .withExactArgs('service');
+    jaegerApiActions.fetchServiceOperations('service');
+    expect(called.verify()).toBeTruthy();
+  });
+
+  it('@JAEGER_API/FETCH_DEEP_DEPENDENCY_GRAPH should fetch the graph by params', () => {
+    mock.expects('fetchDeepDependencyGraph').withExactArgs(query);
+    jaegerApiActions.fetchDeepDependencyGraph(query);
+    expect(() => mock.verify()).not.toThrow();
+  });
+
+  it('@JAEGER_API/FETCH_DEEP_DEPENDENCY_GRAPH should return the promise', () => {
+    const { payload } = jaegerApiActions.fetchDeepDependencyGraph(query);
+    expect(isPromise(payload)).toBeTruthy();
+  });
+
+  it('@JAEGER_API/FETCH_DEEP_DEPENDENCY_GRAPH should attach the query as meta', () => {
+    const { meta } = jaegerApiActions.fetchDeepDependencyGraph(query);
+    expect(meta.query).toEqual(query);
+  });
+
+  it('@JAEGER_API/FETCH_DEPENDENCIES should call the JaegerAPI', () => {
+    const called = mock.expects('fetchDependencies').once();
+    jaegerApiActions.fetchDependencies();
+    expect(called.verify()).toBeTruthy();
+  });
 });

packages/jaeger-ui/src/api/jaeger.js

@@ -76,23 +76,26 @@ export const DEFAULT_DEPENDENCY_LOOKBACK = moment.duration(1, 'weeks').asMillise
 
 const JaegerAPI = {
   apiRoot: DEFAULT_API_ROOT,
-  fetchTrace(id) {
-    return getJSON(`${this.apiRoot}traces/${id}`);
-  },
   archiveTrace(id) {
     return getJSON(`${this.apiRoot}archive/${id}`, { method: 'POST' });
   },
-  searchTraces(query) {
-    return getJSON(`${this.apiRoot}traces`, { query });
+  fetchDeepDependencyGraph(query) {
+    return getJSON(`${this.apiRoot}deep-dependency-graph`, { query });
   },
-  fetchServices() {
-    return getJSON(`${this.apiRoot}services`);
+  fetchDependencies(endTs = new Date().getTime(), lookback = DEFAULT_DEPENDENCY_LOOKBACK) {
+    return getJSON(`${this.apiRoot}dependencies`, { query: { endTs, lookback } });
   },
   fetchServiceOperations(serviceName) {
     return getJSON(`${this.apiRoot}services/${encodeURIComponent(serviceName)}/operations`);
   },
-  fetchDependencies(endTs = new Date().getTime(), lookback = DEFAULT_DEPENDENCY_LOOKBACK) {
-    return getJSON(`${this.apiRoot}dependencies`, { query: { endTs, lookback } });
+  fetchServices() {
+    return getJSON(`${this.apiRoot}services`);
+  },
+  fetchTrace(id) {
+    return getJSON(`${this.apiRoot}traces/${id}`);
+  },
+  searchTraces(query) {
+    return getJSON(`${this.apiRoot}traces`, { query });
   },
 };