public void ViewDataModelSetter_DoesNotThrow_IfValueIncompatibleWithSourceDeclaredType(
object model,
Type expectedType)
{
// Arrange
var httpContext = new DefaultHttpContext();
var actionContext = new ActionContext(httpContext, new RouteData(), new ActionDescriptor());
var viewData = new ViewDataDictionary <int>(new EmptyModelMetadataProvider());
var viewContext = new ViewContext(
actionContext,
NullView.Instance,
viewData,
new TempDataDictionary(httpContext, Mock.Of <ITempDataProvider>()),
TextWriter.Null,
new HtmlHelperOptions());
var viewComponentDescriptor = new ViewComponentDescriptor();
var viewComponentContext = new ViewComponentContext(
viewComponentDescriptor,
new Dictionary <string, object>(),
new HtmlTestEncoder(),
viewContext,
TextWriter.Null);
// Act (does not throw)
// Non-ints can be assigned despite type restrictions in the source ViewDataDictionary.
viewComponentContext.ViewData.Model = model;
// Assert
Assert.Equal(expectedType, viewComponentContext.ViewData.ModelMetadata.ModelType);
}
public async Task ExecuteAsync_ViewComponentResult_AllowsNullViewDataAndTempData()
{
// Arrange
var methodInfo = typeof(TextViewComponent).GetMethod(nameof(TextViewComponent.Invoke));
var descriptor = new ViewComponentDescriptor()
{
FullName = "Full.Name.Text",
ShortName = "Text",
TypeInfo = typeof(TextViewComponent).GetTypeInfo(),
MethodInfo = methodInfo,
Parameters = methodInfo.GetParameters(),
};
var actionContext = CreateActionContext(descriptor);
var viewComponentResult = new ViewComponentResult
{
Arguments = new { name = "World!" },
ViewData = null,
TempData = null,
ViewComponentName = "Text"
};
// Act
await viewComponentResult.ExecuteResultAsync(actionContext);
// No assert, just confirm it didn't throw
}
private static ViewComponentContext GetViewComponentContext(IView view, Stream stream)
{
var actionContext = new ActionContext(new DefaultHttpContext(), new RouteData(), new ActionDescriptor());
var viewData = new ViewDataDictionary(new EmptyModelMetadataProvider());
var viewContext = new ViewContext(
actionContext,
view,
viewData,
new TempDataDictionary(actionContext.HttpContext, new SessionStateTempDataProvider()),
TextWriter.Null,
new HtmlHelperOptions());
var writer = new StreamWriter(stream)
{
AutoFlush = true
};
var viewComponentDescriptor = new ViewComponentDescriptor()
{
TypeInfo = typeof(object).GetTypeInfo(),
};
var viewComponentContext = new ViewComponentContext(
viewComponentDescriptor,
new Dictionary <string, object>(),
new HtmlTestEncoder(),
viewContext,
writer);
return(viewComponentContext);
}
public async Task ViewComponentResult_NoContentTypeSet_PreservesResponseContentType()
{
// Arrange
var descriptor = new ViewComponentDescriptor()
{
FullName = "Full.Name.Text",
ShortName = "Text",
Type = typeof(TextViewComponent),
};
var actionContext = CreateActionContext(descriptor);
var expectedContentType = "application/x-will-not-be-overridden";
actionContext.HttpContext.Response.ContentType = expectedContentType;
var viewComponentResult = new ViewComponentResult()
{
Arguments = new object[] { "World!" },
ViewComponentName = "Text",
TempData = _tempDataDictionary,
};
// Act
await viewComponentResult.ExecuteResultAsync(actionContext);
// Assert
Assert.Equal(expectedContentType, actionContext.HttpContext.Response.ContentType);
}
public async Task ExecuteResultAsync_SetsStatusCode()
{
// Arrange
var methodInfo = typeof(TextViewComponent).GetMethod(nameof(TextViewComponent.Invoke));
var descriptor = new ViewComponentDescriptor()
{
FullName = "Full.Name.Text",
ShortName = "Text",
TypeInfo = typeof(TextViewComponent).GetTypeInfo(),
MethodInfo = methodInfo,
Parameters = methodInfo.GetParameters(),
};
var actionContext = CreateActionContext(descriptor);
var viewComponentResult = new ViewComponentResult()
{
Arguments = new { name = "World!" },
ViewComponentType = typeof(TextViewComponent),
StatusCode = 404,
TempData = _tempDataDictionary,
};
// Act
await viewComponentResult.ExecuteResultAsync(actionContext);
// Assert
Assert.Equal(404, actionContext.HttpContext.Response.StatusCode);
}
private static ViewComponentContext GetViewComponentContext(IView view, Stream stream)
{
var actionContext = new ActionContext(new DefaultHttpContext(), new RouteData(), new ActionDescriptor());
var viewData = new ViewDataDictionary(new EmptyModelMetadataProvider());
var viewContext = new ViewContext(
actionContext,
view,
viewData,
null,
TextWriter.Null,
new HtmlHelperOptions());
var writer = new StreamWriter(stream)
{
AutoFlush = true
};
var viewComponentDescriptor = new ViewComponentDescriptor()
{
Type = typeof(object),
};
var viewComponentContext = new ViewComponentContext(viewComponentDescriptor, new object[0], viewContext, writer);
return(viewComponentContext);
}
public async Task ExecuteResultAsync_ExecutesViewComponent_ByFullName()
{
// Arrange
var methodInfo = typeof(TextViewComponent).GetMethod(nameof(TextViewComponent.Invoke));
var descriptor = new ViewComponentDescriptor()
{
FullName = "Full.Name.Text",
ShortName = "Text",
TypeInfo = typeof(TextViewComponent).GetTypeInfo(),
MethodInfo = methodInfo,
Parameters = methodInfo.GetParameters(),
};
var actionContext = CreateActionContext(descriptor);
var viewComponentResult = new ViewComponentResult()
{
Arguments = new { name = "World!" },
ViewComponentName = "Full.Name.Text",
TempData = _tempDataDictionary,
};
// Act
await viewComponentResult.ExecuteResultAsync(actionContext);
// Assert
var body = ReadBody(actionContext.HttpContext.Response);
Assert.Equal("Hello, World!", body);
}
public async Task ExecuteResultAsync_UsesDictionaryArguments()
{
// Arrange
var descriptor = new ViewComponentDescriptor()
{
FullName = "Full.Name.Text",
ShortName = "Text",
Type = typeof(TextViewComponent),
MethodInfo = typeof(TextViewComponent).GetMethod(nameof(TextViewComponent.Invoke)),
};
var actionContext = CreateActionContext(descriptor);
var viewComponentResult = new ViewComponentResult()
{
Arguments = new Dictionary <string, object> {
["name"] = "World!"
},
ViewComponentName = "Text",
TempData = _tempDataDictionary,
};
// Act
await viewComponentResult.ExecuteResultAsync(actionContext);
// Assert
var body = ReadBody(actionContext.HttpContext.Response);
Assert.Equal("Hello, World!", body);
}
public async Task ExecuteResultAsync_ExecutesSyncViewComponent()
{
// Arrange
var descriptor = new ViewComponentDescriptor()
{
FullName = "Full.Name.Text",
ShortName = "Text",
Type = typeof(TextViewComponent),
};
var actionContext = CreateActionContext(descriptor);
var viewComponentResult = new ViewComponentResult()
{
Arguments = new object[] { "World!" },
ViewComponentName = "Text",
TempData = _tempDataDictionary,
};
// Act
await viewComponentResult.ExecuteResultAsync(actionContext);
// Assert
var body = ReadBody(actionContext.HttpContext.Response);
Assert.Equal("Hello, World!", body);
}
public async Task ViewComponentResult_NoContentTypeSet_PreservesResponseContentType(
string responseContentType,
string expectedContentType)
{
// Arrange
var methodInfo = typeof(TextViewComponent).GetMethod(nameof(TextViewComponent.Invoke));
var descriptor = new ViewComponentDescriptor()
{
FullName = "Full.Name.Text",
ShortName = "Text",
TypeInfo = typeof(TextViewComponent).GetTypeInfo(),
MethodInfo = methodInfo,
Parameters = methodInfo.GetParameters(),
};
var actionContext = CreateActionContext(descriptor);
actionContext.HttpContext.Response.ContentType = expectedContentType;
var viewComponentResult = new ViewComponentResult()
{
Arguments = new { name = "World!" },
ViewComponentName = "Text",
TempData = _tempDataDictionary,
};
// Act
await viewComponentResult.ExecuteResultAsync(actionContext);
// Assert
Assert.Equal(expectedContentType, actionContext.HttpContext.Response.ContentType);
}
public async Task ExecuteAsync_ViewComponentResult_AllowsNullViewDataAndTempData()
{
// Arrange
var descriptor = new ViewComponentDescriptor()
{
FullName = "Full.Name.Text",
ShortName = "Text",
Type = typeof(TextViewComponent),
};
var actionContext = CreateActionContext(descriptor);
var viewComponentResult = new ViewComponentResult
{
Arguments = new object[] { "World!" },
ViewData = null,
TempData = null,
ViewComponentName = "Text"
};
// Act
await viewComponentResult.ExecuteResultAsync(actionContext);
// No assert, just confirm it didn't throw
}
public async Task ExecuteResultAsync_SetsStatusCode()
{
// Arrange
var descriptor = new ViewComponentDescriptor()
{
FullName = "Full.Name.Text",
ShortName = "Text",
Type = typeof(TextViewComponent),
};
var actionContext = CreateActionContext(descriptor);
var viewComponentResult = new ViewComponentResult()
{
Arguments = new object[] { "World!" },
ViewComponentType = typeof(TextViewComponent),
StatusCode = 404,
TempData = _tempDataDictionary,
};
// Act
await viewComponentResult.ExecuteResultAsync(actionContext);
// Assert
Assert.Equal(404, actionContext.HttpContext.Response.StatusCode);
}
public async Task ViewComponentResult_SetsContentTypeHeader_OverrideResponseContentType()
{
// Arrange
var descriptor = new ViewComponentDescriptor()
{
FullName = "Full.Name.Text",
ShortName = "Text",
Type = typeof(TextViewComponent),
MethodInfo = typeof(TextViewComponent).GetMethod(nameof(TextViewComponent.Invoke)),
};
var actionContext = CreateActionContext(descriptor);
var expectedContentType = "text/html; charset=utf-8";
actionContext.HttpContext.Response.ContentType = "application/x-will-be-overridden";
var viewComponentResult = new ViewComponentResult()
{
Arguments = new { name = "World!" },
ViewComponentName = "Text",
ContentType = new MediaTypeHeaderValue("text/html")
{
Encoding = Encoding.UTF8
},
TempData = _tempDataDictionary,
};
// Act
await viewComponentResult.ExecuteResultAsync(actionContext);
// Assert
Assert.Equal(expectedContentType, actionContext.HttpContext.Response.ContentType);
}
/// <inheritdoc />
public ViewComponentDescriptor TryGetViewComponentDescriptor(MethodInfo methodInfo)
{
ViewComponentDescriptor viewComponentDescriptor = null;
Cache.TryGetValue(methodInfo, out viewComponentDescriptor);
return(viewComponentDescriptor);
}
internal IDictionary <string, object?> GetArgumentDictionary(ViewComponentDescriptor descriptor, object?arguments)
{
if (arguments != null)
{
if (descriptor.Parameters.Count == 1 && descriptor.Parameters[0].ParameterType.IsAssignableFrom(arguments.GetType()))
{
return(new Dictionary <string, object?>(capacity: 1, comparer: StringComparer.OrdinalIgnoreCase)
{
{ descriptor.Parameters[0].Name !, arguments }
});
/// <summary>
/// Creates a new <see cref="ViewComponentContext"/>.
/// </summary>
/// <param name="viewComponentDescriptor">
/// The <see cref="ViewComponentContext"/> for the View Component being invoked.
/// </param>
/// <param name="arguments">The View Component arguments.</param>
/// <param name="viewContext">The <see cref="ViewContext"/>.</param>
/// <param name="writer">The <see cref="TextWriter"/> for writing output.</param>
public ViewComponentContext(
[NotNull] ViewComponentDescriptor viewComponentDescriptor,
[NotNull] object[] arguments,
[NotNull] ViewContext viewContext,
[NotNull] TextWriter writer)
{
ViewComponentDescriptor = viewComponentDescriptor;
Arguments = arguments;
ViewContext = viewContext;
Writer = writer;
}
private ExpandoObject ToExpando(IQueryCollection query, string viewComponentType)
{
ViewComponentDescriptor vcDescriptor = _selector.SelectComponent(viewComponentType);
if (vcDescriptor == null)
{
throw new Exception($"Unable to find definition of ViewComponent ({viewComponentType})");
}
MethodBase invokeMethod = vcDescriptor.TypeInfo.GetMethod("InvokeAsync");
if (invokeMethod == null)
{
throw new Exception($"InvokeAsync method not found in ViewComponent ({viewComponentType})");
}
ParameterInfo[] paramInfo = invokeMethod.GetParameters();
var expando = new ExpandoObject() as IDictionary <string, object>;
foreach (var param in paramInfo)
{
if (query.ContainsKey(param.Name))
{
if (param.ParameterType == typeof(string))
{
expando.Add(param.Name, query[param.Name].ToString());
}
else if (param.ParameterType == typeof(bool))
{
expando.Add(param.Name, Convert.ToBoolean(query[param.Name]));
}
else if (param.ParameterType == typeof(int))
{
expando.Add(param.Name, Convert.ToInt32(query[param.Name]));
}
else if (param.ParameterType == typeof(double))
{
expando.Add(param.Name, Convert.ToDouble(query[param.Name]));
}
else if (param.ParameterType == typeof(DateTime))
{
expando.Add(param.Name, Convert.ToDateTime(query[param.Name]));
}
// TO DO: Add conversions for arrays, collections, and classes
}
}
return((ExpandoObject)expando);
}
private static ViewComponentContext GetViewComponentContext(IView view, ViewDataDictionary viewData)
{
var actionContext = new ActionContext(new DefaultHttpContext(), new RouteData(), new ActionDescriptor());
var viewContext = new ViewContext(actionContext, view, viewData, null, TextWriter.Null);
var viewComponentDescriptor = new ViewComponentDescriptor()
{
Type = typeof(object),
};
var viewComponentContext = new ViewComponentContext(viewComponentDescriptor, new object[0], viewContext, TextWriter.Null);
return(viewComponentContext);
}
private static ViewComponentDescriptor CreateDescriptor(TypeInfo typeInfo)
{
var methodInfo = FindMethod(typeInfo.AsType());
var candidate = new ViewComponentDescriptor
{
FullName = ViewComponentConventions.GetComponentFullName(typeInfo),
ShortName = ViewComponentConventions.GetComponentName(typeInfo),
TypeInfo = typeInfo,
MethodInfo = methodInfo,
Parameters = methodInfo.GetParameters()
};
return(candidate);
}
private static ViewComponentContext GetViewComponentContext(
IView view,
ViewDataDictionary viewData,
object diagnosticListener = null)
{
var diagnosticSource = new DiagnosticListener("Microsoft.AspNetCore");
if (diagnosticListener == null)
{
diagnosticListener = new TestDiagnosticListener();
}
diagnosticSource.SubscribeWithAdapter(diagnosticListener);
var serviceProvider = new Mock <IServiceProvider>();
serviceProvider.Setup(s => s.GetService(typeof(DiagnosticListener))).Returns(diagnosticSource);
var httpContext = new DefaultHttpContext();
httpContext.RequestServices = serviceProvider.Object;
var actionContext = new ActionContext(httpContext, new RouteData(), new ActionDescriptor());
var viewContext = new ViewContext(
actionContext,
view,
viewData,
new TempDataDictionary(httpContext, Mock.Of <ITempDataProvider>()),
TextWriter.Null,
new HtmlHelperOptions());
var viewComponentDescriptor = new ViewComponentDescriptor()
{
ShortName = "Invoke",
TypeInfo = typeof(object).GetTypeInfo(),
MethodInfo = typeof(object).GetTypeInfo().DeclaredMethods.First()
};
var viewComponentContext = new ViewComponentContext(
viewComponentDescriptor,
new Dictionary <string, object>(),
new HtmlTestEncoder(),
viewContext,
TextWriter.Null);
return(viewComponentContext);
}
/// <summary>
/// Creates a new <see cref="ViewComponentContext"/>.
/// </summary>
/// <param name="viewComponentDescriptor">
/// The <see cref="ViewComponentContext"/> for the View Component being invoked.
/// </param>
/// <param name="arguments">The View Component arguments.</param>
/// <param name="viewContext">The <see cref="ViewContext"/>.</param>
/// <param name="writer">The <see cref="TextWriter"/> for writing output.</param>
public ViewComponentContext(
[NotNull] ViewComponentDescriptor viewComponentDescriptor,
[NotNull] object[] arguments,
[NotNull] ViewContext viewContext,
[NotNull] TextWriter writer)
{
ViewComponentDescriptor = viewComponentDescriptor;
Arguments = arguments;
// We want to create a defensive copy of the VDD here so that changes done in the VC
// aren't visible in the calling view.
ViewContext = new ViewContext(
viewContext,
viewContext.View,
new ViewDataDictionary(viewContext.ViewData),
writer);
}
private void SetAttributeDescriptors(ViewComponentDescriptor viewComponentDescriptor,
TagHelperDescriptor tagHelperDescriptor)
{
var methodParameters = viewComponentDescriptor.MethodInfo.GetParameters();
var attributeDescriptors = new List <TagHelperAttributeDescriptor>();
var indexerDescriptors = new List <TagHelperAttributeDescriptor>();
var requiredAttributeDescriptors = new List <TagHelperRequiredAttributeDescriptor>();
foreach (var parameter in methodParameters)
{
var lowerKebabName = TagHelperDescriptorFactory.ToHtmlCase(parameter.Name);
var typeName = GetCSharpTypeName(parameter.ParameterType);
var descriptor = new TagHelperAttributeDescriptor
{
Name = lowerKebabName,
PropertyName = parameter.Name,
TypeName = typeName
};
descriptor.IsEnum = parameter.ParameterType.GetTypeInfo().IsEnum;
descriptor.IsIndexer = false;
attributeDescriptors.Add(descriptor);
var indexerDescriptor = GetIndexerAttributeDescriptor(parameter, lowerKebabName);
if (indexerDescriptor != null)
{
indexerDescriptors.Add(indexerDescriptor);
}
else
{
// Set required attributes only for non-indexer attributes. Indexer attributes can't be required attributes
// because there are two ways of setting values for the attribute.
requiredAttributeDescriptors.Add(new TagHelperRequiredAttributeDescriptor
{
Name = lowerKebabName
});
}
}
attributeDescriptors.AddRange(indexerDescriptors);
tagHelperDescriptor.Attributes = attributeDescriptors;
tagHelperDescriptor.RequiredAttributes = requiredAttributeDescriptors;
}
public ViewComponentContext(
ViewComponentDescriptor viewComponentDescriptor,
IDictionary <string, object?> arguments,
HtmlEncoder htmlEncoder,
ViewContext viewContext,
TextWriter writer)
{
if (viewComponentDescriptor == null)
{
throw new ArgumentNullException(nameof(viewComponentDescriptor));
}
if (arguments == null)
{
throw new ArgumentNullException(nameof(arguments));
}
if (htmlEncoder == null)
{
throw new ArgumentNullException(nameof(htmlEncoder));
}
if (viewContext == null)
{
throw new ArgumentNullException(nameof(viewContext));
}
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
ViewComponentDescriptor = viewComponentDescriptor;
Arguments = arguments;
HtmlEncoder = htmlEncoder;
// We want to create a defensive copy of the VDD here so that changes done in the VC
// aren't visible in the calling view.
ViewContext = new ViewContext(
viewContext,
viewContext.View,
new ViewDataDictionary <object>(viewContext.ViewData),
writer);
}
public async Task ViewComponentResult_SetsContentTypeHeader(
string contentType,
string expectedContentType)
{
// Arrange
var methodInfo = typeof(TextViewComponent).GetMethod(nameof(TextViewComponent.Invoke));
var descriptor = new ViewComponentDescriptor()
{
FullName = "Full.Name.Text",
ShortName = "Text",
TypeInfo = typeof(TextViewComponent).GetTypeInfo(),
MethodInfo = methodInfo,
Parameters = methodInfo.GetParameters(),
};
var actionContext = CreateActionContext(descriptor);
var contentTypeBeforeViewResultExecution = contentType?.ToString();
var viewComponentResult = new ViewComponentResult()
{
Arguments = new { name = "World!" },
ViewComponentName = "Text",
ContentType = contentType,
TempData = _tempDataDictionary,
};
// Act
await viewComponentResult.ExecuteResultAsync(actionContext);
// Assert
var resultContentType = actionContext.HttpContext.Response.ContentType;
MediaTypeAssert.Equal(expectedContentType, resultContentType);
// Check if the original instance provided by the user has not changed.
// Since we do not have access to the new instance created within the view executor,
// check if at least the content is the same.
var contentTypeAfterViewResultExecution = contentType?.ToString();
MediaTypeAssert.Equal(contentTypeBeforeViewResultExecution, contentTypeAfterViewResultExecution);
}
public async Task ExecuteResultAsync_WithCustomViewComponentHelper_ForLargeText()
{
// Arrange
var expected = new string('a', 64 * 1024 * 1024);
var methodInfo = typeof(TextViewComponent).GetMethod(nameof(TextViewComponent.Invoke));
var descriptor = new ViewComponentDescriptor()
{
FullName = "Full.Name.Text",
ShortName = "Text",
TypeInfo = typeof(TextViewComponent).GetTypeInfo(),
MethodInfo = methodInfo,
Parameters = methodInfo.GetParameters(),
};
var result = Task.FromResult <IHtmlContent>(new HtmlContentBuilder().AppendHtml(expected));
var helper = Mock.Of <IViewComponentHelper>(h => h.InvokeAsync(It.IsAny <Type>(), It.IsAny <object>()) == result);
var httpContext = new DefaultHttpContext();
var services = CreateServices(diagnosticListener: null, httpContext, new[] { descriptor });
services.AddSingleton <IViewComponentHelper>(helper);
httpContext.RequestServices = services.BuildServiceProvider();
httpContext.Response.Body = new MemoryStream();
var actionContext = new ActionContext(httpContext, new RouteData(), new ActionDescriptor());
var viewComponentResult = new ViewComponentResult()
{
Arguments = new { name = "World!" },
ViewComponentType = typeof(TextViewComponent),
TempData = _tempDataDictionary,
};
// Act
await viewComponentResult.ExecuteResultAsync(actionContext);
// Assert
var body = ReadBody(actionContext.HttpContext.Response);
Assert.Equal(expected, body);
}
private TagHelperDescriptor CreateDescriptor(ViewComponentDescriptor viewComponentDescriptor)
{
var assemblyName = viewComponentDescriptor.TypeInfo.Assembly.GetName().Name;
var tagName = GetTagName(viewComponentDescriptor);
var typeName = $"__Generated__{viewComponentDescriptor.ShortName}ViewComponentTagHelper";
var tagHelperDescriptor = new TagHelperDescriptor
{
TagName = tagName,
TypeName = typeName,
AssemblyName = assemblyName
};
SetAttributeDescriptors(viewComponentDescriptor, tagHelperDescriptor);
tagHelperDescriptor.PropertyBag.Add(
ViewComponentTagHelperDescriptorConventions.ViewComponentNameKey, viewComponentDescriptor.ShortName);
return(tagHelperDescriptor);
}
public void Constructor_PerformsDefensiveCopies()
{
// Arrange
var httpContext = new DefaultHttpContext();
var actionContext = new ActionContext(httpContext, new RouteData(), new ActionDescriptor());
var viewData = new ViewDataDictionary(new EmptyModelMetadataProvider());
var tempData = new TempDataDictionary(httpContext, Mock.Of <ITempDataProvider>());
var viewContext = new ViewContext(
actionContext,
NullView.Instance,
viewData,
tempData,
TextWriter.Null,
new HtmlHelperOptions());
var viewComponentDescriptor = new ViewComponentDescriptor();
// Act
var viewComponentContext = new ViewComponentContext(
viewComponentDescriptor,
new Dictionary <string, object>(),
new HtmlTestEncoder(),
viewContext,
TextWriter.Null);
// Assert
// New ViewContext but initial View and TextWriter copied over.
Assert.NotSame(viewContext, viewComponentContext.ViewContext);
Assert.Same(tempData, viewComponentContext.TempData);
Assert.Same(viewContext.View, viewComponentContext.ViewContext.View);
Assert.Same(viewContext.Writer, viewComponentContext.ViewContext.Writer);
// Double-check the convenience properties.
Assert.Same(viewComponentContext.ViewContext.ViewData, viewComponentContext.ViewData);
Assert.Same(viewComponentContext.ViewContext.TempData, viewComponentContext.TempData);
Assert.Same(viewComponentContext.ViewContext.Writer, viewComponentContext.Writer);
// New VDD instance but initial ModelMetadata copied over.
Assert.NotSame(viewData, viewComponentContext.ViewData);
Assert.Same(viewData.ModelMetadata, viewComponentContext.ViewData.ModelMetadata);
}
private static ViewComponentContext GetViewComponentContext(IView view, ViewDataDictionary viewData, object diagnosticListener = null)
{
var diagnosticSource = new DiagnosticListener("Microsoft.AspNet");
if (diagnosticListener == null)
{
diagnosticListener = new TestDiagnosticListener();
}
diagnosticSource.SubscribeWithAdapter(diagnosticListener);
var serviceProvider = new Mock <IServiceProvider>();
serviceProvider.Setup(s => s.GetService(typeof(DiagnosticSource))).Returns(diagnosticSource);
var httpContext = new DefaultHttpContext();
httpContext.RequestServices = serviceProvider.Object;
var actionContext = new ActionContext(httpContext, new RouteData(), new ActionDescriptor());
var viewContext = new ViewContext(
actionContext,
view,
viewData,
new TempDataDictionary(new HttpContextAccessor(), new SessionStateTempDataProvider()),
TextWriter.Null,
new HtmlHelperOptions());
var viewComponentDescriptor = new ViewComponentDescriptor()
{
Type = typeof(object),
};
var viewComponentContext = new ViewComponentContext(
viewComponentDescriptor,
new object[0],
viewContext,
TextWriter.Null);
return(viewComponentContext);
}
private async Task <IHtmlContent> InvokeCoreAsync(ViewComponentDescriptor descriptor, object arguments)
{
var argumentDictionary = GetArgumentDictionary(descriptor, arguments);
var viewBuffer = new ViewBuffer(_viewBufferScope, descriptor.FullName, ViewBuffer.ViewComponentPageSize);
using (var writer = new ViewBufferTextWriter(viewBuffer, _viewContext.Writer.Encoding))
{
var context = new ViewComponentContext(descriptor, argumentDictionary, _htmlEncoder, _viewContext, writer);
var invoker = _invokerFactory.CreateInstance(context);
if (invoker == null)
{
throw new InvalidOperationException($"ViewComponentFactory_ReturnedNull:{descriptor.FullName}");
}
await invoker.InvokeAsync(context);
return(viewBuffer);
}
}
public async Task ExecuteResultAsync_ExecutesViewComponent_AndWritesDiagnosticSource()
{
// Arrange
var methodInfo = typeof(TextViewComponent).GetMethod(nameof(TextViewComponent.Invoke));
var descriptor = new ViewComponentDescriptor()
{
FullName = "Full.Name.Text",
ShortName = "Text",
TypeInfo = typeof(TextViewComponent).GetTypeInfo(),
MethodInfo = methodInfo,
Parameters = methodInfo.GetParameters(),
};
var adapter = new TestDiagnosticListener();
var actionContext = CreateActionContext(adapter, descriptor);
var viewComponentResult = new ViewComponentResult()
{
Arguments = new { name = "World!" },
ViewComponentName = "Text",
TempData = _tempDataDictionary,
};
// Act
await viewComponentResult.ExecuteResultAsync(actionContext);
// Assert
var body = ReadBody(actionContext.HttpContext.Response);
Assert.Equal("Hello, World!", body);
Assert.NotNull(adapter.BeforeViewComponent?.ActionDescriptor);
Assert.NotNull(adapter.BeforeViewComponent?.ViewComponentContext);
Assert.NotNull(adapter.BeforeViewComponent?.ViewComponent);
Assert.NotNull(adapter.AfterViewComponent?.ActionDescriptor);
Assert.NotNull(adapter.AfterViewComponent?.ViewComponentContext);
Assert.NotNull(adapter.AfterViewComponent?.ViewComponentResult);
Assert.NotNull(adapter.AfterViewComponent?.ViewComponent);
}
/// <summary>
/// Creates a <see cref="ViewComponentDescriptor"/> by inspecting the
/// specified view component type.
/// </summary>
/// <param name="viewComponentType">Type of the view component.</param>
/// <returns></returns>
public ViewComponentDescriptor Collect(Type viewComponentType)
{
if (viewComponentType == null) throw new ArgumentNullException("viewComponentType");
if (type2Desc.ContainsKey(viewComponentType))
{
return type2Desc[viewComponentType];
}
object[] attrs = viewComponentType.GetCustomAttributes(typeof(ViewComponentDetailsAttribute), true);
ViewComponentDescriptor descriptor;
if (attrs.Length == 0)
{
descriptor = ViewComponentDescriptor.Empty;
}
else
{
ViewComponentDetailsAttribute details = (ViewComponentDetailsAttribute) attrs[0];
IViewComponentCacheKeyGenerator generator = null;
if (details.Cache == ViewComponentCache.Always)
{
generator = new AlwaysCacheKeyGenerator();
}
else if (details.CacheKeyFactory != null)
{
try
{
generator = (IViewComponentCacheKeyGenerator)
Activator.CreateInstance(details.CacheKeyFactory);
}
catch(Exception ex)
{
throw new MonoRailException(
"Could not instantiate IViewComponentCacheKeyGenerator implementation or " +
"it does not implement this interface. Type: " + details.CacheKeyFactory.FullName, ex);
}
}
descriptor = new ViewComponentDescriptor(details.Cache != ViewComponentCache.Disabled, details.Cache, generator);
}
type2Desc[viewComponentType] = descriptor;
return descriptor;
}
