Skip to content

Commit 3093aaa

Browse files
mwhelanmwhelan
committed
Merge pull request #63 from MehdiK/type-cleanup
Type cleanup
2 parents 87eb80d + 5b94473 commit 3093aaa

62 files changed

Lines changed: 337 additions & 337 deletions

File tree

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

‎Samples/TestStack.BDDfy.Samples/Atm/HtmlReportConfig.cs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,7 @@ public class HtmlReportConfig : DefaultHtmlReportConfiguration
1010
{
1111
public override bool RunsOn(Story story)
1212
{
13-
return story.MetaData.Type.Namespace != null && story.MetaData.Type.Namespace.EndsWith("Atm");
13+
return story.Metadata.Type.Namespace != null && story.Metadata.Type.Namespace.EndsWith("Atm");
1414
}
1515

1616
/// <summary>

‎Samples/TestStack.BDDfy.Samples/CustomTextReporter.cs‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -43,14 +43,14 @@ static CustomTextReporter()
4343
public void Process(Story story)
4444
{
4545
// use this report only for tic tac toe stories
46-
if (story.MetaData == null || !story.MetaData.Type.Name.Contains("TicTacToe"))
46+
if (story.Metadata == null || !story.Metadata.Type.Name.Contains("TicTacToe"))
4747
return;
4848

4949
var scenario = story.Scenarios.First();
5050
var scenarioReport = new StringBuilder();
5151
scenarioReport.AppendLine(string.Format(" SCENARIO: {0} ", scenario.Title));
5252

53-
if (scenario.Result != StepExecutionResult.Passed && scenario.Steps.Any(s => s.Exception != null))
53+
if (scenario.Result != Result.Passed && scenario.Steps.Any(s => s.Exception != null))
5454
{
5555
scenarioReport.Append(string.Format(" {0} : ", scenario.Result));
5656
scenarioReport.AppendLine(scenario.Steps.First(s => s.Result == scenario.Result).Exception.Message);
@@ -59,7 +59,7 @@ public void Process(Story story)
5959
scenarioReport.AppendLine();
6060

6161
foreach (var step in scenario.Steps)
62-
scenarioReport.AppendLine(string.Format(" [{1}] {0}", step.StepTitle, step.Result));
62+
scenarioReport.AppendLine(string.Format(" [{1}] {0}", step.Title, step.Result));
6363

6464
scenarioReport.AppendLine("--------------------------------------------------------------------------------");
6565
scenarioReport.AppendLine();

‎TestStack.BDDfy.Tests/Configuration/ProcessorPipelineTests.cs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -35,7 +35,7 @@ public void DoesNotReturnConsoleReportWhenItIsDeactivated()
3535
[Test]
3636
public void DoesNotReturnConsoleReportForExcludedStories()
3737
{
38-
Configurator.Processors.ConsoleReport.RunsOn(s => s.MetaData != null);
38+
Configurator.Processors.ConsoleReport.RunsOn(s => s.Metadata != null);
3939
var processors = Configurator.Processors.GetProcessors(new Story(null)).ToList();
4040

4141
Assert.IsFalse(processors.Any(p => p is ConsoleReporter));

‎TestStack.BDDfy.Tests/Configuration/TestRunnerTests.cs‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -76,17 +76,17 @@ private static void Verify(Engine testRun)
7676
{
7777
Assert.Throws<Exception>(() => testRun.Run());
7878
var scenario = testRun.Story.Scenarios.First();
79-
Assert.AreEqual(StepExecutionResult.Failed, scenario.Result);
79+
Assert.AreEqual(Result.Failed, scenario.Result);
8080
var steps = scenario.Steps;
8181

8282
Assert.AreEqual(4, steps.Count);
83-
Assert.AreEqual(StepExecutionResult.Passed, steps[0].Result);
83+
Assert.AreEqual(Result.Passed, steps[0].Result);
8484
Assert.AreEqual(ExecutionOrder.SetupState, steps[0].ExecutionOrder);
85-
Assert.AreEqual(StepExecutionResult.Passed, steps[1].Result);
85+
Assert.AreEqual(Result.Passed, steps[1].Result);
8686
Assert.AreEqual(ExecutionOrder.Transition, steps[1].ExecutionOrder);
87-
Assert.AreEqual(StepExecutionResult.Failed, steps[2].Result);
87+
Assert.AreEqual(Result.Failed, steps[2].Result);
8888
Assert.AreEqual(ExecutionOrder.Assertion, steps[2].ExecutionOrder);
89-
Assert.AreEqual(StepExecutionResult.NotExecuted, steps[3].Result);
89+
Assert.AreEqual(Result.NotExecuted, steps[3].Result);
9090
Assert.AreEqual(ExecutionOrder.ConsecutiveAssertion, steps[3].ExecutionOrder);
9191
}
9292
}
@@ -118,17 +118,17 @@ private static void Verify(Engine testRun)
118118
{
119119
Assert.Throws<Exception>(() => testRun.Run());
120120
var scenario = testRun.Story.Scenarios.First();
121-
Assert.AreEqual(StepExecutionResult.Failed, scenario.Result);
121+
Assert.AreEqual(Result.Failed, scenario.Result);
122122
var steps = scenario.Steps;
123123

124124
Assert.AreEqual(4, steps.Count);
125-
Assert.AreEqual(StepExecutionResult.Passed, steps[0].Result);
125+
Assert.AreEqual(Result.Passed, steps[0].Result);
126126
Assert.AreEqual(ExecutionOrder.SetupState, steps[0].ExecutionOrder);
127-
Assert.AreEqual(StepExecutionResult.Passed, steps[1].Result);
127+
Assert.AreEqual(Result.Passed, steps[1].Result);
128128
Assert.AreEqual(ExecutionOrder.Transition, steps[1].ExecutionOrder);
129-
Assert.AreEqual(StepExecutionResult.Failed, steps[2].Result);
129+
Assert.AreEqual(Result.Failed, steps[2].Result);
130130
Assert.AreEqual(ExecutionOrder.Assertion, steps[2].ExecutionOrder);
131-
Assert.AreEqual(StepExecutionResult.Passed, steps[3].Result);
131+
Assert.AreEqual(Result.Passed, steps[3].Result);
132132
Assert.AreEqual(ExecutionOrder.ConsecutiveAssertion, steps[3].ExecutionOrder);
133133
}
134134
}

‎TestStack.BDDfy.Tests/Exceptions/ExceptionThrowingTest.cs‎

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -86,35 +86,35 @@ private void SetThrowingStep(ThrowingMethods methodToThrow)
8686
}
8787
}
8888

