wave/src/test/java/org/waveprotocol/wave/model/adt/docbased/DocumentBasedMonotonicValueTest.java

/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 */
package org.waveprotocol.wave.model.adt.docbased;


import junit.framework.TestCase;

import org.waveprotocol.wave.model.adt.MonotonicValue;
import org.waveprotocol.wave.model.adt.ObservableMonotonicValue;
import org.waveprotocol.wave.model.adt.docbased.TestUtil.ValueContext;
import org.waveprotocol.wave.model.document.ObservableMutableDocument;
import org.waveprotocol.wave.model.document.operation.impl.AttributesImpl;
import org.waveprotocol.wave.model.document.util.DefaultDocumentEventRouter;
import org.waveprotocol.wave.model.testing.BasicFactories;
import org.waveprotocol.wave.model.testing.ExtraAsserts;
import org.waveprotocol.wave.model.util.Serializer;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Test cases for {@link DocumentBasedMonotonicValue}.
 *
 */

public class DocumentBasedMonotonicValueTest extends TestCase {

  private final static String CONTAINER_TAG = "supplement";
  private final static String ENTRY_TAG = "all";
  private final static String VALUE_ATTR = "read";

  private static final class MockListener<C extends Comparable<C>> implements
      ObservableMonotonicValue.Listener<C>{

    private final List<C> expectedValues;
    private int index = 0;

    public MockListener() {
      this.expectedValues = new ArrayList<C>();
    }

    @Override
    public void onSet(C oldValue, C newValue) {
      if (index == expectedValues.size() - 1) {
        fail("Unexpected event #" + (index + 1) + " " + oldValue + " -> " + newValue);
      }
      assertEquals(expectedValues.get(index), oldValue);
      index++;
      assertEquals(expectedValues.get(index), newValue);
    }

    void finished() {
      assertEquals(expectedValues.size() - 1, index);
    }

    C getLast() {
      if (expectedValues.isEmpty()) {
        throw new RuntimeException("Must have at least one expected value, which would be initial");
      }
      return expectedValues.get(expectedValues.size() - 1);
    }

    @SuppressWarnings("unchecked")
    void expect(C ... expectedValues) {
      this.expectedValues.addAll(Arrays.asList(expectedValues));
    }
  }

  /**
   * Hack for simulating mutation events caused by a remote agent making
   * modifications to the document underlying the map.
   *
   * Used to be used to simulate document events. Documents now broadcast
   * events.
   *
   * TODO(user): delete all the scaffolding that's obviated by real events.
   */
  private final static class FungeStack<N, E extends N, C extends Comparable<C>> {
    private final ValueContext<N, E> context;
    private final DocumentBasedMonotonicValue<E, C> target;
    private final Serializer<C> serializer;
    private final MockListener<C> listener = new MockListener<C>();

    public FungeStack(ValueContext<N, E> context,
        DocumentBasedMonotonicValue<E, C> target, Serializer<C> serializer) {
      this.context = context;
      this.target = target;
      this.serializer = serializer;
      target.addListener(listener);
    }

    void addEntry(C value) {
      Map<String, String> attrs = new HashMap<String, String>();
      attrs.put(VALUE_ATTR, serializer.toString(value));
      E child =
          context.doc.createChildElement(context.container, ENTRY_TAG, new AttributesImpl(attrs));
    }

    void assertSubstrateEquals(Integer ... expected) {
      ExtraAsserts.assertStructureEquivalent(substrate(expected).doc, context.doc);
    }
  }

  /** Target state, containing the map being tested and its subtrate. */
  private FungeStack<?, ?, Integer> stack;

  //
  // Test-specific setup helpers.
  //

  /**
   * Creates an target map based on an initial list of entries.  The entries
   * are used to build a substrate document, and the target map is instantiated
   * on that substrate.
   */
  private void createTargetOn(Integer ... state) {
    fungeCreateTargetOn(substrate(state));
  }

  // Funge method to work around Sun JDK's laughably poor type inference.
  private <N> void fungeCreateTargetOn(ValueContext<N, ?> context) {
    createTargetOn(context);
  }

  /**
   * Creates a target map on a substrate.
   */
  private <N, E extends N> void createTargetOn(ValueContext<N, E> context) {
    DocumentBasedMonotonicValue<E, Integer> target =
      DocumentBasedMonotonicValue.create(DefaultDocumentEventRouter.create(context.doc),
          context.container, Serializer.INTEGER, ENTRY_TAG, VALUE_ATTR);

    // Eventually, the target map and the substrate should be sufficient state for all tests.
    // However, in order to simulate document events, the two need to be wrapped together in a
    // FungeStack so that Java knows that the element type-parameters match.
    stack = new FungeStack<N, E, Integer>(context, target, Serializer.INTEGER);
  }

