public void CanUploadContentFromFullByteArray(string blobName)
{
var blob = new StandaloneAzureBlockBlob(BasePath, blobName);
blob.UploadFromByteArrayAsync(Encoding.UTF8.GetBytes("File content")).Wait();
Assert.Equal("File content", File.ReadAllText(blob.Uri.LocalPath));
}
public void WillCopyMetadataFromSourceWherePresent()
{
var buffer = Encoding.UTF8.GetBytes("File content");
var sourceBlob = new StandaloneAzureBlockBlob(BasePath, SourceBlobName);
sourceBlob.UploadFromByteArrayAsync(buffer, 0, buffer.Length).Wait();
sourceBlob.Metadata["thing"] = "something";
sourceBlob.Properties.ContentType = "whatever";
sourceBlob.SetMetadata();
sourceBlob.SetProperties();
var destinationBlob = new StandaloneAzureBlockBlob(BasePath, DestinationBlobName);
destinationBlob.StartCopyFromBlob(sourceBlob);
destinationBlob.FetchAttributes();
new
{
Metadata = new Dictionary<string, string>
{
{"thing", "something"}
},
Properties = new
{
ContentType = "whatever",
Length = (long) 12
}
}.ToExpectedObject().ShouldMatch(destinationBlob);
}
public void CanUploadContentFromByteArrayWithRangeSpecifier(int index, int count, string expectedContent, string blobName)
{
var buffer = Encoding.UTF8.GetBytes("File content");
var blob = new StandaloneAzureBlockBlob(BasePath, blobName);
blob.UploadFromByteArrayAsync(buffer, index, count).Wait();
Assert.Equal(expectedContent, File.ReadAllText(blob.Uri.LocalPath));
}
public void CopyStateIsSuccessAfterCopy()
{
var buffer = Encoding.UTF8.GetBytes("File content");
var sourceBlob = new StandaloneAzureBlockBlob(BasePath, SourceBlobName);
sourceBlob.UploadFromByteArrayAsync(buffer, 0, buffer.Length).Wait();
var destinationBlob = new StandaloneAzureBlockBlob(BasePath, DestinationBlobName);
destinationBlob.StartCopyFromBlob(sourceBlob);
}
public void CanUploadContentFromFile(string blobName)
{
var sourceFilePath = Path.Combine(BasePath, "source");
File.WriteAllText(sourceFilePath, "Source file");
var blob = new StandaloneAzureBlockBlob(BasePath, blobName);
blob.UploadFromFileAsync(sourceFilePath);
Assert.Equal("Source file", File.ReadAllText(blob.Uri.LocalPath));
}
public void CanDeleteBlob(string blobName)
{
var buffer = Encoding.UTF8.GetBytes("File content");
var blob = new StandaloneAzureBlockBlob(BasePath, blobName);
blob.UploadFromByteArrayAsync(buffer, 0, buffer.Length).Wait();
blob.Delete();
Assert.False(File.Exists(blob.Uri.LocalPath));
}
public void CanCopyBlob()
{
var buffer = Encoding.UTF8.GetBytes("File content");
var sourceBlob = new StandaloneAzureBlockBlob(BasePath, SourceBlobName);
sourceBlob.UploadFromByteArrayAsync(buffer, 0, buffer.Length).Wait();
var destinationBlob = new StandaloneAzureBlockBlob(BasePath, DestinationBlobName);
destinationBlob.StartCopyFromBlob(sourceBlob);
Assert.Equal("File content", File.ReadAllText(destinationBlob.Uri.LocalPath));
}
public void DefaultsToEmptyMetadataOnFetchWithNoSavedMetadata(string blobName)
{
var sourceBlob = new StandaloneAzureBlockBlob(BasePath, blobName);
CreateBlobContent(sourceBlob);
sourceBlob.FetchAttributes();
new
{
Metadata = new Dictionary<string, string>()
}.ToExpectedObject().ShouldMatch(sourceBlob);
}
public void CanDeleteBlobMetadata(string blobName)
{
var buffer = Encoding.UTF8.GetBytes("File content");
var blob = new StandaloneAzureBlockBlob(BasePath, blobName);
blob.UploadFromByteArrayAsync(buffer, 0, buffer.Length).Wait();
blob.Metadata["thing"] = "something";
blob.SetMetadata();
blob.Delete();
Assert.False(File.Exists(Path.Combine(BasePath, ".meta", blobName)));
}
public void CanOverwriteBlob(string source, string destination)
{
var sourceBuffer = Encoding.UTF8.GetBytes("File content");
var sourceBlob = new StandaloneAzureBlockBlob(BasePath, source);
sourceBlob.UploadFromByteArrayAsync(sourceBuffer, 0, sourceBuffer.Length).Wait();
var originalContentBuffer = Encoding.UTF8.GetBytes("Original content");
var destinationBlob = new StandaloneAzureBlockBlob(BasePath, destination);
destinationBlob.UploadFromByteArrayAsync(originalContentBuffer, 0, originalContentBuffer.Length).Wait();
destinationBlob.StartCopyFromBlob(sourceBlob.Uri);
Assert.Equal("File content", File.ReadAllText(destinationBlob.Uri.LocalPath));
}
public ListMetadataTests()
: base(DirectoryType.Container)
{
var flatBlob = new StandaloneAzureBlockBlob(BasePath, "flat");
flatBlob.UploadFromByteArrayAsync(Encoding.UTF8.GetBytes("flat"));
flatBlob.Metadata["thing"] = "flat";
flatBlob.SetMetadata();
var withPath = new StandaloneAzureBlockBlob(BasePath, @"random\path\blob");
withPath.UploadFromByteArrayAsync(Encoding.UTF8.GetBytes("withPath"));
withPath.Metadata["thing"] = "withPath";
withPath.SetMetadata();
}
public void CanUploadContentFromStream(string blobName)
{
using (var memoryStream = new MemoryStream())
{
var sourceContent = GenerateSourceContent();
var buffer = Encoding.UTF8.GetBytes(sourceContent);
memoryStream.Write(buffer, 0, buffer.Length);
memoryStream.Position = 0;
var blob = new StandaloneAzureBlockBlob(BasePath, blobName);
blob.UploadFromStreamAsync(memoryStream).Wait();
Assert.Equal(sourceContent, File.ReadAllText(blob.Uri.LocalPath));
}
}
public void DefaultsToOctetStreamWhenLoadingPropertiesWhenPreviouslyUnset()
{
var blob = new StandaloneAzureBlockBlob(BasePath, BlobName);
CreateBlobContent(blob);
blob.FetchAttributes();
new
{
Properties = new
{
ContentType = "application/octet-stream",
Length = (long) 12
}
}.ToExpectedObject().ShouldMatch(blob);
}
public void WillHaveCorrectValuesWhenGivenContainerDirectoryAndBlobName()
{
var blob = new StandaloneAzureBlockBlob(BasePath, BlobName);
new
{
Uri = _blobUri,
Name = BlobName,
Properties = new
{
Length = (long) -1,
ContentType = (string) null
},
Metadata = new Dictionary<string, string>()
}.ToExpectedObject().ShouldMatch(blob);
}
public async Task CanDownloadBlboToStreamAsync(string blobName)
{
var blob = new StandaloneAzureBlockBlob(BasePath, blobName);
await blob.UploadFromByteArrayAsync(Encoding.UTF8.GetBytes("Streamable content"));
using (var memoryStream = new MemoryStream())
{
await blob.DownloadToStreamAsync(memoryStream);
memoryStream.Position = 0;
using (var streamReader = new StreamReader(memoryStream))
{
Assert.Equal("Streamable content", streamReader.ReadToEnd());
}
}
}
public void CopyStateIsFailedIfBlobLocked(string source, string destination)
{
var buffer = Encoding.UTF8.GetBytes("File content");
var sourceBlob = new StandaloneAzureBlockBlob(BasePath, source);
sourceBlob.UploadFromByteArrayAsync(buffer, 0, buffer.Length).Wait();
using (new FileStream(sourceBlob.Uri.LocalPath, FileMode.Append, FileAccess.Write, FileShare.None))
{
var destinationBlob = new StandaloneAzureBlockBlob(BasePath, destination);
destinationBlob.StartCopyFromBlob(sourceBlob.Uri);
new
{
Status = CopyStatus.Failed,
StatusDescription = new NotNullComparison()
}.ToExpectedObject().ShouldMatch(destinationBlob.CopyState);
}
}
public void CanPersistAndRetrieveMetadata(string blobName)
{
var sourceBlob = new StandaloneAzureBlockBlob(BasePath, blobName);
CreateBlobContent(sourceBlob);
sourceBlob.Metadata["thing"] = "something";
sourceBlob.SetMetadata();
var loadedBlob = new StandaloneAzureBlockBlob(BasePath, blobName);
loadedBlob.FetchAttributes();
new
{
Metadata = new Dictionary<string, string>
{
{ "thing", "something"}
}
}.ToExpectedObject().ShouldMatch(loadedBlob);
}
public void CanPersistPropertiesAsync()
{
var sourceBlob = new StandaloneAzureBlockBlob(BasePath, BlobName);
CreateBlobContent(sourceBlob);
sourceBlob.Properties.ContentType = "something";
sourceBlob.SetPropertiesAsync().Wait();
var loadedBlob = new StandaloneAzureBlockBlob(BasePath, BlobName);
loadedBlob.FetchAttributes();
new
{
Properties = new
{
ContentType = "something",
Length = (long) 12
}
}.ToExpectedObject().ShouldMatch(loadedBlob);
}
public void WillNotCopyMetadataWhereItDoesNotExist()
{
var buffer = Encoding.UTF8.GetBytes("File content");
var sourceBlob = new StandaloneAzureBlockBlob(BasePath, SourceBlobName);
sourceBlob.UploadFromByteArrayAsync(buffer, 0, buffer.Length).Wait();
var destinationBlob = new StandaloneAzureBlockBlob(BasePath, DestinationBlobName);
destinationBlob.StartCopyFromBlob(sourceBlob);
Assert.False(File.Exists(Path.Combine(BasePath, ".meta", DestinationBlobName)));
}
public void FetchingAttributesOverwritesAnyUnsavedPropertyValues()
{
var sourceBlob = new StandaloneAzureBlockBlob(BasePath, BlobName);
CreateBlobContent(sourceBlob);
sourceBlob.Properties.ContentType = "something";
sourceBlob.SetProperties();
var loadedBlob = new StandaloneAzureBlockBlob(BasePath, BlobName);
loadedBlob.FetchAttributes();
sourceBlob.Properties.ContentType = "something else";
loadedBlob.FetchAttributes();
new
{
Properties = new
{
ContentType = "something",
Length = (long)12
}
}.ToExpectedObject().ShouldMatch(loadedBlob);
}
public void CopyStateIsNullBeforeCopy()
{
var blob = new StandaloneAzureBlockBlob(BasePath, SourceBlobName);
Assert.Null(blob.CopyState);
}
public void MetadataNotPersistedUntilSet(string blobName)
{
var sourceBlob = new StandaloneAzureBlockBlob(BasePath, blobName);
CreateBlobContent(sourceBlob);
sourceBlob.Metadata["thing"] = "something";
var loadedBlob = new StandaloneAzureBlockBlob(BasePath, blobName);
loadedBlob.FetchAttributes();
new
{
Metadata = new Dictionary<string, string>()
}.ToExpectedObject().ShouldMatch(loadedBlob);
}
public void FetchingPropertiesOverwritesAnyUnsavedMetadataValues(string blobName)
{
var sourceBlob = new StandaloneAzureBlockBlob(BasePath, blobName);
CreateBlobContent(sourceBlob);
sourceBlob.Metadata["thing"] = "something";
sourceBlob.SetMetadata();
var loadedBlob = new StandaloneAzureBlockBlob(BasePath, blobName);
loadedBlob.FetchAttributes();
loadedBlob.Metadata["other thing"] = "whatever";
loadedBlob.FetchAttributes();
new
{
Metadata = new Dictionary<string, string>
{
{ "thing", "something"}
}
}.ToExpectedObject().ShouldMatch(loadedBlob);
}
public void WillRemoveExistingMetadataWhereSourceDoesNotHaveMetadata(string source, string destination)
{
var buffer = Encoding.UTF8.GetBytes("File content");
var sourceBlob = new StandaloneAzureBlockBlob(BasePath, source);
sourceBlob.UploadFromByteArrayAsync(buffer, 0, buffer.Length).Wait();
var originalContentBuffer = Encoding.UTF8.GetBytes("Original content");
var destinationBlob = new StandaloneAzureBlockBlob(BasePath, destination);
destinationBlob.UploadFromByteArrayAsync(originalContentBuffer, 0, originalContentBuffer.Length).Wait();
destinationBlob.Metadata["thing"] = "other thing";
destinationBlob.SetMetadata();
destinationBlob.StartCopyFromBlob(sourceBlob.Uri);
Assert.False(File.Exists(Path.Combine(BasePath, ".meta", destination)));
}
public void CopyStateIsSuccessAfterCopy(string source, string destination)
{
var buffer = Encoding.UTF8.GetBytes("File content");
var sourceBlob = new StandaloneAzureBlockBlob(BasePath, source);
sourceBlob.UploadFromByteArrayAsync(buffer, 0, buffer.Length).Wait();
var destinationBlob = new StandaloneAzureBlockBlob(BasePath, destination);
destinationBlob.StartCopyFromBlob(sourceBlob.Uri);
Assert.Equal(CopyStatus.Success, destinationBlob.CopyState.Status);
}
public void WillThrowOnSaveOfMetadataWhenFileWriteRetriesExhausted(string blobName)
{
var metadataPath = Path.Combine(BasePath, ".meta", blobName);
var sourceBlob = new StandaloneAzureBlockBlob(BasePath, blobName);
CreateBlobContent(sourceBlob);
sourceBlob.Metadata["thing"] = "something";
sourceBlob.SetMetadata();
var loadedBlob = new StandaloneAzureBlockBlob(BasePath, blobName);
loadedBlob.FetchAttributes();
loadedBlob.Metadata["other thing"] = "whatever";
using (File.Open(metadataPath, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
{
Assert.Throws<StorageException>(() => loadedBlob.SetMetadata());
}
}
public void SavingPreservesUnknownMetadata(string blobName)
{
var sourceBlob = new StandaloneAzureBlockBlob(BasePath, blobName);
CreateBlobContent(sourceBlob);
sourceBlob.Metadata["thing"] = "something";
sourceBlob.SetMetadata();
var metadataPath = Path.Combine(BasePath, ".meta", blobName);
var expectedProperties = new Dictionary<string, string>
{
{"foo", "bar"}, {"couci-couça","svo-svo"}
};
WriteJsonPropertiesToFile(metadataPath, expectedProperties);
var loadedBlob = new StandaloneAzureBlockBlob(BasePath, blobName);
loadedBlob.FetchAttributes();
loadedBlob.Metadata["another thing"] = "whatever else";
loadedBlob.SetMetadata();
using (var reader = new StreamReader(metadataPath))
{
var loaded = JObject.Load(new JsonTextReader(reader));
var actualMetadata = loaded["Metadata"];
Assert.Equal("something", actualMetadata["thing"]);
Assert.Equal("whatever else", actualMetadata["another thing"]);
expectedProperties.ToList().ForEach(kvp =>
Assert.Equal(kvp.Value, loaded[kvp.Key])
);
}
}
public void WillThrowOnFetchOfAttributesIfBlobDoesNotExist(string blobName)
{
var blob = new StandaloneAzureBlockBlob(BasePath, blobName);
Assert.Throws<StorageException>(() => blob.FetchAttributes());
}
public void WillThrowOnSaveOfPropertiesIfBlobDoesNotExist()
{
var blob = new StandaloneAzureBlockBlob(BasePath, BlobName);
Assert.Throws<StorageException>(() => blob.SetProperties());
}
public void WillThrowOnAsyncSaveOfMetadataIfBlobDoesNotExist(string blobName)
{
var blob = new StandaloneAzureBlockBlob(BasePath, blobName);
AssertEx.Throws<StorageException>(() => blob.SetMetadataAsync());
}