89-
private ExecutionStep GetStep(string stepTitle)
89+
private Step GetStep(string stepTitle)
9090
{
91-
return _scenario.Steps.First(s => s.StepTitle == stepTitle);
91+
return _scenario.Steps.First(s => s.Title == stepTitle);
9292
}
9393

94-
ExecutionStep GivenStep
94+
Step GivenStep
9595
{
9696
get
9797
{
9898
return GetStep("Given");
9999
}
100100
}
101101

102-
ExecutionStep WhenStep
102+
Step WhenStep
103103
{
104104
get {
105105
return GetStep("When");
106106
}
107107
}
108108

109-
ExecutionStep ThenStep
109+
Step ThenStep
110110
{
111111
get
112112
{
113113
return GetStep("Then");
114114
}
115115
}
116116

117-
ExecutionStep TearDownStep
117+
Step TearDownStep
118118
{
119119
get
120120
{
@@ -134,30 +134,30 @@ Scenario Scenario
134134

135135
public void AssertTearDownMethodIsExecuted()
136136
{
137-
Assert.That(TearDownStep.Result, Is.EqualTo(StepExecutionResult.Passed));
137+
Assert.That(TearDownStep.Result, Is.EqualTo(Result.Passed));
138138
}
139139

140-
public void AssertGivenStepResult(StepExecutionResult result)
140+
public void AssertGivenStepResult(Result result)
141141
{
142142
Assert.That(GivenStep.Result, Is.EqualTo(result));
143143
}
144144

145-
public void AssertWhenStepResult(StepExecutionResult result)
145+
public void AssertWhenStepResult(Result result)
146146
{
147147
Assert.That(WhenStep.Result, Is.EqualTo(result));
148148
}
149149

150-
public void AssertThenStepResult(StepExecutionResult result)
150+
public void AssertThenStepResult(Result result)
151151
{
152152
Assert.That(ThenStep.Result, Is.EqualTo(result));
153153
}
154154

155-
public void AssertScenarioResult(StepExecutionResult result)
155+
public void AssertScenarioResult(Result result)
156156
{
157157
Assert.That(Scenario.Result, Is.EqualTo(result));
158158
}
159159

160-
public void AssertStoryResult(StepExecutionResult result)
160+
public void AssertStoryResult(Result result)
161161
{
162162
Assert.That(Story.Result, Is.EqualTo(result));
163163
}

‎TestStack.BDDfy.Tests/Exceptions/NotImplementedException/WhenGivenThrowsNotImplementedException.cs‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -18,70 +18,70 @@ private void ExecuteUsingReflectingScanners()
1818
public void GivenIsReportedAsNotImplementedWhenUsingReflectingScanners()
1919
{
2020
ExecuteUsingReflectingScanners();
21-
Sut.AssertGivenStepResult(StepExecutionResult.NotImplemented);
21+
Sut.AssertGivenStepResult(Result.NotImplemented);
2222
}
2323

2424
[Test]
2525
public void GivenIsReportedAsNotImplementedWhenUsingFluentScanners()
2626
{
2727
ExecuteUsingFluentScanner();
28-
Sut.AssertGivenStepResult(StepExecutionResult.NotImplemented);
28+
Sut.AssertGivenStepResult(Result.NotImplemented);
2929
}
3030

3131
[Test]
3232
public void WhenIsNotExecutedWhenUsingReflectingScanners()
3333
{
3434
ExecuteUsingReflectingScanners();
35-
Sut.AssertWhenStepResult(StepExecutionResult.NotExecuted);
35+
Sut.AssertWhenStepResult(Result.NotExecuted);
3636
}
3737

3838
[Test]
3939
public void WhenIsNotExecutedWhenUsingFluentScanners()
4040
{
4141
ExecuteUsingFluentScanner();
42-
Sut.AssertWhenStepResult(StepExecutionResult.NotExecuted);
42+
Sut.AssertWhenStepResult(Result.NotExecuted);
4343
}
4444

4545
[Test]
4646
public void ThenIsNotExecutedWhenUsingReflectingScanner()
4747
{
4848
ExecuteUsingReflectingScanners();
49-
Sut.AssertThenStepResult(StepExecutionResult.NotExecuted);
49+
Sut.AssertThenStepResult(Result.NotExecuted);
5050
}
5151

5252
[Test]
5353
public void ThenIsNotExecutedWhenUsingFluentScanner()
5454
{
5555
ExecuteUsingFluentScanner();
56-
Sut.AssertThenStepResult(StepExecutionResult.NotExecuted);
56+
Sut.AssertThenStepResult(Result.NotExecuted);
5757
}
5858

5959
[Test]
6060
public void ScenarioResultReturnsNotImplementedWhenUsingReflectingScanners()
6161
{
6262
ExecuteUsingReflectingScanners();
63-
Sut.AssertScenarioResult(StepExecutionResult.NotImplemented);
63+
Sut.AssertScenarioResult(Result.NotImplemented);
6464
}
6565

6666
[Test]
6767
public void ScenarioResultReturnsNotImplementedWhenUsingFluentScanner()
6868
{
6969
ExecuteUsingFluentScanner();
70-
Sut.AssertScenarioResult(StepExecutionResult.NotImplemented);
70+
Sut.AssertScenarioResult(Result.NotImplemented);
7171
}
7272

7373
[Test]
7474
public void StoryResultReturnsNotImplementedWhenUsingReflectingScanners()
7575
{
7676
ExecuteUsingReflectingScanners();
77-
Sut.AssertStoryResult(StepExecutionResult.NotImplemented);
77+
Sut.AssertStoryResult(Result.NotImplemented);
7878
}
7979

8080
[Test]
8181
public void StoryResultReturnsNotImplementedWhenUsingFluentScanner()
8282
{
8383
ExecuteUsingFluentScanner();
84-
Sut.AssertStoryResult(StepExecutionResult.NotImplemented);
84+
Sut.AssertStoryResult(Result.NotImplemented);
8585
}
8686

8787
[Test]

‎TestStack.BDDfy.Tests/Exceptions/NotImplementedException/WhenThenThrowsNotImplementedException.cs‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -18,35 +18,35 @@ private void ExecuteUsingFluentScanner()
1818
public void GivenIsReportedAsSuccessfulWhenUsingReflectingScanners()
1919
{
2020
ExecuteUsingReflectingScanners();
21-
Sut.AssertGivenStepResult(StepExecutionResult.Passed);
21+
Sut.AssertGivenStepResult(Result.Passed);
2222
}
2323

2424
[Test]
2525
public void WhenIsReportedAsSuccessfulWhenUsingReflectingScanners()
2626
{
2727
ExecuteUsingReflectingScanners();
28-
Sut.AssertWhenStepResult(StepExecutionResult.Passed);
28+
Sut.AssertWhenStepResult(Result.Passed);
2929
}
3030

3131
[Test]
3232
public void ThenIsReportedAsNotImplemenetedWhenUsingReflectingScanners()
3333
{
3434
ExecuteUsingReflectingScanners();
35-
Sut.AssertThenStepResult(StepExecutionResult.NotImplemented);
35+
Sut.AssertThenStepResult(Result.NotImplemented);
3636
}
3737

3838
[Test]
3939
public void ScenarioResultReturnsNoImplementedWhenUsingReflectingScanners()
4040
{
4141
ExecuteUsingReflectingScanners();
42-
Sut.AssertScenarioResult(StepExecutionResult.NotImplemented);
42+
Sut.AssertScenarioResult(Result.NotImplemented);
4343
}
4444

4545
[Test]
4646
public void StoryResultReturnsNoImplementedWhenUsingReflectingScanners()
4747
{
4848
ExecuteUsingReflectingScanners();
49-
Sut.AssertStoryResult(StepExecutionResult.NotImplemented);
49+
Sut.AssertStoryResult(Result.NotImplemented);
5050
}
5151

5252
[Test]
@@ -60,35 +60,35 @@ public void TearDownMethodIsExecutedWhenUsingReflectingScanners()
6060
public void GivenIsReportedAsSuccessfulWhenUsingFluentScanner()
6161
{
6262
ExecuteUsingFluentScanner();
63-
Sut.AssertGivenStepResult(StepExecutionResult.Passed);
63+
Sut.AssertGivenStepResult(Result.Passed);
6464
}
6565

6666
[Test]
6767
public void WhenIsReportedAsSuccessfulWhenUsingFluentScanner()
6868
{
6969
ExecuteUsingFluentScanner();
70-
Sut.AssertWhenStepResult(StepExecutionResult.Passed);
70+
Sut.AssertWhenStepResult(Result.Passed);
7171
}
7272

7373
[Test]
7474
public void ThenIsReportedAsNotImplemenetedWhenUsingFluentScanner()
7575
{
7676
ExecuteUsingFluentScanner();
77-
Sut.AssertThenStepResult(StepExecutionResult.NotImplemented);
77+
Sut.AssertThenStepResult(Result.NotImplemented);
7878
}
7979

8080
[Test]
8181
public void ScenarioResultReturnsNoImplementedWhenUsingFluentScanner()
8282
{
8383
ExecuteUsingFluentScanner();
84-
Sut.AssertScenarioResult(StepExecutionResult.NotImplemented);
84+
Sut.AssertScenarioResult(Result.NotImplemented);
8585
}
8686

8787
[Test]
8888
public void StoryResultReturnsNoImplementedWhenUsingFluentScanner()
8989
{
9090
ExecuteUsingFluentScanner();
91-
Sut.AssertStoryResult(StepExecutionResult.NotImplemented);
91+
Sut.AssertStoryResult(Result.NotImplemented);
9292
}
9393

9494
[Test]

0 commit comments

Comments
 (0)