specification

Type Members

1. case class AcceptanceCreationPath(path: Seq[Int]) extends CreationPath with Product with Serializable

2. case class Action(action: LazyParameter[Result] = lazyParameter(Success()), location: Location = new Location, isolable: Boolean = true, creationPath: Option[CreationPath] = None) extends Fragment with Executable with Isolable with Product with Serializable

   An Action is similar to a Step but can be executed concurrently with other examples.

3. trait After extends Context

   The After trait can be inherited by classes representing a context where an action must be executing after the main executable action

4. trait AfterContextExample[C <: After] extends ExamplesFactory

   For each created example use a given After context

5. trait AfterEach extends After with Apply

   apply an After context to each Example

6. trait AfterExample extends AfterContextExample[After]

   For each created example use a given after method

7. trait AllExpectations extends StoredExpectations with ExamplesFactory with SpecificationStructure with ArgumentsArgs

   This trait can be mixed-in a specification to allow examples to have all of their expectations being evaluated (unless the example body throws an exception of course).

8. trait Analysis extends DependencyMatchers

   This trait provides integrated analysis method for a scala project

9. trait Apply extends Context

   Apply a Context to a sequence of fragments containing examples.

10. trait Around extends Context

    The Around trait can be inherited by classes which will execute some code inside the around method provided by the context.

11. trait AroundContextExample[C <: Around] extends ExamplesFactory

    For each created example use a given Around context

12. trait AroundEach extends Around with Apply

    apply an Around context to each Example

13. trait AroundExample extends AroundContextExample[Around]

    For each created example use a given around method

14. trait AroundOutside[+T] extends Around with Outside[T]

    The AroundOutside trait can be inherited by classes which will execute some code inside a given context, with a function using that context and actions before and after if necessary.

15. trait BaseSpecification extends SpecificationStructure with FragmentsBuilder with SpecificationInclusion

    A Base specification contains the minimum elements for a Specification

16. trait Before extends Context

    The Before trait can be inherited by classes representing a context where an action must be executing before the main executable action

17. trait BeforeAfter extends Before with After

    The BeforeAfter trait allows to declare before and after actions to execute before and after an Example

18. trait BeforeAfterAround extends Before with After with Around

    The BeforeAfter trait allows to declare before, around and after actions

19. trait BeforeAfterAroundContextExample[C <: BeforeAfterAround] extends ExamplesFactory

    For each created example use a given BeforeAfterAround context

20. trait BeforeAfterAroundEach extends BeforeAfterAround with Apply

    apply a BeforeAfterAround context to each Example

21. trait BeforeAfterAroundExample extends BeforeAfterAroundContextExample[BeforeAfterAround]

    For each created example use a given before/after method

22. trait BeforeAfterContextExample[C <: BeforeAfter] extends ExamplesFactory

    For each created example use a given BeforeAfter context

23. trait BeforeAfterEach extends BeforeAfter with Apply

    apply a BeforeAfter context to each Example

24. trait BeforeAfterExample extends BeforeAfterContextExample[BeforeAfter]

    For each created example use a given before/after method

25. trait BeforeContextExample[C <: Before] extends ExamplesFactory

    For each created example use a given Before context

26. trait BeforeEach extends Before with Apply

    apply a Before context to each Example

27. trait BeforeExample extends BeforeContextExample[Before]

    For each created example use a given after method

28. trait Context extends Scope

    generic trait for Before, After, Around

29. trait Contexts extends AnyRef

    This trait is only used when we wish to write after actions in unit specifications like this

30. trait ContextsInjection extends Contexts

31. sealed trait CreationPath extends AnyRef

32. class DecoratedExampleFactory extends ExampleFactory

    Decorated creation where the body of the example can be surrounded with a given context if necessary

33. class DefaultExampleFactory extends ExampleFactory

    Default implementation for the example factory trait just creating an Example object

34. trait DefaultFragmentsFormatting extends FragmentsFormatting with TagsAssociation

35. case class Example extends Fragment with Executable with Isolable with Product with Serializable

    A Example is:

36. trait ExampleFactory extends AnyRef

    This trait defines methods for creating Examples.

37. trait ExamplesFactory extends AnyRef

38. case class ExamplesGroup(name: String = "") extends Product with Serializable

39. case class ExecutedBacktab(n: Int = 1, location: Location = new Location) extends ExecutedStandardFragment with Product with Serializable

40. case class ExecutedBr(location: Location = new Location) extends ExecutedStandardFragment with Product with Serializable

41. case class ExecutedEnd(location: Location = new Location) extends ExecutedStandardFragment with Product with Serializable

42. sealed trait ExecutedFragment extends AnyRef

    The Executed Fragments represent pieces of a Specification which have already been executed to provide a Result

43. case class ExecutedNoText(original: Fragment, timer: SimpleTimer = new SimpleTimer, location: Location = new Location) extends ExecutedFragment with Product with Serializable

    This executed Fragment is used when no text must be displayed (for the successful execution of an Action for example)

44. case class ExecutedResult(s: FormattedString, result: Result, timer: SimpleTimer, location: Location, statistics: Stats) extends ExecutedFragment with Product with Serializable

