public void FormatFilter_ExplicitContentType_SetOnResponse_TakesPrecedence()
{
// Arrange
var mediaType = MediaTypeHeaderValue.Parse("application/foo");
var mockObjects = new MockObjects("json", FormatSource.QueryData);
var response = new Mock <HttpResponse>();
response.Setup(r => r.ContentType).Returns("application/foo");
var httpContext = new Mock <HttpContext>();
httpContext.Setup(c => c.Response).Returns(response.Object);
httpContext.Setup(c => c.Request.Query["format"]).Returns("json");
var actionContext = new ActionContext(httpContext.Object, new RouteData(), new ActionDescriptor());
var resultExecutingContext = new ResultExecutingContext(
actionContext,
new IFilterMetadata[] { },
new ObjectResult("Hello!"),
controller: new object());
var resourceExecutingContext = new ResourceExecutingContext(
actionContext,
new IFilterMetadata[] { },
new List <IValueProviderFactory>());
var filter = new FormatFilter(mockObjects.OptionsManager, NullLoggerFactory.Instance);
// Act
filter.OnResourceExecuting(resourceExecutingContext);
filter.OnResultExecuting(resultExecutingContext);
// Assert
var result = Assert.IsType <ObjectResult>(resultExecutingContext.Result);
Assert.Empty(result.ContentTypes);
}
public void FormatFilter_ContextContainsFormat_Custom(
string format,
FormatSource place,
string contentType)
{
// Arrange
var mediaType = new StringSegment(contentType);
var mockObjects = new MockObjects(format, place);
var resultExecutingContext = mockObjects.CreateResultExecutingContext();
var resourceExecutingContext = mockObjects.CreateResourceExecutingContext(new IFilterMetadata[] { });
mockObjects.MvcOptions.FormatterMappings.SetMediaTypeMappingForFormat(
format,
MediaTypeHeaderValue.Parse(contentType));
var filter = new FormatFilter(mockObjects.OptionsManager, NullLoggerFactory.Instance);
// Act
filter.OnResourceExecuting(resourceExecutingContext);
filter.OnResultExecuting(resultExecutingContext);
// Assert
var objectResult = Assert.IsType <ObjectResult>(resultExecutingContext.Result);
Assert.Single(objectResult.ContentTypes);
MediaTypeAssert.Equal(mediaType, objectResult.ContentTypes[0]);
}
public void FormatFilter_ContextContainsFormat_DefaultFormat(string format, FormatSource place)
{
// Arrange
var mediaType = new StringSegment("application/json");
var mockObjects = new MockObjects(format, place);
var resultExecutingContext = mockObjects.CreateResultExecutingContext();
var resourceExecutingContext = mockObjects.CreateResourceExecutingContext(new IFilterMetadata[] { });
var filter = new FormatFilter(mockObjects.OptionsManager, NullLoggerFactory.Instance);
// Act
filter.OnResourceExecuting(resourceExecutingContext);
// Assert
Assert.Null(resourceExecutingContext.Result);
// Act
filter.OnResultExecuting(resultExecutingContext);
// Assert
var objectResult = Assert.IsType <ObjectResult>(resultExecutingContext.Result);
Assert.Single(objectResult.ContentTypes);
MediaTypeAssert.Equal(mediaType, objectResult.ContentTypes[0]);
}
private bool ModFilter(object item)
{
TroveModViewModel mod = item as TroveModViewModel;
var ic = StringComparison.OrdinalIgnoreCase;
bool search = true, types = true, subtypes = true, format = true;
try
{
search = string.IsNullOrEmpty(SearchFilter) || mod.DataObject.Name?.IndexOf(SearchFilter, ic) >= 0 || mod.DataObject.Author?.IndexOf(SearchFilter, ic) >= 0 ||
mod.DataObject.Type?.IndexOf(SearchFilter, ic) >= 0 || mod.DataObject.SubType?.IndexOf(SearchFilter, ic) >= 0;
types = string.IsNullOrEmpty(TypeFilter) || TypeFilter.Equals(Strings.GetMoreModsViewModel_AllTypes, ic) ||
mod.DataObject.Type == null || mod.DataObject.Type.Equals(TypeFilter, ic);
subtypes = string.IsNullOrEmpty(SubTypeFilter) || SubTypeFilter.Equals(Strings.GetMoreModsViewModel_AllSubTypes, ic) ||
mod.DataObject.SubType == null || mod.DataObject.SubType.Equals(SubTypeFilter, ic);
format = string.IsNullOrEmpty(FormatFilter) || FormatFilter.Equals(Strings.GetMoreModsViewModel_AllFormats, ic) ||
mod.DataObject.Downloads.Any(d => d.Format.Equals(FormatFilter, ic));
}
catch (Exception ex)
{
log.Error("Mod filter error", ex);
if (log.IsDebugEnabled)
{
log.DebugFormat("Mod Name: [{0}], Author: [{1}], Type: [{2}], SubType: [{3}], SearchFilter: [{4}], TypeFilter: [{5}], SubTypeFilter: [{6}], FormatFilter: [{7}]",
mod?.DataObject?.Name, mod?.DataObject?.Author, mod?.DataObject?.Type, mod?.DataObject?.SubType, SearchFilter, TypeFilter, SubTypeFilter, FormatFilter);
}
}
return(search && types && subtypes && format);
}
public void FormatFilter_InvalidProperty()
{
var filter = new FormatFilter("tmp", "${lvl}_error_${message}");
var data = new EventData()
.Add("lvl", "Debug")
.Add("Message", "theMessage");
var result = filter.Filter(data);
Assert.AreEqual(result.Value, "Debug_error_${message}");
Assert.AreEqual(result.Key, "tmp");
}
public void FormatFilter_ContextDoesntContainFormat()
{
// Arrange
var mockObjects = new MockObjects();
var resourceExecutingContext = mockObjects.CreateResourceExecutingContext(new IFilterMetadata[] { });
var filter = new FormatFilter(mockObjects.OptionsManager, NullLoggerFactory.Instance);
// Act
filter.OnResourceExecuting(resourceExecutingContext);
// Assert
Assert.Null(resourceExecutingContext.Result);
}
public void FormatFilter_GetFormat_UsesInvariantCulture()
{
// Arrange
var mockObjects = new MockObjects();
var context = mockObjects.CreateResultExecutingContext();
context.RouteData.Values["format"] = new DateTimeOffset(2018, 10, 31, 7, 37, 38, TimeSpan.FromHours(-7));
var expected = "10/31/2018 07:37:38 -07:00";
var filterAttribute = new FormatFilterAttribute();
var filter = new FormatFilter(mockObjects.OptionsManager, NullLoggerFactory.Instance);
// Act
var format = filter.GetFormat(context);
// Assert
Assert.Equal(expected, filter.GetFormat(context));
}
public void FormatFilter_GetFormat(
string input,
FormatSource place,
string expected)
{
// Arrange
var mockObjects = new MockObjects(input, place);
var context = mockObjects.CreateResultExecutingContext();
var filterAttribute = new FormatFilterAttribute();
var filter = new FormatFilter(mockObjects.OptionsManager, NullLoggerFactory.Instance);
// Act
var format = filter.GetFormat(context);
// Assert
Assert.Equal(expected, filter.GetFormat(context));
}
public void FormatFilter_ContextContainsFormat_InRouteAndQueryData()
{
// If the format is present in both route and query data, the one in route data wins
// Arrange
var mediaType = new StringSegment("application/json");
var mockObjects = new MockObjects("json", FormatSource.RouteData);
var httpContext = new Mock <HttpContext>();
httpContext.Setup(c => c.Response).Returns(new Mock <HttpResponse>().Object);
// Query contains xml
httpContext.Setup(c => c.Request.Query.ContainsKey("format")).Returns(true);
httpContext.Setup(c => c.Request.Query["format"]).Returns("xml");
// RouteData contains json
var data = new RouteData();
data.Values.Add("format", "json");
var ac = new ActionContext(httpContext.Object, data, new ActionDescriptor());
var resultExecutingContext = new ResultExecutingContext(
ac,
new IFilterMetadata[] { },
new ObjectResult("Hello!"),
controller: new object());
var resourceExecutingContext = new ResourceExecutingContext(
ac,
new IFilterMetadata[] { },
new List <IValueProviderFactory>());
var filter = new FormatFilter(mockObjects.OptionsManager, NullLoggerFactory.Instance);
// Act
filter.OnResourceExecuting(resourceExecutingContext);
filter.OnResultExecuting(resultExecutingContext);
// Assert
var objectResult = Assert.IsType <ObjectResult>(resultExecutingContext.Result);
Assert.Single(objectResult.ContentTypes);
MediaTypeAssert.Equal(mediaType, objectResult.ContentTypes[0]);
}
public void FormatFilter_ContextContainsFormat_ContainsProducesFilter_Matching(
string format,
FormatSource place,
string contentType)
{
// Arrange
var produces = new ProducesAttribute(contentType, new string[] { "application/foo", "text/bar" });
var mockObjects = new MockObjects(format, place);
var resourceExecutingContext = mockObjects.CreateResourceExecutingContext(new IFilterMetadata[] { produces });
var filter = new FormatFilter(mockObjects.OptionsManager, NullLoggerFactory.Instance);
// Act
filter.OnResourceExecuting(resourceExecutingContext);
// Assert
Assert.Null(resourceExecutingContext.Result);
}
public void FormatFilter_ContextContainsNonExistingFormat(
string format,
FormatSource place)
{
// Arrange
var mockObjects = new MockObjects(format, place);
var resourceExecutingContext = mockObjects.CreateResourceExecutingContext(new IFilterMetadata[] { });
var filter = new FormatFilter(mockObjects.OptionsManager, NullLoggerFactory.Instance);
// Act
filter.OnResourceExecuting(resourceExecutingContext);
// Assert
var actionResult = resourceExecutingContext.Result;
Assert.IsType <NotFoundResult>(actionResult);
}
public void FormatFilter_LessSpecificThan_Produces()
{
// Arrange
var produces = new ProducesAttribute("application/xml;version=1", new string[] { });
var mockObjects = new MockObjects("xml", FormatSource.RouteData);
var resourceExecutingContext = mockObjects.CreateResourceExecutingContext(new IFilterMetadata[] { produces });
mockObjects.MvcOptions.FormatterMappings.SetMediaTypeMappingForFormat(
"xml",
MediaTypeHeaderValue.Parse("application/xml"));
var filter = new FormatFilter(mockObjects.OptionsManager, NullLoggerFactory.Instance);
// Act
filter.OnResourceExecuting(resourceExecutingContext);
// Assert
Assert.Null(resourceExecutingContext.Result);
}
public void FormatFilter_ContextContainsFormat_ContainsProducesFilter_Conflicting(
string format,
FormatSource place)
{
// Arrange
var produces = new ProducesAttribute("application/xml", new string[] { "application/foo", "text/bar" });
var mockObjects = new MockObjects(format, place);
var resourceExecutingContext = mockObjects.CreateResourceExecutingContext(new IFilterMetadata[] { produces });
mockObjects.MvcOptions.FormatterMappings.SetMediaTypeMappingForFormat(
"xml",
MediaTypeHeaderValue.Parse("application/xml"));
var filter = new FormatFilter(mockObjects.OptionsManager, NullLoggerFactory.Instance);
// Act
filter.OnResourceExecuting(resourceExecutingContext);
// Assert
var result = Assert.IsType <NotFoundResult>(resourceExecutingContext.Result);
}
private void TryExportAllFormats(string inputImage, string outputImage, string outputExtension, FormatFilter filter = FormatFilter.All)
{
var model = new Models(1);
model.AddImageFromFile(inputImage);
model.Apply();
var tex = (TextureArray2D)model.Pipelines[0].Image;
var eFmt = ExportDescription.GetExportFormat(outputExtension);
string errors = "";
int numErrors = 0;
foreach (var format in eFmt.Formats)
{
if (format.IsCompressed())
{
if ((FormatFilter.Compressed & filter) == 0)
{
continue;
}
}
else if ((FormatFilter.Uncompressed & filter) == 0)
{
continue;
}
try
{
var desc = new ExportDescription(tex, outputImage, outputExtension);
desc.FileFormat = format;
model.Export.Export(desc);
}
catch (Exception e)
{
errors += $"{format}: {e.Message}\n";
++numErrors;
}
}
if (errors.Length > 0)
{
throw new Exception($"export failed for {numErrors}/{eFmt.Formats.Count} formats:\n" + errors);
}
}
