public void CreateHandlerMethods_CopiesPropertiesFromHandlerModel()
{
// Arrange
var actionDescriptor = new PageActionDescriptor();
var handlerTypeInfo = typeof(ModelWithHandler).GetTypeInfo();
var handlerModel = new PageHandlerModel(handlerTypeInfo.GetMethod(nameof(ModelWithHandler.OnGetCustomerAsync)), new object[0])
{
HttpMethod = "GET",
HandlerName = "Customer",
};
var pageApplicationModel = new PageApplicationModel(actionDescriptor, handlerTypeInfo, new object[0])
{
HandlerMethods =
{
handlerModel,
}
};
// Act
var handlerDescriptors = CompiledPageActionDescriptorBuilder.CreateHandlerMethods(pageApplicationModel);
// Assert
Assert.Collection(
handlerDescriptors,
d =>
{
Assert.Equal(handlerModel.MethodInfo, d.MethodInfo);
Assert.Equal(handlerModel.HttpMethod, d.HttpMethod);
Assert.Equal(handlerModel.HandlerName, d.Name);
});
}
public void ApplyConventions_RemovingParameterModelAsPartOfConventionWorks()
{
// Arrange
var descriptor = new PageActionDescriptor();
var methodInfo = GetType().GetMethod(nameof(OnGet), BindingFlags.Instance | BindingFlags.NonPublic);
var parameterInfo = methodInfo.GetParameters()[0];
var applicationModel = new PageApplicationModel(descriptor, typeof(object).GetTypeInfo(), Array.Empty <object>());
var handlerModel = new PageHandlerModel(methodInfo, Array.Empty <object>());
var parameterModelConvention = new Mock <IParameterModelBaseConvention>();
var parameterModel = new PageParameterModel(parameterInfo, new[] { parameterModelConvention.Object })
{
Handler = handlerModel,
};
applicationModel.HandlerMethods.Add(handlerModel);
handlerModel.Parameters.Add(parameterModel);
parameterModelConvention.Setup(p => p.Apply(It.IsAny <ParameterModelBase>()))
.Callback((ParameterModelBase m) =>
{
var model = Assert.IsType <PageParameterModel>(m);
model.Handler.Parameters.Remove(model);
})
.Verifiable();
var conventionCollection = new PageConventionCollection();
// Act
DefaultPageLoader.ApplyConventions(conventionCollection, applicationModel);
// Assert
parameterModelConvention.Verify();
}
public void ApplyConventions_InvokesPropertyModelConventions_DeclaredGlobally()
{
// Arrange
var descriptor = new PageActionDescriptor();
var methodInfo = GetType().GetMethod(nameof(OnGet), BindingFlags.Instance | BindingFlags.NonPublic);
var propertyInfo = GetType().GetProperty(nameof(TestProperty), BindingFlags.Instance | BindingFlags.NonPublic);
var applicationModel = new PageApplicationModel(descriptor, typeof(object).GetTypeInfo(), Array.Empty <object>());
var handlerModel = new PageHandlerModel(methodInfo, Array.Empty <object>());
var propertyModel = new PagePropertyModel(propertyInfo, Array.Empty <object>());
applicationModel.HandlerMethods.Add(handlerModel);
applicationModel.HandlerProperties.Add(propertyModel);
var propertyModelConvention = new Mock <IParameterModelBaseConvention>();
propertyModelConvention.Setup(p => p.Apply(It.IsAny <ParameterModelBase>()))
.Callback((ParameterModelBase m) =>
{
Assert.Same(propertyModel, m);
})
.Verifiable();
var conventionCollection = new PageConventionCollection {
propertyModelConvention.Object
};
// Act
DefaultPageLoader.ApplyConventions(conventionCollection, applicationModel);
// Assert
propertyModelConvention.Verify();
}
public void ApplyConventions_RemovingHandlerAsPartOfHandlerModelConvention_Works()
{
// Arrange
var descriptor = new PageActionDescriptor();
var methodInfo = GetType().GetMethod(nameof(OnGet), BindingFlags.Instance | BindingFlags.NonPublic);
var handlerModelConvention = new Mock <IPageHandlerModelConvention>();
var applicationModel = new PageApplicationModel(descriptor, typeof(object).GetTypeInfo(), Array.Empty <object>());
var handlerModel = new PageHandlerModel(methodInfo, new[] { handlerModelConvention.Object })
{
Page = applicationModel,
};
applicationModel.HandlerMethods.Add(handlerModel);
handlerModelConvention.Setup(p => p.Apply(It.IsAny <PageHandlerModel>()))
.Callback((PageHandlerModel m) =>
{
m.Page.HandlerMethods.Remove(m);
})
.Verifiable();
var conventionCollection = new PageConventionCollection();
// Act
DefaultPageLoader.ApplyConventions(conventionCollection, applicationModel);
// Assert
handlerModelConvention.Verify();
}
public void ApplyConventions_InvokesHandlerModelConventions()
{
// Arrange
var descriptor = new PageActionDescriptor();
var methodInfo = GetType().GetMethod(nameof(OnGet), BindingFlags.Instance | BindingFlags.NonPublic);
var handlerModelConvention = new Mock <IPageHandlerModelConvention>();
var applicationModel = new PageApplicationModel(descriptor, typeof(object).GetTypeInfo(), Array.Empty <object>());
var handlerModel = new PageHandlerModel(methodInfo, new[] { handlerModelConvention.Object });
applicationModel.HandlerMethods.Add(handlerModel);
handlerModelConvention.Setup(p => p.Apply(It.IsAny <PageHandlerModel>()))
.Callback((PageHandlerModel m) =>
{
Assert.Same(handlerModel, m);
})
.Verifiable();
var conventionCollection = new PageConventionCollection(Mock.Of <IServiceProvider>());
// Act
CompiledPageActionDescriptorFactory.ApplyConventions(conventionCollection, applicationModel);
// Assert
handlerModelConvention.Verify();
}
public void CreateHandlerMethods_CopiesParameterDescriptorsFromParameterModel()
{
// Arrange
var actionDescriptor = new PageActionDescriptor();
var handlerTypeInfo = typeof(HandlerWithParameters).GetTypeInfo();
var handlerMethod = handlerTypeInfo.GetMethod(nameof(HandlerWithParameters.OnPost));
var parameters = handlerMethod.GetParameters();
var parameterModel1 = new PageParameterModel(parameters[0], new object[0])
{
ParameterName = "test-name"
};
var parameterModel2 = new PageParameterModel(parameters[1], new object[0])
{
BindingInfo = new BindingInfo(),
};
var handlerModel = new PageHandlerModel(handlerMethod, new object[0])
{
Parameters =
{
parameterModel1,
parameterModel2,
}
};
var pageApplicationModel = new PageApplicationModel(actionDescriptor, handlerTypeInfo, new object[0])
{
HandlerMethods =
{
handlerModel,
}
};
// Act
var handlerDescriptors = CompiledPageActionDescriptorBuilder.CreateHandlerMethods(pageApplicationModel);
// Assert
Assert.Collection(
Assert.Single(handlerDescriptors).Parameters,
p =>
{
Assert.Equal(parameters[0], p.ParameterInfo);
Assert.Equal(typeof(string), p.ParameterType);
Assert.Equal(parameterModel1.ParameterName, p.Name);
},
p =>
{
Assert.Equal(parameters[1], p.ParameterInfo);
Assert.Equal(typeof(int), p.ParameterType);
Assert.Same(parameterModel2.BindingInfo, p.BindingInfo);
});
}
// internal for unit testing
internal static HandlerParameterDescriptor[] CreateHandlerParameters(PageHandlerModel handlerModel)
{
var methodParameters = handlerModel.Parameters;
var parameters = new HandlerParameterDescriptor[methodParameters.Count];
for (var i = 0; i < parameters.Length; i++)
{
var parameterModel = methodParameters[i];
parameters[i] = new HandlerParameterDescriptor {
BindingInfo = parameterModel.BindingInfo,
Name = parameterModel.ParameterName,
ParameterInfo = parameterModel.ParameterInfo,
ParameterType = parameterModel.ParameterInfo.ParameterType,
};
}
return(parameters);
}
protected override PageHandlerModel CreateHandlerModel(MethodInfo method)
{
if (method == null)
{
throw new ArgumentNullException(nameof(method));
}
if (!IsHandler(method))
{
return(null);
}
if (!TryParseHandlerMethod(
method.Name, out var httpMethod, out var handlerName))
{
return(null);
}
var handlerModel = new PageHandlerModel(
method,
method.GetCustomAttributes(inherit: true))
{
Name = method.Name,
HandlerName = handlerName,
HttpMethod = httpMethod,
};
var methodParameters = handlerModel.MethodInfo.GetParameters();
for (var i = 0; i < methodParameters.Length; i++)
{
var parameter = methodParameters[i];
var parameterModel = CreateParameterModel(parameter);
parameterModel.Handler = handlerModel;
handlerModel.Parameters.Add(parameterModel);
}
return(handlerModel);
}
/// <summary>
/// Creates a new instance of <see cref="PageHandlerModel"/> from a given <see cref="PageHandlerModel"/>.
/// </summary>
/// <param name="other">The <see cref="PageHandlerModel"/> which needs to be copied.</param>
public PageHandlerModel(PageHandlerModel other)
{
if (other == null)
{
throw new ArgumentNullException(nameof(other));
}
MethodInfo = other.MethodInfo;
HandlerName = other.HandlerName;
HttpMethod = other.HttpMethod;
Name = other.Name;
Page = other.Page;
// These are just metadata, safe to create new collections
Attributes = new List <object>(other.Attributes);
Properties = new Dictionary <object, object?>(other.Properties);
// Make a deep copy of other 'model' types.
Parameters = new List <PageParameterModel>(other.Parameters.Select(p => new PageParameterModel(p)
{
Handler = this
}));
}
//页面加载时调用(每一个路由地址)，在IPageApplicationModelConvention约定之后执行
public void Apply(PageHandlerModel model)
{
//目前还不清楚能做什么
}
public void Apply(PageHandlerModel model)
{
// Access the PageHandlerModel
}
public void Apply(PageHandlerModel model)
{
}
