fix a lot of tests

Author: MichaelBuessemeyer

frontend/javascripts/test/api/api_skeleton_latest.spec.ts

@@ -297,10 +297,12 @@ describe("API Skeleton", () => {
       {
         name: "group 3",
         groupId: 3,
+        isExpanded: false,
       },
       {
         name: "group 7",
         groupId: 7,
+        isExpanded: false,
       },
     ]);
 

frontend/javascripts/test/reducers/update_action_application/skeleton.spec.ts

@@ -91,7 +91,6 @@ const actionNamesHelper: Record<ApplicableSkeletonUpdateAction["name"], true> =
   updateUserBoundingBoxInSkeletonTracing: true,
   updateUserBoundingBoxVisibilityInSkeletonTracing: true,
   deleteUserBoundingBoxInSkeletonTracing: true,
-  // TODOM: Write tests for these update actions!!!
   updateActiveNode: true,
   updateTreeVisibility: true,
   updateTreeGroupVisibility: true,
@@ -134,6 +133,7 @@ describe("Update Action Application for SkeletonTracing", () => {
     SkeletonTracingActions.setActiveNodeAction(1),
     createNode(), // nodeId=11, tree components {11,1,2,9,10} {4,5,6,7,8}
     SkeletonTracingActions.deleteEdgeAction(1, 2), // tree components {11,1} {2,9,10} {4,5,6,7,8}
+    SkeletonTracingActions.setTreeVisibilityAction(1, false),
     SkeletonTracingActions.createTreeAction(),
     createNode(), // nodeId=12
     createNode(), // nodeId=13
@@ -152,6 +152,7 @@ describe("Update Action Application for SkeletonTracing", () => {
       makeBasicGroupObject(3, "group 3"),
       makeBasicGroupObject(7, "group 7"),
     ]),
+    SkeletonTracingActions.toggleTreeGroupAction(3),
     SkeletonTracingActions.setTreeGroupAction(7, 2),
     SkeletonTracingActions.setTreeEdgeVisibilityAction(2, false),
   ];
@@ -255,15 +256,27 @@ describe("Update Action Application for SkeletonTracing", () => {
         diffSkeletonTracing(newState.annotation.skeleton!, newState2.annotation.skeleton!),
       ),
     );
-
+    const updateActionsWithoutUpdatingActiveNode = updateActions.slice(0, 2);
     const newState3 = transformStateAsReadOnly(newState, (state) =>
       applyActions(state, [
-        SkeletonTracingActions.applySkeletonUpdateActionsFromServerAction(updateActions),
+        SkeletonTracingActions.applySkeletonUpdateActionsFromServerAction(
+          updateActionsWithoutUpdatingActiveNode,
+        ),
+      ]),
+    );
+
+    let { activeNodeId } = enforceSkeletonTracing(newState3.annotation);
+    expect(activeNodeId).toBe(null);
+
+    const updateActiveNodeAction = updateActions[2];
+    const newState4 = transformStateAsReadOnly(newState, (state) =>
+      applyActions(state, [
+        SkeletonTracingActions.applySkeletonUpdateActionsFromServerAction([updateActiveNodeAction]),
       ]),
     );
 
-    const { activeNodeId } = enforceSkeletonTracing(newState3.annotation);
-    expect(activeNodeId).toBeNull();
+    activeNodeId = enforceSkeletonTracing(newState4.annotation).activeNodeId;
+    expect(activeNodeId).toBe(1);
   });
 
   it("should clear the active node and active tree if the active tree was deleted", () => {
@@ -278,9 +291,10 @@ describe("Update Action Application for SkeletonTracing", () => {
       createNode, // nodeId=1
       createNode, // nodeId=2
       SkeletonTracingActions.setActiveTreeAction(2),
-    ]);
+    ]); // active tree: 2, active bode: null
     expect(getActiveTree(enforceSkeletonTracing(newState.annotation))?.treeId).toBe(2);
 
