public async Task ShouldSerializeToXmlUsingNamespaceOverrides()
{
const string prefix = "google";
var dto = BuildDto();
var serializerSettings = new XmlContentSerializerSettings {
XmlNamespaces = new XmlSerializerNamespaces()
};
serializerSettings.XmlNamespaces.Add(prefix, "https://google.com");
var sut = new XmlContentSerializer(serializerSettings);
var content = sut.ToHttpContent(dto);
var document = new XmlDocument();
document.LoadXml(await content.ReadAsStringAsync());
Assert.Equal(prefix, document["Dto"]?["Name", "https://google.com"]?.Prefix);
}
public void WriteToXmlWriterWritesCorrectXml(
XmlContentSerializer serializer,
AtomXmlWriter <XmlContentSerializer> writer,
AtomFeed feed,
Generator <XmlAttributedTestEventX> eventGenerator)
{
// Fixture setup
var sb = new StringBuilder();
using (var w = XmlWriter.Create(sb))
{
var entries = feed.Entries.Zip(
eventGenerator,
(entry, @event) => entry.WithContent(
entry.Content.WithItem(@event))).ToList();
var sut = feed.WithEntries(entries);
// Exercise system
sut.WriteTo(w, serializer);
// Verify outcome
w.Flush();
var expectedLinks = string.Concat(sut.Links.Select(writer.ToXml));
var expectedEntries = string.Concat(entries.Select(writer.ToXml));
var expected = XDocument.Parse(
"<feed xmlns=\"http://www.w3.org/2005/Atom\">" +
" <id>" + sut.Id.ToString() + "</id>" +
" <title type=\"text\">" + sut.Title + "</title>" +
" <updated>" + sut.Updated.ToString("o") + "</updated>" +
" <author>" +
" <name>" + sut.Author.Name + "</name>" +
" </author>" +
expectedLinks +
expectedEntries +
"</feed>");
var actual = XDocument.Parse(sb.ToString());
Assert.Equal(expected, actual, new XNodeEqualityComparer());
}
// Teardown
}
public void ReverseYieldsCorrectEvents(
[Frozen(As = typeof(ITypeResolver))] TestEventTypeResolver dummyResolver,
[Frozen(As = typeof(IContentSerializer))] XmlContentSerializer dummySerializer,
[Frozen(As = typeof(IAtomEventStorage))] AtomEventsInMemory dummyInjectedIntoSut,
[Frozen] UuidIri dummyId,
AtomEventObserver <XmlAttributedTestEventX> writer,
LifoEvents <XmlAttributedTestEventX> sut,
List <XmlAttributedTestEventX> expected)
{
expected.ForEach(e => writer.AppendAsync(e).Wait());
var actual = sut.Reverse();
Assert.True(
expected.SequenceEqual(actual),
"Events should be yielded in a FIFO order");
Assert.True(
expected.Cast <object>().SequenceEqual(actual.OfType <object>()),
"Events should be yielded in a FIFO order");
}
public void SutCanRoundTripAttributedClassInstance(
XmlContentSerializer sut,
XmlAttributedTestEventX xatex)
{
using (var ms = new MemoryStream())
using (var w = XmlWriter.Create(ms))
{
sut.Serialize(w, xatex);
w.Flush();
ms.Position = 0;
using (var r = XmlReader.Create(ms))
{
var content = sut.Deserialize(r);
var actual = Assert.IsAssignableFrom <XmlAttributedTestEventX>(content.Item);
Assert.Equal(xatex.Number, actual.Number);
Assert.Equal(xatex.Text, actual.Text);
}
}
}
public void SerializeCorrectlySerializesAttributedClassInstance(
XmlContentSerializer sut,
XmlAttributedTestEventX xate)
{
var sb = new StringBuilder();
using (var w = XmlWriter.Create(sb))
{
sut.Serialize(w, xate);
w.Flush();
var actual = sb.ToString();
var expected = XDocument.Parse(
"<test-event-x xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns=\"http://grean:rocks\">" +
" <number>" + xate.Number + "</number>" +
" <text>" + xate.Text + "</text>" +
"</test-event-x>");
Assert.Equal(expected, XDocument.Parse(actual), new XNodeEqualityComparer());
}
}
public async Task ShouldSerializeToXmlUsingAttributeOverrides()
{
const string overridenRootElementName = "dto-ex";
var dto = BuildDto();
var serializerSettings = new XmlContentSerializerSettings();
var attributes = new XmlAttributes {
XmlRoot = new XmlRootAttribute(overridenRootElementName)
};
serializerSettings.XmlAttributeOverrides.Add(dto.GetType(), attributes);
var sut = new XmlContentSerializer(serializerSettings);
var content = sut.ToHttpContent(dto);
var document = new XmlDocument();
document.LoadXml(await content.ReadAsStringAsync());
Assert.Equal(overridenRootElementName, document.DocumentElement?.Name);
}
public void SutYieldsPagedEvents(
[Frozen(As = typeof(ITypeResolver))] TestEventTypeResolver dummyResolver,
[Frozen(As = typeof(IContentSerializer))] XmlContentSerializer dummySerializer,
[Frozen(As = typeof(IAtomEventStorage))] AtomEventsInMemory dummyInjectedIntoSut,
[Frozen] UuidIri dummyId,
AtomEventObserver <XmlAttributedTestEventX> writer,
FifoEvents <XmlAttributedTestEventX> sut,
Generator <XmlAttributedTestEventX> eventGenerator)
{
var expected = eventGenerator.Take(writer.PageSize * 2 + 1).ToList();
expected.ForEach(e => writer.AppendAsync(e).Wait());
Assert.True(
expected.SequenceEqual(sut),
"Events should be yielded in a FIFO order");
Assert.True(
expected.Cast <object>().SequenceEqual(sut.OfType <object>()),
"Events should be yielded in a FIFO order");
}
public void WriteTwoEventsOnlyWritesIndexOnce(
AtomEventWriteUsage usage,
[Frozen(As = typeof(ITypeResolver))] TestEventTypeResolver dummyResolver,
[Frozen(As = typeof(IContentSerializer))] XmlContentSerializer dummySerializer,
[Frozen(As = typeof(IAtomEventStorage))] SpyAtomEventStore spyStore,
AtomEventWriterFactory <XmlAttributedTestEventX> writerFactory,
AtomEventObserver <XmlAttributedTestEventX> sut,
Generator <XmlAttributedTestEventX> eventGenerator)
{
var events = eventGenerator.Take(2).ToList();
var writer = writerFactory.Create(usage);
events.ForEach(e => writer.WriteTo(sut, e));
var writtenIds = spyStore.ObservedArguments
.OfType <AtomFeed>()
.Select(f => f.Id);
Assert.Equal(1, writtenIds.Count(id => sut.Id == id));
}
public void FeedsReturnWrittenFeeds(
AtomEventsInMemory sut,
IEnumerable <AtomFeedBuilder <XmlAttributedTestEventY> > feedBuilders,
XmlContentSerializer serializer)
{
var feeds = feedBuilders.Select(b => b.Build());
foreach (var f in feeds)
{
using (var w = sut.CreateFeedWriterFor(f))
f.WriteTo(w, serializer);
}
var actual = sut.Feeds.Select(s => AtomFeed.Parse(s, serializer));
var expected = new HashSet <AtomFeed>(feeds, new AtomFeedComparer());
Assert.True(
expected.SetEquals(actual),
"Written feeds should be enumerated.");
}
public void ClientCanReadSecondFeed(
AtomEventsInMemory sut,
AtomFeedBuilder <XmlAttributedTestEventX> feedBuilder1,
AtomFeedBuilder <XmlAttributedTestEventY> feedBuilder2,
XmlContentSerializer serializer)
{
var other = feedBuilder1.Build();
var expected = feedBuilder2.Build();
using (var w = sut.CreateFeedWriterFor(other))
other.WriteTo(w, serializer);
using (var w = sut.CreateFeedWriterFor(expected))
expected.WriteTo(w, serializer);
using (var r = sut.CreateFeedReaderFor(expected.Locate()))
{
var actual = AtomFeed.ReadFrom(r, serializer);
Assert.Equal(expected, actual, new AtomFeedComparer());
}
}
public async Task XmlEncodingShouldMatchWriterSettingAsync()
{
var encoding = Encoding.UTF32;
var serializerSettings = new XmlContentSerializerSettings
{
XmlReaderWriterSettings = new XmlReaderWriterSettings()
{
WriterSettings = new XmlWriterSettings()
{
Encoding = encoding
}
}
};
var sut = new XmlContentSerializer(serializerSettings);
var dto = BuildDto();
var content = sut.ToHttpContent(dto);
var xml = XDocument.Parse(await content.ReadAsStringAsync());
var documentEncoding = xml.Declaration.Encoding;
Assert.Equal(encoding.WebName, documentEncoding);
}
public void WriteCorrectlyStoresFeed(
AtomEventWriteUsage usage,
[Frozen(As = typeof(ITypeResolver))] TestEventTypeResolver dummyResolver,
[Frozen(As = typeof(IContentSerializer))] XmlContentSerializer dummySerializer,
[Frozen(As = typeof(IAtomEventStorage))] AtomEventsInMemory storage,
AtomEventWriterFactory <XmlAttributedTestEventX> writerFactory,
AtomEventObserver <XmlAttributedTestEventX> sut,
XmlAttributedTestEventX expectedEvent)
{
var before = DateTimeOffset.Now;
writerFactory.Create(usage).WriteTo(sut, expectedEvent);
var writtenFeeds = storage.Feeds.Select(ParseAtomFeed);
var actual = FindFirstPage(writtenFeeds, sut.Id);
var expectedFeed =
new AtomFeedLikeness(before, actual.Id, expectedEvent);
Assert.True(
expectedFeed.Equals(actual),
"Expected feed must match actual feed.");
}
public void WriteCorrectlyStoresLastLinkOnIndex(
AtomEventWriteUsage usage,
[Frozen(As = typeof(ITypeResolver))] TestEventTypeResolver dummyResolver,
[Frozen(As = typeof(IContentSerializer))] XmlContentSerializer dummySerializer,
[Frozen(As = typeof(IAtomEventStorage))] AtomEventsInMemory storage,
AtomEventWriterFactory <XmlAttributedTestEventX> writerFactory,
AtomEventObserver <XmlAttributedTestEventX> sut,
XmlAttributedTestEventX expectedEvent)
{
var before = DateTimeOffset.Now;
writerFactory.Create(usage).WriteTo(sut, expectedEvent);
var writtenFeeds = storage.Feeds.Select(ParseAtomFeed);
var index = FindIndex(writtenFeeds, sut.Id);
var firstLink = index.Links.SingleOrDefault(l => l.IsFirstLink);
Assert.NotNull(firstLink);
var lastLink = index.Links.SingleOrDefault(l => l.IsLastLink);
Assert.NotNull(lastLink);
Assert.Equal(firstLink.Href, lastLink.Href);
}
public void SutIsContentSerializer(XmlContentSerializer sut)
{
Assert.IsAssignableFrom <IContentSerializer>(sut);
}
public void ScanWithNullAssemblyThrows()
{
Assert.Throws <ArgumentNullException>(() =>
XmlContentSerializer.Scan(null));
}
public void AttemptToCorrecLastLinkDoesNotThrowOnFailure(
AtomEventWriteUsage usage,
[Frozen(As = typeof(ITypeResolver))] TestEventTypeResolver dummyResolver,
[Frozen(As = typeof(IContentSerializer))] XmlContentSerializer dummySerializer,
[Frozen] Mock <IAtomEventStorage> storeStub,
AtomEventsInMemory innerStorage,
AtomEventWriterFactory <XmlAttributedTestEventX> writerFactory,
AtomEventObserver <XmlAttributedTestEventX> sut,
Generator <XmlAttributedTestEventX> eventGenerator)
{
// Fixture setup
storeStub
.Setup(s => s.CreateFeedReaderFor(It.IsAny <Uri>()))
.Returns((Uri u) => innerStorage.CreateFeedReaderFor(u));
storeStub
.Setup(s => s.CreateFeedWriterFor(It.IsAny <AtomFeed>()))
.Returns((AtomFeed f) => innerStorage.CreateFeedWriterFor(f));
var writer = writerFactory.Create(usage);
var events = eventGenerator.Take(sut.PageSize * 2 + 1).ToList();
events.ForEach(e => writer.WriteTo(sut, e));
/* Point the 'last' link to the second page, instead of to the last
* page. This simulates that when the true last page was created,
* the index wasn't correctly updated. This could for example
* happen due to a network failure. */
var writtenFeeds = innerStorage.Feeds.Select(ParseAtomFeed);
var index = FindIndex(writtenFeeds, sut.Id);
var firstPage = FindFirstPage(writtenFeeds, sut.Id);
var nextPage = FindNextPage(firstPage, writtenFeeds);
var incorrectLastLink =
nextPage.Links.Single(l => l.IsSelfLink).ToLastLink();
index = index.WithLinks(index.Links
.Where(l => !l.IsLastLink)
.Concat(new[] { incorrectLastLink }));
using (var w = innerStorage.CreateFeedWriterFor(index))
index.WriteTo(w, sut.Serializer);
/* Configure storage to fail when writing the index, but not for
* other documents. */
storeStub
.Setup(s => s.CreateFeedWriterFor(
It.Is <AtomFeed>(f => f.Id != index.Id)))
.Returns((AtomFeed f) => innerStorage.CreateFeedWriterFor(f));
storeStub
.Setup(s => s.CreateFeedWriterFor(
It.Is <AtomFeed>(f => f.Id == index.Id)))
.Throws(new Exception("On-purpose write failure."));
var expected = eventGenerator.First();
// Exercise system
writer.WriteTo(sut, expected);
// Verify outcome
writtenFeeds = innerStorage.Feeds.Select(ParseAtomFeed);
var lastPage = FindLastPage(writtenFeeds, sut.Id);
Assert.True(
lastPage.Entries.Select(e => e.Content.Item).Any(expected.Equals),
"Last written event should be present.");
// Teardown
}
public void CreateTypeResolverWithNullAssemblyThrows()
{
Assert.Throws <ArgumentNullException>(() =>
XmlContentSerializer.CreateTypeResolver(null));
}
public void WriteMoreThanPageSizeDoesNotThrowWhenIndexWriteFails(
int initialPageCount,
int secondaryPageCount,
AtomEventWriteUsage usage,
[Frozen(As = typeof(ITypeResolver))] TestEventTypeResolver dummyResolver,
[Frozen(As = typeof(IContentSerializer))] XmlContentSerializer dummySerializer,
[Frozen] Mock <IAtomEventStorage> storeStub,
AtomEventsInMemory innerStorage,
AtomEventWriterFactory <XmlAttributedTestEventX> writerFactory,
AtomEventObserver <XmlAttributedTestEventX> sut,
Generator <XmlAttributedTestEventX> eventGenerator)
{
// Fixture setup
storeStub
.Setup(s => s.CreateFeedReaderFor(It.IsAny <Uri>()))
.Returns((Uri u) => innerStorage.CreateFeedReaderFor(u));
storeStub
.Setup(s => s.CreateFeedWriterFor(It.IsAny <AtomFeed>()))
.Returns((AtomFeed f) => innerStorage.CreateFeedWriterFor(f));
var writer = writerFactory.Create(usage);
/* Write some pages full. */
var events =
eventGenerator.Take(sut.PageSize * initialPageCount).ToList();
events.ForEach(e => writer.WriteTo(sut, e));
/* Find the index. */
var writtenFeeds = innerStorage.Feeds.Select(ParseAtomFeed);
var index = FindIndex(writtenFeeds, sut.Id);
/* Configure storage to fail when writing the index, but not for
* other documents. */
storeStub
.Setup(s => s.CreateFeedWriterFor(
It.Is <AtomFeed>(f => f.Id != index.Id)))
.Returns((AtomFeed f) => innerStorage.CreateFeedWriterFor(f));
storeStub
.Setup(s => s.CreateFeedWriterFor(
It.Is <AtomFeed>(f => f.Id == index.Id)))
.Throws(new Exception("On-purpose write failure."));
/* Write some more pages, this time with the index update
* consistently failing. */
eventGenerator
.Take(sut.PageSize * secondaryPageCount)
.ToList()
.ForEach(e => writer.WriteTo(sut, e));
// Exercise system
var expected = eventGenerator.Take(sut.PageSize).ToList();
expected.ForEach(e => writer.WriteTo(sut, e));
// Verify outcome
writtenFeeds = innerStorage.Feeds.Select(ParseAtomFeed);
var lastPage = FindLastPage(writtenFeeds, sut.Id);
Assert.True(
lastPage.Entries
.Select(e => e.Content.Item)
.Reverse()
.SequenceEqual(expected),
"Last written events should be present."
);
// Teardown
}