45. case class ExecutedSpecEnd(end: SpecEnd, location: Location = new Location, stats: Stats = Stats()) extends ExecutedFragment with Product with Serializable

46. case class ExecutedSpecStart(start: SpecStart, location: Location = new Location, stats: Stats = Stats().startTimer) extends ExecutedFragment with Product with Serializable

47. case class ExecutedSpecification(name: SpecName, fs: Seq[ExecutedFragment]) extends Product with Serializable

    A specification with a name and all of its fragments already executed

48. trait ExecutedStandardFragment extends ExecutedFragment

49. case class ExecutedTab(n: Int = 1, location: Location = new Location) extends ExecutedStandardFragment with Product with Serializable

50. case class ExecutedText(textFragment: Text, location: Location = new Location) extends ExecutedFragment with Product with Serializable

51. sealed trait ExecutingFragment extends AnyRef

    The Executing Fragment trait represent a Fragment being executed.

52. case class ExecutingSpecification(name: SpecName, arguments: Arguments, fs: Seq[ExecutingFragment], executor: ExecutorService) extends Product with Serializable

    a specification with a name and a sequence of fragments being executed

53. case class FinishedExecutingFragment(f: ExecutedFragment) extends ExecutingFragment with Product with Serializable

    embed an already executed Fragment

54. trait Fixture[T] extends AnyRef

    A Fixture can be implicitly passed to a set of examples taking a function as an input.

55. trait FixtureExample[T] extends AnyRef

    For each created example use a given after method

56. case class FormFormattedString(f: () ⇒ Form, formatting: Formatting = Formatting(), isEmpty: Boolean = false, display: (Form) ⇒ String = (ff: Form) => new FormCell(ff).text) extends FormattedString with Product with Serializable

    The FormFormattedString embeds the description of a form as text or as Xml

57. trait FormFragmentExecution extends FragmentExecution

    This trait executes Form Fragments in addition to other fragments

58. trait FormFragmentsBuilder extends FragmentsBuilder

59. trait FormSpecificationStringContext extends SpecificationStringContext

    Allow to use forms inside interpolated strings starting with s2 in order to build the specification content

60. trait FormattedString extends AnyRef

61. case class Formatting(flow: Boolean = false, markdown: Boolean = true, verbatim: Boolean = true) extends Product with Serializable

    Formatting for Text fragments

62. trait FormattingFragments extends AnyRef

    Set of fragments which can be used for formatting

63. trait FormattingTags extends Tags

64. trait Forms extends FormsBuilder with FormFragmentsBuilder with DecoratedProperties with FormFragmentExecution with FormSpecificationStringContext

    Allow a Form to be inserted among Fragments as a Text Fragment Allow a Form to be used as an example body and return a Result automatically

65. sealed trait Fragment extends AnyRef

    A Fragment is a piece of a specification.

66. trait FragmentExecution extends AnyRef

    This trait executes Fragments

67. case class Fragments(specTitle: Option[SpecName] = None, middle: Seq[Fragment] = Stream().toSeq, arguments: Arguments = Arguments(), linked: Linked = Linked()) extends Product with Serializable

    A Fragments object is a list of fragments with a SpecStart and a SpecEnd

68. trait FragmentsBuilder extends ExamplesFactory with ImplicitParameters with FormattingTags

    This trait provides function to create specification Fragments:

69. trait FragmentsFormatting extends AnyRef

    This trait post-process fragments.

70. class FragmentsFragment extends AnyRef

    Fragments can be chained with the ^ method

71. abstract class Given[T] extends RegexExtractor[Unit, T]

    This step can start a sequence of Given / When / Then.

72. abstract class GivenThen extends RegexExtractor[String, Result]

73. class GivenThenFunction[R] extends GivenThen

74. trait GivenWhenThen extends RegexStepsFactory with TuplesToSeq with FragmentsBuilder with SpecificationStringContext with ArgumentsArgs

    This trait provides building blocks to create steps and examples from regular expression.

75. trait Grouped extends GroupsLike

    This trait can be used to standardize names for groups of examples in an acceptance specification.

76. trait Groups extends GroupsLike

    This trait can be used to standardize names for groups of examples in an acceptance specification.

77. trait GroupsLike extends AnyRef

78. abstract class HtmlLink extends AnyRef

    The HtmlLink class represents a link in a specification with an identifier (either a spec name, or a string) and link elements.

79. case class LazyExecutingFragment(f: () ⇒ ExecutedFragment, original: Fragment) extends ExecutingFragment with Product with Serializable

    embed an executing Fragment into a function to execute it on demand

80. case class Linked(link: Option[HtmlLink] = None, seeOnly: Boolean = false, hidden: Boolean = false) extends Product with Serializable

    encapsulation of the linking behaviour

81. case class MarkdownLink(name: String, url: String) extends Product with Serializable

    This class provides functionalities for manipulating Markdown links

82. case class MutableCreationPath(path: Seq[Int]) extends CreationPath with Product with Serializable

