/**
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* @author Gabriel Roldan (OpenGeo) 2010
*
*/
package org.geowebcache.diskquota;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import junit.framework.TestCase;
import org.geowebcache.grid.GridSubset;
import org.geowebcache.layer.TileLayer;
import org.geowebcache.mime.MimeException;
import org.geowebcache.mime.MimeType;
import org.geowebcache.storage.TileObject;
import org.geowebcache.storage.blobstore.file.FilePathGenerator;
public class LayerCacheInfoBuilderTest extends TestCase {
private LayerCacheInfoBuilder infoBuilder;
private final int blockSize = 2048;
private File rootCacheDir;
private ExecutorService threadPool;
FilePathGenerator pathGenerator = new FilePathGenerator("") {
protected String getParametersId(String base, java.util.Map<String,String> parameters) throws IOException {
// we assume no collisions for these tests
String parametersKvp = getParametersKvp(parameters);
return buildKey(parametersKvp);
};
};
public void testFake() {
}
/*
* TODO fix tests /*
*
* @Override protected void setUp() throws Exception { File target = new File("target"); if
* (!target.exists() || !target.isDirectory() || !target.canWrite()) { throw new
* IllegalStateException("Can't set up tests, " + target.getAbsolutePath() +
* " is not a writable directory"); }
*
* rootCacheDir = new File(target, getClass().getSimpleName());
* FileUtils.rmFileCacheDir(rootCacheDir, null); rootCacheDir.mkdirs();
*
* threadPool = Executors.newSingleThreadExecutor();
*
* infoBuilder = new LayerCacheInfoBuilder(rootCacheDir, threadPool); }
*
* @Override protected void tearDown() throws Exception { if (threadPool != null) {
* threadPool.shutdownNow(); } if (rootCacheDir != null) {
* FileUtils.rmFileCacheDir(rootCacheDir, null); } }
*
* public void testBuildCacheInfo() throws MimeException, IOException, InterruptedException {
*
* final String layerName = "MockLayer"; TileLayer mockLayer =
* EasyMock.createMock(TileLayer.class);
* EasyMock.expect(mockLayer.getName()).andReturn(layerName).anyTimes(); GridSet gridSet = new
* GridSetBroker(false, false).WORLD_EPSG4326; GridSubset gridSubset =
* GridSubsetFactory.createGridSubSet(gridSet); EasyMock.expect(mockLayer.getGridSubsets())
* .andReturn( new Hashtable<String, GridSubset>(Collections.singletonMap( gridSubset.getName(),
* gridSubset))).anyTimes(); EasyMock.replay(mockLayer);
*
* final String gridSetId = gridSubset.getName(); final LayerQuota layerQuota = new
* LayerQuota(layerName, "MockPolicy"); final int numFiles = 10; final int fileSize =
* this.blockSize + 1;
*
* ExpirationPolicy mockPolicy = EasyMock.createMock(ExpirationPolicy.class);
*
* mockPolicy.createTileInfo(EasyMock.eq(layerQuota), EasyMock.eq(gridSetId),
* EasyMock.anyLong(), EasyMock.anyLong(), EasyMock.anyInt());
* EasyMock.expectLastCall().times(numFiles); EasyMock.replay(mockPolicy);
*
* mockSeed(mockLayer, numFiles, fileSize);
*
* layerQuota.setExpirationPolicy(mockPolicy);
*
* infoBuilder.buildCacheInfo(mockLayer, layerQuota);
*
* // be careful and don't wait more than 30s long startTime = System.currentTimeMillis(); long
* ellapsedTime = 0; while (infoBuilder.isRunning(layerName)) { Thread.sleep(500); ellapsedTime
* = System.currentTimeMillis() - startTime; if (ellapsedTime > 30000) {
* fail(LayerCacheInfoBuilder.class.getSimpleName() +
* ".buildCacheInfo was running for too long, aborting test!"); } } EasyMock.verify(mockLayer);
* EasyMock.verify(mockPolicy);
*
* // was layer used quota updated? final int blockFileSize = (int) Math.ceil((double) fileSize
* / this.blockSize) this.blockSize; final long expectedCacheSize = numFiles * blockFileSize;
*
* Quota expectedUsedQuota = new Quota(expectedCacheSize, StorageUnit.B);
*
* Quota usedQuota = layerQuota.getUsedQuota();
*
* assertTrue(usedQuota.getBytes().longValue() > 0);
*
* assertEquals(0L, usedQuota.difference(expectedUsedQuota).getBytes().longValue()); }
*/
/**
* Seeds {@code numFiles} fake tiles of {@code fileSize} each at random tile indices
*
* @param layer
* @param numFiles
* @throws MimeException
* @throws IOException
*/
private void mockSeed(TileLayer layer, int numFiles, int fileSize) throws MimeException,
IOException {
final String layerName = layer.getName();
final GridSubset gridSubset = layer.getGridSubset(layer.getGridSubsets().iterator().next());
final String gridSetId = gridSubset.getName();
final String prefix = this.rootCacheDir.getAbsolutePath();
String format = "image/png";
final MimeType mimeType = MimeType.createFromFormat(format);
final byte[] mockTileContents = new byte[fileSize];
Arrays.fill(mockTileContents, (byte) 0xFF);
// just to control the same tile is not created more than once
Set<String> addedTiles = new HashSet<String>();
long[] tileIndex;
while (addedTiles.size() < numFiles) {
int level = (int) (gridSubset.getZoomStart() + ((gridSubset.getZoomStop() - gridSubset
.getZoomStart()) * Math.random()));
String tileKey = null;
File tilePath;
do {
long[] coverage = gridSubset.getCoverage(level);// {minx,miny,maxx,maxy,z}
long x = (long) (coverage[0] + ((coverage[2] - coverage[0]) * Math.random()));
long y = (long) (coverage[1] + ((coverage[3] - coverage[1]) * Math.random()));
tileIndex = new long[] { x, y, level };
TileObject tile = TileObject.createCompleteTileObject(layerName, tileIndex, gridSetId, format, null, null);
tilePath = pathGenerator.tilePath(tile, mimeType);
tileKey = tilePath.getAbsolutePath();
} while (addedTiles.contains(tileKey));
addedTiles.add(tileKey);
File tileDir = tilePath.getParentFile();
tileDir.mkdirs();
FileOutputStream fout = new FileOutputStream(tilePath);
try {
fout.write(mockTileContents);
} finally {
fout.close();
}
}
}
}