test/com/google/enterprise/adaptor/DownloadDumpHandlerTest.java - plexi - Git at Google

 // Copyright 2013 Google Inc. All Rights Reserved.
 //
 // 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.adaptor;

 import static org.junit.Assert.*;

 import org.junit.After;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;

 import java.io.ByteArrayInputStream;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.charset.Charset;

 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.TimeZone;
 import java.util.TreeMap;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipInputStream;


 /**
  * Tests for {@link DownloadDumpHandler}.
  */
 public class DownloadDumpHandlerTest {
   private final Config config = new Config();
   private DownloadDumpHandler handler =
       new ModifiedDownloadDumpHandler(config, "adaptor");
   private final String pathPrefix = "/";
   private final MockHttpContext httpContext =
       new MockHttpContext(handler, pathPrefix);
   private MockHttpExchange ex = createExchange("");
   private TimeZone previousTimeZone;

   @Rule
   public ExpectedException thrown = ExpectedException.none();

   @Before
   public void setUp() {
     // problems arise if gsa.version is left unset
     config.setValue("gsa.version", "7.0.14-114");
     previousTimeZone = TimeZone.getDefault();
     TimeZone.setDefault(TimeZone.getTimeZone("PST"));
   }

   @After
   public void tearDown() {
     TimeZone.setDefault(previousTimeZone);
   }

   @Test
   public void testNullConfig() throws Exception {
     thrown.expect(NullPointerException.class);
     handler = new DownloadDumpHandler(null, "feedname", null);
   }

   @Test
   public void testNullFeedName() throws Exception {
     thrown.expect(NullPointerException.class);
     handler = new ModifiedDownloadDumpHandler(config, null);
   }

   @Test
   public void testIllegalFeedName() throws Exception {
     thrown.expect(IllegalArgumentException.class);
     handler = new ModifiedDownloadDumpHandler(config, "bad\"name");
   }

   @Test
   public void testPost() throws Exception {
     ex = new MockHttpExchange("POST", pathPrefix, httpContext);
     handler.handle(ex);
     assertEquals(405, ex.getResponseCode());
   }

   @Test
   public void testNotFound() throws Exception {
     ex = createExchange("notfound");
     handler.handle(ex);
     assertEquals(404, ex.getResponseCode());
   }

   @Test
   public void testLogFilesWithCannedLogsDir() throws Exception {
     // set up File using MockFile
     MockFile mockLogsDir = new MockFile("parentDir").setChildren(new File[] {
       new MockFile("log1.log").setFileContents("Log file 1"),
       new MockFile("log1.log.lck").setFileContents("skipped lock file"),
       new MockFile("log2.log").setFileContents("Log file 2"),
       new MockFile("subdir").setChildren(new File[] {
         new MockFile("nested.log").setFileContents("This file skipped.")
       })});
     MockTimeProvider timeProvider = new MockTimeProvider();
     timeProvider.time = 1383763470000L; // November 6, 2013 @ 10:44:30
     StatRpcMethod statRpcMethod = new MockStatRpcMethod(
         new MockJournal(new MockTimeProvider()),
         new MockAdaptor(),
         /*isAdaptorIncremental=*/ false,
         /*configFile=*/ new MockFile("no-such-dir").setExists(false));
     handler = new ModifiedDownloadDumpHandler(config, "adaptor",
         statRpcMethod, mockLogsDir, timeProvider);
     handler.handle(ex);
     assertEquals(200, ex.getResponseCode());
     assertEquals("application/zip",
         ex.getResponseHeaders().getFirst("Content-Type"));
     assertEquals("attachment; filename=\"adaptor-20131106.zip\"",
         ex.getResponseHeaders().getFirst("Content-Disposition"));
     // extract the zip contents and just count the number of entries
     byte[] zipContents = ex.getResponseBytes();
     int entries = countZipEntries(zipContents);
     assertEquals(5, entries); /* 2 log files + thread dump + config + stats */

     // verify contents of thread dump
     String threadContents = extractFileFromZip("threaddump.txt", zipContents);
     assertTrue(threadContents.contains("Thread[Signal Dispatcher,"));
     assertTrue(threadContents.contains("Thread[main,"));

     // verify contents of config file
     String configContents = extractFileFromZip("config.txt", zipContents);
     // search for: \ngsa.version[spaces]= 7.0.14-114\n
     int position = configContents.indexOf("\ngsa.version");
     assertTrue(position > 0);
     int equals = configContents.indexOf("=", position);
     assertTrue(equals > 0);
     assertEquals("= 7.0.14-114\n",
         configContents.substring(equals, equals + 13));

     // verify contents of stats file
     String goldenStats = "versionJvm = 1.6.0\n\n"
         + "isIncrementalSupported = false\n"
         + "numTotalDocIdsPushed   = 0\n\n";
     String statsContents = extractFileFromZip("stats.txt", zipContents);
     assertEquals(goldenStats, statsContents);
   }

   @Test
   public void testLogFilesWithNoLogsDir() throws Exception {
     handler = new ModifiedDownloadDumpHandler(config, "myadaptor",
         new MockFile("no-such-dir").setExists(false), new MockTimeProvider());
     handler.handle(ex);
     assertEquals(200, ex.getResponseCode());
     assertEquals("attachment; filename=\"myadaptor-19691231.zip\"",
         ex.getResponseHeaders().getFirst("Content-Disposition"));
     int entries = countZipEntries(ex.getResponseBytes());
     assertEquals(2, entries); /* 0 log files + thread dump + config */
   }

   @Test
   public void testLogFilesWithEmptyStats() throws Exception {
     // set up File using MockFile
     handler = new ModifiedDownloadDumpHandler(config, "myadaptor",
         new MockFile("no-such-dir").setExists(false), new MockTimeProvider());
     StatRpcMethod statRpcMethod = new MockStatRpcMethod(
         new MockJournal(new MockTimeProvider()),
         new MockAdaptor(),
         /*isAdaptorIncremental=*/ false,
         /*configFile=*/ new MockFile("no-such-dir").setExists(false)) {

       /** generate neither versionStats nor simpleStats maps */
       @Override
       public Object run(List request) {
         Map<String, Object> results = new HashMap<String, Object>();
         Map<String, Object> otherStats = new HashMap<String, Object>();
         otherStats.put("someBooleanValue", false);
         otherStats.put("someLongValue", 42L);
         // rest omitted
         results.put("otherStats", otherStats);

         return Collections.unmodifiableMap(results);
       }
     };
     handler = new ModifiedDownloadDumpHandler(config, "adaptor",
         statRpcMethod, new MockFile("no-such-dir").setExists(false),
         new MockTimeProvider());
     handler.handle(ex);
     assertEquals(200, ex.getResponseCode());
     assertEquals("application/zip",
         ex.getResponseHeaders().getFirst("Content-Type"));
     // extract the zip contents and just count the number of entries
     byte[] zipContents = ex.getResponseBytes();
     int entries = countZipEntries(zipContents);
     assertEquals(3, entries); /* 0 log files + thread dump + config + stats */

     // verify contents of stats file
     String goldenStats = "";
     String statsContents = extractFileFromZip("stats.txt", zipContents);
     assertEquals(goldenStats, statsContents);
   }

   @Test
   public void testLogFilesWithUnusualStats() throws Exception {
     // set up File using MockFile
     handler = new ModifiedDownloadDumpHandler(config, "myadaptor",
         new MockFile("no-such-dir").setExists(false), new MockTimeProvider());
     StatRpcMethod statRpcMethod = new MockStatRpcMethod(
         new MockJournal(new MockTimeProvider()),
         new MockAdaptor(),
         /*isAdaptorIncremental=*/ false,
         /*configFile=*/ new MockFile("no-such-dir").setExists(false)) {

       /** generate neither versionStats nor simpleStats maps */
       @Override
       public Object run(List request) {
         Map<String, Object> results = new HashMap<String, Object>();
         Map<String, Object> simpleStats = new TreeMap<String, Object>();
         // keys get sorted into alphabetic order in golden map below
         simpleStats.put("whenStarted", "non-numeric value");
         simpleStats.put("lastSuccessfulFullPushEnd", null);
         simpleStats.put("currentFullPushStart", 0);
         simpleStats.put("lastSuccessfulIncremementalPushStart", -5);
         simpleStats.put("currentIncrementalPushEnd", 1389735897000L);
         // rest omitted
         results.put("simpleStats", simpleStats);

         return Collections.unmodifiableMap(results);
       }
     };
     handler = new ModifiedDownloadDumpHandler(config, "adaptor",
         statRpcMethod, new MockFile("no-such-dir").setExists(false),
         new MockTimeProvider());
     handler.handle(ex);
     assertEquals(200, ex.getResponseCode());
     assertEquals("application/zip",
         ex.getResponseHeaders().getFirst("Content-Type"));
     // extract the zip contents and just count the number of entries
     byte[] zipContents = ex.getResponseBytes();
     int entries = countZipEntries(zipContents);
     assertEquals(3, entries); /* 0 log files + thread dump + config + stats */

     // verify contents of stats file
     String goldenStats = "currentFullPushStart                 = 0\n"
         + "currentIncrementalPushEnd            = 01/14/2014 21:44:57 +0000\n"
         + "lastSuccessfulFullPushEnd            = [null]\n"
         + "lastSuccessfulIncremementalPushStart = -5\n"
         + "whenStarted                          = non-numeric value\n\n";
     String statsContents = extractFileFromZip("stats.txt", zipContents);
     assertEquals(goldenStats, statsContents);
   }

   private MockHttpExchange createExchange(String path) {
     return new MockHttpExchange("GET", pathPrefix + path, httpContext);
   }

   private int countZipEntries(byte[] bytes) throws IOException {
     ZipInputStream zis = new ZipInputStream(new ByteArrayInputStream(bytes));
     int entries = 0;
     ZipEntry nextEntry = null;
     do {
       nextEntry = zis.getNextEntry();
       if (null != nextEntry) {
         entries++;
       }
     } while (nextEntry != null);
     zis.close();
     return entries;
   }

   /**
    * extracts the contents of a specified filename from a given zip (as a
    * <code>String</code>)
    */
   private String extractFileFromZip(String filename, byte[] zipContents)
       throws IOException {
     ZipInputStream zis = new ZipInputStream(
         new ByteArrayInputStream(zipContents));
     ZipEntry ze = null;
     while ((ze = zis.getNextEntry()) != null) {
       if (ze.getName().equals(filename)) {
         return IOHelper.readInputStreamToString(zis, Charset.forName("UTF-8"));
       }
     }
     return null; // file not found
   }

   private static class ModifiedDownloadDumpHandler extends DownloadDumpHandler {
     public ModifiedDownloadDumpHandler(Config config, String feedName) {
       super(config, feedName, null);
     }

     ModifiedDownloadDumpHandler(Config config, String feedName, File logsDir,
         TimeProvider timeProvider) {
       super(config, feedName, null, logsDir, timeProvider);
     }

     ModifiedDownloadDumpHandler(Config config, String feedName,
         StatRpcMethod statRpcMethod, File logsDir, TimeProvider timeProvider) {
       super(config, feedName, statRpcMethod, logsDir, timeProvider);
     }

     @Override
     InputStream createInputStream(File file) throws IOException {
       if (!(file instanceof MockFile)) {
         throw new IllegalArgumentException("implemented only for MockFile.");
       }
       return ((MockFile) file).createInputStream();
     }
   }

   private static class MockStatRpcMethod extends StatRpcMethod {
     MockStatRpcMethod(Journal journal, Adaptor adaptor,
         boolean isAdaptorIncremental, File configFile) {
       super(journal, adaptor, isAdaptorIncremental, configFile);
     }

     @Override
     public Object run(List request) {
       Map<String, Object> golden = new HashMap<String, Object>();
       Map<String, Object> simpleStats = new HashMap<String, Object>();
       simpleStats.put("isIncrementalSupported", false);
       simpleStats.put("numTotalDocIdsPushed", 0L);
       // rest omitted
       golden.put("simpleStats", simpleStats);

       Map<String, Object> versionMap = new HashMap<String, Object>();
       versionMap.put("versionJvm", "1.6.0");
       // rest omitted

       golden.put("versionStats", versionMap);

       return Collections.unmodifiableMap(golden);
     }
   }
 }
	// Copyright 2013 Google Inc. All Rights Reserved.
	//
	// 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.adaptor;

	import static org.junit.Assert.*;

	import org.junit.After;
	import org.junit.Before;
	import org.junit.Rule;
	import org.junit.Test;
	import org.junit.rules.ExpectedException;

	import java.io.ByteArrayInputStream;
	import java.io.File;
	import java.io.IOException;
	import java.io.InputStream;
	import java.nio.charset.Charset;

	import java.util.Collections;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.TimeZone;
	import java.util.TreeMap;
	import java.util.zip.ZipEntry;
	import java.util.zip.ZipInputStream;


	/**
	* Tests for {@link DownloadDumpHandler}.
	*/
	public class DownloadDumpHandlerTest {
	private final Config config = new Config();
	private DownloadDumpHandler handler =
	new ModifiedDownloadDumpHandler(config, "adaptor");
	private final String pathPrefix = "/";
	private final MockHttpContext httpContext =
	new MockHttpContext(handler, pathPrefix);
	private MockHttpExchange ex = createExchange("");
	private TimeZone previousTimeZone;

	@Rule
	public ExpectedException thrown = ExpectedException.none();

	@Before
	public void setUp() {
	// problems arise if gsa.version is left unset
	config.setValue("gsa.version", "7.0.14-114");
	previousTimeZone = TimeZone.getDefault();
	TimeZone.setDefault(TimeZone.getTimeZone("PST"));
	}

	@After
	public void tearDown() {
	TimeZone.setDefault(previousTimeZone);
	}

	@Test
	public void testNullConfig() throws Exception {
	thrown.expect(NullPointerException.class);
	handler = new DownloadDumpHandler(null, "feedname", null);
	}

	@Test
	public void testNullFeedName() throws Exception {
	thrown.expect(NullPointerException.class);
	handler = new ModifiedDownloadDumpHandler(config, null);
	}

	@Test
	public void testIllegalFeedName() throws Exception {
	thrown.expect(IllegalArgumentException.class);
	handler = new ModifiedDownloadDumpHandler(config, "bad\"name");
	}

	@Test
	public void testPost() throws Exception {
	ex = new MockHttpExchange("POST", pathPrefix, httpContext);
	handler.handle(ex);
	assertEquals(405, ex.getResponseCode());
	}

	@Test
	public void testNotFound() throws Exception {
	ex = createExchange("notfound");
	handler.handle(ex);
	assertEquals(404, ex.getResponseCode());
	}

	@Test
	public void testLogFilesWithCannedLogsDir() throws Exception {
	// set up File using MockFile
	MockFile mockLogsDir = new MockFile("parentDir").setChildren(new File[] {
	new MockFile("log1.log").setFileContents("Log file 1"),
	new MockFile("log1.log.lck").setFileContents("skipped lock file"),
	new MockFile("log2.log").setFileContents("Log file 2"),
	new MockFile("subdir").setChildren(new File[] {
	new MockFile("nested.log").setFileContents("This file skipped.")
	})});
	MockTimeProvider timeProvider = new MockTimeProvider();
	timeProvider.time = 1383763470000L; // November 6, 2013 @ 10:44:30
	StatRpcMethod statRpcMethod = new MockStatRpcMethod(
	new MockJournal(new MockTimeProvider()),
	new MockAdaptor(),
	/isAdaptorIncremental=/ false,
	/configFile=/ new MockFile("no-such-dir").setExists(false));
	handler = new ModifiedDownloadDumpHandler(config, "adaptor",
	statRpcMethod, mockLogsDir, timeProvider);
	handler.handle(ex);
	assertEquals(200, ex.getResponseCode());
	assertEquals("application/zip",
	ex.getResponseHeaders().getFirst("Content-Type"));
	assertEquals("attachment; filename=\"adaptor-20131106.zip\"",
	ex.getResponseHeaders().getFirst("Content-Disposition"));
	// extract the zip contents and just count the number of entries
	byte[] zipContents = ex.getResponseBytes();
	int entries = countZipEntries(zipContents);
	assertEquals(5, entries); /* 2 log files + thread dump + config + stats */

	// verify contents of thread dump
	String threadContents = extractFileFromZip("threaddump.txt", zipContents);
	assertTrue(threadContents.contains("Thread[Signal Dispatcher,"));
	assertTrue(threadContents.contains("Thread[main,"));

	// verify contents of config file
	String configContents = extractFileFromZip("config.txt", zipContents);
	// search for: \ngsa.version[spaces]= 7.0.14-114\n
	int position = configContents.indexOf("\ngsa.version");
	assertTrue(position > 0);
	int equals = configContents.indexOf("=", position);
	assertTrue(equals > 0);
	assertEquals("= 7.0.14-114\n",
	configContents.substring(equals, equals + 13));

	// verify contents of stats file
	String goldenStats = "versionJvm = 1.6.0\n\n"
	+ "isIncrementalSupported = false\n"
	+ "numTotalDocIdsPushed = 0\n\n";
	String statsContents = extractFileFromZip("stats.txt", zipContents);
	assertEquals(goldenStats, statsContents);
	}

	@Test
	public void testLogFilesWithNoLogsDir() throws Exception {
	handler = new ModifiedDownloadDumpHandler(config, "myadaptor",
	new MockFile("no-such-dir").setExists(false), new MockTimeProvider());
	handler.handle(ex);
	assertEquals(200, ex.getResponseCode());
	assertEquals("attachment; filename=\"myadaptor-19691231.zip\"",
	ex.getResponseHeaders().getFirst("Content-Disposition"));
	int entries = countZipEntries(ex.getResponseBytes());
	assertEquals(2, entries); /* 0 log files + thread dump + config */
	}

	@Test
	public void testLogFilesWithEmptyStats() throws Exception {
	// set up File using MockFile
	handler = new ModifiedDownloadDumpHandler(config, "myadaptor",
	new MockFile("no-such-dir").setExists(false), new MockTimeProvider());
	StatRpcMethod statRpcMethod = new MockStatRpcMethod(
	new MockJournal(new MockTimeProvider()),
	new MockAdaptor(),
	/isAdaptorIncremental=/ false,
	/configFile=/ new MockFile("no-such-dir").setExists(false)) {

	/** generate neither versionStats nor simpleStats maps */
	@Override
	public Object run(List request) {
	Map<String, Object> results = new HashMap<String, Object>();
	Map<String, Object> otherStats = new HashMap<String, Object>();
	otherStats.put("someBooleanValue", false);
	otherStats.put("someLongValue", 42L);
	// rest omitted
	results.put("otherStats", otherStats);

	return Collections.unmodifiableMap(results);
	}
	};
	handler = new ModifiedDownloadDumpHandler(config, "adaptor",
	statRpcMethod, new MockFile("no-such-dir").setExists(false),
	new MockTimeProvider());
	handler.handle(ex);
	assertEquals(200, ex.getResponseCode());
	assertEquals("application/zip",
	ex.getResponseHeaders().getFirst("Content-Type"));
	// extract the zip contents and just count the number of entries
	byte[] zipContents = ex.getResponseBytes();
	int entries = countZipEntries(zipContents);
	assertEquals(3, entries); /* 0 log files + thread dump + config + stats */

	// verify contents of stats file
	String goldenStats = "";
	String statsContents = extractFileFromZip("stats.txt", zipContents);
	assertEquals(goldenStats, statsContents);
	}

	@Test
	public void testLogFilesWithUnusualStats() throws Exception {
	// set up File using MockFile
	handler = new ModifiedDownloadDumpHandler(config, "myadaptor",
	new MockFile("no-such-dir").setExists(false), new MockTimeProvider());
	StatRpcMethod statRpcMethod = new MockStatRpcMethod(
	new MockJournal(new MockTimeProvider()),
	new MockAdaptor(),
	/isAdaptorIncremental=/ false,
	/configFile=/ new MockFile("no-such-dir").setExists(false)) {

	/** generate neither versionStats nor simpleStats maps */
	@Override
	public Object run(List request) {
	Map<String, Object> results = new HashMap<String, Object>();
	Map<String, Object> simpleStats = new TreeMap<String, Object>();
	// keys get sorted into alphabetic order in golden map below
	simpleStats.put("whenStarted", "non-numeric value");
	simpleStats.put("lastSuccessfulFullPushEnd", null);
	simpleStats.put("currentFullPushStart", 0);
	simpleStats.put("lastSuccessfulIncremementalPushStart", -5);
	simpleStats.put("currentIncrementalPushEnd", 1389735897000L);
	// rest omitted
	results.put("simpleStats", simpleStats);

	return Collections.unmodifiableMap(results);
	}
	};
	handler = new ModifiedDownloadDumpHandler(config, "adaptor",
	statRpcMethod, new MockFile("no-such-dir").setExists(false),
	new MockTimeProvider());
	handler.handle(ex);
	assertEquals(200, ex.getResponseCode());
	assertEquals("application/zip",
	ex.getResponseHeaders().getFirst("Content-Type"));
	// extract the zip contents and just count the number of entries
	byte[] zipContents = ex.getResponseBytes();
	int entries = countZipEntries(zipContents);
	assertEquals(3, entries); /* 0 log files + thread dump + config + stats */

	// verify contents of stats file
	String goldenStats = "currentFullPushStart = 0\n"
	+ "currentIncrementalPushEnd = 01/14/2014 21:44:57 +0000\n"
	+ "lastSuccessfulFullPushEnd = [null]\n"
	+ "lastSuccessfulIncremementalPushStart = -5\n"
	+ "whenStarted = non-numeric value\n\n";
	String statsContents = extractFileFromZip("stats.txt", zipContents);
	assertEquals(goldenStats, statsContents);
	}

	private MockHttpExchange createExchange(String path) {
	return new MockHttpExchange("GET", pathPrefix + path, httpContext);
	}

	private int countZipEntries(byte[] bytes) throws IOException {
	ZipInputStream zis = new ZipInputStream(new ByteArrayInputStream(bytes));
	int entries = 0;
	ZipEntry nextEntry = null;
	do {
	nextEntry = zis.getNextEntry();
	if (null != nextEntry) {
	entries++;
	}
	} while (nextEntry != null);
	zis.close();
	return entries;
	}

	/**
	* extracts the contents of a specified filename from a given zip (as a
	* <code>String</code>)
	*/
	private String extractFileFromZip(String filename, byte[] zipContents)
	throws IOException {
	ZipInputStream zis = new ZipInputStream(
	new ByteArrayInputStream(zipContents));
	ZipEntry ze = null;
	while ((ze = zis.getNextEntry()) != null) {
	if (ze.getName().equals(filename)) {
	return IOHelper.readInputStreamToString(zis, Charset.forName("UTF-8"));
	}
	}
	return null; // file not found
	}

	private static class ModifiedDownloadDumpHandler extends DownloadDumpHandler {
	public ModifiedDownloadDumpHandler(Config config, String feedName) {
	super(config, feedName, null);
	}

	ModifiedDownloadDumpHandler(Config config, String feedName, File logsDir,
	TimeProvider timeProvider) {
	super(config, feedName, null, logsDir, timeProvider);
	}

	ModifiedDownloadDumpHandler(Config config, String feedName,
	StatRpcMethod statRpcMethod, File logsDir, TimeProvider timeProvider) {
	super(config, feedName, statRpcMethod, logsDir, timeProvider);
	}

	@Override
	InputStream createInputStream(File file) throws IOException {
	if (!(file instanceof MockFile)) {
	throw new IllegalArgumentException("implemented only for MockFile.");
	}
	return ((MockFile) file).createInputStream();
	}
	}

	private static class MockStatRpcMethod extends StatRpcMethod {
	MockStatRpcMethod(Journal journal, Adaptor adaptor,
	boolean isAdaptorIncremental, File configFile) {
	super(journal, adaptor, isAdaptorIncremental, configFile);
	}

	@Override
	public Object run(List request) {
	Map<String, Object> golden = new HashMap<String, Object>();
	Map<String, Object> simpleStats = new HashMap<String, Object>();
	simpleStats.put("isIncrementalSupported", false);
	simpleStats.put("numTotalDocIdsPushed", 0L);
	// rest omitted
	golden.put("simpleStats", simpleStats);

	Map<String, Object> versionMap = new HashMap<String, Object>();
	versionMap.put("versionJvm", "1.6.0");
	// rest omitted

	golden.put("versionStats", versionMap);

	return Collections.unmodifiableMap(golden);
	}
	}
	}