OrderedSnapshotWriterTest.java

// Copyright 2013 Google 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.

package com.google.enterprise.connector.util.diffing;

import static org.easymock.EasyMock.capture;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.expectLastCall;
import static org.easymock.EasyMock.getCurrentArguments;
import static org.easymock.EasyMock.isA;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;

import junit.framework.TestCase;

import org.easymock.Capture;
import org.easymock.CaptureType;
import org.easymock.IAnswer;

import java.util.List;

public class OrderedSnapshotWriterTest extends TestCase {
  /* A mockable, comparable snapshot interface. */
  private interface ComparableDocumentSnapshot
      extends DocumentSnapshot, Comparable<DocumentSnapshot> {
  }

  /** Creates a mock snapshot that expects only calls to getDocumentId. */
  /* TODO(jlacey): This method is copied in DocumentSnapshotComparatorTest. */
  private <T extends DocumentSnapshot> T getDocumentId(Class<T> snapshotClass,
      String docid) {
    T snapshot = createMock(snapshotClass);
    expect(snapshot.getDocumentId())
        .andReturn(docid)
        .anyTimes();
    replay(snapshot);
    return snapshot;
  }

  /** Creates a mock comparable snapshot that compares numeric document IDs. */
  private DocumentSnapshot numericCompareTo(final String docid) {
    ComparableDocumentSnapshot snapshot =
        createMock(ComparableDocumentSnapshot.class);
    expect(snapshot.compareTo(isA(DocumentSnapshot.class)))
        .andAnswer(new IAnswer<Integer>() {
              public Integer answer() throws Throwable {
                return Integer.valueOf(docid).compareTo(
                    Integer.valueOf(
                        ((DocumentSnapshot) getCurrentArguments()[0])
                        .getDocumentId()));
              }
            })
        .anyTimes();
    expect(snapshot.getDocumentId())
        .andReturn(docid)
        .anyTimes();
    replay(snapshot);
    return snapshot;
  }

  /**
   * Tests that writing the given snapshots to the writer actually
   * writes the snapshots with the given document IDs.
   */
  private void testOrderedSnapshotWriter(List<DocumentSnapshot> snapshots,
      List<String> docids) throws SnapshotWriterException {
    SnapshotWriter writer = createMock(SnapshotWriter.class);
    final Capture<DocumentSnapshot> captures =
        new Capture<DocumentSnapshot>(CaptureType.ALL);
    writer.write(capture(captures));
    expectLastCall().anyTimes();
    expect(writer.getRecordCount())
        .andAnswer(new IAnswer<Long>() {
              public Long answer() throws Throwable {
                return new Long(captures.getValues().size());
              }
            });
    replay(writer);

    OrderedSnapshotWriter ordered = new OrderedSnapshotWriter(writer);
    for (DocumentSnapshot snapshot : snapshots) {
      ordered.write(snapshot);
    }

    assertEquals(docids.size(), ordered.getRecordCount());
    assertEquals(docids, getDocumentIds(captures.getValues()));
  }

  /** Transforms a list of snapshots to a list of their document IDs. */
  private List<String> getDocumentIds(List<DocumentSnapshot> snapshots) {
    List<String> docids = Lists.newArrayList();
    for (DocumentSnapshot snapshot : snapshots) {
      docids.add(snapshot.getDocumentId());
    }
    return docids;
  }

  /** Transforms an array of docids to a list of mock snapshots. */
  private List<DocumentSnapshot> docidOrdering(String... docids) {
    List<DocumentSnapshot> snapshots = Lists.newArrayList();
    for (String docid : docids) {
      snapshots.add(getDocumentId(DocumentSnapshot.class, docid));
    }
    return snapshots;
  }

  /**
   * Transforms an array of docids to a list of mock comparable
   * snapshots that compare numeric document IDs.
   */
  private List<DocumentSnapshot> numericOrdering(String... docids) {
    List<DocumentSnapshot> snapshots = Lists.newArrayList();
    for (String docid : docids) {
      snapshots.add(numericCompareTo(docid));
    }
    return snapshots;
  }

  public void testUniqueDocids() throws SnapshotWriterException {
    testOrderedSnapshotWriter(
        docidOrdering("1", "2", "3", "4", "5"),
        ImmutableList.of("1", "2", "3", "4", "5"));
  }

  public void testDuplicateDocids() throws SnapshotWriterException {
    testOrderedSnapshotWriter(
        docidOrdering("1", "2", "3", "4", "2", "4", "5"),
        ImmutableList.of("1", "2", "3", "4", "5"));
  }

  public void testUnpaddedNumericDocids() throws SnapshotWriterException {
    testOrderedSnapshotWriter(
        docidOrdering(
            "1", "5", "10", "15", "50", "100", "200", "500"),
        ImmutableList.of(
            "1", "5", "50", "500"));
  }

  public void testPaddedNumericDocids() throws SnapshotWriterException {
    testOrderedSnapshotWriter(
        docidOrdering(
            "001", "005", "010", "015", "050", "100", "200", "500"),
        ImmutableList.of(
            "001", "005", "010", "015", "050", "100", "200", "500"));
  }

  /** Finally, the piece de resistance. */
  public void testNumericComparator() throws SnapshotWriterException {
    testOrderedSnapshotWriter(
        numericOrdering(
            "1", "5", "10", "15", "50", "100", "200", "500"),
        ImmutableList.of(
            "1", "5", "10", "15", "50", "100", "200", "500"));
  }

  public void testClose() throws SnapshotWriterException {
    SnapshotWriter writer = createMock(SnapshotWriter.class);
    writer.close();
    replay(writer);

    OrderedSnapshotWriter ordered = new OrderedSnapshotWriter(writer);
    ordered.close();
    verify(writer);
  }

  public void testGetPath() throws SnapshotWriterException {
    SnapshotWriter writer = createMock(SnapshotWriter.class);
    expect(writer.getPath())
        .andReturn("/something/else");
    replay(writer);

    OrderedSnapshotWriter ordered = new OrderedSnapshotWriter(writer);
    assertEquals("/something/else", ordered.getPath());
  }

  public void testGetRecordCount() throws SnapshotWriterException {
    SnapshotWriter writer = createMock(SnapshotWriter.class);
    expect(writer.getRecordCount())
        .andReturn(42L);
    replay(writer);

    OrderedSnapshotWriter ordered = new OrderedSnapshotWriter(writer);
    assertEquals(42L, ordered.getRecordCount());
  }
}