  /**
   * Creates a substrate based on a list of entries.
   *
   * @param values list of entries to include in the document state
   * @return a map-context view of the document state
   */
  private static ValueContext<?, ?> substrate(Integer ... values) {
    return substrate(BasicFactories.observableDocumentProvider().create("data",
        Collections.<String, String>emptyMap()),
        values);
  }

  /**
   * Populates a document with an initial map state defined by an entry list.
   *
   * @return a map-context view of the document state.
   */
  private static <N, E extends N> ValueContext<N, E> substrate(
      ObservableMutableDocument<N, E, ?> doc,
      Integer ... values) {
    // Insert container element
    E container = doc.createChildElement(doc.getDocumentElement(), CONTAINER_TAG,
        Collections.<String,String>emptyMap());

    // Insert entries
    for (Integer x : values) {
      Map<String, String> attrs = new HashMap<String, String>();
      attrs.put(VALUE_ATTR, Serializer.INTEGER.toString(x));
      doc.createChildElement(container, ENTRY_TAG, new AttributesImpl(attrs));
    }

    return new ValueContext<N, E>(doc, container);
  }

  /**
   * Asserts that the test-target's document substrate is in an expected state.
   *
   * @param expected  list of entries describing the expected state
   */
  private void assertSubstrateEquals(Integer ... expected) {
    stack.assertSubstrateEquals(expected);
  }

  /**
   * Creates an empty map as the test target.
   */
  private void createEmptyValue() {
    createTargetOn();
  }

  /**
   * Adds an entry to the target value's underlying state.  This simulates a
   * concurrent modification by some other agent.
   *
   * @param value
   */
  private void addEntry(int value) {
    stack.addEntry(value);
  }

  /**
   * @return the target map being tested.
   */
  private MonotonicValue<Integer> getTarget() {
    return stack.target;
  }

  /**
   * Sets up event handling mock
   * @param values history of values, including the initial one
   */
  private void expectHistory(Integer ... values) {
    stack.listener.expect(values);
  }

  private void check() {
    stack.listener.finished();
    assertEquals(new Integer(stack.listener.getLast()), getTarget().get());
  }

  /**
   * Checks the value is in the expected state, and that it is represented by
   * the given set of numbers.
   *
   * @param substrateValues
   */
  private void checkDirty(Integer ... substrateValues) {
    check();
    assertSubstrateEquals(substrateValues);
  }

  /**
   * Check the value is in the expected state, and that it is represented
   * cleanly; i.e., only one element in the substrate.
   */
  private void checkClean() {
    check();
    assertSubstrateEquals(stack.listener.getLast());
  }

  public void testSetOnEmptyStateIsReturnedByGetAndInsertsIntoSubstrate() {
    createEmptyValue();
    expectHistory(null, 10);
    getTarget().set(10);
    checkClean();
  }

  public void testLeavesObsoleteEntriesOnLoadButCleansOnWrite() {
    // Set up the target with some initial state.
    createTargetOn(10, 30, 20);
    assertSubstrateEquals(10, 30, 20);

    expectHistory(30, 40);
    getTarget().set(40);
    checkClean();
  }

  public void testSetOfALesserValuesDoesNothing() {
    // Set up the target with some initial state.
    createTargetOn(10);
    getTarget().set(5);

    assertEquals(new Integer(10), getTarget().get());
    assertSubstrateEquals(10);
  }

  public void testSetOfAGreaterValuesReplacesOld() {
    // Set up the target with some initial state.
    createTargetOn(10);
    expectHistory(10, 20);
    getTarget().set(20);
    checkClean();
  }

  public void testRemoteAddedLesserEntriesScheduledForRemoval() {
    // Set up the target with some initial state.

    createTargetOn(20);
    expectHistory(20);

    // Add an entry remotely.
    addEntry(10);
    checkDirty(20, 10);

    // Perform mutation, expecting cleanup.
    expectHistory(30);
    getTarget().set(30);
    checkClean();
  }

  public void testRemoteAddedGreaterEntriesReplaceOldEntryButIsNotCleaned() {
    // Set up the target with some initial state.
    createTargetOn(10);
    expectHistory(10, 20);

    // Add an entry remotely.
    addEntry(20);
    checkDirty(10, 20);
  }
}