/// <summary> /// Creates a test command for use in running this test. /// </summary> /// <returns></returns> public static TestCommand MakeTestCommand(TestMethod test) { // Command to execute test TestCommand command = new TestMethodCommand(test); // Add any wrappers to the TestMethodCommand foreach (IWrapTestMethod wrapper in test.Method.GetCustomAttributes <IWrapTestMethod>(true)) { command = wrapper.Wrap(command); } // Wrap in TestActionCommand command = new TestActionCommand(command); // Wrap in SetUpTearDownCommand command = new SetUpTearDownCommand(command); // Add wrappers that apply before setup and after teardown foreach (ICommandWrapper decorator in test.Method.GetCustomAttributes <IWrapSetUpTearDown>(true)) { command = decorator.Wrap(command); } // Add command to set up context using attributes that implement IApplyToContext IApplyToContext[] changes = test.Method.GetCustomAttributes <IApplyToContext>(true); if (changes.Length > 0) { command = new ApplyChangesToContextCommand(command, changes); } return(command); }
/// <summary> /// Creates a test command for use in running this test. /// </summary> /// <returns></returns> public static TestCommand MakeTestCommand(TestMethod test) { if (test.RunState != RunState.Runnable && test.RunState != RunState.Explicit) { return(new SkipCommand(test)); } // Command to execute test TestCommand command = new TestMethodCommand(test); // Wrap in TestActionCommand command = new TestActionCommand(command); // Wrap in SetUpTearDownCommand command = new SetUpTearDownCommand(command); // Add commands from Decorators supplied by attributes foreach (ICommandDecorator decorator in test.Method.GetCustomAttributes(typeof(ICommandDecorator), true)) { command = decorator.Decorate(command); } // Add command to set up context using attributes that implement IApplyToContext IApplyToContext[] changes = (IApplyToContext[])test.Method.GetCustomAttributes(typeof(IApplyToContext), true); if (changes.Length > 0) { command = new ApplyChangesToContextCommand(command, changes); } return(command); }
/// <summary> /// Gets the command to be executed before any of /// the child tests are run. /// </summary> /// <returns>A TestCommand</returns> public static TestCommand MakeOneTimeSetUpCommand(TestSuite suite, List<SetUpTearDownItem> setUpTearDown, List<TestActionItem> actions) { // Handle skipped tests if (suite.RunState != RunState.Runnable && suite.RunState != RunState.Explicit) return MakeSkipCommand(suite); // Build the OneTimeSetUpCommand itself TestCommand command = new OneTimeSetUpCommand(suite, setUpTearDown, actions); // Prefix with any IApplyToContext items from attributes IList<IApplyToContext> changes = null; if (suite.TypeInfo != null) changes = suite.TypeInfo.GetCustomAttributes<IApplyToContext>(true); else if (suite.Method != null) changes = suite.Method.GetCustomAttributes<IApplyToContext>(true); else { var testAssembly = suite as TestAssembly; if (testAssembly != null) #if PORTABLE changes = new List<IApplyToContext>(testAssembly.Assembly.GetAttributes<IApplyToContext>()); #else changes = (IApplyToContext[])testAssembly.Assembly.GetCustomAttributes(typeof(IApplyToContext), true); #endif } if (changes != null && changes.Count > 0) command = new ApplyChangesToContextCommand(command, changes); return command; }
public void ShouldPassAfter2RepeatsAndTimeoutIsResetEachTime() { // Rather than testing with sleeps, this tests that the execution will occur in the correct // order by checking which commands are run when. As the repeat command comes first, the // timeout will be reset each time it runs var test = TestBuilder.MakeTestFromMethod(typeof(HelperMethodForTimeoutsClass), nameof(HelperMethodForTimeoutsClass.ShouldPassAfter2RepeatsAndTimeoutIsResetEachTime)); SimpleWorkItem work = TestBuilder.CreateWorkItem(test) as SimpleWorkItem; var method = typeof(SimpleWorkItem).GetMethod("MakeTestCommand", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly); TestCommand command = (TestCommand)method.Invoke(work, null); Assert.That(command, Is.TypeOf(typeof(RepeatAttribute.RepeatedTestCommand))); RepeatAttribute.RepeatedTestCommand repeatedCommand = (RepeatAttribute.RepeatedTestCommand)command; command = GetInnerCommand(repeatedCommand); Assert.That(command, Is.TypeOf(typeof(TimeoutCommand))); TimeoutCommand timeoutCommand = (TimeoutCommand)command; command = GetInnerCommand(timeoutCommand); Assert.That(command, Is.TypeOf(typeof(ApplyChangesToContextCommand))); ApplyChangesToContextCommand applyChangesToContextCommand = (ApplyChangesToContextCommand)command; command = GetInnerCommand(applyChangesToContextCommand); Assert.That(command, Is.TypeOf(typeof(TestMethodCommand))); }
/// <summary> /// Gets the command to be executed before any of /// the child tests are run. /// </summary> /// <returns>A TestCommand</returns> public static TestCommand MakeOneTimeSetUpCommand(TestSuite suite, List<SetUpTearDownItem> setUpTearDown, List<TestActionItem> actions) { // Handle skipped tests if (suite.RunState != RunState.Runnable && suite.RunState != RunState.Explicit) return MakeSkipCommand(suite); // Build the OneTimeSetUpCommand itself TestCommand command = new OneTimeSetUpCommand(suite, setUpTearDown, actions); // Prefix with any IApplyToContext items from attributes if (suite.TypeInfo != null) { IApplyToContext[] changes = suite.TypeInfo.GetCustomAttributes<IApplyToContext>(true); if (changes.Length > 0) command = new ApplyChangesToContextCommand(command, changes); } if (suite.Method!=null) { IApplyToContext[] changes = suite.Method.GetCustomAttributes<IApplyToContext>(true); if (changes.Length > 0) command = new ApplyChangesToContextCommand(command, changes); } return command; }
/// <summary> /// Gets the command to be executed before any of /// the child tests are run. /// </summary> /// <returns>A TestCommand</returns> public static TestCommand MakeOneTimeSetUpCommand(TestSuite suite, List <SetUpTearDownItem> setUpTearDown, List <TestActionItem> actions) { // Handle skipped tests if (suite.RunState != RunState.Runnable && suite.RunState != RunState.Explicit) { return(MakeSkipCommand(suite)); } // Build the OneTimeSetUpCommand itself TestCommand command = new OneTimeSetUpCommand(suite, setUpTearDown, actions); // Prefix with any IApplyToContext items from attributes if (suite.TypeInfo != null) { IApplyToContext[] changes = suite.TypeInfo.GetCustomAttributes <IApplyToContext>(true); if (changes.Length > 0) { command = new ApplyChangesToContextCommand(command, changes); } } if (suite.Method != null) { IApplyToContext[] changes = suite.Method.GetCustomAttributes <IApplyToContext>(true); if (changes.Length > 0) { command = new ApplyChangesToContextCommand(command, changes); } } return(command); }
private TestCommand MakeOneTimeSetUpCommand(List <SetUpTearDownItem> setUpTearDown, List <TestActionItem> actions) { TestCommand command = new EmptyTestCommand(Test); // Add Action Commands int index = actions.Count; while (--index >= 0) { command = new BeforeTestActionCommand(command, actions[index]); } if (Test.TypeInfo != null) { // Build the OneTimeSetUpCommands foreach (SetUpTearDownItem item in setUpTearDown) { command = new OneTimeSetUpCommand(command, item); } // Construct the fixture if necessary if (!Test.TypeInfo.IsStaticClass) { command = new ConstructFixtureCommand(command); } } // Prefix with any IApplyToContext items from attributes foreach (var attr in Test.GetCustomAttributes <IApplyToContext>(true)) { command = new ApplyChangesToContextCommand(command, attr); } return(command); }
/// <summary> /// Creates a test command for use in running this test. /// </summary> /// <returns></returns> protected override TestCommand MakeTestCommand() { TestCommand command = new TestMethodCommand(this); command = ApplyDecoratorsToCommand(command); IApplyToContext[] changes = (IApplyToContext[])this.Method.GetCustomAttributes(typeof(IApplyToContext), true); if (changes.Length > 0) { command = new ApplyChangesToContextCommand(command, changes); } return(command); }
/// <summary> /// Gets the command to be executed before any of /// the child tests are run. /// </summary> /// <returns>A TestCommand</returns> public virtual TestCommand GetOneTimeSetUpCommand() { TestCommand command = new OneTimeSetUpCommand(this); if (this.FixtureType != null) { IApplyToContext[] changes = (IApplyToContext[])this.FixtureType.GetCustomAttributes(typeof(IApplyToContext), true); if (changes.Length > 0) { command = new ApplyChangesToContextCommand(command, changes); } } return(command); }
/// <summary> /// Creates a test command for use in running this test. /// </summary> /// <returns></returns> public virtual TestCommand MakeTestCommand() { if (RunState != RunState.Runnable && RunState != RunState.Explicit) { return(new SkipCommand(this)); } TestCommand command = new TestMethodCommand(this); command = ApplyDecoratorsToCommand(command); IApplyToContext[] changes = (IApplyToContext[])this.Method.GetCustomAttributes(typeof(IApplyToContext), true); if (changes.Length > 0) { command = new ApplyChangesToContextCommand(command, changes); } return(command); }
/// <summary> /// Gets the command to be executed before any of /// the child tests are run. /// </summary> /// <returns>A TestCommand</returns> public static TestCommand MakeOneTimeSetUpCommand(TestSuite suite, List <SetUpTearDownItem> setUpTearDown, List <TestActionItem> actions) { // Handle skipped tests if (suite.RunState != RunState.Runnable && suite.RunState != RunState.Explicit) { return(MakeSkipCommand(suite)); } // Build the OneTimeSetUpCommand itself TestCommand command = new OneTimeSetUpCommand(suite, setUpTearDown, actions); // Prefix with any IApplyToContext items from attributes IList <IApplyToContext> changes = null; if (suite.TypeInfo != null) { changes = (IApplyToContext[])suite.TypeInfo.GetCustomAttributes <IApplyToContext>(true); } else if (suite.Method != null) { changes = (IApplyToContext[])suite.Method.GetCustomAttributes <IApplyToContext>(true); } else { var testAssembly = suite as TestAssembly; if (testAssembly != null) #if PORTABLE { //changes = new List<IApplyToContext>(testAssembly.Assembly.GetAttributes<IApplyToContext>()); changes = new List <IApplyToContext>(); } #else { changes = (IApplyToContext[])testAssembly.Assembly.GetCustomAttributes(typeof(IApplyToContext), true); } #endif } if (changes != null && changes.Count > 0) { command = new ApplyChangesToContextCommand(command, changes); } return(command); }
/// <summary> /// Gets the command to be executed before any of /// the child tests are run. /// </summary> /// <returns>A TestCommand</returns> private static TestCommand MakeSetUpCommand(TestSuite suite, SetUpTearDownList setUpTearDown) { if (suite.RunState != RunState.Runnable && suite.RunState != RunState.Explicit) { return(new SkipCommand(suite)); } TestCommand command = new OneTimeSetUpCommand(suite, setUpTearDown); if (suite.FixtureType != null) { IApplyToContext[] changes = (IApplyToContext[])suite.FixtureType.GetCustomAttributes(typeof(IApplyToContext), true); if (changes.Length > 0) { command = new ApplyChangesToContextCommand(command, changes); } } return(command); }
/// <summary> /// Gets the command to be executed before any of /// the child tests are run. /// </summary> /// <returns>A TestCommand</returns> public virtual TestCommand GetOneTimeSetUpCommand() { if (RunState != RunState.Runnable && RunState != RunState.Explicit) { return(new SkipCommand(this)); } TestCommand command = new OneTimeSetUpCommand(this); if (this.FixtureType != null) { IApplyToContext[] changes = (IApplyToContext[])this.FixtureType.GetCustomAttributes(typeof(IApplyToContext), true); if (changes.Length > 0) { command = new ApplyChangesToContextCommand(command, changes); } } return(command); }
/// <summary> /// Creates a test command for use in running this test. /// </summary> /// <returns></returns> public static TestCommand MakeTestCommand(TestMethod test) { if (test.RunState != RunState.Runnable && test.RunState != RunState.Explicit) { return(new SkipCommand(test)); } // Command to execute test TestCommand command = new TestMethodCommand(test); // Add any wrappers to the TestMethodCommand foreach (IWrapTestMethod wrapper in test.Method.GetCustomAttributes(typeof(IWrapTestMethod), true)) { command = wrapper.Wrap(command); } // Wrap in TestActionCommand command = new TestActionCommand(command); // Wrap in SetUpTearDownCommand command = new SetUpTearDownCommand(command); // Add wrappers that apply before setup and after teardown foreach (ICommandWrapper decorator in test.Method.GetCustomAttributes(typeof(IWrapSetUpTearDown), true)) { command = decorator.Wrap(command); } // Add command to set up context using attributes that implement IApplyToContext IApplyToContext[] changes = (IApplyToContext[])test.Method.GetCustomAttributes(typeof(IApplyToContext), true); if (changes.Length > 0) { command = new ApplyChangesToContextCommand(command, changes); } return(command); }
/// <summary> /// Creates a test command for use in running this test. /// </summary> /// <returns></returns> public static TestCommand MakeTestCommand(TestMethod test) { // Command to execute test TestCommand command = new TestMethodCommand(test); // Add any wrappers to the TestMethodCommand foreach (IWrapTestMethod wrapper in test.Method.GetCustomAttributes<IWrapTestMethod>(true)) command = wrapper.Wrap(command); // Wrap in TestActionCommand command = new TestActionCommand(command); // Wrap in SetUpTearDownCommand command = new SetUpTearDownCommand(command); // Add wrappers that apply before setup and after teardown foreach (ICommandWrapper decorator in test.Method.GetCustomAttributes<IWrapSetUpTearDown>(true)) command = decorator.Wrap(command); // Add command to set up context using attributes that implement IApplyToContext IApplyToContext[] changes = test.Method.GetCustomAttributes<IApplyToContext>(true); if (changes.Length > 0) command = new ApplyChangesToContextCommand(command, changes); return command; }
/// <summary> /// Creates a test command for use in running this test. /// </summary> /// <returns>A TestCommand</returns> private TestCommand MakeTestCommand() { if (Test.RunState == RunState.Runnable || Test.RunState == RunState.Explicit && Filter.IsExplicitMatch(Test)) { // Command to execute test TestCommand command = new TestMethodCommand(_testMethod); var method = _testMethod.Method; // Add any wrappers to the TestMethodCommand foreach (IWrapTestMethod wrapper in method.GetCustomAttributes <IWrapTestMethod>(true)) { command = wrapper.Wrap(command); } // Create TestActionCommands using attributes of the method foreach (ITestAction action in Test.Actions) { if (action.Targets == ActionTargets.Default || action.Targets.HasFlag(ActionTargets.Test)) { command = new TestActionCommand(command, action); } } ; // Try to locate the parent fixture. In current implementations, the test method // is either one or two levels levels below the TestFixture - if this changes, // so should the following code. TestFixture parentFixture = Test.Parent as TestFixture ?? Test.Parent?.Parent as TestFixture; // In normal operation we should always get the methods from the parent fixture. // However, some of NUnit's own tests can create a TestMethod without a parent // fixture. Most likely, we should stop doing this, but it affects 100s of cases. var setUpMethods = parentFixture?.SetUpMethods ?? Reflect.GetMethodsWithAttribute(Test.TypeInfo.Type, typeof(SetUpAttribute), true); var tearDownMethods = parentFixture?.TearDownMethods ?? Reflect.GetMethodsWithAttribute(Test.TypeInfo.Type, typeof(TearDownAttribute), true); // Wrap in SetUpTearDownCommands var setUpTearDownList = BuildSetUpTearDownList(setUpMethods, tearDownMethods); foreach (var item in setUpTearDownList) { command = new SetUpTearDownCommand(command, item); } // In the current implementation, upstream actions only apply to tests. If that should change in the future, // then actions would have to be tested for here. For now we simply assert it in Debug. We allow // ActionTargets.Default, because it is passed down by ParameterizedMethodSuite. int index = Context.UpstreamActions.Count; while (--index >= 0) { ITestAction action = Context.UpstreamActions[index]; System.Diagnostics.Debug.Assert( action.Targets == ActionTargets.Default || action.Targets.HasFlag(ActionTargets.Test), "Invalid target on upstream action: " + action.Targets.ToString()); command = new TestActionCommand(command, action); } // Add wrappers that apply before setup and after teardown foreach (ICommandWrapper decorator in method.GetCustomAttributes <IWrapSetUpTearDown>(true)) { command = decorator.Wrap(command); } // Add command to set up context using attributes that implement IApplyToContext foreach (var attr in method.GetCustomAttributes <IApplyToContext>(true)) { command = new ApplyChangesToContextCommand(command, attr); } // If a timeout is specified, create a TimeoutCommand #if !NETSTANDARD1_6 // Timeout set at a higher level int timeout = Context.TestCaseTimeout; // Timeout set on this test if (Test.Properties.ContainsKey(PropertyNames.Timeout)) { timeout = (int)Test.Properties.Get(PropertyNames.Timeout); } if (timeout > 0) { command = new TimeoutCommand(command, timeout); } #endif return(command); } else { return(new SkipCommand(_testMethod)); } }
/// <summary> /// Creates a test command for use in running this test. /// </summary> /// <returns></returns> public static TestCommand MakeTestCommand(TestMethod test) { if (test.RunState != RunState.Runnable && test.RunState != RunState.Explicit) return new SkipCommand(test); // Command to execute test TestCommand command = new TestMethodCommand(test); // Add any wrappers to the TestMethodCommand foreach (IWrapTestMethod wrapper in test.Method.GetCustomAttributes(typeof(IWrapTestMethod), true)) command = wrapper.Wrap(command); // Wrap in TestActionCommand command = new TestActionCommand(command); // Wrap in SetUpTearDownCommand command = new SetUpTearDownCommand(command); // Add wrappers that apply before setup and after teardown foreach (ICommandWrapper decorator in test.Method.GetCustomAttributes(typeof(IWrapSetUpTearDown), true)) command = decorator.Wrap(command); // Add command to set up context using attributes that implement IApplyToContext IApplyToContext[] changes = (IApplyToContext[])test.Method.GetCustomAttributes(typeof(IApplyToContext), true); if (changes.Length > 0) command = new ApplyChangesToContextCommand(command, changes); return command; }