public void ShouldThrowExceptionOnInitializationIfCalledWithTheSameMethodCallId() { const int MethodCallId = 123; TestInitializationContext context = new TestInitializationContext(null, typeof(string).GetMethod("Intern"), new object[0]); this.actionDiscoverer.GetInitializationActions(context).Returns(new[] { new InitializationAction("Action1"), new InitializationAction("Action2") }); this.manager.Initialize(MethodCallId, context); Assert.ThrowsDelegate action = () => this.manager.Initialize(MethodCallId, context); Assert.Throws<InvalidOperationException>(action); }
/// <summary> /// Gets initialization actions. /// </summary> /// <param name="context">The initialization context.</param> /// <returns>List of discovered initialization actions.</returns> public sealed override IEnumerable <InitializationAction> GetInitializationActions(object context) { if (context == null) { throw new ArgumentNullException("context"); } TestInitializationContext initializationContext = context as TestInitializationContext; if (initializationContext == null) { throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, "Only contexts derived from '{0}' are supported.", typeof(TestInitializationContext).AssemblyQualifiedName)); } return(this.GetInitializationActions(initializationContext)); }
public void ShouldDiscoverAndExecuteInitializersInOrderOnInitialization() { const int MethodCallId = 123; TestInitializationContext context = new TestInitializationContext(null, typeof(string).GetMethod("Intern"), new object[0]); this.actionDiscoverer.GetInitializationActions(context).Returns(new[] { new InitializationAction("Action1"), new InitializationAction("Action2") }); this.manager.Initialize(MethodCallId, context); Received.InOrder( () => { this.actionExecutor.ExecuteInitializationForAction(Arg.Is<InitializationAction>(action => action.Id == "Action1")); this.actionExecutor.ExecuteInitializationForAction(Arg.Is<InitializationAction>(action => action.Id == "Action2")); }); }
/// <summary> /// Gets initialization actions. /// </summary> /// <param name="context">The test initialization context.</param> /// <returns>List of discovered initialization actions.</returns> protected virtual IEnumerable<InitializationAction> GetInitializationActions(TestInitializationContext context) { if (context == null) { throw new ArgumentNullException("context"); } List<InitializationHandlerAttribute> attributes = Utility.GetAttributes<InitializationHandlerAttribute>(context.Instance.GetType()); attributes.AddRange(Utility.GetAttributes<InitializationHandlerAttribute>(context.Method)); attributes.Sort(InitializationHandlerAttributePriorityComparer.Default); List<InitializationAction> result = new List<InitializationAction>(); foreach (InitializationHandlerAttribute initializationHandlerAttribute in attributes) { result.Add(Utility.InitializationActionFromInitializationHandlerAttribute(initializationHandlerAttribute, context)); } return result; }
public void ShouldEnumerateAndSubstituteValuesForAppropriateParameters() { Action<IComparable, IEnumerable, IDisposable> testDelegate = this.TestMethod; object[] intactParameter = new object[0]; object[] arguments = { null, intactParameter, null }; TestInitializationContext context = new TestInitializationContext(testDelegate.Target, testDelegate.Method, arguments); this.provider.SetInitializationContext(context); Assert.Equal(5, this.provider.ReceivedCalls().Count()); this.provider.Received().TestNeedToProvideValue(Arg.Is<object>(obj => obj == null), Arg.Is<ParameterInfo>(parameter => parameter.Position == 0)); this.provider.Received().TestNeedToProvideValue(Arg.Is<object[]>(obj => obj.Length == 0), Arg.Is<ParameterInfo>(parameter => parameter.Position == 1)); this.provider.Received().TestNeedToProvideValue(Arg.Is<object>(obj => obj == null), Arg.Is<ParameterInfo>(parameter => parameter.Position == 2)); this.provider.Received().TestResolveValue(Arg.Is<object>(obj => obj == null), Arg.Is<ParameterInfo>(parameter => parameter.Position == 0)); this.provider.DidNotReceive().TestResolveValue(Arg.Is<object[]>(obj => obj.Length == 0), Arg.Is<ParameterInfo>(parameter => parameter.Position == 1)); this.provider.Received().TestResolveValue(Arg.Is<object>(obj => obj == null), Arg.Is<ParameterInfo>(parameter => parameter.Position == 2)); }
public void ShouldDiscoverActionsByInitializationHandlerAttributes() { const string Argument = "argument"; TestInitializationActionDiscoverer actionDiscoverer = new TestInitializationActionDiscoverer(); Test test = new Test(); IEnumerable<InitializationAction> actions = actionDiscoverer.GetInitializationActions(new TestInitializationContext(test, typeof(Test).GetMethod("TestMethod"), new object[] { Argument })).ToArray(); Assert.Equal(1, actions.Count()); TestInitializationContext expectedInitializationContext = new TestInitializationContext(test, typeof(Test).GetMethod("TestMethod"), new object[] { Argument }); Assert.Equal(typeof(InitializationHandler1).AssemblyQualifiedName, actions.Single().Id); Assert.IsType<InitializationHandler>(actions.Single().State); Assert.Equal(typeof(InitializationHandler1), ((InitializationHandler)actions.Single().State).Type); Assert.Equal(new object[] { "parameter" }, ((InitializationHandler)actions.Single().State).Arguments); Assert.Equal(expectedInitializationContext.Instance, ((TestInitializationContext)actions.Single().Context).Instance); Assert.Equal(expectedInitializationContext.Method, ((TestInitializationContext)actions.Single().Context).Method); Assert.Equal(expectedInitializationContext.Arguments, ((TestInitializationContext)actions.Single().Context).Arguments); }
/// <summary> /// Gets initialization actions. /// </summary> /// <param name="context">The test initialization context.</param> /// <returns>List of discovered initialization actions.</returns> protected virtual IEnumerable <InitializationAction> GetInitializationActions(TestInitializationContext context) { if (context == null) { throw new ArgumentNullException("context"); } List <InitializationHandlerAttribute> attributes = Utility.GetAttributes <InitializationHandlerAttribute>(context.Instance.GetType()); attributes.AddRange(Utility.GetAttributes <InitializationHandlerAttribute>(context.Method)); attributes.Sort(InitializationHandlerAttributePriorityComparer.Default); List <InitializationAction> result = new List <InitializationAction>(); foreach (InitializationHandlerAttribute initializationHandlerAttribute in attributes) { result.Add(Utility.InitializationActionFromInitializationHandlerAttribute(initializationHandlerAttribute, context)); } return(result); }
public void ShouldSetInitializationContextIfInitializationHandlerImplementsIInitializationContextAware() { InitializationActionExecutor executor = new InitializationActionExecutor(); TestInitializationContext context = new TestInitializationContext(null, typeof(string).GetMethod("Intern"), new object[0]); InitializationAction action = new InitializationAction("Action") { State = new InitializationHandler(typeof(InitializationContextAwareInitializer), new object[0]), Context = context }; InitializationContextAwareInitializer.InitializationContext = null; executor.ExecuteInitializationForAction(action); Assert.Equal(context, InitializationContextAwareInitializer.InitializationContext); }