public void GetStreamValidation()
{
Stream stream0 = null;
Stream stream1 = null;
try
{
MultipartFormDataContent content = new MultipartFormDataContent();
content.Add(new StringContent("Not a file"), "notafile");
content.Add(new StringContent("This is a file"), "file", "filename");
MultipartFormDataStreamProvider instance = new MultipartFormDataStreamProvider(Path.GetTempPath());
stream0 = instance.GetStream(content.ElementAt(0).Headers);
Assert.IsType <MemoryStream>(stream0);
stream1 = instance.GetStream(content.ElementAt(1).Headers);
Assert.IsType <FileStream>(stream1);
Assert.Equal(1, instance.BodyPartFileNames.Count);
Assert.Contains("BodyPart", instance.BodyPartFileNames.Values.ElementAt(0));
}
finally
{
if (stream0 != null)
{
stream0.Close();
}
if (stream1 != null)
{
stream1.Close();
}
}
}
public void ExpectedValidationErrorsRaised(object model, Type type, Dictionary <string, string> expectedErrors)
{
// Arrange
ModelMetadataProvider metadataProvider = new DataAnnotationsModelMetadataProvider();
HttpActionContext actionContext = ContextUtil.CreateActionContext();
// Act
Assert.DoesNotThrow(() =>
new DefaultBodyModelValidator().Validate(model, type, metadataProvider, actionContext, string.Empty)
);
// Assert
Dictionary <string, string> actualErrors = new Dictionary <string, string>();
foreach (KeyValuePair <string, ModelState> keyStatePair in actionContext.ModelState)
{
foreach (ModelError error in keyStatePair.Value.Errors)
{
actualErrors.Add(keyStatePair.Key, error.ErrorMessage);
}
}
Assert.Equal(expectedErrors.Count, actualErrors.Count);
foreach (KeyValuePair <string, string> keyErrorPair in expectedErrors)
{
Assert.Contains(keyErrorPair.Key, actualErrors.Keys);
Assert.Equal(keyErrorPair.Value, actualErrors[keyErrorPair.Key]);
}
}
public void ApiControllerCannotBeReused()
{
// Arrange
var config = new HttpConfiguration();
var singletonController = new Mock <ApiController> {
CallBase = true
}.Object;
var mockDescriptor = new Mock <HttpControllerDescriptor>(config, "MyMock", singletonController.GetType())
{
CallBase = true
};
mockDescriptor.Setup(d => d.CreateController(It.IsAny <HttpRequestMessage>())).Returns(singletonController);
var mockSelector = new Mock <DefaultHttpControllerSelector>(config)
{
CallBase = true
};
mockSelector.Setup(s => s.SelectController(It.IsAny <HttpRequestMessage>())).Returns(mockDescriptor.Object);
config.Routes.MapHttpRoute("default", "", new { controller = "MyMock" });
config.Services.Replace(typeof(IHttpControllerSelector), mockSelector.Object);
var server = new HttpServer(config);
var invoker = new HttpMessageInvoker(server);
// Act
HttpResponseMessage response1 = invoker.SendAsync(new HttpRequestMessage(HttpMethod.Get, "http://localhost/"), CancellationToken.None).Result;
HttpResponseMessage response2 = invoker.SendAsync(new HttpRequestMessage(HttpMethod.Get, "http://localhost/"), CancellationToken.None).Result;
// Assert
Assert.NotEqual(HttpStatusCode.InternalServerError, response1.StatusCode);
Assert.Equal(HttpStatusCode.InternalServerError, response2.StatusCode);
Assert.Contains("Cannot reuse an 'ApiController' instance. 'ApiController' has to be constructed per incoming message.", response2.Content.ReadAsStringAsync().Result);
}
public void ConvertResponse_Returns_Error_Response_When_Formatter_Write_Throws_Immediately()
{
// Arrange
Mock <JsonMediaTypeFormatter> formatterMock = new Mock <JsonMediaTypeFormatter>()
{
CallBase = true
};
formatterMock.Setup(m => m.WriteToStreamAsync(It.IsAny <Type>(),
It.IsAny <object>(),
It.IsAny <Stream>(),
It.IsAny <HttpContent>(),
It.IsAny <TransportContext>())).Throws(new NotSupportedException("Expected error"));
MemoryStream memoryStream = new MemoryStream();
Mock <HttpContextBase> contextMock = CreateMockHttpContextBaseForResponse(memoryStream);
HttpResponseBase responseBase = contextMock.Object.Response;
HttpRequestMessage request = new HttpRequestMessage();
request.Properties.Add(HttpPropertyKeys.IsLocalKey, new Lazy <bool>(() => true));
HttpResponseMessage response = new HttpResponseMessage()
{
RequestMessage = request
};
response.Content = new ObjectContent <string>("hello", formatterMock.Object);
// Act
Task task = HttpControllerHandler.ConvertResponse(contextMock.Object, response, request);
task.Wait();
// Assert preparation -- deserialize the HttpError response
HttpError httpError = null;
memoryStream.Seek(0L, SeekOrigin.Begin);
using (StreamContent content = new StreamContent(memoryStream))
{
content.Headers.ContentType = JsonMediaTypeFormatter.DefaultMediaType;
httpError = content.ReadAsAsync <HttpError>().Result;
}
// Assert
Assert.Equal <int>((int)HttpStatusCode.InternalServerError, responseBase.StatusCode);
Assert.True(responseBase.Headers["Content-Type"].StartsWith(JsonMediaTypeFormatter.DefaultMediaType.MediaType));
Assert.Equal("An error has occurred.", httpError["Message"]);
Assert.Equal("The 'ObjectContent`1' type failed to serialize the response body for content type 'application/json; charset=utf-8'.", httpError["ExceptionMessage"]);
Assert.Equal(typeof(InvalidOperationException).FullName, httpError["ExceptionType"]);
Assert.True(httpError.ContainsKey("StackTrace"));
HttpError innerError = (httpError["InnerException"] as JObject).ToObject <HttpError>();
Assert.NotNull(innerError);
Assert.Equal(typeof(NotSupportedException).FullName, innerError["ExceptionType"].ToString());
Assert.Equal("Expected error", innerError["ExceptionMessage"]);
Assert.Contains("System.Net.Http.HttpContent.CopyToAsync", innerError["StackTrace"].ToString());
}
public void FindKeysWithPrefixRecognizesRootChilden()
{
// Arrange
IDictionary <string, int> dict = new Dictionary <string, int>()
{
{ "[0]", 1 },
{ "Name", 2 },
{ "Address.Street", 3 },
{ "", 4 }
};
// Act
List <int> results = DictionaryExtensions.FindKeysWithPrefix <int>(dict, "").Select(kvp => kvp.Value).ToList();
// Assert
Assert.Equal(4, results.Count);
Assert.Contains(1, results);
Assert.Contains(2, results);
Assert.Contains(3, results);
Assert.Contains(4, results);
}
public void ValidationErrorsNotAddedOnInvalidFields()
{
// Arrange
ModelMetadataProvider metadataProvider = new DataAnnotationsModelMetadataProvider();
HttpActionContext actionContext = ContextUtil.CreateActionContext();
object model = new Address()
{
Street = "Microsoft Way"
};
actionContext.ModelState.AddModelError("Street", "error");
// Act
new DefaultBodyModelValidator().Validate(model, typeof(Address), metadataProvider, actionContext, string.Empty);
// Assert
Assert.Contains("Street", actionContext.ModelState.Keys);
ModelState streetState = actionContext.ModelState["Street"];
Assert.Equal(1, streetState.Errors.Count);
}
public void MultipleValidationErrorsOnSameMemberReported()
{
// Arrange
ModelMetadataProvider metadataProvider = new DataAnnotationsModelMetadataProvider();
HttpActionContext actionContext = ContextUtil.CreateActionContext();
object model = new Address()
{
Street = "Microsoft Way"
};
// Act
Assert.DoesNotThrow(() =>
new DefaultBodyModelValidator().Validate(model, typeof(Address), metadataProvider, actionContext, string.Empty)
);
// Assert
Assert.Contains("Street", actionContext.ModelState.Keys);
ModelState streetState = actionContext.ModelState["Street"];
Assert.Equal(2, streetState.Errors.Count);
}
public void GetStream()
{
Stream stream0 = null;
Stream stream1 = null;
try
{
string tempPath = Path.GetTempPath();
MultipartFormDataContent content = new MultipartFormDataContent();
content.Add(new StringContent("Content 1"), "NoFile");
content.Add(new StringContent("Content 2"), "File", "Filename");
MultipartFileStreamProvider provider = new MultipartFileStreamProvider(tempPath);
stream0 = provider.GetStream(content, content.ElementAt(0).Headers);
stream1 = provider.GetStream(content, content.ElementAt(1).Headers);
Assert.IsType <FileStream>(stream0);
Assert.IsType <FileStream>(stream1);
Assert.Equal(2, provider.FileData.Count);
string partialFileName = String.Format("{0}BodyPart_", tempPath);
Assert.Contains(partialFileName, provider.FileData[0].LocalFileName);
Assert.Contains(partialFileName, provider.FileData[1].LocalFileName);
Assert.Same(content.ElementAt(0).Headers.ContentDisposition, provider.FileData[0].Headers.ContentDisposition);
Assert.Same(content.ElementAt(1).Headers.ContentDisposition, provider.FileData[1].Headers.ContentDisposition);
}
finally
{
if (stream0 != null)
{
stream0.Close();
}
if (stream1 != null)
{
stream1.Close();
}
}
}
