998 lines
27 KiB
C#
998 lines
27 KiB
C#
//
|
|
// System.Web.HttpResponseTest.cs - Unit tests for System.Web.HttpResponse
|
|
//
|
|
// Author:
|
|
// Miguel de Icaza <miguel@ximian.com>
|
|
//
|
|
// Copyright (C) 2005 Novell, Inc (http://www.novell.com)
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining
|
|
// a copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System.Configuration.Provider;
|
|
using System.IO;
|
|
using System.Text;
|
|
using System.Web;
|
|
using System.Web.Routing;
|
|
using System.Web.Caching;
|
|
|
|
using NUnit.Framework;
|
|
|
|
using MonoTests.Common;
|
|
|
|
namespace MonoTests.System.Web {
|
|
|
|
public class FakeHttpWorkerRequest2 : HttpWorkerRequest {
|
|
public Hashtable KnownResponseHeaders;
|
|
public Hashtable UnknownResponseHeaders;
|
|
public int return_kind;
|
|
|
|
public FakeHttpWorkerRequest2 (int re)
|
|
{
|
|
KnownResponseHeaders = CollectionsUtil.CreateCaseInsensitiveHashtable();
|
|
UnknownResponseHeaders = CollectionsUtil.CreateCaseInsensitiveHashtable();
|
|
return_kind = re;
|
|
}
|
|
|
|
public override string GetUriPath()
|
|
{
|
|
return "/fake";
|
|
}
|
|
|
|
public override string GetQueryString()
|
|
{
|
|
return "GetQueryString";
|
|
}
|
|
|
|
public override string GetRawUrl()
|
|
{
|
|
return "/GetRawUrl";
|
|
}
|
|
|
|
public override string GetHttpVerbName()
|
|
{
|
|
return "GET";
|
|
}
|
|
|
|
public override string GetHttpVersion()
|
|
{
|
|
if (return_kind == 1)
|
|
return "HTTP/1.0";
|
|
else
|
|
return "HTTP/1.1";
|
|
}
|
|
|
|
public override string GetRemoteAddress()
|
|
{
|
|
return "__GetRemoteAddress";
|
|
}
|
|
|
|
public override int GetRemotePort()
|
|
{
|
|
return 1010;
|
|
}
|
|
|
|
public override string GetLocalAddress()
|
|
{
|
|
return "GetLocalAddress";
|
|
}
|
|
|
|
public override string GetAppPath ()
|
|
{
|
|
return "AppPath";
|
|
}
|
|
|
|
public override int GetLocalPort()
|
|
{
|
|
return 2020;
|
|
}
|
|
|
|
public bool status_sent;
|
|
public int status_code;
|
|
public string status_string;
|
|
|
|
public override void SendStatus(int s, string x)
|
|
{
|
|
status_sent = true;
|
|
status_code = s;
|
|
status_string = x;
|
|
}
|
|
|
|
void AddHeader (Hashtable table, string header_name, object header)
|
|
{
|
|
object o = table [header_name];
|
|
if (o == null)
|
|
table.Add (header_name, header);
|
|
else {
|
|
ArrayList al = o as ArrayList;
|
|
if (al == null) {
|
|
al = new ArrayList ();
|
|
al.Add (o);
|
|
table [header_name] = al;
|
|
} else
|
|
al = o as ArrayList;
|
|
|
|
al.Add (header);
|
|
}
|
|
}
|
|
|
|
bool headers_sent;
|
|
public override void SendKnownResponseHeader(int x, string j)
|
|
{
|
|
string header_name = HttpWorkerRequest.GetKnownRequestHeaderName (x);
|
|
AddHeader (KnownResponseHeaders, header_name, new KnownResponseHeader (x, j));
|
|
headers_sent = true;
|
|
}
|
|
|
|
public override void SendUnknownResponseHeader(string a, string b)
|
|
{
|
|
AddHeader (UnknownResponseHeaders, a, new UnknownResponseHeader (a, b));
|
|
headers_sent = true;
|
|
}
|
|
|
|
bool data_sent;
|
|
public byte [] data;
|
|
public int data_len;
|
|
public int total = 0;
|
|
|
|
public override void SendResponseFromMemory(byte[] arr, int x)
|
|
{
|
|
data_sent = true;
|
|
if (data != null) {
|
|
byte [] tmp = new byte [data.Length + x];
|
|
Array.Copy (data, tmp, data.Length);
|
|
Array.Copy (arr, 0, tmp, data.Length, x);
|
|
data = tmp;
|
|
data_len = data.Length;
|
|
} else {
|
|
data = new byte [x];
|
|
for (int i = 0; i < x; i++)
|
|
data [i] = arr [i];
|
|
data_len = x;
|
|
}
|
|
total += x;
|
|
}
|
|
|
|
public override void SendResponseFromFile(string a, long b , long c)
|
|
{
|
|
data_sent = true;
|
|
}
|
|
|
|
public override void SendResponseFromFile (IntPtr a, long b, long c)
|
|
{
|
|
data_sent = true;
|
|
}
|
|
|
|
public override void FlushResponse(bool x)
|
|
{
|
|
}
|
|
|
|
public override void EndOfRequest() {
|
|
}
|
|
|
|
public override string GetKnownRequestHeader (int index)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public bool OutputProduced {
|
|
get {
|
|
return headers_sent || data_sent;
|
|
}
|
|
}
|
|
}
|
|
|
|
class KnownResponseHeader
|
|
{
|
|
private int index;
|
|
private string value;
|
|
|
|
public KnownResponseHeader (int index, string value)
|
|
{
|
|
this.index = index;
|
|
this.value = value;
|
|
}
|
|
|
|
public int Index {
|
|
get { return index; }
|
|
}
|
|
|
|
public string Value {
|
|
get { return value; }
|
|
}
|
|
}
|
|
|
|
class UnknownResponseHeader
|
|
{
|
|
private string name;
|
|
private string value;
|
|
|
|
public UnknownResponseHeader (string name, string value)
|
|
{
|
|
this.name = name;
|
|
this.value = value;
|
|
}
|
|
|
|
public string Name {
|
|
get { return name; }
|
|
}
|
|
|
|
public string Value {
|
|
get { return value; }
|
|
}
|
|
}
|
|
|
|
[TestFixture]
|
|
public class HttpResponseTest {
|
|
public static HttpContext Cook (int re, out FakeHttpWorkerRequest2 f)
|
|
{
|
|
f = new FakeHttpWorkerRequest2 (re);
|
|
HttpContext c = new HttpContext (f);
|
|
|
|
return c;
|
|
}
|
|
|
|
[SetUp]
|
|
public void SetUp ()
|
|
{
|
|
AppDomain.CurrentDomain.SetData (".appPath", AppDomain.CurrentDomain.BaseDirectory);
|
|
}
|
|
|
|
[Test]
|
|
public void Test_Response ()
|
|
{
|
|
FakeHttpWorkerRequest2 f;
|
|
HttpContext c = Cook (1, out f);
|
|
|
|
c.Response.Write ("a");
|
|
Assert.AreEqual (false, f.OutputProduced, "T1");
|
|
c.Response.Flush ();
|
|
Assert.AreEqual (1, f.data_len, "T2");
|
|
c.Response.Write ("Hola");
|
|
Assert.AreEqual (1, f.data_len, "T3");
|
|
c.Response.Flush ();
|
|
Assert.AreEqual (5, f.data_len, "T4");
|
|
Assert.AreEqual ((byte) 'a', f.data [0], "T5");
|
|
Assert.AreEqual ((byte) 'H', f.data [1], "T6");
|
|
Assert.AreEqual ((byte) 'o', f.data [2], "T7");
|
|
Assert.AreEqual ((byte) 'l', f.data [3], "T8");
|
|
Assert.AreEqual ((byte) 'a', f.data [4], "T9");
|
|
}
|
|
|
|
[Test]
|
|
public void TestResponse_Chunked ()
|
|
{
|
|
FakeHttpWorkerRequest2 f;
|
|
HttpContext c = Cook (2, out f);
|
|
|
|
c.Response.Write ("a");
|
|
Assert.AreEqual (false, f.OutputProduced, "CT1");
|
|
c.Response.Flush ();
|
|
Assert.AreEqual (6, f.total, "CT2");
|
|
c.Response.Write ("Hola");
|
|
Assert.AreEqual (6, f.total, "CT3");
|
|
c.Response.Flush ();
|
|
|
|
}
|
|
|
|
[Test]
|
|
public void Status1 ()
|
|
{
|
|
FakeHttpWorkerRequest2 f;
|
|
HttpContext c = Cook (2, out f);
|
|
|
|
HttpResponse resp = c.Response;
|
|
resp.Status = "200 Lalala";
|
|
Assert.AreEqual (200, resp.StatusCode, "ST1");
|
|
Assert.AreEqual ("Lalala", resp.StatusDescription, "ST2");
|
|
|
|
resp.Status = "10000 La la la";
|
|
Assert.AreEqual (10000, resp.StatusCode, "ST3");
|
|
Assert.AreEqual ("La la la", resp.StatusDescription, "ST4");
|
|
|
|
resp.Status = "-1 La la la";
|
|
Assert.AreEqual (-1, resp.StatusCode, "ST5");
|
|
Assert.AreEqual ("La la la", resp.StatusDescription, "ST6");
|
|
|
|
resp.Status = "-200 La la la";
|
|
Assert.AreEqual (-200, resp.StatusCode, "ST7");
|
|
Assert.AreEqual ("La la la", resp.StatusDescription, "ST8");
|
|
|
|
resp.Status = "200 ";
|
|
Assert.AreEqual (200, resp.StatusCode, "ST7");
|
|
Assert.AreEqual ("", resp.StatusDescription, "ST8");
|
|
}
|
|
|
|
[Test]
|
|
public void Status2 ()
|
|
{
|
|
FakeHttpWorkerRequest2 f;
|
|
HttpContext c = Cook (2, out f);
|
|
|
|
HttpResponse resp = c.Response;
|
|
try {
|
|
resp.Status = "200";
|
|
Assert.Fail ("#1");
|
|
} catch (HttpException) {
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void Status3 ()
|
|
{
|
|
FakeHttpWorkerRequest2 f;
|
|
HttpContext c = Cook (2, out f);
|
|
|
|
HttpResponse resp = c.Response;
|
|
try {
|
|
resp.Status = "200\t";
|
|
Assert.Fail ("#1");
|
|
} catch (HttpException) {
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void Status4 ()
|
|
{
|
|
FakeHttpWorkerRequest2 f;
|
|
HttpContext c = Cook (2, out f);
|
|
|
|
HttpResponse resp = c.Response;
|
|
|
|
Assert.AreEqual (200, resp.StatusCode, "STT1");
|
|
Assert.AreEqual (HttpWorkerRequest.GetStatusDescription (200), resp.StatusDescription, "STT2");
|
|
|
|
resp.StatusCode = 400;
|
|
Assert.AreEqual (400, resp.StatusCode, "STT3");
|
|
Assert.AreEqual (HttpWorkerRequest.GetStatusDescription (400), resp.StatusDescription, "STT4");
|
|
|
|
resp.StatusDescription = "Something else";
|
|
Assert.AreEqual (400, resp.StatusCode, "STT5");
|
|
Assert.AreEqual ("Something else", resp.StatusDescription, "STT6");
|
|
|
|
resp.StatusDescription = null;
|
|
Assert.AreEqual (400, resp.StatusCode, "STT7");
|
|
Assert.AreEqual (HttpWorkerRequest.GetStatusDescription (400), resp.StatusDescription, "STT8");
|
|
}
|
|
|
|
//
|
|
// TODO: Add test for BinaryWrite and the various writes to check for Chunked Mode
|
|
//`
|
|
|
|
[Test]
|
|
public void SetCacheability ()
|
|
{
|
|
FakeHttpWorkerRequest2 f;
|
|
HttpContext c = Cook (1, out f);
|
|
|
|
//
|
|
// Basically the values from CacheControl are useless once Response.Cache is used
|
|
//
|
|
c.Response.Cache.SetCacheability (HttpCacheability.ServerAndNoCache);
|
|
Assert.AreEqual ("private", c.Response.CacheControl, "C1");
|
|
|
|
c.Response.Cache.SetCacheability (HttpCacheability.ServerAndPrivate);
|
|
Assert.AreEqual ("private", c.Response.CacheControl, "C2");
|
|
|
|
c.Response.Cache.SetCacheability (HttpCacheability.NoCache);
|
|
Assert.AreEqual ("private", c.Response.CacheControl, "C3");
|
|
|
|
c.Response.Cache.SetCacheability (HttpCacheability.Private);
|
|
Assert.AreEqual ("private", c.Response.CacheControl, "C4");
|
|
|
|
c.Response.Cache.SetCacheability (HttpCacheability.Server);
|
|
Assert.AreEqual ("private", c.Response.CacheControl, "C5");
|
|
|
|
c.Response.Cache.SetCacheability (HttpCacheability.Public);
|
|
Assert.AreEqual ("private", c.Response.CacheControl, "C6");
|
|
}
|
|
|
|
//
|
|
// Test the values allowed; .NET only documents private and public, but
|
|
// "no-cache" from the spec is also allowed
|
|
//
|
|
[Test]
|
|
public void CacheControl ()
|
|
{
|
|
FakeHttpWorkerRequest2 f;
|
|
HttpContext c = Cook (1, out f);
|
|
|
|
// Default value.
|
|
Assert.AreEqual ("private", c.Response.CacheControl, "D1");
|
|
|
|
c.Response.CacheControl = "private";
|
|
Assert.AreEqual ("private", c.Response.CacheControl, "D2");
|
|
|
|
c.Response.CacheControl = "public";
|
|
Assert.AreEqual ("public", c.Response.CacheControl, "D3");
|
|
|
|
c.Response.CacheControl = "no-cache";
|
|
Assert.AreEqual ("no-cache", c.Response.CacheControl, "D4");
|
|
|
|
c.Response.CacheControl = null;
|
|
Assert.AreEqual ("private", c.Response.CacheControl, "D5");
|
|
|
|
c.Response.CacheControl = "";
|
|
Assert.AreEqual ("private", c.Response.CacheControl, "D6");
|
|
}
|
|
|
|
//
|
|
// Just checks if the AddFileDepend* methods accept values, added after bug #342511
|
|
[Test]
|
|
public void AddFileDependencies ()
|
|
{
|
|
FakeHttpWorkerRequest2 f;
|
|
HttpContext c = Cook (1, out f);
|
|
|
|
ArrayList a = new ArrayList (1);
|
|
a.Add ("somefile.txt");
|
|
c.Response.AddFileDependencies (a);
|
|
|
|
string[] sa = new string [1] {"somefile.txt"};
|
|
c = Cook (1, out f);
|
|
c.Response.AddFileDependencies (sa);
|
|
|
|
c = Cook (1, out f);
|
|
c.Response.AddFileDependency ("somefile.txt");
|
|
}
|
|
|
|
[Test] // bug #488702
|
|
public void WriteHeaders ()
|
|
{
|
|
FakeHttpWorkerRequest2 f;
|
|
HttpContext c = Cook (2, out f);
|
|
|
|
HttpResponse resp = c.Response;
|
|
resp.CacheControl = "public";
|
|
resp.Cache.SetCacheability (HttpCacheability.NoCache);
|
|
resp.ContentType = "text/xml";
|
|
resp.AppendHeader ("Content-Disposition", "inline");
|
|
resp.AppendHeader ("Content-Type", "application/ms-word");
|
|
resp.AppendHeader ("Content-Length", "40");
|
|
resp.AppendHeader ("Transfer-Encoding", "compress");
|
|
resp.AppendHeader ("My-Custom-Header", "never");
|
|
resp.AppendHeader ("My-Custom-Header", "always");
|
|
|
|
Assert.AreEqual ("public", resp.CacheControl, "#A1");
|
|
Assert.AreEqual ("application/ms-word", resp.ContentType, "#A2");
|
|
Assert.AreEqual (0, f.KnownResponseHeaders.Count, "#A3");
|
|
Assert.AreEqual (0, f.UnknownResponseHeaders.Count, "#A4");
|
|
|
|
resp.Flush ();
|
|
|
|
KnownResponseHeader known;
|
|
|
|
Assert.AreEqual (6, f.KnownResponseHeaders.Count, "#B1");
|
|
|
|
known = (KnownResponseHeader)f.KnownResponseHeaders ["Content-Length"];
|
|
Assert.AreEqual (HttpWorkerRequest.HeaderContentLength, known.Index, "#B2");
|
|
Assert.AreEqual ("40", known.Value, "#B3");
|
|
|
|
known = (KnownResponseHeader)f.KnownResponseHeaders["Transfer-Encoding"];
|
|
Assert.AreEqual (HttpWorkerRequest.HeaderTransferEncoding, known.Index, "#B4");
|
|
Assert.AreEqual ("compress", known.Value, "#B5");
|
|
|
|
known = (KnownResponseHeader)f.KnownResponseHeaders["Cache-Control"];
|
|
Assert.AreEqual (HttpWorkerRequest.HeaderCacheControl, known.Index, "#B6");
|
|
Assert.AreEqual ("no-cache", known.Value, "#B7");
|
|
|
|
known = (KnownResponseHeader)f.KnownResponseHeaders["Pragma"];
|
|
Assert.AreEqual (HttpWorkerRequest.HeaderPragma, known.Index, "#B8");
|
|
Assert.AreEqual ("no-cache", known.Value, "#B9");
|
|
|
|
known = (KnownResponseHeader)f.KnownResponseHeaders["Expires"];
|
|
Assert.AreEqual (HttpWorkerRequest.HeaderExpires, known.Index, "#B10");
|
|
Assert.AreEqual ("-1", known.Value, "#B11");
|
|
|
|
known = (KnownResponseHeader)f.KnownResponseHeaders["Content-Type"];
|
|
Assert.AreEqual (HttpWorkerRequest.HeaderContentType, known.Index, "#B12");
|
|
Assert.AreEqual ("application/ms-word", known.Value, "#B13");
|
|
|
|
UnknownResponseHeader unknown;
|
|
|
|
Assert.AreEqual (3, f.UnknownResponseHeaders.Count, "#C1");
|
|
|
|
unknown = (UnknownResponseHeader) f.UnknownResponseHeaders ["X-AspNet-Version"];
|
|
Assert.AreEqual ("X-AspNet-Version", unknown.Name, "#C2");
|
|
Assert.AreEqual (Environment.Version.ToString (3), unknown.Value, "#C3");
|
|
|
|
unknown = (UnknownResponseHeader) f.UnknownResponseHeaders ["Content-Disposition"];
|
|
Assert.AreEqual ("Content-Disposition", unknown.Name, "#C4");
|
|
Assert.AreEqual ("inline", unknown.Value, "#C5");
|
|
|
|
ArrayList al = f.UnknownResponseHeaders ["My-Custom-Header"] as ArrayList;
|
|
Assert.AreEqual (2, al.Count, "#C6");
|
|
|
|
unknown = (UnknownResponseHeader) al [0];
|
|
Assert.AreEqual ("My-Custom-Header", unknown.Name, "#C7");
|
|
Assert.AreEqual ("never", unknown.Value, "#C8");
|
|
|
|
unknown = (UnknownResponseHeader) al [1];
|
|
Assert.AreEqual ("My-Custom-Header", unknown.Name, "#C9");
|
|
Assert.AreEqual ("always", unknown.Value, "#C10");
|
|
}
|
|
|
|
[Test] // pull #866
|
|
public void WriteHeadersNoCharset ()
|
|
{
|
|
FakeHttpWorkerRequest2 f;
|
|
HttpContext c = Cook (2, out f);
|
|
|
|
HttpResponse resp = c.Response;
|
|
resp.ContentType = "text/plain";
|
|
|
|
Assert.AreEqual ("text/plain", resp.ContentType, "#A1");
|
|
|
|
resp.Flush ();
|
|
|
|
KnownResponseHeader known;
|
|
|
|
AssertHelper.LessOrEqual (1, f.KnownResponseHeaders.Count, "#B1");
|
|
|
|
known = (KnownResponseHeader)f.KnownResponseHeaders ["Content-Type"];
|
|
Assert.AreEqual (HttpWorkerRequest.HeaderContentType, known.Index, "#B2");
|
|
Assert.AreEqual ("text/plain", known.Value, "#B3");
|
|
}
|
|
|
|
[Test] // pull #866
|
|
public void WriteHeadersHasCharset ()
|
|
{
|
|
FakeHttpWorkerRequest2 f;
|
|
HttpContext c = Cook (2, out f);
|
|
|
|
HttpResponse resp = c.Response;
|
|
resp.ContentType = "text/plain";
|
|
resp.Charset = "big5";
|
|
|
|
Assert.AreEqual ("text/plain", resp.ContentType, "#A1");
|
|
Assert.AreEqual ("big5", resp.Charset, "#A2");
|
|
|
|
resp.Flush ();
|
|
|
|
KnownResponseHeader known;
|
|
|
|
AssertHelper.LessOrEqual (1, f.KnownResponseHeaders.Count, "#B1");
|
|
|
|
known = (KnownResponseHeader)f.KnownResponseHeaders ["Content-Type"];
|
|
Assert.AreEqual (HttpWorkerRequest.HeaderContentType, known.Index, "#B2");
|
|
Assert.AreEqual ("text/plain; charset=big5", known.Value, "#B3");
|
|
}
|
|
|
|
[Test] // bug #485557
|
|
[Category ("NotWorking")] // bug #488702
|
|
public void ClearHeaders ()
|
|
{
|
|
FakeHttpWorkerRequest2 f;
|
|
HttpContext c = Cook (2, out f);
|
|
|
|
HttpResponse resp = c.Response;
|
|
resp.CacheControl = "public";
|
|
resp.Cache.SetCacheability (HttpCacheability.NoCache);
|
|
resp.ContentType = "text/xml";
|
|
resp.AppendHeader ("Content-Disposition", "inline");
|
|
resp.AppendHeader ("Content-Type", "application/ms-word");
|
|
resp.AppendHeader ("Content-Length", "40");
|
|
resp.AppendHeader ("Transfer-Encoding", "compress");
|
|
resp.AppendHeader ("My-Custom-Header", "never");
|
|
resp.AppendHeader ("My-Custom-Header", "always");
|
|
resp.ClearHeaders ();
|
|
|
|
Assert.AreEqual ("private", resp.CacheControl, "#A1");
|
|
Assert.AreEqual ("text/html", resp.ContentType, "#A2");
|
|
Assert.AreEqual (0, f.KnownResponseHeaders.Count, "#A3");
|
|
Assert.AreEqual (0, f.UnknownResponseHeaders.Count, "#A4");
|
|
|
|
resp.Flush ();
|
|
|
|
KnownResponseHeader known;
|
|
|
|
Assert.AreEqual (3, f.KnownResponseHeaders.Count, "#B1");
|
|
|
|
known = (KnownResponseHeader) f.KnownResponseHeaders ["Transfer-Encoding"];
|
|
Assert.AreEqual (HttpWorkerRequest.HeaderTransferEncoding, known.Index, "#B2");
|
|
Assert.AreEqual ("chunked", known.Value, "#B3");
|
|
|
|
known = (KnownResponseHeader) f.KnownResponseHeaders ["Cache-Control"];
|
|
Assert.AreEqual (HttpWorkerRequest.HeaderCacheControl, known.Index, "#B4");
|
|
Assert.AreEqual ("private", known.Value, "#B5");
|
|
|
|
known = (KnownResponseHeader) f.KnownResponseHeaders ["Content-Type"];
|
|
Assert.AreEqual (HttpWorkerRequest.HeaderContentType, known.Index, "#B6");
|
|
Assert.AreEqual ("text/html", known.Value, "#B7");
|
|
|
|
Assert.AreEqual (1, f.UnknownResponseHeaders.Count, "#C1");
|
|
UnknownResponseHeader unknown = (UnknownResponseHeader) f.UnknownResponseHeaders ["X-AspNet-Version"];
|
|
Assert.AreEqual ("X-AspNet-Version", unknown.Name, "#C2");
|
|
Assert.AreEqual (Environment.Version.ToString (3), unknown.Value, "#C3");
|
|
}
|
|
|
|
[Test]
|
|
public void Constructor ()
|
|
{
|
|
var resp = new HttpResponse (null);
|
|
Assert.IsNull (resp.Output, "#A1");
|
|
}
|
|
[Test]
|
|
public void RedirectPermanent ()
|
|
{
|
|
FakeHttpWorkerRequest2 request;
|
|
HttpContext context = Cook (1, out request);
|
|
AssertExtensions.Throws<ArgumentNullException> (() => {
|
|
context.Response.RedirectPermanent (null);
|
|
}, "#A1");
|
|
|
|
AssertExtensions.Throws<ArgumentException> (() => {
|
|
context.Response.RedirectPermanent ("http://invalid\nurl.com");
|
|
}, "#A2");
|
|
|
|
AssertExtensions.Throws<ArgumentNullException> (() => {
|
|
context.Response.RedirectPermanent (null, true);
|
|
}, "#A3");
|
|
|
|
AssertExtensions.Throws<ArgumentException> (() => {
|
|
context.Response.RedirectPermanent ("http://invalid\nurl.com", true);
|
|
}, "#A4");
|
|
}
|
|
|
|
[Test]
|
|
public void RedirectToRoute ()
|
|
{
|
|
var resp = new HttpResponse (new StringWriter ());
|
|
// Ho, ho, ho!
|
|
AssertExtensions.Throws<NullReferenceException> (() => {
|
|
resp.RedirectToRoute ("SomeRoute");
|
|
}, "#A1");
|
|
|
|
FakeHttpWorkerRequest2 request;
|
|
HttpContext context = Cook (1, out request);
|
|
|
|
// From RouteCollection.GetVirtualPath
|
|
AssertExtensions.Throws<ArgumentException> (() => {
|
|
context.Response.RedirectToRoute ("SomeRoute");
|
|
}, "#A2");
|
|
|
|
AssertExtensions.Throws<InvalidOperationException> (() => {
|
|
context.Response.RedirectToRoute (new { productId = "1", category = "widgets" });
|
|
}, "#A3");
|
|
}
|
|
|
|
[Test]
|
|
public void RemoveOutputCacheItem ()
|
|
{
|
|
AssertExtensions.Throws<ArgumentNullException> (() => {
|
|
HttpResponse.RemoveOutputCacheItem (null, "MyProvider");
|
|
}, "#A1");
|
|
|
|
AssertExtensions.Throws<ArgumentException> (() => {
|
|
HttpResponse.RemoveOutputCacheItem ("badPath", null);
|
|
}, "#A2");
|
|
|
|
Assert.IsNull (OutputCache.Providers, "#A3");
|
|
HttpResponse.RemoveOutputCacheItem ("/Path", null);
|
|
|
|
AssertExtensions.Throws<ProviderException> (() => {
|
|
HttpResponse.RemoveOutputCacheItem ("/Path", String.Empty);
|
|
}, "#A3");
|
|
|
|
AssertExtensions.Throws<ProviderException> (() => {
|
|
HttpResponse.RemoveOutputCacheItem ("/Path", "MyProvider");
|
|
}, "#A4");
|
|
}
|
|
|
|
[Test]
|
|
public void OutputSetter ()
|
|
{
|
|
FakeHttpWorkerRequest2 request;
|
|
HttpContext context = Cook (1, out request);
|
|
|
|
Assert.IsNotNull (context.Response.Output, "#A1");
|
|
context.Response.Output = null;
|
|
Assert.IsNull (context.Response.Output, "#A2");
|
|
|
|
// Classy...
|
|
AssertExtensions.Throws<NullReferenceException> (() => {
|
|
context.Response.Write ('t');
|
|
}, "#A3-1");
|
|
|
|
AssertExtensions.Throws<NullReferenceException> (() => {
|
|
context.Response.Write ((object) 5);
|
|
}, "#A3-2");
|
|
|
|
AssertExtensions.Throws<NullReferenceException> (() => {
|
|
context.Response.Write ("string");
|
|
}, "#A3-3");
|
|
|
|
AssertExtensions.Throws<NullReferenceException> (() => {
|
|
context.Response.Write (new char [] { '1' }, 0, 1);
|
|
}, "#A3-4");
|
|
|
|
AssertExtensions.Throws<NullReferenceException> (() => {
|
|
context.Response.Write ((object) null);
|
|
}, "#A3-5");
|
|
}
|
|
}
|
|
|
|
[TestFixture]
|
|
public class HttpResponseOutputStreamTest
|
|
{
|
|
FakeHttpWorkerRequest2 worker;
|
|
HttpContext context;
|
|
HttpResponse response;
|
|
Stream out_stream;
|
|
|
|
[SetUp]
|
|
public void Setup ()
|
|
{
|
|
context = Cook (2, out worker);
|
|
response = context.Response;
|
|
out_stream = response.OutputStream;
|
|
}
|
|
|
|
[TearDown]
|
|
public void TearDown ()
|
|
{
|
|
if (response != null)
|
|
response.Close ();
|
|
}
|
|
|
|
[Test]
|
|
public void CanRead ()
|
|
{
|
|
Assert.IsFalse (out_stream.CanRead, "#1");
|
|
out_stream.Close ();
|
|
Assert.IsFalse (out_stream.CanRead, "#2");
|
|
}
|
|
|
|
[Test]
|
|
public void CanSeek ()
|
|
{
|
|
Assert.IsFalse (out_stream.CanSeek, "#1");
|
|
out_stream.Close ();
|
|
Assert.IsFalse (out_stream.CanSeek, "#2");
|
|
}
|
|
|
|
[Test]
|
|
public void CanWrite ()
|
|
{
|
|
Assert.IsTrue (out_stream.CanWrite, "#1");
|
|
out_stream.Close ();
|
|
Assert.IsTrue (out_stream.CanWrite, "#2");
|
|
}
|
|
|
|
[Test]
|
|
public void Flush ()
|
|
{
|
|
byte [] buffer = Encoding.UTF8.GetBytes ("mono");
|
|
out_stream.Write (buffer, 0, buffer.Length);
|
|
out_stream.Flush ();
|
|
Assert.AreEqual (0, worker.data_len);
|
|
}
|
|
|
|
[Test]
|
|
public void Length ()
|
|
{
|
|
try {
|
|
long len = out_stream.Length;
|
|
Assert.Fail ("#1:" + len);
|
|
} catch (NotSupportedException ex) {
|
|
Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void Position ()
|
|
{
|
|
try {
|
|
long pos = out_stream.Position;
|
|
Assert.Fail ("#A1:" + pos);
|
|
} catch (NotSupportedException ex) {
|
|
Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#A2");
|
|
Assert.IsNull (ex.InnerException, "#A3");
|
|
Assert.IsNotNull (ex.Message, "#A4");
|
|
}
|
|
|
|
try {
|
|
out_stream.Position = 0;
|
|
Assert.Fail ("#B1");
|
|
} catch (NotSupportedException ex) {
|
|
Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#B2");
|
|
Assert.IsNull (ex.InnerException, "#B3");
|
|
Assert.IsNotNull (ex.Message, "#B4");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void Read ()
|
|
{
|
|
byte [] buffer = new byte [5];
|
|
|
|
try {
|
|
out_stream.Read (buffer, 0, buffer.Length);
|
|
Assert.Fail ("#1");
|
|
} catch (NotSupportedException ex) {
|
|
Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void Seek ()
|
|
{
|
|
try {
|
|
out_stream.Seek (5, SeekOrigin.Begin);
|
|
Assert.Fail ("#1");
|
|
} catch (NotSupportedException ex) {
|
|
Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void SetLength ()
|
|
{
|
|
try {
|
|
out_stream.SetLength (5L);
|
|
Assert.Fail ("#1");
|
|
} catch (NotSupportedException ex) {
|
|
Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void Write ()
|
|
{
|
|
byte [] buffer;
|
|
|
|
buffer = Encoding.UTF8.GetBytes ("mono");
|
|
out_stream.Write (buffer, 0, buffer.Length);
|
|
buffer = Encoding.UTF8.GetBytes ("just rocks!!");
|
|
out_stream.Write (buffer, 5, 6);
|
|
out_stream.Write (buffer, 0, 4);
|
|
Assert.IsFalse (worker.OutputProduced, "#1");
|
|
response.Flush ();
|
|
Assert.IsTrue (worker.OutputProduced, "#2");
|
|
|
|
string output = Encoding.UTF8.GetString (worker.data);
|
|
Assert.AreEqual ("e\r\nmonorocks!just\r\n", output);
|
|
}
|
|
|
|
[Test]
|
|
public void Write_Buffer_Null ()
|
|
{
|
|
try {
|
|
out_stream.Write ((byte []) null, 0, 0);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("buffer", ex.ParamName, "#5");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void Write_Count_Negative ()
|
|
{
|
|
byte [] buffer = new byte [] { 0x0a, 0x1f, 0x2d };
|
|
|
|
// offset < 0
|
|
try {
|
|
out_stream.Write (buffer, 1, -1);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentOutOfRangeException ex) {
|
|
Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("count", ex.ParamName, "#5");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void Write_Count_Overflow ()
|
|
{
|
|
byte [] buffer;
|
|
|
|
buffer = Encoding.UTF8.GetBytes ("Mono");
|
|
out_stream.Write (buffer, 0, buffer.Length + 5);
|
|
buffer = Encoding.UTF8.GetBytes ("Just Rocks!!");
|
|
out_stream.Write (buffer, 5, buffer.Length - 2);
|
|
response.Flush ();
|
|
|
|
string output = Encoding.UTF8.GetString (worker.data);
|
|
Assert.AreEqual ("b\r\nMonoRocks!!\r\n", output);
|
|
}
|
|
|
|
[Test]
|
|
public void Write_Offset_Negative ()
|
|
{
|
|
byte [] buffer = new byte [] { 0x0a, 0x1f, 0x2d };
|
|
|
|
// offset < 0
|
|
try {
|
|
out_stream.Write (buffer, -1, 0);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentOutOfRangeException ex) {
|
|
Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("offset", ex.ParamName, "#5");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void Write_Offset_Overflow ()
|
|
{
|
|
byte [] buffer = new byte [] { 0x0a, 0x1f, 0x2d };
|
|
|
|
// offset == buffer length
|
|
try {
|
|
out_stream.Write (buffer, buffer.Length, 0);
|
|
Assert.Fail ("#A1");
|
|
} catch (ArgumentOutOfRangeException ex) {
|
|
Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
|
|
Assert.IsNull (ex.InnerException, "#A3");
|
|
Assert.IsNotNull (ex.Message, "#A4");
|
|
Assert.AreEqual ("offset", ex.ParamName, "#A5");
|
|
}
|
|
|
|
// offset > buffer length
|
|
try {
|
|
out_stream.Write (buffer, buffer.Length + 1, 0);
|
|
Assert.Fail ("#B1");
|
|
} catch (ArgumentOutOfRangeException ex) {
|
|
Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
|
|
Assert.IsNull (ex.InnerException, "#B3");
|
|
Assert.IsNotNull (ex.Message, "#B4");
|
|
Assert.AreEqual ("offset", ex.ParamName, "#B5");
|
|
}
|
|
|
|
response.Flush ();
|
|
Assert.AreEqual (0, worker.data_len);
|
|
}
|
|
|
|
[Test]
|
|
public void Write_Stream_Closed ()
|
|
{
|
|
byte [] buffer = Encoding.UTF8.GetBytes ("mono");
|
|
out_stream.Close ();
|
|
out_stream.Write (buffer, 0, buffer.Length);
|
|
response.Flush ();
|
|
|
|
string output = Encoding.UTF8.GetString (worker.data);
|
|
Assert.AreEqual ("4\r\nmono\r\n", output);
|
|
}
|
|
|
|
HttpContext Cook (int re, out FakeHttpWorkerRequest2 f)
|
|
{
|
|
f = new FakeHttpWorkerRequest2 (re);
|
|
return new HttpContext (f);
|
|
}
|
|
}
|
|
}
|