AlternateContentFilterInputStreamTest.java

// Copyright 2011 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.common;

import com.google.enterprise.connector.pusher.MockFeedConnection;
import com.google.enterprise.connector.pusher.XmlFeed;
import com.google.enterprise.connector.spi.SpiConstants.FeedType;
import com.google.enterprise.connector.traversal.FileSizeLimitInfo;

import junit.framework.TestCase;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * Tests AlternateContentFilterInputStream.
 */
public class AlternateContentFilterInputStreamTest extends TestCase {
  private static final String CONTENT = "Original Content";
  private static final String ALTERNATE_CONTENT = "Alternate Content";
  private static final String PREFIX = "Prefix ";
  private static final String SUFFIX = " Suffix";

  /** Test null source InputStream yields alternate content. */
  public void testNullSourceInputStream() throws Exception {
    checkACIS((InputStream) null, ALTERNATE_CONTENT);
  }

  /** Test empty source InputStream yields alternate content. */
  public void testEmptySourceInputStream() throws Exception {
    checkACIS(new EmptyInputStream(), ALTERNATE_CONTENT);
  }

  /** Test large source InputStream yields alternate content. */
  public void testBigSourceInputStream() throws Exception {
    checkACIS(new BigInputStream(), ALTERNATE_CONTENT);
  }

  /** Test normal source InputStream does not return alternate content. */
  public void testGoodInputStream() throws Exception {
    checkACIS(CONTENT, CONTENT);
  }

  /** Test null alternate InputStream returns default of 1 space. */
  public void testNullAlternateInputStream() throws Exception {
    checkACISReadByte(null, null, " ");
  }

  /** Test XmlFeed Rollback. */
  public void testFeedRollback() throws Exception {
    checkACIS(new BigInputStream(), newFeed(), ALTERNATE_CONTENT);
  }

  /** Test No XmlFeed Rollback. */
  public void testNoFeedRollback() throws Exception {
    checkACIS(new ByteArrayInputStream(CONTENT.getBytes()), newFeed(), CONTENT);
  }

  /** Test XmlFeed Rollback using single byte read(). */
  public void testFeedRollBackReadByte() throws Exception {
    checkACISReadByte(new BigInputStream(), ALTERNATE_CONTENT);
  }

  /** Test XmlFeed Rollback using single byte read(). */
  public void testFeedRollBackEmptyReadByte() throws Exception {
    checkACISReadByte(new EmptyInputStream(), ALTERNATE_CONTENT);
  }

  /** Test No XmlFeed Rollback using single byte read(). */
  public void testNoFeedRollBackReadByte() throws Exception {
    checkACISReadByte(new ByteArrayInputStream(CONTENT.getBytes()), CONTENT);
  }

  /** Returns a new XmlFeed */
  private XmlFeed newFeed() throws IOException {
    return new XmlFeed("test", FeedType.CONTENT, new FileSizeLimitInfo(),
                       null, new MockFeedConnection());
  }

  /** Check the AlternateContentInputStream produces the correct results. */
  private void checkACIS(String input, String expectedResult)
      throws Exception {
    checkACIS(new ByteArrayInputStream(input.getBytes()), expectedResult);
  }

  /** Check the AlternateContentInputStream produces the correct results. */
  private void checkACIS(InputStream source, String expectedResult)
      throws Exception {
    checkACIS(source, null, expectedResult);
  }

  /** Check the AlternateContentInputStream produces the correct results. */
  private void checkACIS(InputStream source, XmlFeed feed, String expectedResult)
      throws Exception {
    if (feed != null) {
      feed.reset(0);
      feed.write(PREFIX.getBytes());
    }
    InputStream alt = new ByteArrayInputStream(ALTERNATE_CONTENT.getBytes());
    InputStream is = new AlternateContentFilterInputStream(source, alt, null);
    assertNotNull(is);
    byte[] buffer = new byte[8192];
    int totalBytesRead = 0;
    int bytesRead;
    do {
      bytesRead = is.read(buffer, totalBytesRead, buffer.length - totalBytesRead);
      if (bytesRead > 0) {
        if (feed != null) {
          feed.write(buffer, totalBytesRead, bytesRead);
        }
        totalBytesRead += bytesRead;
      }
    } while (bytesRead != -1);
    assertEquals(expectedResult, new String(buffer, 0, totalBytesRead));
    if (feed != null) {
      feed.write(SUFFIX.getBytes());
      assertEquals(PREFIX + expectedResult + SUFFIX, feed.toString());
    }
  }

  /**
   * Check the AlternateContentInputStream single byte read() produces the
   * correct results.
   */
  private void checkACISReadByte(InputStream source, String expectedResult)
      throws Exception {
    checkACISReadByte(source,
                      new ByteArrayInputStream(ALTERNATE_CONTENT.getBytes()),
                      expectedResult);
  }

  /**
   * Check the AlternateContentInputStream single byte read() produces the
   * correct results.
   */
  private void checkACISReadByte(InputStream source, InputStream alt,
      String expectedResult) throws Exception {
    XmlFeed feed = newFeed();
    feed.reset(0);
    feed.write(PREFIX.getBytes());
    InputStream is = new AlternateContentFilterInputStream(source, alt, feed);
    assertFalse(is.markSupported());
    for (int ch; (ch = is.read()) != -1; feed.write(ch)) ;
    feed.write(SUFFIX.getBytes());
    assertEquals(PREFIX + expectedResult + SUFFIX, feed.toString());
  }

  private class BigInputStream extends BigEmptyDocumentFilterInputStream {
    public BigInputStream() {
      super(new ByteArrayInputStream("abcdefg".getBytes()), 4);
    }
  }

  private class EmptyInputStream extends BigEmptyDocumentFilterInputStream {
    public EmptyInputStream() {
      super(new ByteArrayInputStream("".getBytes()), 4);
    }
  }
}