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()); }