Example #1
0
 protected UntaggedHooksFirstExecutionProcessor(IExecutionOrchestrator executionOrchestrator,
                                                IAssemblyLoader assemblyLoader,
                                                IReflectionWrapper reflectionWrapper)
     : base(executionOrchestrator, assemblyLoader, reflectionWrapper)
 {
     Strategy = new UntaggedHooksFirstStrategy();
 }
Example #2
0
        public void ShouldFetchTaggedHooksAfterUntaggedHooks()
        {
            var applicableHooks = new UntaggedHooksFirstStrategy().GetApplicableHooks(new List <string> {
                "Foo"
            }, _hookMethods).ToList();

            AssertEx.ContainsMethods(new[] { applicableHooks[0], applicableHooks[1] }, "Blah", "Zed");
        }
Example #3
0
        public void ShouldFetchTaggedHooksInSortedOrder()
        {
            var applicableHooks = new UntaggedHooksFirstStrategy().GetApplicableHooks(new List <string> {
                "Foo"
            }, _hookMethods).ToList();

            Assert.That(applicableHooks[0].Name, Is.EqualTo("Blah"));
            Assert.That(applicableHooks[1].Name, Is.EqualTo("Zed"));
        }
        public void ShouldFetchTaggedHooksAfterUntaggedHooks()
        {
            var applicableHooks = new UntaggedHooksFirstStrategy().GetApplicableHooks(new List <string> {
                "Foo"
            }, _hookMethods).ToList();

            Assert.That(applicableHooks[0], Is.EqualTo(GetType().GetMethod("Blah").FullyQuallifiedName()));
            Assert.That(applicableHooks[1], Is.EqualTo(GetType().GetMethod("Zed").FullyQuallifiedName()));
        }
        public void ShouldFetchUntaggedHooksInSortedOrder()
        {
            var applicableHooks = new UntaggedHooksFirstStrategy().GetApplicableHooks(new List <string> {
                "Foo"
            }, _hookMethods).ToList();

            Assert.That(applicableHooks[2], Is.EqualTo(GetType().GetMethod("Baz").FullyQuallifiedName()));
            Assert.That(applicableHooks[3], Is.EqualTo(GetType().GetMethod("Foo").FullyQuallifiedName()));
        }
        public void ShouldFetchUntaggedHooksInSortedOrder()
        {
            var applicableHooks = new UntaggedHooksFirstStrategy()
                                  .GetApplicableHooks(new List <string> {
                "Foo"
            }, _hookMethods).ToList();

            Assert.AreEqual(applicableHooks[2], "my.foo.type.Zed");
            Assert.AreEqual(applicableHooks[3], "my.foo.type.Foo");
        }
        public void ShouldFetchTaggedHooksInSortedOrder()
        {
            var applicableHooks = new UntaggedHooksFirstStrategy()
                                  .GetApplicableHooks(new List <string> {
                "Foo"
            }, _hookMethods).ToList();

            var expectedMethods = new[] {
                "my.foo.type.Baz",
                "my.foo.type.Blah",
                "my.foo.type.Zed",
                "my.foo.type.Foo"
            };

            Assert.AreEqual(expectedMethods, applicableHooks);
        }
 protected UntaggedHooksFirstExecutionProcessor(IExecutionOrchestrator executionOrchestrator)
     : base(executionOrchestrator)
 {
     Strategy = new UntaggedHooksFirstStrategy();
 }
Example #9
0
 protected UntaggedHooksFirstExecutionProcessor(IHookRegistry hookRegistry, IMethodExecutor methodExecutor)
     : base(hookRegistry, methodExecutor)
 {
     Strategy = new UntaggedHooksFirstStrategy();
 }
Example #10
0
 protected UntaggedHooksFirstExecutionProcessor(IMethodExecutor methodExecutor, IAssemblyLoader assemblyLoader, IReflectionWrapper reflectionWrapper)
     : base(methodExecutor, assemblyLoader, reflectionWrapper)
 {
     Strategy = new UntaggedHooksFirstStrategy();
 }
 protected UntaggedHooksFirstExecutionProcessor(IMethodExecutor methodExecutor)
     : base(methodExecutor)
 {
     Strategy = new UntaggedHooksFirstStrategy();
 }