@truedat/dd 8.13.5 → 8.13.7

package/src/sagas/__tests__/createGraph.spec.js

@@ -1,20 +1,15 @@
 import { compile } from "path-to-regexp";
-import { takeLatest } from "redux-saga/effects";
+import { takeEvery } from "redux-saga/effects";
 import { testSaga } from "redux-saga-test-plan";
 import { apiJson, apiJsonPost, JSON_OPTS } from "@truedat/core/services/api";
 import {
   createGraphRequestSaga,
   createGraphSaga,
-  POLLING_CANCELLED,
   selectLineageQuery,
 } from "../createGraph";
+import { generateGraph } from "../graph/generation";
 import { polling } from "../graph/polling";
-import {
-  cancelPoll,
-  createGraph,
-  fetchGraph,
-  excludeNode,
-} from "../../routines";
+import { createGraph, excludeNode } from "../../routines";
 import { API_GRAPHS, API_GRAPH_HASH } from "../../api";
 
 const graphAcceptedData = {
@@ -50,8 +45,8 @@ describe("sagas: createGraphRequestSaga", () => {
       testSaga(createGraphRequestSaga)
         .next()
         .all([
-          takeLatest(createGraph.TRIGGER, createGraphSaga),
-          takeLatest(excludeNode.TRIGGER, createGraphSaga),
+          takeEvery(createGraph.TRIGGER, createGraphSaga),
+          takeEvery(excludeNode.TRIGGER, createGraphSaga),
         ])
         .finish()
         .isDone();
@@ -68,7 +63,7 @@ describe("sagas: createGraphRequestSaga", () => {
 });
 
 describe("sagas: createGraphSaga", () => {
-  const isRedirected = false;
+  const isRedirected = true;
 
   const query = {
     ids: ["BASILEAII_HIST_PROA_MOROSIDAD [ 2 ] [ 1 ].SOBREGIROCAPITAL"],
@@ -77,74 +72,19 @@ describe("sagas: createGraphSaga", () => {
     isRedirected,
   };
 
-  const graphAccepted = {
-    data: graphAcceptedData,
-    status: 202,
-  };
-
-  const graphCreated = {
-    data: { ...graphData, isRedirected },
-    status: 201,
-  };
-
-  it("should put a success action when uuids are requested and a 201 (created) graph data response is returned", () => {
-    expect(() => {
-      testSaga(createGraphSaga)
-        .next()
-        .select(selectLineageQuery)
-        .next(query)
-        .put(createGraph.request(query))
-        .next()
-        .call(apiJsonPost, API_GRAPHS, query, JSON_OPTS)
-        .next(graphCreated)
-        .put(createGraph.success(graphCreated))
-        .next()
-        .put(createGraph.fulfill())
-        .next()
-        .isDone();
-    }).not.toThrow();
-  });
-
-  it("should fork a polling task when uuids are requested and a 202 (accepted) graph hash response is returned. Then, wait for task cancellation.", () => {
-    expect(() => {
-      testSaga(createGraphSaga)
-        .next()
-        .select(selectLineageQuery)
-        .next(query)
-        .put(createGraph.request(query))
-        .next()
-        .call(apiJsonPost, API_GRAPHS, query, JSON_OPTS)
-        .next(graphAccepted)
-        .put(fetchGraph.request(graphAccepted))
-        .next()
-        .fork(polling, createGraph, graphAccepted, isRedirected)
-        .next()
-        .take(cancelPoll.TRIGGER)
-        .next()
-        .cancel()
-        .next()
-        .put(createGraph.fulfill())
-        .next()
-        .isDone();
-    }).not.toThrow();
-  });
-
-  it("should put a failure action when the call returns an error", () => {
-    const message = "Request failed";
-    const error = { message };
-
+  it("should pass the query and redirect intent to the shared graph generation", () => {
     expect(() => {
       testSaga(createGraphSaga)
         .next()
         .select(selectLineageQuery)
         .next(query)
-        .put(createGraph.request(query))
-        .next()
-        .call(apiJsonPost, API_GRAPHS, query, JSON_OPTS)
-        .throw(error)
-        .put(createGraph.failure(message))
-        .next()
-        .put(createGraph.fulfill())
+        .call(
+          generateGraph,
+          createGraph,
+          apiJsonPost,
+          [API_GRAPHS, query, JSON_OPTS],
+          isRedirected,
+        )
         .next()
         .isDone();
     }).not.toThrow();
@@ -152,8 +92,6 @@ describe("sagas: createGraphSaga", () => {
 });
 
 describe("generator: polling", () => {
-  const isRedirected = false;
-
   const graphAccepted = {
     data: graphAcceptedData,
     status: 202,
@@ -165,67 +103,64 @@ describe("generator: polling", () => {
   };
 
   const graphCompleted = {
-    data: { ...graphData, isRedirected },
+    data: graphData,
     status: 200,
   };
 
+  const url = compile(API_GRAPH_HASH)({ hash: graphAccepted.data.graph_hash });
+  const progressFor = (retry) => ({
+    ...graphPending,
+    data: {
+      ...graphPending.data,
+      graph_hash: graphAccepted.data.graph_hash,
+      retry,
+    },
+  });
+
   it("polling should keep requesting by graph hash until graph is received", () => {
+    const onProgress = jest.fn();
+
     expect(() => {
-      testSaga(polling, createGraph, graphAccepted, isRedirected)
+      testSaga(polling, graphAccepted, onProgress)
         .next()
         .delay(1000)
         .next()
-        .call(
-          apiJson,
-          compile(API_GRAPH_HASH)({ hash: graphAccepted.data.graph_hash }),
-          JSON_OPTS,
-        )
+        .call(apiJson, url, JSON_OPTS)
         .next(graphPending)
-        .put(
-          fetchGraph.failure({
-            data: { graph_hash: graphAccepted.data.graph_hash, retry: 1 },
-          }),
-        )
+        .call(onProgress, progressFor(1))
         .next()
-        .cancelled()
-        .next(false)
         .delay(1200)
         .next()
-        .call(
-          apiJson,
-          compile(API_GRAPH_HASH)({ hash: graphAccepted.data.graph_hash }),
-          JSON_OPTS,
-        )
-        .next(graphCompleted)
-        .cancelled()
-        .next(false)
-        .put(createGraph.success(graphCompleted))
+        .call(apiJson, url, JSON_OPTS)
+        .next(graphPending)
+        .call(onProgress, progressFor(2))
         .next()
-        .isDone();
+        .delay(1440)
+        .next()
+        .call(apiJson, url, JSON_OPTS)
+        .next(graphCompleted)
+        .returns(graphCompleted);
     }).not.toThrow();
   });
 
-  it("cancel should stop polling and return createGraph failure", () => {
-    expect(() => {
-      testSaga(polling, createGraph, graphAccepted, isRedirected)
-        .next()
-        .delay(1000)
-        .next()
-        .call(
-          apiJson,
-          compile(API_GRAPH_HASH)({ hash: graphAccepted.data.graph_hash }),
-          JSON_OPTS,
-        )
-        .next(graphPending)
-        .put(
-          fetchGraph.failure({
-            data: { graph_hash: graphAccepted.data.graph_hash, retry: 1 },
-          }),
-        )
-        .next()
-        .cancelled()
-        .next(true)
-        .put(createGraph.failure(POLLING_CANCELLED));
-    }).not.toThrow();
+  it("retries a network error without reporting the previous response as new progress", () => {
+    const onProgress = jest.fn();
+    testSaga(polling, graphAccepted, onProgress)
+      .next()
+      .delay(1000)
+      .next()
+      .call(apiJson, url, JSON_OPTS)
+      .next(graphPending)
+      .call(onProgress, progressFor(1))
+      .next()
+      .delay(1200)
+      .next()
+      .call(apiJson, url, JSON_OPTS)
+      .throw(new Error("offline"))
+      .delay(1440)
+      .next()
+      .call(apiJson, url, JSON_OPTS)
+      .next(graphCompleted)
+      .returns(graphCompleted);
   });
 });

package/src/sagas/__tests__/fetchGraph.spec.js

@@ -0,0 +1,19 @@
+import { testSaga } from "redux-saga-test-plan";
+import { apiJson, JSON_OPTS } from "@truedat/core/services/api";
+import { compile } from "path-to-regexp";
+import { fetchGraph } from "../../routines";
+import { API_GRAPH } from "../../api";
+import { fetchGraphSaga } from "../fetchGraph";
+import { generateGraph } from "../graph/generation";
+
+test("loading a saved graph uses the shared generation lifecycle", () => {
+  const payload = { id: "42" };
+  testSaga(fetchGraphSaga, { payload })
+    .next()
+    .call(generateGraph, fetchGraph, apiJson, [
+      compile(API_GRAPH)(payload),
+      JSON_OPTS,
+    ])
+    .next()
+    .isDone();
+});

package/src/sagas/createGraph.js

@@ -1,78 +1,26 @@
 import _ from "lodash/fp";
-import {
-  all,
-  call,
-  cancel,
-  fork,
-  put,
-  select,
-  take,
-  takeLatest,
-} from "redux-saga/effects";
+import { all, call, select, takeEvery } from "redux-saga/effects";
 import { apiJsonPost, JSON_OPTS } from "@truedat/core/services/api";
-import { excludeNode, cancelPoll, createGraph, fetchGraph } from "../routines";
+import { excludeNode, createGraph } from "../routines";
 import { API_GRAPHS } from "../api";
-import { polling } from "./graph/polling";
+import { generateGraph } from "./graph/generation";
 
 export const selectLineageQuery = _.prop("lineageQuery");
 
-export const POLLING_CANCELLED = "Polling cancelled!";
-
 export function* createGraphSaga() {
-  try {
-    const body = yield select(selectLineageQuery);
-    yield put(createGraph.request(body));
-
-    /* graph is either new (accepted) or "created" (actually previously stored
-      from an earlier accepted one) */
-    const graphAcceptedOrCreated = yield call(
-      apiJsonPost,
-      API_GRAPHS,
-      body,
-      JSON_OPTS,
-    );
-
-    if (graphAcceptedOrCreated.status === 202) {
-      yield put(fetchGraph.request(graphAcceptedOrCreated));
-      // starts the task in the background
-      const pollingTask = yield fork(
-        polling,
-        createGraph,
-        graphAcceptedOrCreated,
-        body.isRedirected,
-      );
-
-      // wait for the user stop action
-      yield take(cancelPoll.TRIGGER);
-      // user clicked stop. cancel the background task
-      // this will cause the forked bgSync task to jump into its finally block
-      yield cancel(pollingTask);
-    } else if (graphAcceptedOrCreated.status === 201) {
-      yield put(
-        createGraph.success({
-          ...graphAcceptedOrCreated,
-          data: {
-            ...graphAcceptedOrCreated.data,
-            isRedirected: body.isRedirected,
-          },
-        }),
-      );
-    }
-  } catch (error) {
-    if (error.response) {
-      const { status, data } = error.response;
-      yield put(createGraph.failure({ status, data }));
-    } else {
-      yield put(createGraph.failure(error.message));
-    }
-  } finally {
-    yield put(createGraph.fulfill());
-  }
+  const body = yield select(selectLineageQuery);
+  yield call(
+    generateGraph,
+    createGraph,
+    apiJsonPost,
+    [API_GRAPHS, body, JSON_OPTS],
+    body.isRedirected,
+  );
 }
 
 export function* createGraphRequestSaga() {
   yield all([
-    takeLatest(createGraph.TRIGGER, createGraphSaga),
-    takeLatest(excludeNode.TRIGGER, createGraphSaga),
+    takeEvery(createGraph.TRIGGER, createGraphSaga),
+    takeEvery(excludeNode.TRIGGER, createGraphSaga),
   ]);
 }

package/src/sagas/fetchGraph.js

@@ -1,52 +1,20 @@
 import _ from "lodash/fp";
 import { compile } from "path-to-regexp";
-import { call, cancel, fork, put, take, takeLatest } from "redux-saga/effects";
+import { call, takeEvery } from "redux-saga/effects";
 import { apiJson, JSON_OPTS } from "@truedat/core/services/api";
 import { API_GRAPH } from "../api";
-import { cancelPoll, fetchGraph } from "../routines";
-import { polling } from "./graph/polling";
+import { fetchGraph } from "../routines";
+import { generateGraph } from "./graph/generation";
 
 const toApiPath = compile(API_GRAPH);
 
 export const selectLineageQuery = _.prop("lineageQuery");
 
 export function* fetchGraphSaga({ payload }) {
-  try {
-    const url = toApiPath(payload);
-    yield put(fetchGraph.request(payload));
-
-    /* graph is either new (202 accepted) or 200 OK*/
-    const graphAcceptedOrFetched = yield call(apiJson, url, JSON_OPTS);
-
-    if (graphAcceptedOrFetched.status === 202) {
-      yield put(fetchGraph.request(graphAcceptedOrFetched));
-      // starts the task in the background
-      const pollingTask = yield fork(
-        polling,
-        fetchGraph,
-        graphAcceptedOrFetched,
-      );
-
-      // wait for the user stop action
-      yield take(cancelPoll.TRIGGER);
-      // user clicked stop. cancel the background task
-      // this will cause the forked bgSync task to jump into its finally block
-      yield cancel(pollingTask);
-    } else if (graphAcceptedOrFetched.status === 200) {
-      yield put(yield put(fetchGraph.success(graphAcceptedOrFetched.data)));
-    }
-  } catch (error) {
-    if (error.response) {
-      const { status, data } = error.response;
-      yield put(fetchGraph.failure({ status, data }));
-    } else {
-      yield put(fetchGraph.failure(error.message));
-    }
-  } finally {
-    yield put(fetchGraph.fulfill());
-  }
+  const url = toApiPath(payload);
+  yield call(generateGraph, fetchGraph, apiJson, [url, JSON_OPTS]);
 }
 
 export function* fetchGraphRequestSaga() {
-  yield takeLatest(fetchGraph.TRIGGER, fetchGraphSaga);
+  yield takeEvery(fetchGraph.TRIGGER, fetchGraphSaga);
 }

package/src/sagas/graph/__tests__/backgroundGraphs.spec.js

@@ -0,0 +1,22 @@
+import { testSaga } from "redux-saga-test-plan";
+import { watchBackgroundGraphs, selectGeneration } from "../generation";
+import {
+  backgroundGraph,
+  clearGraph,
+  graphGeneration,
+} from "../../../routines";
+
+test("does not keep a timer running when no background graph is pending", () => {
+  const actions = [
+    backgroundGraph.TRIGGER,
+    clearGraph.TRIGGER,
+    graphGeneration.REQUEST,
+  ];
+  testSaga(watchBackgroundGraphs)
+    .next()
+    .take(actions)
+    .next()
+    .select(selectGeneration)
+    .next({ jobs: {} })
+    .take(actions);
+});

package/src/sagas/graph/__tests__/generation.spec.js

@@ -0,0 +1,247 @@
+import { apiJson } from "@truedat/core/services/api";
+import { runSaga, stdChannel } from "redux-saga";
+import { graphLoading } from "../../../reducers/graphLoading";
+import { graphGenerationState } from "../../../reducers/graphGenerationState";
+import { generateGraph } from "../generation";
+import {
+  backgroundGraph,
+  createGraph,
+  fetchGraph,
+  fetchLineageEvents,
+} from "../../../routines";
+
+const run = (api) => {
+  const actions = [];
+  let state = { graphGenerationState: undefined, graphLoading: false };
+  const dispatch = (action) => {
+    actions.push(action);
+    state = {
+      graphGenerationState: graphGenerationState(
+        state.graphGenerationState,
+        action,
+      ),
+      graphLoading: graphLoading(state.graphLoading, action),
+    };
+  };
+  const task = runSaga(
+    { dispatch, getState: () => state },
+    generateGraph,
+    createGraph,
+    api,
+    ["/graphs", {}],
+    true,
+  );
+  return { task, actions, dispatch, getState: () => state };
+};
+
+test("progress is loading, not failure", () => {
+  const progress = { data: { graph_hash: "a", retry: 2 } };
+  expect(graphLoading(true, fetchGraph.request(progress))).toEqual(progress);
+});
+
+test("close before the response keeps the graph in background", async () => {
+  let resolve;
+  const api = () =>
+    new Promise((done) => {
+      resolve = done;
+    });
+  const job = run(api);
+  job.dispatch(backgroundGraph());
+  resolve({ status: 201, data: { id: 42 } });
+  await job.task.toPromise();
+  expect(
+    job.actions.some((action) => action.type === createGraph.SUCCESS),
+  ).toBe(false);
+  expect(job.getState().graphLoading).toBe(false);
+  job.dispatch(
+    fetchLineageEvents.success({
+      data: [{ graph_id: 42, status: "COMPLETED" }],
+    }),
+  );
+  expect(
+    Object.values(job.getState().graphGenerationState.jobs)[0].status,
+  ).toBe("completed");
+});
+
+test("a foreground success publishes the graph", async () => {
+  const job = run(async () => ({ status: 201, data: { id: 42 } }));
+  await job.task.toPromise();
+  expect(
+    job.actions.find((action) => action.type === createGraph.SUCCESS).payload
+      .data,
+  ).toEqual({ id: 42, isRedirected: true });
+  expect(job.getState().graphLoading).toBe(false);
+});
+
+test("network failure is explicit and ends loading", async () => {
+  const job = run(async () => {
+    throw new Error("network");
+  });
+  await job.task.toPromise();
+  expect(
+    Object.values(job.getState().graphGenerationState.jobs)[0].status,
+  ).toBe("failed");
+  expect(
+    job.actions.filter((action) => action.type === createGraph.FAILURE),
+  ).toHaveLength(1);
+  expect(job.getState().graphLoading).toBe(false);
+});
+
+test("normalizes the GET graph envelope before publishing", async () => {
+  const job = run(async () => ({
+    status: 200,
+    data: { data: { id: 42, resources: [] } },
+  }));
+  await job.task.toPromise();
+  expect(
+    job.actions.find((action) => action.type === createGraph.SUCCESS).payload
+      .data.id,
+  ).toBe(42);
+});
+
+test("a late response cannot replace or finish the newer foreground request", async () => {
+  const actions = [];
+  let state = { graphGenerationState: undefined, graphLoading: false };
+  const dispatch = (action) => {
+    actions.push(action);
+    state = {
+      graphGenerationState: graphGenerationState(
+        state.graphGenerationState,
+        action,
+      ),
+      graphLoading: graphLoading(state.graphLoading, action),
+    };
+  };
+  let firstDone;
+  let secondDone;
+  const environment = { dispatch, getState: () => state };
+  const first = runSaga(
+    environment,
+    generateGraph,
+    createGraph,
+    () =>
+      new Promise((resolve) => {
+        firstDone = resolve;
+      }),
+    ["/graphs", {}],
+  );
+  const second = runSaga(
+    environment,
+    generateGraph,
+    createGraph,
+    () =>
+      new Promise((resolve) => {
+        secondDone = resolve;
+      }),
+    ["/graphs", {}],
+  );
+  firstDone({ status: 201, data: { id: 1 } });
+  await first.toPromise();
+  expect(state.graphLoading).toBeTruthy();
+  expect(actions.some((action) => action.type === createGraph.SUCCESS)).toBe(
+    false,
+  );
+  secondDone({ status: 201, data: { id: 2 } });
+  await second.toPromise();
+  expect(
+    actions
+      .filter((action) => action.type === createGraph.SUCCESS)
+      .map((action) => action.payload.data.id),
+  ).toEqual([2]);
+  expect(state.graphLoading).toBe(false);
+});
+
+test.each(["COMPLETED", "FAILED"])(
+  "stops polling on a %s event without publishing or failing the active graph",
+  async (status) => {
+    jest.useFakeTimers();
+    const channel = stdChannel();
+    const actions = [];
+    let state = { graphGenerationState: undefined, graphLoading: false };
+    const dispatch = (action) => {
+      actions.push(action);
+      state = {
+        graphGenerationState: graphGenerationState(
+          state.graphGenerationState,
+          action,
+        ),
+        graphLoading: graphLoading(state.graphLoading, action),
+      };
+      channel.put(action);
+    };
+    const api = jest.fn(async () => ({
+      status: 202,
+      data: { graph_hash: "a" },
+    }));
+    const task = runSaga(
+      { channel, dispatch, getState: () => state },
+      generateGraph,
+      createGraph,
+      api,
+      [],
+    );
+    try {
+      await Promise.resolve();
+      await Promise.resolve();
+      dispatch(backgroundGraph());
+      dispatch(
+        fetchLineageEvents.success({
+          data: [{ graph_hash: "a", graph_id: 5, status }],
+        }),
+      );
+      await Promise.resolve();
+      await Promise.resolve();
+      expect(task.isRunning()).toBe(false);
+      expect(jest.getTimerCount()).toBe(0);
+      expect(
+        actions.some(({ type }) =>
+          [createGraph.SUCCESS, createGraph.FAILURE].includes(type),
+        ),
+      ).toBe(false);
+      expect(Object.values(state.graphGenerationState.jobs)[0].status).toBe(
+        status === "COMPLETED" ? "completed" : "failed",
+      );
+    } finally {
+      task.cancel();
+      jest.useRealTimers();
+    }
+  },
+);
+
+jest.mock("@truedat/core/services/api", () => ({
+  apiJson: jest.fn(),
+  JSON_OPTS: {},
+}));
+
+test.each([false, true])(
+  "transient polling errors preserve the job (background=%s)",
+  async (background) => {
+    jest.useFakeTimers();
+    apiJson.mockReset();
+    apiJson
+      .mockRejectedValueOnce({ response: { status: 503 } })
+      .mockResolvedValueOnce({ status: 200, data: { id: 42 } });
+    const job = run(async () => ({ status: 202, data: { graph_hash: "a" } }));
+    try {
+      if (background) job.dispatch(backgroundGraph());
+      await jest.advanceTimersByTimeAsync(1000);
+      expect(
+        Object.values(job.getState().graphGenerationState.jobs)[0].status,
+      ).toBe("pending");
+      expect(job.actions.some(({ type }) => type === createGraph.FAILURE)).toBe(
+        false,
+      );
+      await jest.runAllTimersAsync();
+      await job.task.toPromise();
+      expect(
+        Object.values(job.getState().graphGenerationState.jobs)[0].status,
+      ).toBe(background ? "awaitingEvent" : "completed");
+      expect(job.actions.some(({ type }) => type === createGraph.SUCCESS)).toBe(
+        !background,
+      );
+    } finally {
+      job.task.cancel();
+      jest.useRealTimers();
+    }
+  },
+);