83. trait NoAutoExamples extends NoBooleanAutoExamples with NoResultAutoExamples with NoMatchResultAutoExamples with NoDataTableAutoExamples

    This trait ca be used to deactivate all automatic conversions to examples

84. trait NoBangExamples extends FragmentsBuilder

    This trait deactivates the implicit on Strings which is used to create examples with !

85. trait NoBooleanAutoExamples extends AutoExamples

    This trait can be used to deactivate the Boolean conversions to fragments and examples

86. trait NoContexts extends Contexts

    Use this trait to deactivate the Contexts implicits

87. trait NoDataTableAutoExamples extends AutoExamples

    This trait can be used to deactivate the DataTable conversions to fragments and examples

88. trait NoFragmentsBuilder extends FragmentsBuilder with NoToHtmlLinkFragments

    This trait can be used to deactivate implicits for building fragments

89. trait NoMatchResultAutoExamples extends AutoExamples

    This trait can be used to deactivate the MatchResult conversions to fragments and examples

90. trait NoResultAutoExamples extends AutoExamples

    This trait can be used to deactivate the Result conversions to fragments and examples

91. trait NoToHtmlLinkFragments extends FragmentsBuilder

    This trait can be used to deactivate implicits for ~ and ~/ operators on strings

92. trait Outside[+T] extends AnyRef

    The Outside trait can be inherited by classes which will execute some code inside the outside method provided by the context.

93. case class PromisedExecutingFragment(promised: Promise[ExecutedFragment], original: Fragment) extends ExecutingFragment with Product with Serializable

    embed an executed Fragment into a promise

94. trait RegexFragment extends AnyRef

95. trait RegexStepsFactory extends ImplicitParameters

96. class ResultsContext extends StoredResultsContext

    This class is used to evaluate a Context as a sequence of results by side-effects.

97. trait Scope extends matcher.Scope

    Marker trait that is used to create a new scope with variables and implicitly converted to a Success in a mutable Specification

98. case class SimpleFormattedString(t: String = "", formatting: Formatting = Formatting(), isEmpty: Boolean = false, isCode: Boolean = true) extends FormattedString with Product with Serializable

99. trait Snippets extends execute.Snippets

    Snippets of code can be extracted from interpolated specification strings.

100. case class SpecEnd(specName: SpecName, isSeeOnlyLink: Boolean = false, location: Location = new Location) extends Fragment with Product with Serializable

     End of a specification.

101. case class SpecHtmlLink(name: SpecName, beforeText: String = "", linkText: String = "", afterText: String = "", tip: String = "") extends HtmlLink with Product with Serializable

102. trait SpecIdentification extends AnyRef

     Identification information for a specification

103. sealed trait SpecName extends SpecIdentification

     Name declaration for a specification

104. trait SpecPart extends AnyRef

105. case class SpecStart(specName: SpecName, arguments: Arguments = Arguments(), linked: Linked = Linked(), location: Location = new Location) extends Fragment with Product with Serializable

     Start of a specification.

106. trait SpecificationInclusion extends AnyRef

     additional methods to include other specifications or Fragments

107. trait SpecificationNavigation extends AnyRef

     This trait models "what happens" before a fragment is created in terms of side-effects.

108. trait SpecificationStringContext extends AnyRef

     Allow to use fragments inside interpolated strings starting with s2 in order to build the specification content

109. trait SpecificationStructure extends DefaultFragmentsFormatting

     The structure of a Specification is simply defined as a sequence of fragments

110. case class Stats(examples: Int = 0, successes: Int = 0, expectations: Int = 0, failures: Int = 0, errors: Int = 0, pending: Int = 0, skipped: Int = 0, trend: Option[Stats] = None, timer: SimpleTimer = new SimpleTimer) extends Product with Serializable

     The Stats class store results for the number of: - successes - expectations - failures - errors - pending - skipped

111. case class Step(step: LazyParameter[Result], stopOnFail: Boolean = false, location: Location = new Location, isolable: Boolean = true) extends Fragment with Executable with Isolable with Product with Serializable

     An Step creates a fragment that will either return an Error Result if there is an exception or a Success.

112. trait StoredExpectationsContext extends StoredExpectations with StoredResultsContext

     This trait can be used when it is not desirable to use the AllExpectations trait, that is, when the specification examples must be executed concurrently and not isolated.

113. trait StoredResultsContext extends Context

     This trait is a context which will use the results provided by the class inheriting that trait.

114. trait Tables extends DataTables with NoBangExamples

115. trait Tags extends AnyRef

     The tags trait allows the creation of Tags fragments in a Specification

116. trait TagsAssociation extends AnyRef

117. case class Text(text: SimpleFormattedString, location: Location = new Location) extends Fragment with Product with Serializable

     Free text, describing the system to specify

118. abstract class Then[T] extends RegexExtractor[Either[Result, T], (T, Result)]

     This step define checks in a sequence of Given / When / Then.

119. case class UrlHtmlLink(url: String, beforeText: String = "", linkText: String = "", afterText: String = "", tip: String = "") extends HtmlLink with Product with Serializable

120. abstract class When[P, T] extends RegexExtractor[P, T]

     This step define conditions in a sequence of Given / When / Then.