public void Should_UnitTestFeatureGeneratorProvider_create_UnitTestFeatureGenerator_instance()
        {
            var generatorProvider = CreateUnitTestFeatureGeneratorProvider();
            var anyFeature        = ParserHelper.CreateAnyDocument();
            var generator         = generatorProvider.CreateGenerator(anyFeature);

            generator.Should().BeOfType <UnitTestFeatureGenerator>();
        }
        public void Should_UnitTestFeatureGeneratorProvider_create_valid_instance()
        {
            var generatorProvider = CreateUnitTestFeatureGeneratorProvider();
            var anyFeature        = ParserHelper.CreateAnyDocument();
            var generator         = generatorProvider.CreateGenerator(anyFeature);

            generator.Should().NotBeNull();
        }
        public void Should_create_UnitTestFeatureGenerator_with_default_setup()
        {
            var featureGeneratorRegistry = CreateFeatureGeneratorRegistry();

            var anyDocument = ParserHelper.CreateAnyDocument();
            var generator   = featureGeneratorRegistry.CreateGenerator(anyDocument);

            generator.Should().BeOfType <UnitTestFeatureGenerator>();
        }
        public void Should_TagFilteredFeatureGeneratorProvider_not_be_applied_for_feature_with_no_tgas()
        {
            container.RegisterTypeAs <TestTagFilteredFeatureGeneratorProvider, IFeatureGeneratorProvider>("mytag");

            SpecFlowDocument theDocument = ParserHelper.CreateAnyDocument();

            var featureGeneratorRegistry = CreateFeatureGeneratorRegistry();

            var generator = featureGeneratorRegistry.CreateGenerator(theDocument);

            generator.Should().NotBe(TestTagFilteredFeatureGeneratorProvider.DummyGenerator);
        }
        public void Should_TagFilteredFeatureGeneratorProvider_applied_for_registered_tag_name_with_at()
        {
            container.RegisterTypeAs <TestTagFilteredFeatureGeneratorProvider, IFeatureGeneratorProvider>("@mytag");

            SpecFlowDocument theDocument = ParserHelper.CreateAnyDocument(tags: new[] { "mytag" });

            var featureGeneratorRegistry = CreateFeatureGeneratorRegistry();

            var generator = featureGeneratorRegistry.CreateGenerator(theDocument);

            generator.Should().Be(TestTagFilteredFeatureGeneratorProvider.DummyGenerator);
        }
        public void Should_use_generic_provider_with_higher_priority()
        {
            var dummyGenerator = new Mock <IFeatureGenerator>().Object;

            var genericHighPrioProvider = new Mock <IFeatureGeneratorProvider>();

            genericHighPrioProvider.Setup(p => p.CreateGenerator(It.IsAny <SpecFlowDocument>())).Returns(dummyGenerator);
            genericHighPrioProvider.Setup(p => p.CanGenerate(It.IsAny <SpecFlowDocument>())).Returns(true); // generic
            genericHighPrioProvider.Setup(p => p.Priority).Returns(1);                                      // high-prio

            container.RegisterInstanceAs(genericHighPrioProvider.Object, "custom");

            var featureGeneratorRegistry = CreateFeatureGeneratorRegistry();

            var anyFeature = ParserHelper.CreateAnyDocument();
            var generator  = featureGeneratorRegistry.CreateGenerator(anyFeature);

            generator.Should().Be(dummyGenerator);
        }
        public void Should_skip_high_priority_provider_when_not_applicable()
        {
            var dummyGenerator = new Mock <IFeatureGenerator>().Object;

            SpecFlowDocument theDocument = ParserHelper.CreateAnyDocument();

            var genericHighPrioProvider = new Mock <IFeatureGeneratorProvider>();

            genericHighPrioProvider.Setup(p => p.CreateGenerator(It.IsAny <SpecFlowDocument>())).Returns(dummyGenerator);
            genericHighPrioProvider.Setup(p => p.CanGenerate(theDocument)).Returns(false); // not applicable for aFeature
            genericHighPrioProvider.Setup(p => p.Priority).Returns(1);                     // high-prio

            container.RegisterInstanceAs(genericHighPrioProvider.Object, "custom");

            var featureGeneratorRegistry = CreateFeatureGeneratorRegistry();

            var generator = featureGeneratorRegistry.CreateGenerator(theDocument);

            generator.Should().BeOfType <UnitTestFeatureGenerator>();
        }
        public void Should_call_provider_wiht_the_given_feature()
        {
            var dummyGenerator = new Mock <IFeatureGenerator>().Object;

            var genericHighPrioProvider = new Mock <IFeatureGeneratorProvider>();

            genericHighPrioProvider.Setup(p => p.CreateGenerator(It.IsAny <SpecFlowDocument>())).Returns(dummyGenerator);
            genericHighPrioProvider.Setup(p => p.CanGenerate(It.IsAny <SpecFlowDocument>())).Returns(true); // generic
            genericHighPrioProvider.Setup(p => p.Priority).Returns(1);                                      // high-prio

            container.RegisterInstanceAs(genericHighPrioProvider.Object, "custom");

            var featureGeneratorRegistry = CreateFeatureGeneratorRegistry();

            SpecFlowDocument theDocument = ParserHelper.CreateAnyDocument();

            featureGeneratorRegistry.CreateGenerator(theDocument);

            genericHighPrioProvider.Verify(p => p.CreateGenerator(theDocument), Times.Once());
        }
 protected IFeatureGenerator CreateUnitTestFeatureGenerator()
 {
     return(container.Resolve <UnitTestFeatureGeneratorProvider>().CreateGenerator(ParserHelper.CreateAnyDocument()));
 }
