public void Activate_UsesPassedInViewDataDictionaryInstance_IfPassedInTypeMatches()
{
// Arrange
var typeActivator = new TypeActivator();
var activator = new RazorPageActivator(typeActivator);
var instance = new TestRazorPage();
var myService = new MyService();
var helper = Mock.Of <IHtmlHelper <object> >();
var serviceProvider = new Mock <IServiceProvider>();
serviceProvider.Setup(p => p.GetService(typeof(MyService)))
.Returns(myService);
serviceProvider.Setup(p => p.GetService(typeof(IHtmlHelper <object>)))
.Returns(helper);
var httpContext = new Mock <HttpContext>();
httpContext.SetupGet(c => c.RequestServices)
.Returns(serviceProvider.Object);
var routeContext = new RouteContext(httpContext.Object);
var actionContext = new ActionContext(routeContext, new ActionDescriptor());
var viewData = new ViewDataDictionary <MyModel>(Mock.Of <IModelMetadataProvider>())
{
Model = new MyModel()
};
var viewContext = new ViewContext(actionContext,
Mock.Of <IView>(),
viewData,
TextWriter.Null);
// Act
activator.Activate(instance, viewContext);
// Assert
Assert.Same(viewData, viewContext.ViewData);
}
public static ISelectListDataSource GetDataSource(this ModelMetadata modelMetadata)
{
ISelectListDataSource dataSource = null;
if (modelMetadata is BzwayModelMetadata)
{
var dataSourceAttribute = ((BzwayModelMetadata)modelMetadata).DataSourceAttribute;
if (dataSourceAttribute != null)
{
dataSource = (ISelectListDataSource)TypeActivator.CreateInstance(dataSourceAttribute.DataSourceType);
}
if (dataSource == null)
{
dataSource = ((BzwayModelMetadata)modelMetadata).DataSource;
}
}
else
{
}
if (dataSource == null)
{
return(new EmptySelectListDataSource());
}
else
{
return(dataSource);
}
}
/// <summary>
/// Returns the handler instance from the dependency resolver if there is one registered
/// else returns the activator that calls the default constructor for the give handlerType.
/// </summary>
/// <param name="request">
/// The request.
/// </param>
/// <param name="descriptor">
/// The handler descriptor.
/// </param>
/// <param name="activator">
/// The activator.
/// </param>
/// <returns>
/// The handler.
/// </returns>
private THandler GetInstanceOrActivator(HandlerRequest request, HandlerDescriptor descriptor, out Func <THandler> activator)
{
Contract.Requires(request != null);
Contract.Requires(descriptor != null);
// If dependency resolver returns handler object then use it.
THandler instance = (THandler)request.GetDependencyScope().GetService(descriptor.HandlerType);
if (instance != null)
{
activator = null;
return(instance);
}
switch (descriptor.Lifetime)
{
case HandlerLifetime.Singleton:
activator = this.CreateSingletonActivator(descriptor.HandlerType);
return(null);
case HandlerLifetime.PerRequest:
activator = CreatePerRequestActivator(request, descriptor);
return(null);
case HandlerLifetime.Transient:
activator = TypeActivator.Create <THandler>(descriptor.HandlerType);
return(null);
default:
throw Error.InvalidEnumArgument("descriptor", (int)descriptor.Lifetime, typeof(HandlerLifetime));
}
}
internal static IHandlerResultConverter GetResultConverter(Type type)
{
if (type != null && type.IsGenericParameter)
{
// This can happen if somebody declares an action method as:
// public T Get<T>() { }
throw Error.InvalidOperation(Resources.CommandHandlerDescriptor_NoConverterForGenericParamterTypeExists, type);
}
if (type == null || type == typeof(void))
{
return(VoidResultConverter);
}
if (typeof(HandlerResponse).IsAssignableFrom(type))
{
return(ResponseMessageResultConverter);
}
if (typeof(ICommandHandlerResult).IsAssignableFrom(type))
{
return(null);
}
Type valueConverterType = typeof(ValueResultConverter <>).MakeGenericType(type);
return(TypeActivator.Create <IHandlerResultConverter>(valueConverterType).Invoke());
}
/// <summary>
/// Initializes a new instance of the <see cref="ViewModelDialog{TEntity}"/> class.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="commonServices">The common services.</param>
/// <param name="logger">The logger factory.</param>
/// <param name="automaticValidation"></param>
protected ViewModelDialog(
IContext context,
IBaseCommonServices commonServices,
ILogger logger,
bool automaticValidation = false)
: base(context, commonServices, logger, automaticValidation)
{
Validator = new Action <IObservableClass>(arg =>
{
if (arg is ViewModelDialog <TEntity> vm &&
vm.SelectedItem is IObservableClass selectedItem)
{
if (!selectedItem.Validate())
{
foreach (var error in selectedItem.Errors)
{
vm.Properties[nameof(vm.SelectedItem)].Errors.Add(error);
}
}
}
});
SelectedItem = TypeActivator.CreateInstance <TEntity>();
IsNew = true;
Submit_Command = new Command <TEntity>(async e => await SubmitAsync(e));
}
public void ForeverFrameTransportDisablesRequestBuffering()
{
var qs = new Dictionary <string, string> {
{ "frameId", "1" }
};
var context = new TestContext("/", qs);
var sp = ServiceProviderHelper.CreateServiceProvider();
var ta = new TypeActivator();
var ms = new MemoryStream();
var buffering = new Mock <IHttpBufferingFeature>();
context.MockHttpContext.Setup(m => m.GetFeature <IHttpBufferingFeature>())
.Returns(buffering.Object);
context.MockResponse.SetupAllProperties();
context.MockResponse.Setup(m => m.Body).Returns(ms);
var fft = ta.CreateInstance <ForeverFrameTransport>(sp, context.MockHttpContext.Object);
fft.ConnectionId = "1";
var connection = new Mock <ITransportConnection>();
fft.InitializeResponse(connection.Object).Wait();
buffering.Verify(m => m.DisableRequestBuffering(), Times.Once());
}
public void Activate_DeterminesModelTypeFromProperty()
{
// Arrange
var typeActivator = new TypeActivator();
var activator = new RazorPageActivator(typeActivator);
var instance = new DoesNotDeriveFromRazorPageOfTButHasModelProperty();
var myService = new MyService();
var helper = Mock.Of <IHtmlHelper <object> >();
var serviceProvider = new Mock <IServiceProvider>();
serviceProvider.Setup(p => p.GetService(typeof(MyService)))
.Returns(myService);
serviceProvider.Setup(p => p.GetService(typeof(IHtmlHelper <object>)))
.Returns(helper);
var httpContext = new Mock <HttpContext>();
httpContext.SetupGet(c => c.RequestServices)
.Returns(serviceProvider.Object);
var routeContext = new RouteContext(httpContext.Object);
var actionContext = new ActionContext(routeContext, new ActionDescriptor());
var viewData = new ViewDataDictionary(Mock.Of <IModelMetadataProvider>());
var viewContext = new ViewContext(actionContext,
Mock.Of <IView>(),
viewData,
TextWriter.Null);
// Act
activator.Activate(instance, viewContext);
// Assert
Assert.IsType <ViewDataDictionary <string> >(viewContext.ViewData);
}
public void ViewEngine_ReturnsInstantiatedListOfViewEngines()
{
// Arrange
var service = Mock.Of <ITestService>();
var valueProviderFactory = Mock.Of <IValueProviderFactory>();
var type = typeof(TestValueProviderFactory);
var typeActivator = new TypeActivator();
var serviceProvider = new Mock <IServiceProvider>();
serviceProvider.Setup(p => p.GetService(typeof(ITestService)))
.Returns(service);
var options = new MvcOptions();
options.ValueProviderFactories.Add(valueProviderFactory);
options.ValueProviderFactories.Add(type);
var accessor = new Mock <IOptions <MvcOptions> >();
accessor.SetupGet(a => a.Options)
.Returns(options);
var provider = new DefaultValueProviderFactoryProvider(accessor.Object,
typeActivator,
serviceProvider.Object);
// Act
var result = provider.ValueProviderFactories;
// Assert
Assert.Equal(2, result.Count);
Assert.Same(valueProviderFactory, result[0]);
var testValueProviderFactory = Assert.IsType <TestValueProviderFactory>(result[1]);
Assert.Same(service, testValueProviderFactory.Service);
}
public void EnsureHubThrowsWhenCantResolve()
{
var sp = ServiceProviderHelper.CreateServiceProvider();
var ta = new TypeActivator();
var hubManager = ta.CreateInstance <DefaultHubManager>(sp);
Assert.Throws <InvalidOperationException>(() => hubManager.EnsureHub("__ELLO__"));
}
private void OnSerialized(StreamingContext context)
{
// Always ensure CommerceDataSource is not null, otherwise we are not able to deserialize it in data contract
if (CommerceDataSource == null)
{
CommerceDataSource = TypeActivator.CreateInstance(Type.GetType(CommerceDataSourceType, true)) as ICommerceDataSource;
}
}
private ConstructorDescriptor ActivatorConstructorDescriptor()
{
var _constructorInfos = DescriptorType.GetConstructors();
var _resolveConstructor = (ConstructorInfo)null;
foreach (var _constructorInfo in _constructorInfos)
{
if (Attribute.IsDefined(_constructorInfo, typeof(ResolveConstructorAttribute)))
{
if (_constructorInfo.IsStatic)
{
throw new ResolveResourceException(string.Format(RESOLVECONST_MUSTBE_INSTANCE, DescriptorType.FullName), DescriptorType);
}
if (_resolveConstructor != null)
{
throw new ResolveResourceException(string.Format(RESOLVECONST_ONLYONCE, DescriptorType.FullName), DescriptorType);
}
if (DescriptorType.IsAbstract)
{
throw new ResolveResourceException(string.Format(RESOLVECONST_CANNOTBE_ABSTRACT, DescriptorType.FullName), DescriptorType);
}
_resolveConstructor = _constructorInfo;
}
}
// else we try to get a public and parameter-less constructor
if (_resolveConstructor == null)
{
_resolveConstructor = DescriptorType.GetConstructor(BindingFlags.Public | BindingFlags.Instance, null, EMPTY_PARAMETERS, null);
if (_resolveConstructor == null)
{
_resolveConstructor = DescriptorType.GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, EMPTY_PARAMETERS, null);
}
if (_resolveConstructor == null)
{
throw new ResolveResourceException(string.Format(BUILD_MUSTHAVE_DEFAULTCONST, DescriptorType.FullName), DescriptorType);
}
}
var _constructor = new ConstructorDescriptor();
_constructor.Constructor = _resolveConstructor;
var _parameters = _resolveConstructor.GetParameters();
if (_parameters.Length == 0)
{
_constructor.ConstructorDelegate = TypeActivator.CreateConstructorDelegate(_resolveConstructor);
_constructor.ParameterDescriptors = Enumerable.Empty <ParameterDescriptor>();
}
else
{
_constructor.ConstructorParameterDelegate = TypeActivator.CreateConstructorParametersDelegate(_resolveConstructor);
_constructor.ParameterDescriptors = ResolveConstructorParametersDescriptor(_parameters);
}
return(_constructor);
}
private static Func <THandler> CreateDelegatingActivator(Type handlerType)
{
Contract.Requires(handlerType != null);
Func <THandler> activator = TypeActivator.Create <THandler>(handlerType);
THandler instance = activator();
return(() => instance);
}
public void ResolveInvalidHub()
{
var sp = ServiceProviderHelper.CreateServiceProvider();
var ta = new TypeActivator();
var hubManager = ta.CreateInstance <DefaultHubManager>(sp);
var hubDescriptor = hubManager.ResolveHub("____CoreTestHub____");
Assert.Null(hubDescriptor);
}
public void GetInValidHub()
{
var sp = ServiceProviderHelper.CreateServiceProvider();
var ta = new TypeActivator();
var hubManager = ta.CreateInstance <DefaultHubManager>(sp);
var hubDescriptor = hubManager.GetHub("__ELLO__");
Assert.Null(hubDescriptor);
}
protected override async Task GenerateCode()
{
var destinationPath = Path.Combine(ApplicationEnvironment.ApplicationBasePath, Constants.ViewsFolderName,
Constants.SharedViewsFolderName);
await CopyFolderContentsRecursive(destinationPath, TemplateFolders.First());
var staticFilesInstaller = TypeActivator.CreateInstance <StaticFilesDependencyInstaller>(ServiceProvider);
await staticFilesInstaller.Execute();
}
public void GetValidHubMethodsWithPredicate()
{
var sp = ServiceProviderHelper.CreateServiceProvider();
var ta = new TypeActivator();
var hubManager = ta.CreateInstance <DefaultHubManager>(sp);
var methodDescriptors = hubManager.GetHubMethods("CoreTestHubWithMethod", descriptor => descriptor.Name == "AddNumbers");
Assert.NotNull(methodDescriptors);
Assert.Equal(methodDescriptors.First().Name, "AddNumbers");
}
public void GetValidHub()
{
var sp = ServiceProviderHelper.CreateServiceProvider();
var ta = new TypeActivator();
var hubManager = ta.CreateInstance <DefaultHubManager>(sp);
var hubDescriptor = hubManager.GetHub("CoreTestHub");
Assert.NotNull(hubDescriptor);
Assert.False(hubDescriptor.NameSpecified);
}
public void ResolveHubsIsNotEmpty()
{
var sp = ServiceProviderHelper.CreateServiceProvider();
var ta = new TypeActivator();
var hubManager = ta.CreateInstance <DefaultHubManager>(sp);
var hubDescriptor = hubManager.ResolveHubs();
Assert.NotNull(hubDescriptor);
Assert.NotEmpty(hubDescriptor);
}
public void CreateInstanceWithArgs3()
{
var arr = new byte[20];
var expected = new ArraySegment <byte>(arr, 10, 10);
var actual = (ArraySegment <byte>)TypeActivator.CreateInstance(typeof(ArraySegment <byte>), arr, 10, 10);
Assert.Equal(expected.Array, actual.Array);
Assert.Equal(expected.Offset, actual.Offset);
Assert.Equal(expected.Count, actual.Count);
}
public void GetHubMethodFromInvalidHub()
{
var sp = ServiceProviderHelper.CreateServiceProvider();
var ta = new TypeActivator();
var hubManager = ta.CreateInstance <DefaultHubManager>(sp);
// There is no ________________CoreTestHubWithMethod________________ name
var methodDescriptor = hubManager.GetHubMethod("________________CoreTestHubWithMethod________________", "AddNumbers", new IJsonValue[] { null, null });
Assert.Null(methodDescriptor);
}
public void GetInvalidHubMethod()
{
var sp = ServiceProviderHelper.CreateServiceProvider();
var ta = new TypeActivator();
var hubManager = ta.CreateInstance <DefaultHubManager>(sp);
// The AddNumbers method has 2 parameters, so should not find the method
var methodDescriptor = hubManager.GetHubMethod("CoreTestHubWithMethod", "AddNumbers", null);
Assert.Null(methodDescriptor);
}
public void GetValidHubsWithValidPredicate()
{
var sp = ServiceProviderHelper.CreateServiceProvider();
var ta = new TypeActivator();
var hubManager = ta.CreateInstance <DefaultHubManager>(sp);
var hubDescriptors = hubManager.GetHubs(descriptor => descriptor.Name == "CoreTestHub");
Assert.NotNull(hubDescriptors);
Assert.Equal(hubDescriptors.First().Name, "CoreTestHub");
}
public void ShouldNotResolveHubByTypeNameIfAttributeExists()
{
var sp = ServiceProviderHelper.CreateServiceProvider();
var ta = new TypeActivator();
var hubResolver = ta.CreateInstance <ReflectedHubDescriptorProvider>(sp);
HubDescriptor hub;
hubResolver.TryGetHub("HubWithAttribute", out hub);
Assert.Null(hub);
}
public void ShouldIgnoreCaseWhenDiscoveringHubsUsingManager()
{
var sp = ServiceProviderHelper.CreateServiceProvider();
var ta = new TypeActivator();
var manager = ta.CreateInstance <DefaultHubManager>(sp);
var hub = manager.GetHub("hubwithoutattribute");
Assert.NotNull(hub);
Assert.Equal(hub.Name, "HubWithoutAttribute");
Assert.Equal(hub.NameSpecified, false);
}
private Rule DeserializeAlways(EventSlot slot, XElement element)
{
var rule = (AlwaysRule)TypeActivator.CreateInstance(typeof(AlwaysRule));
foreach (var activityElement in element.Elements("activity"))
{
rule.Activities.Add(DeserializeActivity(activityElement));
}
return(rule);
}
public PriceCalculator()
{
var modules = new List <IPriceCalculationModule>();
foreach (var type in PriceCalculationModules.Modules)
{
modules.Add((IPriceCalculationModule)TypeActivator.CreateInstance(type));
}
_modules = modules;
}
public override object ResolveValue(RuleParameter param, object dataContext)
{
var referenceResolver = TypeActivator.CreateInstance(_referenceResolverType) as IReferenceResolver;
if (referenceResolver == null)
{
throw new InvalidOperationException("Cannot resolve reference resolver type: " + _referenceResolverType + ".");
}
return(referenceResolver.Resolve(_referencingType, dataContext));
}
public static void TestSet17_Method1()
{
//TestSet7
var container = new Container();
container.RegisterType <Type>();
var typeActivator = new TypeActivator();
var runtimeType = new RuntimeType(typeActivator, new InjectionAttribute("Build.Tests.TestSet17.Type"), typeof(Type), true);
runtimeType.SetRuntimeInstance(RuntimeInstance.CreateInstance);
Assert.Throws <TypeInstantiationException>(() => runtimeType.CreateInstance(new object[] { "Build.Tests.TestSet17.Type" }));
}
public static void Method1_3()
{
//TestSet7
var container = new Container();
container.RegisterType <Type>();
var typeActivator = new TypeActivator();
var injectionAttribute = new InjectionAttribute("TestSet17.Type");
var type = (System.Type)null;
Assert.Throws <System.ArgumentNullException>(() => new RuntimeType(typeActivator, injectionAttribute, type, true));
}
public void GetValidHubsWithInvalidPredicate()
{
var sp = ServiceProviderHelper.CreateServiceProvider();
var ta = new TypeActivator();
var hubManager = ta.CreateInstance <DefaultHubManager>(sp);
var hubDescriptors = hubManager.GetHubs(descriptor => descriptor.Name == "CoreTestHub_INVALIDHUB_____");
// Still have an ienumerable sequence
Assert.NotNull(hubDescriptors);
// But there's nothing in the ienumerable
Assert.Empty(hubDescriptors);
}