public void TryMatchMediaTypeThrowsWithNullUriInHttpRequestMessage(string uriPathExtension, string mediaType)
{
UriPathExtensionMapping mapping = new UriPathExtensionMapping(uriPathExtension, mediaType);
string errorMessage = RS.Format(Properties.Resources.NonNullUriRequiredForMediaTypeMapping, typeof(UriPathExtensionMapping).Name);
Assert.Throws <InvalidOperationException>(() => mapping.TryMatchMediaType(new HttpRequestMessage()), errorMessage);
}
public void InvalidTypeCreationExpression()
{
// underminated string literal
Assert.Throws <ParseException>(delegate
{
VerifyQueryDeserialization <DataTypes>("$filter=TimeSpanProp ge time'13:20:00", String.Empty);
},
"Parse error in $filter. Unterminated string literal (at index 29)");
// use of parens rather than quotes
Assert.Throws <ParseException>(delegate
{
VerifyQueryDeserialization <DataTypes>("$filter=TimeSpanProp ge time(13:20:00)", String.Empty);
},
"Parse error in $filter. Invalid 'time' type creation expression. (at index 16)");
// verify the exception returned when type expression that isn't
// one of the supported keyword types is used. In this case it falls
// through as a member expression
Assert.Throws <ParseException>(delegate
{
VerifyQueryDeserialization("$filter=math'123' eq true", String.Empty);
},
"Parse error in $filter. No property or field 'math' exists in type 'Product' (at index 0)");
}
public void Constructor_WhenValueIsNullAndTypeIsNotCompatible_ThrowsException()
{
Assert.Throws <InvalidOperationException>(() =>
{
new ObjectContent(typeof(int), null, new JsonMediaTypeFormatter());
}, "The 'ObjectContent' type cannot accept a null value for the value type 'Int32'.");
}
public void GetStreamThrowsOnNoContentDisposition()
{
MultipartFormDataStreamProvider instance = new MultipartFormDataStreamProvider(Path.GetTempPath());
HttpContent content = new StringContent("text");
Assert.Throws <IOException>(() => { instance.GetStream(content.Headers); }, RS.Format(Properties.Resources.MultipartFormDataStreamProviderNoContentDisposition, "Content-Disposition"));
}
public void Invalid_Action_In_Route()
{
// Arrange
ApiController api = new UsersController();
HttpRouteData route = new HttpRouteData(new HttpRoute());
string actionName = "invalidOp";
route.Values.Add("action", actionName);
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(instance: api, routeData: route, request: new HttpRequestMessage()
{
Method = HttpMethod.Get
});
Type controllerType = typeof(UsersController);
controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, controllerType.Name, controllerType);
controllerContext.Configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
// Act & Assert
var exception = Assert.Throws <HttpResponseException>(() =>
{
HttpResponseMessage message = api.ExecuteAsync(controllerContext, CancellationToken.None).Result;
});
Assert.Equal(HttpStatusCode.NotFound, exception.Response.StatusCode);
var content = Assert.IsType <ObjectContent <HttpError> >(exception.Response.Content);
Assert.Equal("No action was found on the controller 'UsersController' that matches the name 'invalidOp'.",
((HttpError)content.Value)["MessageDetail"]);
}
public void CreateResponse_OnNullConfiguration_ThrowsException()
{
Assert.Throws <InvalidOperationException>(() =>
{
HttpRequestMessageExtensions.CreateResponse(_request, HttpStatusCode.OK, _value, configuration: null);
}, "The request does not have an associated configuration object or the provided configuration was null.");
}
public void TryMatchMediaTypeThrowsWithNullUriInHttpRequestMessage(string queryStringParameterName, string queryStringParameterValue, string mediaType)
{
QueryStringMapping mapping = new QueryStringMapping(queryStringParameterName, queryStringParameterValue, mediaType);
string errorMessage = RS.Format(Properties.Resources.NonNullUriRequiredForMediaTypeMapping, typeof(QueryStringMapping).Name);
Assert.Throws <InvalidOperationException>(() => mapping.TryMatchMediaType(new HttpRequestMessage()), errorMessage);
}
public void ReadAsMultipartAsync_ThrowsOnWriteError()
{
HttpContent content = CreateContent(ValidBoundary, "A", "B", "C");
IOException exception = Assert.Throws <IOException>(() => content.ReadAsMultipartAsync(new WriteErrorStreamProvider()).Result);
Assert.NotNull(exception.InnerException);
Assert.Equal(ExceptionAsyncStreamMessage, exception.InnerException.Message);
}
public void ReadAsMultipartAsync_ThrowsOnBadStreamProvider()
{
HttpContent content = CreateContent(ValidBoundary, "A", "B", "C");
InvalidOperationException exception = Assert.Throws <InvalidOperationException>(() => content.ReadAsMultipartAsync(new BadStreamProvider()).Result);
Assert.NotNull(exception.InnerException);
Assert.Equal(ExceptionStreamProviderMessage, exception.InnerException.Message);
}
public void ReadAsMultipartAsync_ThrowsOnPrematureEndOfStream()
{
HttpContent content = new StreamContent(Stream.Null);
string mediaType = String.Format("multipart/form-data; boundary=\"{0}\"", ValidBoundary);
content.Headers.ContentType = MediaTypeHeaderValue.Parse(mediaType);
Assert.Throws <IOException>(() => content.ReadAsMultipartAsync().Result);
}
public void WriteToStreamAsyncThrowsNotImplemented()
{
FormUrlEncodedMediaTypeFormatter formatter = new FormUrlEncodedMediaTypeFormatter();
Assert.Throws <NotSupportedException>(
() => formatter.WriteToStreamAsync(typeof(object), new object(), Stream.Null, null, null),
"The media type formatter of type 'FormUrlEncodedMediaTypeFormatter' does not support writing because it does not implement the WriteToStreamAsync method.");
}
public void WriteToStreamAsync_ThrowsNotSupportedException()
{
var formatter = new Mock <MediaTypeFormatter> {
CallBase = true
}.Object;
Assert.Throws <NotSupportedException>(() => formatter.WriteToStreamAsync(null, null, null, null, null),
"The media type formatter of type 'MediaTypeFormatterProxy' does not support writing because it does not implement the WriteToStreamAsync method.");
}
public void InvalidCharactersInQuery_TokenizerFails(char ch)
{
Assert.Throws <ParseException>(delegate
{
string filter = String.Format("2 {0} 3", ch);
VerifyQueryDeserialization <DataTypes>("$filter=" + Uri.EscapeDataString(filter), String.Empty);
},
String.Format("Parse error in $filter. Syntax error '{0}' (at index 2)", ch));
}
public void CreateResponse_WhenNoContentNegotiatorInstanceRegistered_Throws()
{
// Arrange
_config.ServiceResolver.SetServices(typeof(IContentNegotiator), new object[] { null });
// Act & Assert
Assert.Throws <InvalidOperationException>(() => HttpRequestMessageExtensions.CreateResponse(_request, HttpStatusCode.OK, _value, _config),
"The provided configuration does not have an instance of the 'System.Net.Http.Formatting.IContentNegotiator' service registered.");
}
public void FirstDispositionNameNoMatch()
{
IEnumerable <HttpContent> content = HttpContentCollectionExtensionsTests.CreateContent();
Assert.Null(content.FirstDispositionNameOrDefault(noMatchDispositionName));
ClearHeaders(content);
Assert.Throws <InvalidOperationException>(() => content.FirstDispositionName(noMatchDispositionName));
}
public void ReadAsMultipartAsync_ReadOnlyStream_Throws()
{
HttpContent content = CreateContent("--", "A", "B", "C");
Assert.Throws <InvalidOperationException>(
() => content.ReadAsMultipartAsync(new ReadOnlyStreamProvider()).Result,
"The stream provider of type 'ReadOnlyStreamProvider' returned a read-only stream. It must return a writable 'Stream' instance."
);
}
public void ReadAsHttpRequestMessageAsync_NoHostHeader_ThrowsIOException()
{
string[] request = new[] {
@"GET / HTTP/1.1",
};
HttpContent content = CreateContent(true, request, null);
Assert.Throws <IOException>(() => content.ReadAsHttpRequestMessageAsync().Result);
}
public void RunSynchronously_Cancels()
{
CancellationTokenSource cts = new CancellationTokenSource();
cts.Cancel();
Task t = TaskHelpers.RunSynchronously(() => { throw new InvalidOperationException(); }, cts.Token);
Assert.Throws <TaskCanceledException>(() => t.Wait());
}
public void SimpleDisplayNameWithUnknownDisplayColumnThrows()
{
// Arrange
var provider = new CachedDataAnnotationsModelMetadataProvider();
// Act & Assert
Assert.Throws <InvalidOperationException>(
() => provider.GetMetadataForType(() => new UnknownDisplayColumnModel(), typeof(UnknownDisplayColumnModel)).SimpleDisplayText,
typeof(UnknownDisplayColumnModel).FullName + " has a DisplayColumn attribute for NoPropertyWithThisName, but property NoPropertyWithThisName does not exist.");
}
public void ReadAsMultipartAsync_ThrowsOnReadError()
{
HttpContent content = new StreamContent(new ReadErrorStream());
string mediaType = String.Format("multipart/form-data; boundary=\"{0}\"", ValidBoundary);
content.Headers.ContentType = MediaTypeHeaderValue.Parse(mediaType);
IOException exception = Assert.Throws <IOException>(() => content.ReadAsMultipartAsync().Result);
Assert.NotNull(exception.InnerException);
Assert.Equal(ExceptionAsyncStreamMessage, exception.InnerException.Message);
}
public void ConvertToThrowsIfNoConverterExists()
{
// Arrange
ValueProviderResult vpr = new ValueProviderResult("x", null, CultureInfo.InvariantCulture);
Type destinationType = typeof(MyClassWithoutConverter);
// Act & Assert
Assert.Throws <InvalidOperationException>(
delegate { vpr.ConvertTo(destinationType); },
"The parameter conversion from type 'System.String' to type 'System.Web.Mvc.Test.ValueProviderResultTest+MyClassWithoutConverter' failed because no type converter can convert between these types.");
}
public void SelectCharacterEncoding_ThrowsIfNoSupportedEncodings()
{
// Arrange
MockMediaTypeFormatter formatter = new MockMediaTypeFormatter {
CallBase = true
};
HttpContent content = new StringContent("Hello World", Encoding.UTF8, "text/plain");
// Act
Assert.Throws <InvalidOperationException>(() => formatter.SelectCharacterEncoding(content.Headers));
}
public void ReadAsHttpRequestMessageAsync_TwoHostHeaders_Throws()
{
string[] request = new[] {
@"GET / HTTP/1.1",
@"Host: somehost.com",
@"Host: otherhost.com",
};
HttpContent content = CreateContent(true, request, null);
Assert.Throws <InvalidOperationException>(() => content.ReadAsHttpRequestMessageAsync().Result);
}
public void ReadAsMultipartAsync_WriteErrorOnStream_Throws()
{
HttpContent content = CreateContent("--", "A", "B", "C");
var ioException = Assert.Throws <IOException>(
() => content.ReadAsMultipartAsync(new WriteErrorStreamProvider()).Result,
"Error writing MIME multipart body part to output stream."
);
Assert.NotNull(ioException.InnerException);
Assert.Equal(ExceptionAsyncStreamMessage, ioException.InnerException.Message);
}
public void ReadAsMultipartAsync_WithBadStreamProvider_Throws()
{
HttpContent content = CreateContent("--", "A", "B", "C");
var invalidOperationException = Assert.Throws <InvalidOperationException>(
() => content.ReadAsMultipartAsync(new BadStreamProvider()).Result,
"The stream provider of type 'BadStreamProvider' threw an exception."
);
Assert.NotNull(invalidOperationException.InnerException);
Assert.Equal(ExceptionStreamProviderMessage, invalidOperationException.InnerException.Message);
}
public void UseDataContractJsonSerializer_True_Indent_Throws()
{
DataContractJsonMediaTypeFormatter jsonFormatter = new DataContractJsonMediaTypeFormatter {
Indent = true
};
MemoryStream memoryStream = new MemoryStream();
HttpContent content = new StringContent(String.Empty);
Assert.Throws <NotSupportedException>(
() => jsonFormatter.WriteToStreamAsync(typeof(XmlMediaTypeFormatterTests.SampleType),
new XmlMediaTypeFormatterTests.SampleType(),
memoryStream, content, transportContext: null));
}
public void ReadAsHttpResponseMessageAsync_Throws_TheHeaderSizeExceededTheDefaultLimit()
{
string[] response = new[] {
@"HTTP/1.1 200 OK",
String.Format("Set-Cookie: {0}={1}", new String('a', 16 * 1024), new String('b', 16 * 1024))
};
Assert.Throws <InvalidOperationException>(() =>
{
HttpContent content = CreateContent(false, response, "sample body");
HttpResponseMessage httpResponse = content.ReadAsHttpResponseMessageAsync().Result;
});
}
public void Constructor_WhenValueIsNotSupportedByFormatter_ThrowsException()
{
Mock <MediaTypeFormatter> formatterMock = new Mock <MediaTypeFormatter>();
formatterMock.Setup(f => f.CanWriteType(typeof(List <string>))).Returns(false).Verifiable();
Assert.Throws <InvalidOperationException>(() =>
{
new ObjectContent(typeof(List <string>), new List <string>(), formatterMock.Object);
}, "The configured formatter 'Castle.Proxies.MediaTypeFormatterProxy' cannot write an object of type 'List`1'.");
formatterMock.Verify();
}
public void GetFacebookCookieInfoThrowsIfCookieIsNotValid()
{
// Arrange
var context = CreateHttpContext(new Dictionary <string, string>
{
{ "fbs_myapp'", "sig=malformed-signature&name=foo&val=bar&uid=MyFacebookName" },
{ "fbs_uid", "MyFacebookName" },
});
// Act and Assert
Assert.Throws <InvalidOperationException>(() => Facebook.GetFacebookCookieInfo(context, "uid"), "Invalid Facebook cookie.");
}
public void ReadAsMultipartAsync_PrematureEndOfStream_Throws()
{
HttpContent content = new StreamContent(Stream.Null);
var contentType = new MediaTypeHeaderValue("multipart/form-data");
contentType.Parameters.Add(new NameValueHeaderValue("boundary", "\"{--\""));
content.Headers.ContentType = contentType;
Assert.Throws <IOException>(
() => content.ReadAsMultipartAsync().Result,
"Unexpected end of MIME multipart stream. MIME multipart message is not complete."
);
}
