public void OnProvidersExecuting_DiscoversHandlersFromModel()
{
// Arrange
var provider = new DefaultPageApplicationModelProvider();
var typeInfo = typeof(PageWithModel).GetTypeInfo();
var modelType = typeof(TestPageModel);
var descriptor = new PageActionDescriptor();
var context = new PageApplicationModelProviderContext(descriptor, typeInfo);
// Act
provider.OnProvidersExecuting(context);
// Assert
Assert.NotNull(context.PageApplicationModel);
Assert.Collection(
context.PageApplicationModel.HandlerMethods.OrderBy(p => p.Name),
handler =>
{
var name = nameof(TestPageModel.OnGetUser);
Assert.Equal(modelType.GetMethod(name), handler.MethodInfo);
Assert.Equal(name, handler.Name);
Assert.Equal("Get", handler.HttpMethod);
Assert.Equal("User", handler.HandlerName);
});
}
public void PopulateHandlerProperties_SupportsGet_OnProperty()
{
// Arrange
var provider = new DefaultPageApplicationModelProvider();
var typeInfo = typeof(ModelSupportsGetOnProperty).GetTypeInfo();
var pageModel = new PageApplicationModel(new PageActionDescriptor(), typeInfo, new object[0]);
// Act
provider.PopulateHandlerProperties(pageModel);
// Assert
var properties = pageModel.HandlerProperties;
Assert.Collection(
properties.OrderBy(p => p.PropertyName),
p =>
{
Assert.Equal(typeInfo.GetProperty(nameof(ModelSupportsGetOnProperty.Property)), p.PropertyInfo);
Assert.NotNull(p.BindingInfo.RequestPredicate);
Assert.True(p.BindingInfo.RequestPredicate(new ActionContext
{
HttpContext = new DefaultHttpContext
{
Request =
{
Method = "GET",
}
}
}));
});
}
public void OnProvidersExecuting_DiscoversProperties_FromAllSubTypesThatDeclaresBindProperty()
{
// Arrange
var provider = new DefaultPageApplicationModelProvider();
var typeInfo = typeof(BindPropertyAttributeOnBaseModelPage).GetTypeInfo();
var descriptor = new PageActionDescriptor();
var context = new PageApplicationModelProviderContext(descriptor, typeInfo);
// Act
provider.OnProvidersExecuting(context);
// Assert
Assert.NotNull(context.PageApplicationModel);
Assert.Collection(
context.PageApplicationModel.HandlerProperties.OrderBy(p => p.PropertyName).Where(p => p.BindingInfo != null),
property =>
{
var name = nameof(ModelLevel3.Property2);
Assert.Equal(typeof(ModelLevel3).GetProperty(name), property.PropertyInfo);
Assert.Equal(name, property.PropertyName);
Assert.NotNull(property.BindingInfo);
},
property =>
{
var name = nameof(ModelLevel3.Property3);
Assert.Equal(typeof(ModelLevel3).GetProperty(name), property.PropertyInfo);
Assert.Equal(name, property.PropertyName);
Assert.NotNull(property.BindingInfo);
});
}
[Fact] // If the model does not have the PageModelAttribute, we look at the page instead.
public void OnProvidersExecuting_FindsHandlerMethodOnPage_WhenModelIsNotAnnotatedWithPageModelAttribute()
{
// Arrange
var provider = new DefaultPageApplicationModelProvider();
var typeInfo = typeof(PageWithHandler).GetTypeInfo();
var context = new PageApplicationModelProviderContext(new PageActionDescriptor(), typeInfo);
// Act
provider.OnProvidersExecuting(context);
// Assert
var pageModel = context.PageApplicationModel;
var propertiesOnPage = pageModel.HandlerProperties
.Where(p => p.PropertyInfo.DeclaringType.GetTypeInfo() == typeInfo);
Assert.Collection(
propertiesOnPage.OrderBy(p => p.PropertyName),
p => Assert.Equal(typeInfo.GetProperty(nameof(PageWithHandler.BindMe)), p.PropertyInfo),
p => Assert.Equal(typeInfo.GetProperty(nameof(PageWithHandler.Model)), p.PropertyInfo));
Assert.Collection(
pageModel.HandlerMethods,
p => Assert.Equal(typeInfo.GetMethod(nameof(PageWithHandler.OnGet)), p.MethodInfo));
Assert.Same(typeof(PageWithHandler).GetTypeInfo(), pageModel.HandlerType);
Assert.Same(typeof(PocoModel).GetTypeInfo(), pageModel.ModelType);
Assert.Same(typeof(PageWithHandler).GetTypeInfo(), pageModel.PageType);
}
[Fact] // If the model has handler methods, we prefer those.
public void CreateDescriptor_FindsHandlerMethod_OnModel()
{
// Arrange
var provider = new DefaultPageApplicationModelProvider();
var typeInfo = typeof(PageWithHandlerThatGetsIgnored).GetTypeInfo();
var modelType = typeof(ModelWithHandler);
var context = new PageApplicationModelProviderContext(new PageActionDescriptor(), typeInfo);
// Act
provider.OnProvidersExecuting(context);
// Assert
var pageModel = context.PageApplicationModel;
Assert.Contains(
pageModel.HandlerProperties,
p => p.PropertyInfo == modelType.GetProperty(nameof(ModelWithHandler.BindMe)));
Assert.Collection(
pageModel.HandlerMethods,
p => Assert.Equal(modelType.GetMethod(nameof(ModelWithHandler.OnGet)), p.MethodInfo));
Assert.Same(typeof(ModelWithHandler).GetTypeInfo(), pageModel.HandlerType);
Assert.Same(typeof(ModelWithHandler).GetTypeInfo(), pageModel.ModelType);
Assert.Same(typeof(PageWithHandlerThatGetsIgnored).GetTypeInfo(), pageModel.PageType);
}
public void PopulateHandlerMethods_DiscoversHandlersFromBaseType()
{
// Arrange
var provider = new DefaultPageApplicationModelProvider();
var typeInfo = typeof(InheritsMethods).GetTypeInfo();
var baseType = typeof(TestSetPageModel);
var pageModel = new PageApplicationModel(new PageActionDescriptor(), typeInfo, new object[0]);
// Act
provider.PopulateHandlerMethods(pageModel);
// Assert
var handlerMethods = pageModel.HandlerMethods;
Assert.Collection(
handlerMethods.OrderBy(h => h.MethodInfo.DeclaringType.Name).ThenBy(h => h.MethodInfo.Name),
handler =>
{
Assert.Equal(nameof(InheritsMethods.OnGet), handler.MethodInfo.Name);
Assert.Equal(typeInfo, handler.MethodInfo.DeclaringType.GetTypeInfo());
},
handler =>
{
Assert.Equal(nameof(TestSetPageModel.OnGet), handler.MethodInfo.Name);
Assert.Equal(baseType, handler.MethodInfo.DeclaringType);
},
handler =>
{
Assert.Equal(nameof(TestSetPageModel.OnPost), handler.MethodInfo.Name);
Assert.Equal(baseType, handler.MethodInfo.DeclaringType);
});
}
public void CreateHandlerMethods_AddsParameterDescriptors()
{
// Arrange
var provider = new DefaultPageApplicationModelProvider();
var typeInfo = typeof(PageWithHandlerParameters).GetTypeInfo();
var expected = typeInfo.GetMethod(nameof(PageWithHandlerParameters.OnPost));
var pageModel = new PageApplicationModel(new PageActionDescriptor(), typeInfo, new object[0]);
// Act
provider.PopulateHandlerMethods(pageModel);
// Assert
var handlerMethods = pageModel.HandlerMethods;
var handler = Assert.Single(handlerMethods);
Assert.Collection(
handler.Parameters,
p =>
{
Assert.NotNull(p.ParameterInfo);
Assert.Equal(typeof(string), p.ParameterInfo.ParameterType);
Assert.Equal("name", p.ParameterName);
},
p =>
{
Assert.NotNull(p.ParameterInfo);
Assert.Equal(typeof(int), p.ParameterInfo.ParameterType);
Assert.Equal("id", p.ParameterName);
Assert.Equal("personId", p.BindingInfo.BinderModelName);
});
}
public void OnProvidersExecuting_DiscoversBindingInfoFromHandler()
{
// Arrange
var provider = new DefaultPageApplicationModelProvider();
var typeInfo = typeof(PageWithBindPropertyModel).GetTypeInfo();
var modelType = typeof(ModelWithBindProperty);
var descriptor = new PageActionDescriptor();
var context = new PageApplicationModelProviderContext(descriptor, typeInfo);
// Act
provider.OnProvidersExecuting(context);
// Assert
Assert.NotNull(context.PageApplicationModel);
Assert.Collection(
context.PageApplicationModel.HandlerProperties.OrderBy(p => p.PropertyName),
property =>
{
Assert.Equal(nameof(ModelWithBindProperty.Property1), property.PropertyName);
Assert.NotNull(property.BindingInfo);
},
property =>
{
Assert.Equal(nameof(ModelWithBindProperty.Property2), property.PropertyName);
Assert.NotNull(property.BindingInfo);
Assert.Equal(BindingSource.Path, property.BindingInfo.BindingSource);
});
}
private static PageApplicationModelProviderContext GetApplicationProviderContext(TypeInfo typeInfo)
{
var defaultProvider = new DefaultPageApplicationModelProvider();
var context = new PageApplicationModelProviderContext(new PageActionDescriptor(), typeInfo);
defaultProvider.OnProvidersExecuting(context);
return(context);
}
public void TryParseHandler_ParsesHandlerNames_InvalidData(string methodName)
{
// Act
var result = DefaultPageApplicationModelProvider.TryParseHandlerMethod(methodName, out var httpMethod, out var handler);
// Assert
Assert.False(result);
Assert.Null(httpMethod);
Assert.Null(handler);
}
private static PageApplicationModelProviderContext GetApplicationProviderContext(TypeInfo typeInfo)
{
var defaultProvider = new DefaultPageApplicationModelProvider(
TestModelMetadataProvider.CreateDefaultProvider(),
Options.Create(new MvcOptions()));
var context = new PageApplicationModelProviderContext(new PageActionDescriptor(), typeInfo);
defaultProvider.OnProvidersExecuting(context);
return(context);
}
public void TryParseHandler_ParsesHandlerNames_ValidData(string methodName, string expectedHttpMethod, string expectedHandler)
{
// Arrange
// Act
var result = DefaultPageApplicationModelProvider.TryParseHandlerMethod(methodName, out var httpMethod, out var handler);
// Assert
Assert.True(result);
Assert.Equal(expectedHttpMethod, httpMethod);
Assert.Equal(expectedHandler, handler);
}
private static PageApplicationModelProviderContext GetApplicationProviderContext(TypeInfo typeInfo)
{
var defaultProvider = new DefaultPageApplicationModelProvider(
TestModelMetadataProvider.CreateDefaultProvider(),
Options.Create(new MvcOptions {
AllowValidatingTopLevelNodes = true
}),
Options.Create(new RazorPagesOptions {
AllowDefaultHandlingForOptionsRequests = true
}));
var context = new PageApplicationModelProviderContext(new PageActionDescriptor(), typeInfo);
defaultProvider.OnProvidersExecuting(context);
return(context);
}
public void PopulateFilters_AddsIFilterMetadataAttributesToModel()
{
// Arrange
var provider = new DefaultPageApplicationModelProvider();
var typeInfo = typeof(FilterModel).GetTypeInfo();
var pageModel = new PageApplicationModel(new PageActionDescriptor(), typeInfo, typeInfo.GetCustomAttributes(inherit: true));
// Act
provider.PopulateFilters(pageModel);
// Assert
Assert.Collection(
pageModel.Filters,
filter => Assert.IsType <TypeFilterAttribute>(filter));
}
public void PopulateHandlerMethods_IgnoreGenericTypeParameters()
{
// Arrange
var provider = new DefaultPageApplicationModelProvider();
var typeInfo = typeof(GenericClassModel).GetTypeInfo();
var pageModel = new PageApplicationModel(new PageActionDescriptor(), typeInfo, new object[0]);
// Act
provider.PopulateHandlerMethods(pageModel);
// Assert
var handlerMethods = pageModel.HandlerMethods;
Assert.Empty(handlerMethods);
}
public void PopulateFilters_AddsPageHandlerPageFilter_IfPageImplementsIPageFilter()
{
// Arrange
var provider = new DefaultPageApplicationModelProvider();
var typeInfo = typeof(ModelImplementingPageFilter).GetTypeInfo();
var pageModel = new PageApplicationModel(new PageActionDescriptor(), typeInfo, typeInfo.GetCustomAttributes(inherit: true));
// Act
provider.PopulateFilters(pageModel);
// Assert
Assert.Collection(
pageModel.Filters,
filter => Assert.IsType <PageHandlerPageFilter>(filter));
}
public void OnProvidersExecuting_ThrowsIfModelPropertyIsNotPublic()
{
// Arrange
var provider = new DefaultPageApplicationModelProvider();
var typeInfo = typeof(PageWithNonVisibleModel).GetTypeInfo();
var descriptor = new PageActionDescriptor();
var context = new PageApplicationModelProviderContext(descriptor, typeInfo);
// Act & Assert
var ex = Assert.Throws <InvalidOperationException>(() => provider.OnProvidersExecuting(context));
// Assert
Assert.Equal(
$"The type '{typeInfo.FullName}' is not a valid page. A page must define a public, non-static 'Model' property.",
ex.Message);
}
public void PopulateHandlerMethods_IgnoresNonPublicMethods()
{
// Arrange
var provider = new DefaultPageApplicationModelProvider();
var typeInfo = typeof(ProtectedModel).GetTypeInfo();
var baseType = typeof(TestSetPageModel);
var pageModel = new PageApplicationModel(new PageActionDescriptor(), typeInfo, new object[0]);
// Act
provider.PopulateHandlerMethods(pageModel);
// Assert
var handlerMethods = pageModel.HandlerMethods;
Assert.Empty(handlerMethods);
}
public void OnProvidersExecuting_ThrowsIfPageDoesNotDeriveFromValidBaseType()
{
// Arrange
var provider = new DefaultPageApplicationModelProvider();
var typeInfo = typeof(InvalidPageWithWrongBaseClass).GetTypeInfo();
var descriptor = new PageActionDescriptor();
var context = new PageApplicationModelProviderContext(descriptor, typeInfo);
// Act & Assert
var ex = Assert.Throws <InvalidOperationException>(() => provider.OnProvidersExecuting(context));
// Assert
Assert.Equal(
$"The type '{typeInfo.FullName}' is not a valid page. A page must inherit from '{typeof(PageBase).FullName}'.",
ex.Message);
}
public void PopulateHandlerMethods_IgnoresMethodWithNonHandlerAttribute()
{
// Arrange
var provider = new DefaultPageApplicationModelProvider();
var typeInfo = typeof(PageWithNonHandlerMethod).GetTypeInfo();
var expected = typeInfo.GetMethod(nameof(PageWithNonHandlerMethod.OnGet), BindingFlags.Public | BindingFlags.Instance);
var pageModel = new PageApplicationModel(new PageActionDescriptor(), typeInfo, new object[0]);
// Act
provider.PopulateHandlerMethods(pageModel);
// Assert
var handlerMethods = pageModel.HandlerMethods;
Assert.Collection(
handlerMethods,
handler => Assert.Same(expected, handler.MethodInfo));
}
public void OnProvidersExecuting_EmptyPage()
{
// Arrange
var provider = new DefaultPageApplicationModelProvider();
var typeInfo = typeof(EmptyPage).GetTypeInfo();
var context = new PageApplicationModelProviderContext(new PageActionDescriptor(), typeInfo);
// Act
provider.OnProvidersExecuting(context);
// Assert
var pageModel = context.PageApplicationModel;
Assert.Empty(pageModel.HandlerProperties.Where(p => p.BindingInfo != null));
Assert.Empty(pageModel.HandlerMethods);
Assert.Same(typeof(EmptyPage).GetTypeInfo(), pageModel.HandlerType);
Assert.Same(typeof(EmptyPage).GetTypeInfo(), pageModel.ModelType);
Assert.Same(typeof(EmptyPage).GetTypeInfo(), pageModel.PageType);
}
public void PopulateHandlerProperties_UsesPropertyHelpers_ToFindProperties()
{
// Arrange
var provider = new DefaultPageApplicationModelProvider();
var typeInfo = typeof(HidesAProperty).GetTypeInfo();
var pageModel = new PageApplicationModel(new PageActionDescriptor(), typeInfo, new object[0]);
// Act
provider.PopulateHandlerProperties(pageModel);
// Assert
var properties = pageModel.HandlerProperties;
Assert.Collection(
properties,
p =>
{
Assert.Equal(typeof(HidesAProperty).GetTypeInfo(), p.PropertyInfo.DeclaringType.GetTypeInfo());
});
}
public void OnProvidersExecuting_DiscoversHandlersFromPage()
{
// Arrange
var provider = new DefaultPageApplicationModelProvider();
var typeInfo = typeof(PageWithModelWithoutHandlers).GetTypeInfo();
var descriptor = new PageActionDescriptor();
var context = new PageApplicationModelProviderContext(descriptor, typeInfo);
// Act
provider.OnProvidersExecuting(context);
// Assert
Assert.NotNull(context.PageApplicationModel);
Assert.Collection(
context.PageApplicationModel.HandlerMethods.OrderBy(p => p.Name),
handler =>
{
var name = nameof(PageWithModelWithoutHandlers.OnGet);
Assert.Equal(typeInfo.GetMethod(name), handler.MethodInfo);
Assert.Equal(name, handler.Name);
Assert.Equal("Get", handler.HttpMethod);
Assert.Null(handler.HandlerName);
},
handler =>
{
var name = nameof(PageWithModelWithoutHandlers.OnPostAsync);
Assert.Equal(typeInfo.GetMethod(name), handler.MethodInfo);
Assert.Equal(name, handler.Name);
Assert.Equal("Post", handler.HttpMethod);
Assert.Null(handler.HandlerName);
},
handler =>
{
var name = nameof(PageWithModelWithoutHandlers.OnPostDeleteCustomerAsync);
Assert.Equal(typeInfo.GetMethod(name), handler.MethodInfo);
Assert.Equal(name, handler.Name);
Assert.Equal("Post", handler.HttpMethod);
Assert.Equal("DeleteCustomer", handler.HandlerName);
});
}
public void CreateHandlerModel_ParsesMethod()
{
// Arrange
var provider = new DefaultPageApplicationModelProvider();
var typeInfo = typeof(PageModelWithHandlerNames).GetTypeInfo();
var pageModel = new PageApplicationModel(new PageActionDescriptor(), typeInfo, new object[0]);
// Act
provider.PopulateHandlerMethods(pageModel);
// Assert
var handlerMethods = pageModel.HandlerMethods;
Assert.Collection(
handlerMethods.OrderBy(h => h.MethodInfo.Name),
handler =>
{
Assert.Same(typeInfo.GetMethod(nameof(PageModelWithHandlerNames.OnPutDeleteAsync)), handler.MethodInfo);
Assert.Equal("Put", handler.HttpMethod);
Assert.Equal("Delete", handler.HandlerName);
});
}
public void OnProvidersExecuting_DiscoversPropertiesFromPage_IfModelTypeDoesNotHaveAttribute()
{
// Arrange
var provider = new DefaultPageApplicationModelProvider();
var typeInfo = typeof(PageWithModelWithoutPageModelAttribute).GetTypeInfo();
var descriptor = new PageActionDescriptor();
var context = new PageApplicationModelProviderContext(descriptor, typeInfo);
// Act
provider.OnProvidersExecuting(context);
// Assert
Assert.NotNull(context.PageApplicationModel);
var propertiesOnPage = context.PageApplicationModel.HandlerProperties
.Where(p => p.PropertyInfo.DeclaringType.GetTypeInfo() == typeInfo);
Assert.Collection(
propertiesOnPage.OrderBy(p => p.PropertyName),
property =>
{
Assert.Equal(typeInfo.GetProperty(nameof(PageWithModelWithoutPageModelAttribute.Model)), property.PropertyInfo);
Assert.Equal(nameof(PageWithModelWithoutPageModelAttribute.Model), property.PropertyName);
},
property =>
{
Assert.Equal(typeInfo.GetProperty(nameof(PageWithModelWithoutPageModelAttribute.Property1)), property.PropertyInfo);
Assert.Null(property.BindingInfo);
Assert.Equal(nameof(PageWithModelWithoutPageModelAttribute.Property1), property.PropertyName);
},
property =>
{
Assert.Equal(typeInfo.GetProperty(nameof(PageWithModelWithoutPageModelAttribute.Property2)), property.PropertyInfo);
Assert.Equal(nameof(PageWithModelWithoutPageModelAttribute.Property2), property.PropertyName);
Assert.NotNull(property.BindingInfo);
Assert.Equal(BindingSource.Path, property.BindingInfo.BindingSource);
});
}
