// Copyright (C) 2011 Splunk Inc.
//
// Splunk Inc. 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 com.splunk.shuttl.archiver.metastore;
import static com.splunk.shuttl.testutil.TUtilsFile.*;
import static org.testng.Assert.*;
import java.io.File;
import java.io.IOException;
import org.apache.commons.io.FileUtils;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import com.splunk.shuttl.archiver.LocalFileSystemPaths;
import com.splunk.shuttl.archiver.archive.ArchiveConfiguration;
import com.splunk.shuttl.archiver.filesystem.ArchiveFileSystem;
import com.splunk.shuttl.archiver.filesystem.ArchiveFileSystemFactory;
import com.splunk.shuttl.archiver.filesystem.PathResolver;
import com.splunk.shuttl.archiver.filesystem.transaction.TransactionExecuter;
import com.splunk.shuttl.archiver.metastore.FlatFileStorage.FlatFileReadException;
import com.splunk.shuttl.archiver.metastore.MetadataStore.CouldNotReadMetadataException;
import com.splunk.shuttl.archiver.model.RemoteBucket;
import com.splunk.shuttl.testutil.TUtilsBucket;
import com.splunk.shuttl.testutil.TUtilsFunctional;
@Test(groups = { "slow-unit" })
public class MetadataStoreReadIntegrationTest {
private ArchiveFileSystem localFileSystem;
private PathResolver pathResolver;
private RemoteBucket remoteBucket;
private FlatFileStorage flatFileStorage;
private File remoteMetadata;
private LocalFileSystemPaths localFileSystemPaths;
private File localMetadata;
private String expectedData;
private MetadataStore metadataStore;
private String fileName;
@BeforeMethod
public void setUp() {
ArchiveConfiguration config = TUtilsFunctional
.getLocalFileSystemConfiguration();
localFileSystem = ArchiveFileSystemFactory.getWithConfiguration(config);
pathResolver = new PathResolver(config);
localFileSystemPaths = new LocalFileSystemPaths(createDirectory());
flatFileStorage = new FlatFileStorage(localFileSystemPaths);
metadataStore = new MetadataStore(pathResolver, flatFileStorage,
localFileSystem, new TransactionExecuter(), localFileSystemPaths);
remoteBucket = TUtilsBucket.createRemoteBucket();
expectedData = "data";
fileName = "FileNameOfMetadataFile.file";
localMetadata = flatFileStorage.getFlatFile(remoteBucket, fileName);
String metadataPath = pathResolver.resolvePathForBucketMetadata(
remoteBucket, localMetadata);
remoteMetadata = new File(metadataPath);
FileUtils.deleteQuietly(remoteMetadata);
FileUtils.deleteQuietly(localMetadata);
}
@AfterMethod
public void tearDown() {
FileUtils.deleteQuietly(remoteMetadata);
FileUtils.deleteQuietly(localMetadata);
}
@Test(expectedExceptions = { CouldNotReadMetadataException.class })
public void readBucketSize_sizeMetadataDoesNotExistLocallyNorRemotely_throws() {
assertFalse(remoteMetadata.exists());
assertFalse(localMetadata.exists());
metadataStore.read(remoteBucket, fileName);
}
public void readBucketSize_sizeMetadataExistsRemotely_readsSize() {
flatFileStorage.writeFlatFile(remoteMetadata, expectedData);
assertTrue(remoteMetadata.exists());
assertFalse(localMetadata.exists());
assertEquals(expectedData, metadataStore.read(remoteBucket, fileName));
}
public void readBucketSize_sizeMetadataExistsLocally_readsSize()
throws IOException {
flatFileStorage.writeFlatFile(localMetadata, expectedData);
assertTrue(localMetadata.exists());
assertNotNull(flatFileStorage.readFlatFile(localMetadata));
assertEquals(expectedData, metadataStore.read(remoteBucket, fileName));
}
public void readBucketSize_localExistingMetadataDoesNotContainSize_getsSize()
throws IOException {
flatFileStorage.writeFlatFile(remoteMetadata, expectedData);
assertTrue(remoteMetadata.exists());
assertTrue(localMetadata.createNewFile());
assertTrue(localMetadata.exists());
try {
flatFileStorage.readFlatFile(localMetadata);
fail();
} catch (FlatFileReadException e) {
}
assertEquals(expectedData, metadataStore.read(remoteBucket, fileName));
}
@Test(expectedExceptions = { CouldNotReadMetadataException.class })
public void readBucketSize_localMetaDoesNotContainDataAndRemoteDoesNotExist_throws()
throws IOException {
assertTrue(localMetadata.createNewFile());
assertFalse(remoteMetadata.exists());
assertTrue(localMetadata.exists());
metadataStore.read(remoteBucket, localMetadata.getName());
}
}