/** * Sets up that the transform call after all existing expectations must be one * with a client input delta consisting of the given ops. * * @return the expectation which should be set to either * {@link Expectation#echo()} the client input delta or return some * transformed delta using * {@link Expectation#transformTo(WaveletOperation...)}. */ public Expectation expect(WaveletOperation... ops) { Expectation expectation = new Expectation(ops); expectations.addLast(expectation); return expectation; }
@Override public DeltaPair transform(Iterable<WaveletOperation> client, Iterable<WaveletOperation> server) { Expectation expectation = expectations.removeFirst(); expectation.assertClientInputValid(client); DeltaPair result = expectation.getOutput(); return result; } }
/** * Test we compose operations after we've transformed. However, we should get several * transformed client operations out in the same delta if they don't compose. */ public void testGettingSeveralOpsInOneDelta() throws TransformException { DeltaTestUtil util = new DeltaTestUtil(BOB); // Do 1 client op queue.add(util.noOpDocOp("blipA")); // Get a server op transformer.expect(util.noOpDocOp("blipA")).echo(); assertEquals(transformer.getOutputServerDelta(), // \u2620 queue.transform(transformer.getInputServerDelta())); // Do another client op queue.add(util.noOpDocOp("blipB")); // Get a server op transformer.expect(util.noOpDocOp("blipA"), util.noOpDocOp("blipB")).echo(); assertEquals(transformer.getOutputServerDelta(), // \u2620 queue.transform(transformer.getInputServerDelta())); // Should get 2 ops in the same delta assertQueueSizeBetween(1, 2); assertEquals(list(util.noOpDocOp("blipA"), util.noOpDocOp("blipB")), copyList(queue.take())); assertQueueIsEmpty(); }
/** * Tests that deltas which become empty due to a transform are discarded from * the queue. */ public void testDeltasEmptyAfterTransformAreDiscarded() throws TransformException { queue.add(BOB_A); queue.add(JIM_A); queue.add(BOB_B); queue.add(TOM_B); queue.add(BOB_C); transformer.expect(BOB_A).kill(); transformer.expect(JIM_A).echo(); transformer.expect(BOB_B).kill(); transformer.expect(TOM_B).echo(); transformer.expect(BOB_C).kill(); assertEquals(transformer.getOutputServerDelta(), // \u2620 queue.transform(transformer.getInputServerDelta())); transformer.checkDone(); assertQueueSizeBetween(1, 2); assertEquals(list(JIM_A), copyList(queue.take())); assertEquals(list(TOM_B), copyList(queue.take())); assertQueueIsEmpty(); }
/** * Since transform and compose doesn't commute, test we don't compose operations after * we've sent the operation. So when we push to head, we shouldn't merge sent deltas. */ public void testNoCompositionWithInsertHead() throws TransformException { DeltaTestUtil util = new DeltaTestUtil(BOB); // Do 1 client op queue.add(util.noOpDocOp("blipA")); // Pushing an op to the head should never merge queue.insertHead(Arrays.asList(util.noOpDocOp("blipA"))); // Get a server op transformer.expect(util.noOpDocOp("blipA")).echo(); transformer.expect(util.noOpDocOp("blipA")).echo(); assertEquals(transformer.getOutputServerDelta(), // \u2620 queue.transform(transformer.getInputServerDelta())); // Should be 2 deltas a the first one is not mergable assertQueueSizeBetween(1, 2); assertEquals(list(util.noOpDocOp("blipA")), copyList(queue.take())); assertEquals(list(util.noOpDocOp("blipA")), copyList(queue.take())); assertQueueIsEmpty(); }
/** * Tests that deltas with the same author are merged if they end up being * consecutive after deltas which were previously dividing them are discarded * in a transform. */ public void testAdjacentDeltasBySameAuthorAfterTransformDiscardsAreMerged() throws TransformException { queue.add(BOB_A); queue.add(JIM_A); queue.add(BOB_B); queue.add(TOM_B); queue.add(BOB_C); transformer.expect(BOB_A).echo(); transformer.expect(JIM_A).kill(); transformer.expect(BOB_B).echo(); transformer.expect(TOM_B).kill(); transformer.expect(BOB_C).echo(); assertEquals(transformer.getOutputServerDelta(), // \u2620 queue.transform(transformer.getInputServerDelta())); transformer.checkDone(); assertQueueSizeBetween(1, 3); assertEquals(list(BOB_A, BOB_B, BOB_C), copyList(queue.take())); assertQueueIsEmpty(); }
/** * Tests that deltas with the same author are merged if they end up being * consecutive after deltas which were previously dividing them are discarded * in a transform. */ public void testAdjacentDeltasBySameAuthorAfterTransformDiscardsAreMerged() throws TransformException { queue.add(BOB_A); queue.add(JIM_A); queue.add(BOB_B); queue.add(TOM_B); queue.add(BOB_C); transformer.expect(BOB_A).echo(); transformer.expect(JIM_A).kill(); transformer.expect(BOB_B).echo(); transformer.expect(TOM_B).kill(); transformer.expect(BOB_C).echo(); assertEquals(transformer.getOutputServerDelta(), // \u2620 queue.transform(transformer.getInputServerDelta())); transformer.checkDone(); assertQueueSizeBetween(1, 3); assertEquals(list(BOB_A, BOB_B, BOB_C), copyList(queue.take())); assertQueueIsEmpty(); }
/** * Test we still compose operations after we've transformed. */ public void testComposistionAfterTransform() throws TransformException { DeltaTestUtil util = new DeltaTestUtil(BOB); // 2 ops merged into one. queue.add(util.noOpDocOp("blipA")); queue.add(util.noOpDocOp("blipA")); // Get a server op transformer.expect(util.noOpDocOp("blipA")).echo(); assertEquals(transformer.getOutputServerDelta(), // \u2620 queue.transform(transformer.getInputServerDelta())); // Adding one more operation after that should not merge into previously // transformed client op queue.add(util.noOpDocOp("blipA")); // This operation should merge into the previous op as the previous op is not // yet transformed queue.add(util.noOpDocOp("blipA")); // Should get 1 op, the result of merging and composing the two deltas. assertQueueSizeBetween(1, 3); assertEquals(list(util.noOpDocOp("blipA")), copyList(queue.take())); assertQueueIsEmpty(); }
/** * Test we compose operations after we've transformed. However, we should get several * transformed client operations out in the same delta if they don't compose. */ public void testGettingSeveralOpsInOneDelta() throws TransformException { DeltaTestUtil util = new DeltaTestUtil(BOB); // Do 1 client op queue.add(util.noOpDocOp("blipA")); // Get a server op transformer.expect(util.noOpDocOp("blipA")).echo(); assertEquals(transformer.getOutputServerDelta(), // \u2620 queue.transform(transformer.getInputServerDelta())); // Do another client op queue.add(util.noOpDocOp("blipB")); // Get a server op transformer.expect(util.noOpDocOp("blipA"), util.noOpDocOp("blipB")).echo(); assertEquals(transformer.getOutputServerDelta(), // \u2620 queue.transform(transformer.getInputServerDelta())); // Should get 2 ops in the same delta assertQueueSizeBetween(1, 2); assertEquals(list(util.noOpDocOp("blipA"), util.noOpDocOp("blipB")), copyList(queue.take())); assertQueueIsEmpty(); }
/** * Test we still compose operations after we've transformed. */ public void testComposistionAfterTransform() throws TransformException { DeltaTestUtil util = new DeltaTestUtil(BOB); // 2 ops merged into one. queue.add(util.noOpDocOp("blipA")); queue.add(util.noOpDocOp("blipA")); // Get a server op transformer.expect(util.noOpDocOp("blipA")).echo(); assertEquals(transformer.getOutputServerDelta(), // \u2620 queue.transform(transformer.getInputServerDelta())); // Adding one more operation after that should not merge into previously // transformed client op queue.add(util.noOpDocOp("blipA")); // This operation should merge into the previous op as the previous op is not // yet transformed queue.add(util.noOpDocOp("blipA")); // Should get 1 op, the result of merging and composing the two deltas. assertQueueSizeBetween(1, 3); assertEquals(list(util.noOpDocOp("blipA")), copyList(queue.take())); assertQueueIsEmpty(); }
/** * Tests that deltas which become empty due to a transform are discarded from * the queue. */ public void testDeltasEmptyAfterTransformAreDiscarded() throws TransformException { queue.add(BOB_A); queue.add(JIM_A); queue.add(BOB_B); queue.add(TOM_B); queue.add(BOB_C); transformer.expect(BOB_A).kill(); transformer.expect(JIM_A).echo(); transformer.expect(BOB_B).kill(); transformer.expect(TOM_B).echo(); transformer.expect(BOB_C).kill(); assertEquals(transformer.getOutputServerDelta(), // \u2620 queue.transform(transformer.getInputServerDelta())); transformer.checkDone(); assertQueueSizeBetween(1, 2); assertEquals(list(JIM_A), copyList(queue.take())); assertEquals(list(TOM_B), copyList(queue.take())); assertQueueIsEmpty(); }
/** * Since transform and compose doesn't commute, test we don't compose operations after * we've sent the operation. So when we push to head, we shouldn't merge sent deltas. */ public void testNoCompositionWithInsertHead() throws TransformException { DeltaTestUtil util = new DeltaTestUtil(BOB); // Do 1 client op queue.add(util.noOpDocOp("blipA")); // Pushing an op to the head should never merge queue.insertHead(Arrays.asList(util.noOpDocOp("blipA"))); // Get a server op transformer.expect(util.noOpDocOp("blipA")).echo(); transformer.expect(util.noOpDocOp("blipA")).echo(); assertEquals(transformer.getOutputServerDelta(), // \u2620 queue.transform(transformer.getInputServerDelta())); // Should be 2 deltas a the first one is not mergable assertQueueSizeBetween(1, 2); assertEquals(list(util.noOpDocOp("blipA")), copyList(queue.take())); assertEquals(list(util.noOpDocOp("blipA")), copyList(queue.take())); assertQueueIsEmpty(); }
/** * Tests that deltas which are transformed make their way back into the queue, * replacing the untransformed versions and being sent out of take(). */ public void testTransformedDeltasReplaceOriginals() throws TransformException { queue.add(BOB_A); queue.add(BOB_B); queue.add(JIM_C); transformer.expect(BOB_A, BOB_B).transformTo(BOB_A); transformer.expect(JIM_C).echo(); assertEquals(transformer.getOutputServerDelta(), // \u2620 queue.transform(transformer.getInputServerDelta())); transformer.checkDone(); assertQueueSizeBetween(1, 2); assertEquals(list(BOB_A), copyList(queue.take())); assertEquals(list(JIM_C), copyList(queue.take())); assertQueueIsEmpty(); }
/** * Tests that deltas which are transformed make their way back into the queue, * replacing the untransformed versions and being sent out of take(). */ public void testTransformedDeltasReplaceOriginals() throws TransformException { queue.add(BOB_A); queue.add(BOB_B); queue.add(JIM_C); transformer.expect(BOB_A, BOB_B).transformTo(BOB_A); transformer.expect(JIM_C).echo(); assertEquals(transformer.getOutputServerDelta(), // \u2620 queue.transform(transformer.getInputServerDelta())); transformer.checkDone(); assertQueueSizeBetween(1, 2); assertEquals(list(BOB_A), copyList(queue.take())); assertEquals(list(JIM_C), copyList(queue.take())); assertQueueIsEmpty(); }
public void testCompositionBeforeTransform() throws TransformException { DeltaTestUtil util = new DeltaTestUtil(BOB); // 2 ops merged into one. queue.add(util.noOpDocOp("blipA")); queue.add(util.noOpDocOp("blipA")); // Get a server op transformer.expect(util.noOpDocOp("blipA")).echo(); assertEquals(transformer.getOutputServerDelta(), // \u2620 queue.transform(transformer.getInputServerDelta())); // Should get only 1 op assertQueueSize(1); assertEquals(list(util.noOpDocOp("blipA")), copyList(queue.take())); assertQueueIsEmpty(); }
public void kill() { transformTo(); }
public void kill() { transformTo(); }
/** * Sets up that the transform call after all existing expectations must be one * with a client input delta consisting of the given ops. * * @return the expectation which should be set to either * {@link Expectation#echo()} the client input delta or return some * transformed delta using * {@link Expectation#transformTo(WaveletOperation...)}. */ public Expectation expect(WaveletOperation... ops) { Expectation expectation = new Expectation(ops); expectations.addLast(expectation); return expectation; }
/** * Gets the delta that should be produced if all expected transforms are * performed in order on the {@link #getInputServerDelta()}. */ public List<WaveletOperation> getOutputServerDelta() { List<WaveletOperation> delta; if (expectations.isEmpty()) { delta = firstServerInputDelta; } else { delta = expectations.getLast().getOutput().getServer(); } return delta; }
public void testCompositionBeforeTransform() throws TransformException { DeltaTestUtil util = new DeltaTestUtil(BOB); // 2 ops merged into one. queue.add(util.noOpDocOp("blipA")); queue.add(util.noOpDocOp("blipA")); // Get a server op transformer.expect(util.noOpDocOp("blipA")).echo(); assertEquals(transformer.getOutputServerDelta(), // \u2620 queue.transform(transformer.getInputServerDelta())); // Should get only 1 op assertQueueSize(1); assertEquals(list(util.noOpDocOp("blipA")), copyList(queue.take())); assertQueueIsEmpty(); }