public Feature ToFeature(string featureFile)
{
var feature = new Feature()
{
@File = featureFile,
@Name = this.Declaration.Name,
@Story = this.Declaration.Story,
};
var rawScenarios = this.Scenarions
.Select(d => new Scenario()
{
@Name = d.Name,
@Scope = d.Scope,
@Statements =
{
@Given = d.GivenStatement,
@When = d.WhenStatement,
@Then = d.ThenStatement
}
})
.ToArray();
foreach (var scenario in rawScenarios) { feature.Scenarios.Add(scenario); }
return feature;
}
public void ShouldGenerateCodeThatWillDefineAFeatureAttributeAndImportsNamespace()
{
// mock
var rootNs = "qualquer.coisa";
var featureFile = @"unidade:\pasta1\arquivo.feature";
var feature = new Feature() { File = featureFile, Name = "Cliente, Exclusão" };
var scenarios = new[] { new Scenario() { Name = "Deve falhar quando cliente está vinculado à [1] produtos." } };
// prepare
var builder = new CSharpFeatureTestCheckersBuilder();
builder.RootNamespace = rootNs;
builder.Feature = feature;
builder.FeaturePath = featureFile;
builder.Scenarios = scenarios;
// do
var code = builder.ToCode();
Console.Write(code);
// check
var hasNamespace = this.HasUsing(code, typeof(TestFeatureAttribute).Namespace);
Assert.IsTrue(hasNamespace);
var hasFeatureAttrib = this.HasFeatureAttribute(code, featureFile);
Assert.IsTrue(hasFeatureAttrib);
}
public void ShouldGenerateTestsCodeThatWouldDescribeEachScenarioStructureInTest()
{
// mock
var rootNs = "qualquer.coisa";
var feature = new Feature() { Name = "Cliente, Exclusão" };
var scenarios = new[]
{
new Scenario() {
Name = "Deve falhar quando cliente está vinculado à [1] produtos.",
Scope = ScenarioScope.BottomUp,
Statements = {
Given = "Dada a tablatura 'INVÁLIDA'",
When = "Quando eu realizo a transcrição",
Then = "Então eu devo receber uma exceção 'InvalidGuitarTabException'"
}
}
};
// prepare
var builder = new CSharpFeatureTestsBuilder();
builder.Feature = feature;
builder.Scenarios = scenarios;
builder.RootNamespace = rootNs;
// do
var code = builder.ToCode();
Console.Write(code);
// check
var hasTextBody = this.HasMethodCallsForGivenWhenThen(code);
Assert.IsTrue(hasTextBody);
}
public void ShouldGenerateCodeThatWillHaveAClassWithTheNameOfTheFeatureAndTheNameOfTheScenario()
{
// mock
var feature = new Feature() { Name = "Cliente, Exclusão" };
var scenario = new Scenario() { Name = "Deve falhar quando cliente está vinculado à [1] produtos." };
// prepare
var builder = this.NewDefaultBuilder();
builder.Feature = feature;
builder.Scenario = scenario;
// do
var code = builder.ToCode();
Console.Write(code);
// check
var hasCorrectClassName = this.HasStepsClassName(code, feature, scenario);
Assert.IsTrue(hasCorrectClassName);
}
public void ShouldGenerateCodeThatWillDefineAParticularScope()
{
// mock
var scope = ScenarioScope.BottomUp;
var rootNs = "qualquer.coisa";
var feature = new Feature() { Name = "Cliente, Exclusão" };
var scenarios = new[] { new Scenario() { Scope = scope, Name = "Deve falhar quando cliente está vinculado à [1] produtos." } };
// prepare
var builder = new CSharpFeatureTestsBuilder();
builder.RootNamespace = rootNs;
builder.Feature = feature;
builder.Scenarios = scenarios;
// do
var code = builder.ToCode();
Console.Write(code);
// check
var hasScopeTrait = this.HasScopeTrait(code, scope);
Assert.IsTrue(hasScopeTrait);
}
public void ShouldGenerateStepsForOneSingleStatement()
{
// mock
var rootNs = "qualquer.coisa";
var feature = new Feature() { Name = "Cliente, Exclusão" };
var scenario = new Scenario()
{
@Name = "Deve falhar quando cliente está vinculado à [1] produtos.",
@Statements =
{
Given = "Dado o arquivo de feature ''",
When = "Quando tento criar o parser",
Then = "Então eu recebo uma exceção do tipo 'NBDD.Framework.Parsers.FeatureFileContentInvalidException'"
}
};
var treatedScenario = scenario.MakeTreatedStatements();
// prepare
var builder = new CSharpFeatureStepsBuilder();
builder.Feature = feature;
builder.Scenario = scenario;
builder.RootNamespace = rootNs;
// do
var code = builder.ToCode();
Console.Write(code);
// check
Assert.IsNotNull(code);
Assert.IsTrue(HasAttribute(code, "Given"), "Atributo 'Given' não encontrado");
Assert.IsTrue(HasStatementMethod(code, scenario.Statements.Given), "Não temos o método para o statement de given");
Assert.IsTrue(HasAttribute(code, "When"), "Atributo 'When' não encontrado");
Assert.IsTrue(HasStatementMethod(code, scenario.Statements.When), "Não temos o método para o statement de when");
Assert.IsTrue(HasAttribute(code, "Then"), "Atributo 'Then' não encontrado");
Assert.IsTrue(HasStatementMethod(code, scenario.Statements.Then), "Não temos o método para o statement de then");
}
private CSharpFeatureStepsBuilder NewDefaultBuilder()
{
// mock
var feature = new Feature() { Name = "Cliente, Exclusão" };
var scenario = new Scenario()
{
@Name = "Deve falhar quando cliente está vinculado à [1] produtos.",
@Statements =
{
Given = "Dado o arquivo de feature ''",
When = "Quando tento criar o parser",
Then = "Então eu recebo uma exceção do tipo 'NBDD.Framework.Parsers.FeatureFileContentInvalidException'"
}
};
// prepare
var builder = new CSharpFeatureStepsBuilder();
builder.RootNamespace = RootNamespace;
builder.Feature = feature;
builder.Scenario = scenario;
return builder;
}
private bool HasStepsClassName(
string code,
Feature feature,
Scenario scenario)
{
var classSignature = string.Concat(
"public class ",
feature.Name.ToClassName(),
"_",
scenario.Name.ToClassName());
return code.Contains(classSignature);
}
private TestsBuilder MakeTestsBuilder(Feature feature)
{
var builder = new CSharpFeatureTestsBuilder();
builder.RootNamespace = this.RootNamespace;
builder.Feature = feature;
builder.FeaturePath = feature.File;
builder.Scenarios = feature.Scenarios;
return builder;
}
private StepsBuilder MakeStepsBuilder(Feature feature, Scenario scenario)
{
var builder = new CSharpFeatureStepsBuilder();
builder.RootNamespace = this.RootNamespace;
builder.Feature = feature;
builder.Scenario = scenario;
return builder;
}
public SpecificationGroup(Feature feature)
{
this.Feature = feature;
this.InitializeStepBuildersDictionaries();
}
public void ShouldGenerateTestsCodeThatWouldRunTestsForEachScenario()
{
// mock
var rootNs = "qualquer.coisa";
var feature = new Feature() { Name = "Cliente, Exclusão" };
var scenarios = new[]
{
new Scenario() { Name = "Deve falhar quando cliente está vinculado à [1] produtos." },
new Scenario() { Name = "Deve falhar quando cliente está vinculado à [99] produtos." },
};
// prepare
var builder = new CSharpFeatureTestsBuilder();
builder.Feature = feature;
builder.Scenarios = scenarios;
builder.RootNamespace = rootNs;
// do
var code = builder.ToCode();
Console.Write(code);
// check
var hasAllTests = this.HasATestForEachScenario(code, feature, scenarios);
Assert.IsTrue(hasAllTests);
}
private bool HasTestForScenario(
string code,
Feature feature,
Scenario scenario)
{
var className = feature.Name.ToClassName();
var methodName = scenario.Name.ToMethodName();
var methodCall = string.Concat("void ", className, "_", methodName, "()");
return code.Contains(methodCall);
}
private bool HasATestForEachScenario(
string code,
Feature feature,
IEnumerable<Scenario> scenarios)
{
foreach (var scenario in scenarios)
{
var hasTestForScenario = this.HasTestForScenario(code, feature, scenario);
if (!hasTestForScenario)
{
return false;
}
}
return true;
}
public void ShouldGenerateTheScopeTraitWhenProvided()
{
// mock
var rootNamespace = "empresa.grupo.modulo";
var feature = new Feature() { Name = "Cliente, Exclusão" };
var scenarios = new Scenario[0];
// prepare
var builder = new CSharpFeatureTestsBuilder();
builder.RootNamespace = rootNamespace;
builder.Feature = feature;
builder.Scenarios = scenarios;
// do
var code = builder.ToCode();
Console.Write(code);
// check
var hasNamespace = this.HasNamespace(code, rootNamespace);
Assert.IsTrue(hasNamespace);
}
private IEnumerable<SpecificationGroup> GenerateSpecificationGroupsFromFeatureFiles(
IEnumerable<string> featureFiles)
{
var list = new List<SpecificationGroup>();
foreach (var featureFile in featureFiles)
{
var scenario = new Scenario() { Name = "CENARIO_TESTE" };
scenario.Statements.Given = "Dado que TESTE";
scenario.Statements.When = "Quando TESTE";
scenario.Statements.Then = "Então TESTE";
var feature = new Feature() { File = featureFile };
feature.Scenarios.Add(scenario);
list.Add(new SpecificationGroup(feature));
}
return list;
}
public void EnsureTestFeature()
{
var featureAttrib = this.TestClass.GetCustomAttribute<TestFeatureAttribute>();
if (featureAttrib == null)
{
throw new InvalidTestClassException(this.TestClass);
}
try
{
var featureRaw = this.ReadFeatureFile(featureAttrib.File);
var parser = new StandardFeatureFileParser(featureRaw);
this.testFeature = parser.ToFeature(featureAttrib.File);
}
catch (Exception inner)
{
throw new FeatureFileCouldNotBeLoadedException(
featureAttrib.File,
inner);
}
}
private Feature FeatureFromFeatureFile(string filePath)
{
var feature = new Feature();
feature.File = filePath;
var featureSpec = this.ReadFeatureFile(filePath);
var parser = new StandardFeatureFileParser(featureSpec);
feature.Name = parser.Declaration.Name;
feature.Story = parser.Declaration.Story;
foreach (var parsedScenario in parser.Scenarions)
{
feature.Scenarios.Add(new Scenario()
{
@Name = parsedScenario.Name,
@Scope = parsedScenario.Scope,
@Statements = {
Given = parsedScenario.GivenStatement,
When = parsedScenario.WhenStatement,
Then = parsedScenario.ThenStatement
}
});
}
return feature;
}