private void GenerateCodeFromFeature(Feature feature, TextWriter writer)
{
CodeDomHelper codeDomHelper = new CodeDomHelper(CodeDomProviderLanguage.CSharp);
XUnitTestGeneratorProvider xUnitTestGeneratorProvider = new XUnitTestGeneratorProvider();
SpecFlowUnitTestConverter converter = FactoryMethods.CreateUnitTestConverter(xUnitTestGeneratorProvider);
var codeNamespace = converter.GenerateUnitTestFixture(feature, "TestClassName", "Target.Namespace");
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
CodeGeneratorOptions options = new CodeGeneratorOptions();
codeProvider.GenerateCodeFromNamespace(codeNamespace, writer, options);
}
private void CompareWithExpectedResult(Feature feature, string expectedResultFileName)
{
string expected = TestFileHelper.ReadFile(expectedResultFileName);
string got = GenerateCodeFromFeature(feature);
Assert.AreEqual(expected, got);
}
private void GenerateCodeFromFeature(Feature feature, string fileName)
{
using (var writer = new StreamWriter(fileName, false, Encoding.UTF8))
{
GenerateCodeFromFeature(feature, writer);
}
}
private object CompileAndCreateTest(string fileName, Feature feature)
{
string className = Path.GetFileNameWithoutExtension(fileName);
const string targetNamespace = "Target.Namespace";
// the row test generation has to be set to false, because our verifications support the old style test generation only
SpecFlowUnitTestConverter converter = new SpecFlowUnitTestConverter(CreateUnitTestGeneratorProvider(), new CodeDomHelper(CodeDomProviderLanguage.CSharp), new GeneratorConfiguration { AllowRowTests = false, AllowDebugGeneratedFiles = true });
var codeNamespace = converter.GenerateUnitTestFixture(feature, className, targetNamespace);
var compileUnit = new CodeCompileUnit();
compileUnit.Namespaces.Add(codeNamespace);
Dictionary<string, string> providerOptions = new Dictionary<string, string>();
providerOptions["CompilerVersion"] = "v3.5";
CSharpCodeProvider codeProvider = new CSharpCodeProvider(providerOptions);
CompilerParameters compilerParameters = new CompilerParameters();
compilerParameters.GenerateInMemory = true;
compilerParameters.TempFiles.KeepFiles = true;
compilerParameters.ReferencedAssemblies.Add(
TestFileHelper.GetAssemblyPath(typeof (GeneratedCodeAttribute))); //System
compilerParameters.ReferencedAssemblies.Add(
TestFileHelper.GetAssemblyPath(typeof (TestAttribute))); //NUnit
compilerParameters.ReferencedAssemblies.Add(
TestFileHelper.GetAssemblyPath(typeof (ITestRunner))); //TechTalk.SpecFlow
var results = codeProvider.CompileAssemblyFromDom(compilerParameters, compileUnit);
if (results.NativeCompilerReturnValue != 0)
throw new InvalidOperationException("Test cannot be compiled: " +
string.Join(Environment.NewLine, results.Errors.Cast<CompilerError>().Select(ce => ce.ToString()).ToArray()));
Type testType = results.CompiledAssembly.GetType(targetNamespace + "." + className, true);
return Activator.CreateInstance(testType);
}
private void SerializeFeature(Feature feature, string fileName)
{
using (var writer = new StreamWriter(fileName, false, Encoding.UTF8))
{
SerializeFeature(feature, writer);
}
}
public static bool MatchPrefix(this ITagFilterMatcher tagFilterMatcher, string tagFilter, Feature feature)
{
if (feature.Tags == null)
return false;
return tagFilterMatcher.MatchPrefix(tagFilter, feature.Tags.Select(t => t.Name));
}
private void CompareWithExpectedResult(Feature feature, string expectedResultFileName)
{
string expected = TestFileHelper.ReadFile(expectedResultFileName).Replace("\r", "");
string got = SerializeFeature(feature).Replace("\r", "");
Assert.AreEqual(expected, got);
}
private string GenerateCodeFromFeature(Feature feature)
{
using (var writer = new Utf8StringWriter())
{
GenerateCodeFromFeature(feature, writer);
return writer.ToString();
}
}
public void Should_UnitTestFeatureGeneratorProvider_create_UnitTestFeatureGenerator_instance()
{
var generatorProvider = CreateUnitTestFeatureGeneratorProvider();
Feature anyFeature = new Feature();
var generator = generatorProvider.CreateGenerator(anyFeature);
generator.Should().BeOfType<UnitTestFeatureGenerator>();
}
public void Should_UnitTestFeatureGeneratorProvider_create_valid_instance()
{
var generatorProvider = CreateUnitTestFeatureGeneratorProvider();
Feature anyFeature = new Feature();
var generator = generatorProvider.CreateGenerator(anyFeature);
generator.Should().NotBeNull();
}
private string SerializeFeature(Feature feature)
{
using (var writer = new Utf8StringWriter())
{
SerializeFeature(feature, writer);
return writer.ToString();
}
}
public ScenarioOutlineViewModel(Feature feature, ScenarioOutline scenarioOutline)
: base(scenarioOutline, feature)
{
var bgSteps = feature.Background != null ? feature.Background.Steps.AsEnumerable() : Enumerable.Empty<ScenarioStep>();
StepTemplates = bgSteps.Concat(scenarioOutline.Steps).Select(x => new StepTemplateViewModel(x)).ToList();
Examples = scenarioOutline.Examples.ExampleSets.Select(x => new ScenarioOutlineExampleSetViewModel(this, x)).ToList();
}
public void Should_create_UnitTestFeatureGenerator_with_default_setup()
{
var featureGeneratorRegistry = CreateFeatureGeneratorRegistry();
Feature anyFeature = new Feature();
var generator = featureGeneratorRegistry.CreateGenerator(anyFeature);
generator.Should().BeOfType<UnitTestFeatureGenerator>();
}
protected override void ExecuteTests(object test, Feature feature)
{
NUnitTestExecutor.ExecuteNUnitTests(test,
delegate(Exception exception)
{
Assert.IsInstanceOf(typeof(InconclusiveException), exception);
return true;
});
}
private void GenerateCodeFromFeature(Feature feature, TextWriter writer)
{
SpecFlowUnitTestConverter converter = FactoryMethods.CreateUnitTestConverter(new NUnitTestConverter());
var codeNamespace = converter.GenerateUnitTestFixture(feature, "TestClassName", "Target.Namespace");
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
CodeGeneratorOptions options = new CodeGeneratorOptions();
codeProvider.GenerateCodeFromNamespace(codeNamespace, writer, options);
}
public static bool GetTagValue(this ITagFilterMatcher tagFilterMatcher, string tagFilter, Feature feature, out string value)
{
if (feature.Tags == null)
{
value = null;
return false;
}
return tagFilterMatcher.GetTagValue(tagFilter, feature.Tags.Select(t => t.Name), out value);
}
public FeatureViewModel(Feature feature)
{
FeatureNode = feature;
if (feature.Background != null)
{
BackgroundSteps = feature.Background.Steps.Select(x => new StepViewModel(x)).ToList();
}
Scenarios = feature.Scenarios.Select(x => x is ScenarioOutline ? (ScenarioViewModelBase)new ScenarioOutlineViewModel(feature, (ScenarioOutline) x) : new ScenarioViewModel(feature, x)).ToList();
}
private static string GetPlainText(string fileName, Scenario scenario, Feature feature)
{
var lines = File.ReadAllLines(fileName);
var nextScenario = feature.Scenarios.SkipWhile(s => s != scenario).Skip(1).FirstOrDefault();
int startLine = scenario.FilePosition.Line;
int endLine = nextScenario == null ? lines.Count() : nextScenario.FilePosition.Line - 1;
return string.Join(Environment.NewLine, lines.Skip(startLine - 1).Take(endLine - startLine + 1)).Replace("\t", " ");
}
private void GenerateCodeFromFeature(Feature feature, TextWriter writer)
{
var codeDomHelper = new CodeDomHelper(CodeDomProviderLanguage.CSharp);
var mbUnitTestGeneratorProvider = new MbUnitTestGeneratorProvider();
var converter = new SpecFlowUnitTestConverter(mbUnitTestGeneratorProvider, codeDomHelper, true);
CodeNamespace codeNamespace = converter.GenerateUnitTestFixture(feature, "TestClassName", "Target.Namespace");
var codeProvider = new CSharpCodeProvider();
var options = new CodeGeneratorOptions();
codeProvider.GenerateCodeFromNamespace(codeNamespace, writer, options);
}
public Feature GetResult()
{
var feature = new Feature(
title,
tags,
description,
background == null ? null : background.GetResult(),
scenarios.Select(sb => sb.GetResult()).ToArray());
feature.SourceFile = sourceFilePath;
return feature;
}
/// <summary>
/// Generates the unit test fixture.
/// </summary>
/// <param name="feature">The feature.</param>
/// <param name="testClassName">Name of the test class.</param>
/// <param name="targetNamespace">The target namespace.</param>
/// <returns>Instance of CodeNamespace.</returns>
public CodeNamespace GenerateUnitTestFixture(Feature feature, string testClassName, string targetNamespace)
{
CodeNamespace result = this.baseFeatureGenerator.GenerateUnitTestFixture(feature, testClassName, targetNamespace);
if (this.IsLiveTest(feature))
{
this.DecorateStaticMethods(result);
this.DecorateFixtureClasses(result);
}
return result;
}
public string GetFeatureText(Feature feature, CultureInfo defaultLanguage = null)
{
defaultLanguage = defaultLanguage ?? new CultureInfo("en-US");
var dialectServices = new GherkinDialectServices(defaultLanguage);
var dialect = dialectServices.GetGherkinDialect(feature);
var result = new StringBuilder();
AppendHeader(defaultLanguage, dialect, result);
AppendTags(result, feature.Tags);
AppendFeatureLine(feature, result);
AppendLine(result);
if (feature.Background != null)
{
AppendBackgroundLine(feature.Background, result);
AppendSteps(feature.Background.Steps, result);
AppendLine(result);
}
foreach (var scenario in feature.Scenarios)
{
var outline = scenario as ScenarioOutline;
bool isOutline = outline != null;
AppendTags(result, scenario.Tags);
AppendScenarioLine(result, scenario, dialect, isOutline);
AppendSteps(scenario.Steps, result);
AppendLine(result);
if (isOutline)
{
foreach (var exampleSet in outline.Examples.ExampleSets)
{
AppendTags(result, exampleSet.Tags);
AppendExampleSetLine(result, dialect, exampleSet);
AppendTable(result, exampleSet.Table, indent);
AppendLine(result);
}
}
AppendLine(result);
}
return result.ToString();
}
public TestClassGenerationContext(Feature feature, CodeNamespace ns, CodeTypeDeclaration testClass, CodeMemberMethod testClassInitializeMethod, CodeMemberMethod testClassCleanupMethod, CodeMemberMethod testInitializeMethod, CodeMemberMethod testCleanupMethod, CodeMemberMethod scenarioInitializeMethod, CodeMemberMethod scenarioCleanupMethod, bool generateRowTests, bool generateAsynchTests)
{
Feature = feature;
Namespace = ns;
TestClass = testClass;
TestClassInitializeMethod = testClassInitializeMethod;
TestClassCleanupMethod = testClassCleanupMethod;
TestInitializeMethod = testInitializeMethod;
TestCleanupMethod = testCleanupMethod;
ScenarioInitializeMethod = scenarioInitializeMethod;
ScenarioCleanupMethod = scenarioCleanupMethod;
GenerateRowTests = generateRowTests;
GenerateAsynchTests = generateAsynchTests;
CustomData = new Dictionary<string, object>();
}
/// <summary>
/// Converts the provided <see cref="SpecFlow.Feature"/> instance into a <see cref="Augurk.Entities.Feature"/> instance.
/// </summary>
/// <param name="feature">The <see cref="SpecFlow.Feature"/> instance that should be converted.</param>
/// <returns>The converted <see cref="Augurk.Entities.Feature"/> instance.</returns>
public static Feature ConvertToFeature(this SpecFlow.Feature feature)
{
if (feature == null)
{
throw new ArgumentNullException("feature");
}
return(new Feature()
{
Title = feature.Title,
Description = feature.Description,
Tags = feature.Tags.ConvertToStrings(),
Scenarios = feature.Scenarios.Select(scenario => scenario.ConvertToScenario()).ToArray(),
Background = feature.Background.ConvertToBackground()
});
}
public static FeatureVm CreateFromSpecFlowFeature(Feature specFlowFeature)
{
return new FeatureVm
{
Background = specFlowFeature.Background,
Comments = specFlowFeature.Comments,
Description = specFlowFeature.Description,
Directory = Path.GetDirectoryName(specFlowFeature.SourceFile),
FileName = Path.GetFileName(specFlowFeature.SourceFile),
Keyword = specFlowFeature.Keyword,
Language = specFlowFeature.Language,
Scenarios = ScenarioListVm.CreateFromSpecFlowScenarios(specFlowFeature.Scenarios),
SourceFile = specFlowFeature.SourceFile,
Tags = specFlowFeature.Tags,
Title = specFlowFeature.Title
};
}
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<Feature>())).Returns(dummyGenerator);
genericHighPrioProvider.Setup(p => p.CanGenerate(It.IsAny<Feature>())).Returns(true); // generic
genericHighPrioProvider.Setup(p => p.Priority).Returns(1); // high-prio
container.RegisterInstanceAs(genericHighPrioProvider.Object, "custom");
var featureGeneratorRegistry = CreateFeatureGeneratorRegistry();
Feature theFeature = new Feature();
featureGeneratorRegistry.CreateGenerator(theFeature);
genericHighPrioProvider.Verify(p => p.CreateGenerator(theFeature), Times.Once());
}
public void WhenIParseTheFile()
{
var contentReader = new StringReader(gherkinContent);
try
{
feature = parser.Parse(contentReader, "sample.feature");
}
catch(SpecFlowParserException ex)
{
parsingErrors = ex;
Console.WriteLine("-> parsing errors");
foreach (ErrorDetail errorDetail in parsingErrors.ErrorDetails)
{
Console.WriteLine("-> {0}:{1} {2}", errorDetail.Line, errorDetail.Column, errorDetail.Message);
}
}
}
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<Feature>())).Returns(dummyGenerator);
genericHighPrioProvider.Setup(p => p.CanGenerate(It.IsAny<Feature>())).Returns(true); // generic
genericHighPrioProvider.Setup(p => p.Priority).Returns(1); // high-prio
container.RegisterInstanceAs(genericHighPrioProvider.Object, "custom");
var featureGeneratorRegistry = CreateFeatureGeneratorRegistry();
Feature anyFeature = new Feature();
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;
Feature theFeature = new Feature();
var genericHighPrioProvider = new Mock<IFeatureGeneratorProvider>();
genericHighPrioProvider.Setup(p => p.CreateGenerator(It.IsAny<Feature>())).Returns(dummyGenerator);
genericHighPrioProvider.Setup(p => p.CanGenerate(theFeature)).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(theFeature);
generator.Should().BeOfType<UnitTestFeatureGenerator>();
}
public Feature GetResult()
{
var scenarioResults = scenarios.Select(sb => sb.GetResult()).ToArray();
comments.Sort((c1, c2) => c1.FilePosition.Line.CompareTo(c2.FilePosition.Line));
var feature = new Feature(
keyword,
title,
tags,
description,
background == null ? null : background.GetResult(),
scenarioResults,
comments.ToArray());
feature.SourceFile = sourceFilePath;
feature.FilePosition = position;
return feature;
}
protected virtual void AppendFeatureLine(Feature feature, StringBuilder result)
{
AppendNodeLine(result, feature.FilePosition, "{0}: {1}", feature.Keyword, feature.Title);
if (!string.IsNullOrEmpty(feature.Description))
AppendMulitLine(result, feature.Description);
}