Пример #10
0
 private static TestClassGenerationContext CreateGenerationContext(string tag)
 {
     return(new TestClassGenerationContext(null, ParserHelper.CreateAnyDocument(new [] { tag }), null, null, null, null, null, null, null, null, null, null, true));
 }
        private static IFeatureGenerator CreateFeatureGenerator(bool parallelCode, string[] ignoreParallelTags)
        {
            var container             = GeneratorContainerBuilder.CreateContainer(new SpecFlowConfigurationHolder(ConfigSource.Default, null), new ProjectSettings());
            var specFlowConfiguration = container.Resolve <SpecFlowConfiguration>();

            specFlowConfiguration.MarkFeaturesParallelizable      = parallelCode;
            specFlowConfiguration.SkipParallelizableMarkerForTags = ignoreParallelTags ??
                                                                    Enumerable.Empty <string>().ToArray();
            container.RegisterInstanceAs(CreateTestGeneratorProvider());

            var generator = container.Resolve <UnitTestFeatureGeneratorProvider>().CreateGenerator(ParserHelper.CreateAnyDocument());

            return(generator);
        }
Пример #12
0
        public static IFeatureGenerator CreateFeatureGenerator(this IUnitTestGeneratorProvider testGeneratorProvider, string[] addNonParallelizableMarkerForTags = null)
        {
            var container             = new GeneratorContainerBuilder().CreateContainer(new SpecFlowConfigurationHolder(ConfigSource.Default, null), new ProjectSettings(), Enumerable.Empty <GeneratorPluginInfo>());
            var specFlowConfiguration = container.Resolve <SpecFlowConfiguration>();

            specFlowConfiguration.AddNonParallelizableMarkerForTags = addNonParallelizableMarkerForTags;
            container.RegisterInstanceAs(testGeneratorProvider);

            var generator = container.Resolve <UnitTestFeatureGeneratorProvider>().CreateGenerator(ParserHelper.CreateAnyDocument());

            return(generator);
        }
Пример #13
0
        private static IFeatureGenerator CreateFeatureGenerator()
        {
            var container = GeneratorContainerBuilder.CreateContainer(new SpecFlowConfigurationHolder(), new ProjectSettings());

            container.RegisterInstanceAs(CreateTestGeneratorProvider());

            var generator = container.Resolve <UnitTestFeatureGeneratorProvider>().CreateGenerator(ParserHelper.CreateAnyDocument());

            return(generator);
        }