+    // newState2 has active tree: 2, active node: null
     const newState2 = applyActions(newState, [SkeletonTracingActions.deleteTreeAction(2)]);
 
     const updateActions = addMissingTimestampProp(
@@ -297,8 +311,8 @@ describe("Update Action Application for SkeletonTracing", () => {
 
     const { activeTreeId, activeNodeId } = enforceSkeletonTracing(newState3.annotation);
 
-    expect(activeNodeId).toBeNull();
-    expect(activeTreeId).toBeNull();
+    expect(activeNodeId).toBe(1);
+    expect(activeTreeId).toBe(1);
   });
 
   afterAll(() => {

frontend/javascripts/test/reducers/update_action_application/volume.spec.ts

@@ -71,7 +71,6 @@ const actionNamesHelper: Record<ApplicableVolumeUpdateAction["name"], true> = {
   deleteUserBoundingBoxInVolumeTracing: true,
   updateSegmentGroupsExpandedState: true,
   updateUserBoundingBoxVisibilityInVolumeTracing: true,
-  // TODOM: Write tests for these update actions below
   updateActiveSegmentId: true,
   updateSegmentVisibility: true,
   updateSegmentGroupVisibility: true,
@@ -117,6 +116,20 @@ describe("Update Action Application for VolumeTracing", () => {
       [makeBasicGroupObject(3, "group 3"), makeBasicGroupObject(7, "group 7")],
       tracingId,
     ),
+    VolumeTracingActions.updateSegmentAction(3, { isVisible: false }, tracingId),
+    // Needs to be visible again for the toggleSegmentGroupAction to turn all segments invisible and thus trigger a compact updateSegmentGroupVisibilityAction.
+    VolumeTracingActions.updateSegmentAction(3, { isVisible: true }, tracingId),
+    // The group with id 3 needs at least one visible cells for the reducer to make to toggle it.
+    VolumeTracingActions.updateSegmentAction(2, { groupId: 3 }, tracingId),
+    // Moreover, at least two are needed to make the compaction evict a updateSegmentGroupVisibilityAction.
+    VolumeTracingActions.createCellAction(4, 4),
+    VolumeTracingActions.setActiveCellAction(4),
+    VolumeTracingActions.updateSegmentAction(
+      4,
+      { groupId: 3, somePosition: [7, 8, 9], isVisible: true },
+      tracingId,
+    ),
+    VolumeTracingActions.toggleSegmentGroupAction(3, tracingId),
     VolumeTracingActions.removeSegmentAction(3, tracingId),
     VolumeTracingActions.setLargestSegmentIdAction(10000),
   ];
@@ -151,22 +164,18 @@ describe("Update Action Application for VolumeTracing", () => {
             userActions.slice(0, beforeVersionIndex),
           );
 
-          const state2WithoutActiveState = applyActions(state2WithActiveCell, [
-            VolumeTracingActions.setActiveCellAction(0),
+          const state2WithoutActiveBoundingBox = applyActions(state2WithActiveCell, [
             setActiveUserBoundingBoxId(null),
           ]);
 
           const actionsToApply = userActions.slice(beforeVersionIndex, afterVersionIndex + 1);
           const state3 = applyActions(
             state2WithActiveCell,
-            actionsToApply.concat([
-              VolumeTracingActions.setActiveCellAction(0),
-              setActiveUserBoundingBoxId(null),
-            ]),
+            actionsToApply.concat([setActiveUserBoundingBoxId(null)]),
           );
-          expect(state2WithoutActiveState !== state3).toBeTruthy();
+          expect(state2WithoutActiveBoundingBox !== state3).toBeTruthy();
 
-          const volumeTracing2 = enforceVolumeTracing(state2WithoutActiveState);
+          const volumeTracing2 = enforceVolumeTracing(state2WithoutActiveBoundingBox);
           const volumeTracing3 = enforceVolumeTracing(state3);
 
           const updateActionsBeforeCompaction = Array.from(
@@ -185,15 +194,36 @@ describe("Update Action Application for VolumeTracing", () => {
             seenActionTypes.add(action.name);
           }
 
-          const reappliedNewState = transformStateAsReadOnly(state2WithoutActiveState, (state) =>
-            applyActions(state, [
-              VolumeTracingActions.applyVolumeUpdateActionsFromServerAction(updateActions),
-              VolumeTracingActions.setActiveCellAction(0),
-              setActiveUserBoundingBoxId(null),
-            ]),
+          let reappliedNewState = transformStateAsReadOnly(
+            state2WithoutActiveBoundingBox,
+            (state) =>
+              applyActions(state, [
+                VolumeTracingActions.applyVolumeUpdateActionsFromServerAction(updateActions),
+                setActiveUserBoundingBoxId(null),
+              ]),
           );
 
-          expect(reappliedNewState).toEqual(state3);
+          // fixing activeUnmappedSegmentId mismatch as the frontend supports a createCellAction,
+          // which sets activeUnmappedSegmentId to null but the matching annotation update action equivalent
+          // "updateActiveSegmentId" sets activeUnmappedSegmentId to undefined.
+          if (
+            reappliedNewState.annotation.volumes[0].activeUnmappedSegmentId == null &&
+            state3.annotation.volumes[0].activeUnmappedSegmentId == null
+          ) {
+            reappliedNewState = update(reappliedNewState, {
+              annotation: {
+                volumes: {
+                  [0]: {
+                    activeUnmappedSegmentId: {
+                      $set: state3.annotation.volumes[0].activeUnmappedSegmentId,
+                    },
+                  },
+                },
+              },
+            });
+          }
+
+          expect(reappliedNewState.annotation.volumes[0]).toEqual(state3.annotation.volumes[0]);
         });
       });
     },

frontend/javascripts/test/sagas/annotation_saga.spec.ts

@@ -20,6 +20,7 @@ import { powerOrga } from "test/fixtures/dummy_organization";
 import { getCurrentMag } from "viewer/model/accessors/flycam_accessor";
 import { setZoomStepAction } from "viewer/model/actions/flycam_actions";
 import { setActiveOrganizationAction } from "viewer/model/actions/organization_actions";
+import { WkDevFlags } from "viewer/api/wk_dev";
 
 const blockingUser = { firstName: "Sample", lastName: "User", id: "1111" };
 
@@ -125,7 +126,9 @@ describe("Annotation Saga", () => {
     expect(context.mocks.acquireAnnotationMutex).not.toHaveBeenCalled();
   });
 
-  it<WebknossosTestContext>("An annotation with isUpdatingCurrentlyAllowed = true and othersMayEdit = true should not try to acquire the annotation mutex.", async (context: WebknossosTestContext) => {
+  it<WebknossosTestContext>("An annotation with isUpdatingCurrentlyAllowed = true and othersMayEdit = true should try to acquire the annotation mutex in liveCollab scenario.", async (context: WebknossosTestContext) => {
+    const initialLiveCollab = WkDevFlags.liveCollab;
+    WkDevFlags.liveCollab = true;
     await setupWebknossosForTesting(
       context,
       "hybrid",
@@ -145,9 +148,33 @@ describe("Annotation Saga", () => {
     expect(context.mocks.acquireAnnotationMutex).toHaveBeenCalled();
     const isUpdatingAllowed = Store.getState().annotation.isUpdatingCurrentlyAllowed;
     expect(isUpdatingAllowed).toBe(true);
+    WkDevFlags.liveCollab = initialLiveCollab;
+  });
+
+  it<WebknossosTestContext>("An annotation with isUpdatingCurrentlyAllowed = true and othersMayEdit = true should try to acquire the annotation mutex not in liveCollab.", async (context: WebknossosTestContext) => {
+    const initialLiveCollab = WkDevFlags.liveCollab;
+    WkDevFlags.liveCollab = false;
+    await setupWebknossosForTesting(
+      context,
+      "hybrid",
+      ({ tracings, annotationProto, dataset, annotation }) => {
+        const annotationWithUpdatingAllowedTrue = update(annotation, {
+          restrictions: { allowUpdate: { $set: true }, allowSave: { $set: true } },
+          othersMayEdit: { $set: true },
+        });
+        return {
+          tracings,
+          annotationProto,
+          dataset,
+          annotation: annotationWithUpdatingAllowedTrue,
+        };
+      },
+    );
+    expect(context.mocks.acquireAnnotationMutex).toHaveBeenCalled();
+    const isUpdatingAllowed = Store.getState().annotation.isUpdatingCurrentlyAllowed;
+    expect(isUpdatingAllowed).toBe(true);
+    WkDevFlags.liveCollab = initialLiveCollab;
   });
-  // TODOM: Test fail from here on when executed in a row and not solely. Fix this. Likely some  test isolation problem or so.
-  // The acquireAnnotationMutex spy reports that it was called although it shouldn't.
 
   it<WebknossosTestContext>("An annotation where othersMayEdit is turned on should try to acquire the annotation mutex.", async (context: WebknossosTestContext) => {
     await setupWebknossosForTesting(context, "hybrid");
@@ -273,7 +300,9 @@ describe("Annotation Saga", () => {
     expect(context.mocks.acquireAnnotationMutex).toHaveBeenCalled();
   });
 
-  it<WebknossosTestContext>(`An annotation with an active proofreading volume annotation with othersMayShare = true should not try to instantly acquire the mutex only after the user switches to a non Proofreading Tool ${ToolsAllowedInProofreadingModeWithoutLiveCollabSupport[1].id}.`, async (context: WebknossosTestContext) => {
+  it<WebknossosTestContext>(`An annotation with an active proofreading volume annotation with othersMayShare = true and liveCollab enabled should not try to instantly acquire the mutex only after the user switches to a non Proofreading Tool ${ToolsAllowedInProofreadingModeWithoutLiveCollabSupport[1].id}.`, async (context: WebknossosTestContext) => {
+    const initialLiveCollab = WkDevFlags.liveCollab;
+    WkDevFlags.liveCollab = true;
     await setupWebknossosForTesting(
       context,
       "hybrid",
@@ -297,5 +326,6 @@ describe("Annotation Saga", () => {
     Store.dispatch(setToolAction(ToolsAllowedInProofreadingModeWithoutLiveCollabSupport[1]));
     await sleep(500);
     expect(context.mocks.acquireAnnotationMutex).toHaveBeenCalled();
+    WkDevFlags.liveCollab = initialLiveCollab;
   });
 });