public void ConvertStringEnumerableToIntArray()
{
// Given
MetadataDictionary initialMetadata = new MetadataDictionary();
MetadataStack metadata = new MetadataStack(initialMetadata);
// When
metadata = metadata.Clone(new[] { new KeyValuePair <string, object>("A", new List <string> {
"1", "2", "3"
}) });
IMetadata <int[]> metadataAs = metadata.MetadataAs <int[]>();
// Then
CollectionAssert.AreEqual(new string[] { "1", "2", "3" }, (IEnumerable)metadata["A"]);
CollectionAssert.AreEqual(new int[] { 1, 2, 3 }, (IEnumerable)metadataAs["A"]);
}
public void ReturnsListForSingleDocument()
{
// Given
IDocument a = Substitute.For <IDocument>();
MetadataDictionary initialMetadata = new MetadataDictionary {
["A"] = a
};
MetadataStack metadata = new MetadataStack(initialMetadata);
// When
IReadOnlyList <IDocument> result = metadata.Documents("A");
// Then
Assert.IsNotNull(result);
CollectionAssert.AreEqual(new[] { a }, result);
}
public void ContainsNewValues()
{
// Given
MetadataDictionary initialMetadata = new MetadataDictionary {
["A"] = "a"
};
MetadataStack metadata = new MetadataStack(initialMetadata);
// When
MetadataStack clone = metadata.Clone(new Dictionary <string, object> {
{ "B", "b" }
});
// Then
Assert.AreEqual("b", clone["B"]);
}
public void ClonedMetadataDoesNotContainNewValues()
{
// Given
MetadataDictionary initialMetadata = new MetadataDictionary {
["A"] = "a"
};
MetadataStack metadata = new MetadataStack(initialMetadata);
// When
MetadataStack clone = metadata.Clone(new Dictionary <string, object> {
{ "B", "b" }
});
// Then
Assert.IsFalse(metadata.ContainsKey("B"));
}
public void ReturnsFalseForInvalidValue()
{
// Given
MetadataDictionary initialMetadata = new MetadataDictionary {
["A"] = "a"
};
MetadataStack metadata = new MetadataStack(initialMetadata);
// When
object value;
bool contains = metadata.TryGetValue("B", out value);
// Then
Assert.IsFalse(contains);
Assert.AreEqual(null, value);
}
public void ReturnsEmptyListForListOfInt()
{
// Given
MetadataDictionary initialMetadata = new MetadataDictionary {
["A"] = new List <int> {
1, 2, 3
}
};
MetadataStack metadata = new MetadataStack(initialMetadata);
// When
IReadOnlyList <IDocument> result = metadata.DocumentList("A");
// Then
Assert.IsNotNull(result);
CollectionAssert.IsEmpty(result);
}
public void ReturnsCorrectResultForConvertedIntList()
{
// Given
MetadataDictionary initialMetadata = new MetadataDictionary {
["A"] = new List <int> {
1, 2, 3
}
};
MetadataStack metadata = new MetadataStack(initialMetadata);
// When
IReadOnlyList <string> result = metadata.List <string>("A");
// Then
Assert.IsNotNull(result);
CollectionAssert.AreEqual(result, new[] { "1", "2", "3" });
}
public void ReplacesValue()
{
// Given
MetadataDictionary initialMetadata = new MetadataDictionary {
["A"] = "a"
};
MetadataStack metadata = new MetadataStack(initialMetadata);
// When
MetadataStack clone = metadata.Clone(new Dictionary <string, object> {
{ "A", "b" }
});
// Then
Assert.AreEqual("a", metadata["A"]);
Assert.AreEqual("b", clone["A"]);
}
public void ReturnsCorrectResultForKeysWithDifferentCase()
{
// Given
MetadataDictionary initialMetadata = new MetadataDictionary
{
["A"] = new SimpleMetadataValue {
Value = "a"
}
};
MetadataStack metadata = new MetadataStack(initialMetadata);
// When
object value = metadata["a"];
// Then
Assert.AreEqual("a", value);
}
public void ReturnsCorrectResultWithDerivedMetadataValue()
{
// Given
MetadataDictionary initialMetadata = new MetadataDictionary
{
["A"] = new DerivedMetadataValue {
Key = "X"
},
["X"] = "x"
};
MetadataStack metadata = new MetadataStack(initialMetadata);
// When
object value = metadata.Get("A");
// Then
Assert.AreEqual("x", value);
}
public void ReturnsCorrectResultWithMetadataValue()
{
// Given
MetadataDictionary initialMetadata = new MetadataDictionary
{
["A"] = new SimpleMetadataValue {
Value = "a"
}
};
MetadataStack metadata = new MetadataStack(initialMetadata);
// When
object value;
bool contains = metadata.TryGetValue("A", out value);
// Then
Assert.IsTrue(contains);
Assert.AreEqual("a", value);
}
public void ReturnsListForList()
{
// Given
IDocument a = new TestDocument();
IDocument b = new TestDocument();
IDocument c = new TestDocument();
MetadataDictionary initialMetadata = new MetadataDictionary {
["A"] = new List <IDocument> {
a, b, c
}
};
MetadataStack metadata = new MetadataStack(initialMetadata);
// When
IReadOnlyList <IDocument> result = metadata.DocumentList("A");
// Then
Assert.IsNotNull(result);
CollectionAssert.AreEqual(new[] { a, b, c }, result);
}
public void ReturnsCorrectDirectoryPathForString(string path, string expected)
{
// Given
MetadataDictionary initialMetadata = new MetadataDictionary();
MetadataStack metadata = new MetadataStack(initialMetadata);
// When
metadata = metadata.Clone(new[] { new KeyValuePair <string, object>("A", path) });
object result = metadata.DirectoryPath("A");
// Then
if (expected == null)
{
Assert.IsNull(result);
}
else
{
Assert.IsInstanceOf <DirectoryPath>(result);
Assert.AreEqual(expected, ((DirectoryPath)result).FullPath);
}
}
public void MetadataValueCalledForEachRequest()
{
// Given
SimpleMetadataValue metadataValue = new SimpleMetadataValue {
Value = "a"
};
MetadataDictionary initialMetadata = new MetadataDictionary {
["A"] = metadataValue
};
MetadataStack metadata = new MetadataStack(initialMetadata);
// When
object value = metadata.Get("A");
value = metadata.Get("A");
value = metadata.Get("A");
// Then
Assert.AreEqual("a", value);
Assert.AreEqual(3, metadataValue.Calls);
}
private Document(string id, MetadataStack metadata, FilePath source, Stream stream, object streamLock, IEnumerable <KeyValuePair <string, object> > items, bool disposeStream)
{
if (id == null)
{
throw new ArgumentNullException(nameof(id));
}
if (source != null && !source.IsAbsolute)
{
throw new ArgumentException("Document sources must be absolute", nameof(source));
}
Id = id;
Source = source;
_metadata = items == null ? metadata : metadata.Clone(items);
if (stream == null)
{
_stream = Stream.Null;
}
else
{
if (!stream.CanRead)
{
throw new ArgumentException("Document stream must support reading.", nameof(stream));
}
if (!stream.CanSeek)
{
_stream = new SeekableStream(stream, disposeStream);
_disposeStream = true;
}
else
{
_stream = stream;
_disposeStream = disposeStream;
}
}
_streamLock = streamLock ?? new object();
}
public void EnumeratingMetadataValuesReturnsCorrectResults()
{
// Given
MetadataDictionary initialMetadata = new MetadataDictionary
{
["A"] = new SimpleMetadataValue {
Value = "a"
},
["B"] = new SimpleMetadataValue {
Value = "b"
},
["C"] = new SimpleMetadataValue {
Value = "c"
}
};
MetadataStack metadata = new MetadataStack(initialMetadata);
// When
object[] values = metadata.Select(x => x.Value).ToArray();
// Then
CollectionAssert.AreEquivalent(new[] { "a", "b", "c" }, values);
}
private Document(string id, MetadataStack metadata, FilePath source, Stream stream, object streamLock, IEnumerable <KeyValuePair <string, object> > items, bool disposeStream)
: this(id, metadata, source, stream, streamLock, null, items, disposeStream)
{
}
private Document(string id, MetadataStack metadata, FilePath source, string content, IEnumerable <KeyValuePair <string, object> > items)
: this(id, metadata, source, null, null, content, items, true)
{
}
