public void Close_IfHasTransformEventsAndIsClosedIsFalse_ShouldRaiseTransformEvents()
{
const string expectedContent = "Test";
Encoding expectedEncoding = Encoding.UTF8;
const string expectedTransformedContent = expectedContent;
byte[] buffer = expectedEncoding.GetBytes(expectedContent);
bool transformRaised = false;
string actualContent = null;
Encoding actualEncoding = null;
string actualTransformedContent = null;
object actualSender = null;
TransformableStream transformableStream = new TransformableStream(Mock.Of<Stream>(), expectedEncoding);
transformableStream.Transform += delegate(object sender, StreamTransformingEventArgs e)
{
transformRaised = true;
actualSender = sender;
actualContent = e.Content;
actualEncoding = e.Encoding;
actualTransformedContent = e.TransformedContent;
};
Assert.IsFalse(transformRaised);
transformableStream.CapturedStream.Write(buffer, 0, buffer.Length);
transformableStream.Close();
Assert.IsTrue(transformRaised);
Assert.AreEqual(transformableStream, actualSender);
Assert.AreEqual(expectedContent, actualContent);
Assert.AreEqual(expectedEncoding, actualEncoding);
Assert.AreEqual(expectedTransformedContent, actualTransformedContent);
}
public void Close_IfHasTransformEventsAndIsClosedIsTrue_ShouldNotRaiseTransformEvents()
{
bool transformRaised = false;
TransformableStream transformableStream = new TransformableStream(Mock.Of<Stream>(), Mock.Of<Encoding>());
transformableStream.Transform += (sender, e) => { transformRaised = true; };
Assert.IsFalse(transformRaised);
transformableStream.IsClosed = true;
transformableStream.Close();
Assert.IsFalse(transformRaised);
}
public void Close_ShouldCallCloseOfTheCapturedStream()
{
Mock<MemoryStream> memoryStreamMock = new Mock<MemoryStream>();
memoryStreamMock.Verify(memoryStream => memoryStream.Close(), Times.Never());
TransformableStream transformableStream = new TransformableStream(Mock.Of<Stream>(), Mock.Of<Encoding>());
// ReSharper disable PossibleNullReferenceException
typeof(CapturableStream).GetField("_capturedStream", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(transformableStream, memoryStreamMock.Object);
// ReSharper restore PossibleNullReferenceException
transformableStream.Close();
memoryStreamMock.Verify(memoryStream => memoryStream.Close(), Times.Once());
}
public virtual void OnPostRequestHandlerExecute(IHttpApplication httpApplication)
{
if(httpApplication == null)
throw new ArgumentNullException("httpApplication");
if(!this.HtmlInvestigator.IsHtmlResponse(httpApplication.Context))
return;
IEnumerable<IHtmlTransformer> htmlTransformers = this.HtmlTransformingContext.GetTransformers().ToArray();
if(!htmlTransformers.Any())
return;
TransformableStream transformableStream = new TransformableStream(httpApplication.Response.Filter, httpApplication.Response.ContentEncoding);
transformableStream.Transform += (sender, streamTransformingEventArgs) => this.OnTransform(streamTransformingEventArgs, htmlTransformers);
httpApplication.Response.Filter = transformableStream;
}
public void Write_IfNotCaptured_ShouldNotCallWriteOfTheCapturedStream()
{
byte[] buffer = new byte[4] {0, 1, 2, 3};
TransformableStream transformableStream = new TransformableStream(Mock.Of<Stream>(), Mock.Of<Encoding>());
Assert.IsFalse(transformableStream.CapturedStream.ToArray().Any());
transformableStream.Write(buffer, 0, buffer.Length);
Assert.IsFalse(transformableStream.CapturedStream.ToArray().Any());
}
public void Write_IfHasTransformEvents_ShouldNotCallWriteOfTheWrappedStream()
{
Mock<Stream> streamMock = new Mock<Stream>();
streamMock.Verify(stream => stream.Write(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>()), Times.Never());
TransformableStream transformableStream = new TransformableStream(streamMock.Object, Mock.Of<Encoding>());
transformableStream.Transform += (sender, args) => { };
byte[] buffer = new byte[DateTime.Now.Millisecond];
transformableStream.Write(buffer, 0, buffer.Length);
streamMock.Verify(stream => stream.Write(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>()), Times.Never());
}
public void Write_IfHasCaptureWriteEvents_ShouldRaiseCaptureWriteEvents()
{
byte[] expectedBuffer = new byte[] {0, 1, 2, 3};
const int expectedOffset = 1;
const int expectedCount = 2;
Encoding expectedEncoding = Encoding.UTF8;
bool captureWriteRaised = false;
IEnumerable<byte> actualBuffer = null;
int? actualOffset = null;
int? actualCount = null;
Encoding actualEncoding = null;
object actualSender = null;
TransformableStream transformableStream = new TransformableStream(Mock.Of<Stream>(), expectedEncoding);
transformableStream.CaptureWrite += delegate(object sender, StreamWriteEventArgs e)
{
captureWriteRaised = true;
actualSender = sender;
actualBuffer = e.Buffer;
actualOffset = e.Offset;
actualCount = e.Count;
actualEncoding = e.Encoding;
};
Assert.IsFalse(captureWriteRaised);
transformableStream.Write(expectedBuffer, expectedOffset, expectedCount);
Assert.IsTrue(captureWriteRaised);
Assert.AreEqual(transformableStream, actualSender);
// ReSharper disable PossibleMultipleEnumeration
Assert.AreEqual(expectedBuffer.Length, actualBuffer.Count());
Assert.AreEqual(expectedBuffer[0], actualBuffer.ElementAt(0));
Assert.AreEqual(expectedBuffer[1], actualBuffer.ElementAt(1));
Assert.AreEqual(expectedBuffer[2], actualBuffer.ElementAt(2));
Assert.AreEqual(expectedBuffer[3], actualBuffer.ElementAt(3));
// ReSharper restore PossibleMultipleEnumeration
Assert.AreEqual(expectedOffset, actualOffset);
Assert.AreEqual(expectedCount, actualCount);
Assert.AreEqual(expectedEncoding, actualEncoding);
}
public void Write_IfCaptured_ShouldCallWriteOfTheCapturedStream()
{
byte[] buffer = new byte[4] {0, 1, 2, 3};
TransformableStream transformableStream = new TransformableStream(Mock.Of<Stream>(), Mock.Of<Encoding>());
transformableStream.Capture += (sender, e) => { };
Assert.IsFalse(transformableStream.CapturedStream.ToArray().Any());
transformableStream.Write(buffer, 0, buffer.Length);
Assert.AreEqual(4, transformableStream.CapturedStream.ToArray().Length);
Assert.AreEqual(0, transformableStream.CapturedStream.ToArray()[0]);
Assert.AreEqual(1, transformableStream.CapturedStream.ToArray()[1]);
Assert.AreEqual(2, transformableStream.CapturedStream.ToArray()[2]);
Assert.AreEqual(3, transformableStream.CapturedStream.ToArray()[3]);
}
public void HasTransformWriteEvents_IfTransformWriteEventsAreNotRegistered_ShouldReturnFalse()
{
TransformableStream transformableStream = new TransformableStream(Mock.Of<Stream>(), Mock.Of<Encoding>());
Assert.IsFalse(transformableStream.HasTransformWriteEvents);
transformableStream = new TransformableStream(Mock.Of<Stream>(), Mock.Of<Encoding>());
Assert.IsFalse(transformableStream.HasTransformWriteEvents);
transformableStream.TransformWrite += TransformWriteEventHandler;
transformableStream.TransformWrite -= TransformWriteEventHandler;
Assert.IsFalse(transformableStream.HasTransformWriteEvents);
}
public void TransformTest()
{
const string originalContent = "Original content";
const string transformedContent = "Transformed content";
Encoding encoding = Encoding.UTF8;
byte[] originalBuffer = encoding.GetBytes(originalContent);
string capturedContent = null;
MemoryStream memoryStream = new MemoryStream();
TransformableStream transformableStream = new TransformableStream(memoryStream, encoding);
transformableStream.Transform += delegate(object sender, StreamTransformingEventArgs e) { e.TransformedContent = transformedContent; };
transformableStream.Capture += delegate(object sender, StreamEventArgs e) { capturedContent = e.Content; };
for(int i = 0; i < originalBuffer.Length; i++)
{
transformableStream.Write(originalBuffer, i, 1);
}
Assert.AreEqual(0, memoryStream.ToArray().Length);
Assert.AreEqual(originalBuffer.Length, transformableStream.CapturedStream.ToArray().Length);
transformableStream.Flush();
Assert.AreEqual(0, memoryStream.ToArray().Length);
Assert.AreEqual(originalBuffer.Length, transformableStream.CapturedStream.ToArray().Length);
transformableStream.Close();
Assert.AreEqual(transformedContent, encoding.GetString(memoryStream.ToArray()));
Assert.AreEqual(transformedContent, capturedContent);
}
public void OnTransform_ShouldRaiseTransformEvents()
{
int numberOfEventsRaised = 0;
TransformableStream transformableStream = new TransformableStream(Mock.Of<Stream>(), Mock.Of<Encoding>());
transformableStream.Transform += (sender, e) => numberOfEventsRaised++;
transformableStream.Transform += (sender, e) => numberOfEventsRaised++;
transformableStream.Transform += (sender, e) => numberOfEventsRaised++;
Assert.AreEqual(0, numberOfEventsRaised);
transformableStream.OnTransform(new StreamTransformingEventArgs(null, Mock.Of<Encoding>()));
Assert.AreEqual(3, numberOfEventsRaised);
}
public void OnTransformWrite_ShouldRaiseTransformWriteEvents()
{
int numberOfEventsRaised = 0;
TransformableStream transformableStream = new TransformableStream(Mock.Of<Stream>(), Mock.Of<Encoding>());
transformableStream.TransformWrite += (sender, e) => numberOfEventsRaised++;
transformableStream.TransformWrite += (sender, e) => numberOfEventsRaised++;
transformableStream.TransformWrite += (sender, e) => numberOfEventsRaised++;
Assert.AreEqual(0, numberOfEventsRaised);
transformableStream.OnTransformWrite(new StreamWriteTransformingEventArgs(new byte[0], It.IsAny<int>(), It.IsAny<int>(), Mock.Of<Encoding>()));
Assert.AreEqual(3, numberOfEventsRaised);
}
public void IsCaptured_ShouldReturnHasCaptureEventsOrHasTransformEvents()
{
bool hasCaptureEvents = DateTime.Now.Second%2 == 0;
bool hasTransformEvents = DateTime.Now.Millisecond%2 == 0;
TransformableStream transformableStream = new TransformableStream(Mock.Of<Stream>(), Mock.Of<Encoding>());
if(hasCaptureEvents)
transformableStream.Capture += (sender, e) => { };
if(hasTransformEvents)
transformableStream.Transform += (sender, e) => { };
Assert.AreEqual(hasCaptureEvents || hasTransformEvents, transformableStream.IsCaptured);
}
public void HasTransformWriteEvents_IfTransformWriteEventsAreRegistered_ShouldReturnTrue()
{
TransformableStream transformableStream = new TransformableStream(Mock.Of<Stream>(), Mock.Of<Encoding>());
transformableStream.TransformWrite += (sender, e) => { };
Assert.IsTrue(transformableStream.HasTransformWriteEvents);
}
public void Close_ShouldSetIsClosedToTrue()
{
TransformableStream transformableStream = new TransformableStream(Mock.Of<Stream>(), Mock.Of<Encoding>());
transformableStream.Close();
Assert.IsTrue(transformableStream.IsClosed);
}
public void TransformWriteTest()
{
byte[] capturedBuffer = null;
int? capturedOffset = null;
int? capturedCount = null;
Encoding encoding = Mock.Of<Encoding>();
using(MemoryStream memoryStream = new MemoryStream())
{
TransformableStream transformableStream = new TransformableStream(memoryStream, encoding);
transformableStream.TransformWrite += delegate(object sender, StreamWriteTransformingEventArgs e)
{
e.TransformedBuffer.Clear();
e.TransformedBuffer.Add(10);
e.TransformedBuffer.Add(11);
e.TransformedBuffer.Add(12);
e.TransformedBuffer.Add(13);
e.TransformedOffset = 1;
e.TransformedCount = 2;
};
transformableStream.CaptureWrite += delegate(object sender, StreamWriteEventArgs e)
{
capturedBuffer = e.Buffer.ToArray();
capturedOffset = e.Offset;
capturedCount = e.Count;
};
transformableStream.Write(new byte[] {1, 2, 3, 4, 5, 6, 7, 8}, 2, 4);
byte[] toArray = memoryStream.ToArray();
Assert.AreEqual(2, toArray.Length);
Assert.AreEqual(11, toArray[0]);
Assert.AreEqual(12, toArray[1]);
Assert.AreEqual(4, capturedBuffer.Length);
Assert.AreEqual(10, capturedBuffer[0]);
Assert.AreEqual(11, capturedBuffer[1]);
Assert.AreEqual(12, capturedBuffer[2]);
Assert.AreEqual(13, capturedBuffer[3]);
Assert.AreEqual(1, capturedOffset);
Assert.AreEqual(2, capturedCount);
}
}
public void Flush_IfHasTransformEvents_ShouldNotCallFlushOfTheWrappedStream()
{
Mock<Stream> streamMock = new Mock<Stream>();
streamMock.Verify(stream => stream.Flush(), Times.Never());
TransformableStream transformableStream = new TransformableStream(streamMock.Object, Mock.Of<Encoding>());
transformableStream.Transform += (sender, e) => { };
transformableStream.Flush();
streamMock.Verify(stream => stream.Flush(), Times.Never());
}
