fsprojects/TickSpec

TickSpec is a Behavior-Driven Development (BDD) framework for .NET that enables teams to define and execute software specifications using Gherkin feature files. It provides a modular architecture with support for multiple test runners, including xUnit, NUnit, MSTest, and Expecto, as well as various coding styles such as attribute-based, functional, and interactive execution. The system facilitates dependency injection and state management across scenarios, offering comprehensive examples for both C\# and F\# developers to integrate BDD practices into their CI/CD pipelines.

12 changes.

The project underwent a significant architectural rewrite, refactoring the core TickSpec library into a modular structure with enhanced Gherkin support and improved debugging capabilities. This period also focused on expanding the framework's ecosystem by introducing official NuGet packages for NUnit and xUnit, migrating to modern .NET SDK-style projects, and providing extensive examples across multiple languages and testing styles.

6 changes.

This period focused on expanding the project's example suite with advanced functional programming and dependency injection patterns. New projects demonstrated behavior-driven development techniques using functional state management, custom DI containers like Autofac, and integration with testing frameworks such as xUnit and NUnit.

5 changes.

This period focused on expanding TickSpec's compatibility by adding official integration examples and wiring for the xUnit, MSTest, and Expecto testing frameworks. The work also established a robust CI/CD pipeline using a FAKE build script with GitHub Actions and NuGet publishing capabilities, alongside comprehensive test coverage for Gherkin parsing edge cases.

The CustomContainer example now demonstrates how to integrate TickSpec with the Autofac dependency injection container. This includes wiring Autofac as an xUnit class fixture to manage the container lifecycle, registering domain types (such as DogRun as a singleton and Cattery/Kennel via delegate factories), and configuring scoped service providers for individual test scenarios. The example features a contrived shelter scenario to illustrate how step definitions can receive injected dependencies and how single-instance resources are handled across the test run.

Examples/ByFeature/CustomContainer · high confidence

Added a new example project in the Examples/ByFramework/Expecto/FSharp.Expecto directory that demonstrates how to use the Expecto testing framework with TickSpec for Behavior-Driven Development. The example includes a calculator domain model and stock management scenarios, implemented as F\# step definitions and feature files, providing a reference implementation for users wanting to integrate Expecto with Gherkin-style tests.

Examples/ByFramework/Expecto, Expecto.FSharp · high confidence

The Examples/ByFeature/DependencyInjection directory now contains a complete example demonstrating dependency injection with TickSpec and NUnit. This includes domain models (Dog, DogBowl), Gherkin feature files defining feeding scenarios, step definitions that utilize an IInstanceProvider for dependency resolution, and NUnit wiring to execute the BDD tests.

Examples/ByFeature/DependencyInjection · high confidence

Added a new F\# example under the MSTest framework that demonstrates how to run BDD (Behavior-Driven Development) tests using TickSpec. The example includes a feature file defining stock return scenarios, step definitions implementing the business logic for buying and returning items, and a test wiring module that discovers and executes these scenarios as MSTest unit tests.

Examples/ByFramework/MSTest, MSTest.FSharp · high confidence

The Examples/ByStyle/Interactive directory now includes a F\# implementation of an interactive Behavior-Driven Development (BDD) story runner. This addition provides a new Calculator.fs example demonstrating how to define Given/When/Then steps and execute feature scenarios interactively, supported by the new StoryRunner.fs module which handles step parsing and execution logic.

Examples/ByStyle/Interactive, FSharp · high confidence

A new example file (Retail.fs) has been added to the F\# xUnit examples directory, defining a simple StockItem record type within the Retail namespace to demonstrate xUnit usage in F\#.

Xunit.FSharp · high confidence

The F\# xUnit example project now includes concrete BDD scenarios for a calculator (addition) and inventory management (stock refunds and replacements). These examples demonstrate how to define feature files, implement step definitions using TickSpec and xUnit attributes, and wire up test execution in F\#.

Examples/ByFramework/xUnit · high confidence

New example files have been added to the Attributes section: Atm.fs demonstrates a simple cash dispensing workflow using abstract types and event yields, while ImpliedPrice.fs provides a TickSpec-based BDD implementation for parsing and validating outright and synthetic market orders from tabular data.

Attributes · high confidence

New functional-style example projects for Hangman and Scrabble have been added to the Examples/ByStyle/Functional directory, providing users with additional reference implementations for these specific game scenarios using the functional programming style.

Functional · medium confidence

New functional-style examples have been added to the Examples/ByStyle/Functional directory, demonstrating the TickSpec framework with Hangman and Scrabble game logic. These examples include feature files (Hangman.feature, Scrabble.feature) defining scenarios, along with corresponding F\# implementation files (Hangman.fs, Scrabble.fs, HangmanSteps.fs, ScrabbleSteps.fs) that utilize the new Functional module's pattern matching and state-handling capabilities. The Scrabble example also includes parameterized scenarios for testing multiple word scores.

Examples/ByStyle/Functional · high confidence

This change introduces the foundational repository structure for the TickSpec BDD framework. It adds essential configuration files including \.gitattributes\ and \.gitignore\ for version control hygiene, a \LICENSE.txt\ adopting the Apache 2.0 license, and \Directory.Build.props\ to standardize build properties (such as F\# Core references and SourceLink) across the solution. The \TickSpec.sln\ file is restructured to organize projects into logical folders (ByFramework, ByStyle, ByFeature) and includes the core library, test project, and various example implementations for xUnit, NUnit, and Expecto. Additionally, \README.md\ and \RELEASE\_NOTES.md\ are added to document usage and version history.

(repo-wide) · high confidence

Added a new FAKE build script (Build.fs) that initializes the execution context from command-line arguments and defines a target pipeline (Clean, Build, Test, Nuget, PublishNuget). The script integrates with GitHub Actions by detecting the CI environment via the BUILD\_NUMBER environment variable to enable continuous integration build flags. It reads versioning information from RELEASE\_NOTES.md and supports publishing NuGet packages only on Windows, requiring the NUGET\_KEY environment variable for authentication with the NuGet API.

fake-build · high confidence

The FunctionalInjection example area now demonstrates a behavior-driven development pattern where step definitions manage and pass state implicitly via function return values. New files define domain models (Dog, Catalog, Wallet) and step implementations (WalletSteps, ShoppingSteps, Room) that use TickSpec attributes to inject and retrieve state (e.g., wallet balance, catalog data) between Given/When/Then steps without explicit global variables. The example also includes a Logger module for scenario lifecycle logging and a renamed StockItem file, illustrating how functional composition can replace traditional class-based state management in BDD scenarios.

FunctionalInjection · high confidence

Adds a new Wiring component (TickSpec.Xunit) that enables running TickSpec-based BDD scenarios within the xUnit framework. This includes build configuration to package the library and a FeatureSetup module that serializes scenarios for individual debugging in IDEs like Visual Studio and Rider, allowing users to execute and debug feature files directly using xUnit.

Wiring · high confidence

The Examples/ByFeature directory now includes two new sample projects demonstrating advanced TickSpec capabilities. The FunctionalInjection example showcases functional dependency injection patterns, featuring scenarios for dog feeding, computer heating, shopping, stock management, and wallet transactions, along with a new NunitWiring module to execute these scenarios. The TaggedExamples project demonstrates how to organize tests using tags (such as @Smoke and @Regression) and shared examples, with specific implementations for HTTP server testing and web login workflows.

Examples/ByFeature/FunctionalInjection · high confidence

Added new example projects for the NUnit framework in both C\# and F\#, providing complete wiring and step-definition implementations for BDD scenarios. The C\# example demonstrates a basic stock-refund scenario, while the F\# example includes more complex features such as a stock replacement scenario with tags and a Tic-Tac-Toe game using parameterized scenarios and table inputs.

Examples/ByFramework/NUnit · high confidence

This release introduces two new NuGet packages, TickSpec.NUnit and TickSpec.xUnit, providing integration for the TickSpec BDD framework with NUnit and xUnit test runners respectively. Each package includes sample content (F\# fixtures and Gherkin feature files) to demonstrate usage, with the xUnit package specifically updated to support xUnit 2 via the new XunitFeature and XunitWiring modules.

Nuget · high confidence

The Examples/ByStyle/Attributes directory now contains a complete set of sample scenarios demonstrating the attribute-based style of behavior-driven development. This includes feature files (e.g., Addition, Coffee, Scrabble) and corresponding F\# step definition modules that use TickSpec attributes (such as \[\<Given\>\], \[\<When\>\], \[\<Then\>\]) to map Gherkin steps to code. The examples cover various BDD patterns including simple scenarios, scenario outlines with data tables, and state management across scenarios, providing a reference implementation for users adopting this testing style.

Examples/ByStyle/Attributes · high confidence

The F\# example project has been removed, deleting the entry point (Program.fs) that previously executed Gherkin feature files using the TickSpec library and the associated C\# assembly metadata file. Users can no longer run or debug the F\#-based Behavior-Driven Development examples provided in this location.

Examples/FSharp · high confidence

The example projects have been restructured into the Examples/ByFramework/CommandLine directory, with C\# and FSharp examples moved from their previous locations. The C\# examples now use the TickSpec.Examples.CSharp namespace and updated execution logic to handle feature file paths explicitly. A new TicTacToe example has been added for both C\# and FSharp, demonstrating game logic with step definitions and feature files. The FSharp example also includes a minor whitespace fix in the feature file.

Examples/ByFramework/CommandLine · high confidence

The TickSpec library has been completely refactored from a single monolithic file into a modular structure, introducing dedicated modules for parsing (BlockParser, FeatureParser, LineParser), execution (ScenarioRun), and dependency injection (ServiceProvider). This rewrite adds support for advanced Gherkin features including Rules, Shared Examples, and doc strings, while also introducing new attributes for event handling (Before/After Scenario/Step) and step scoping (StepScopeAttribute). The framework now supports dynamic code generation for improved debugging experiences and provides a more robust instance provider with circular dependency detection and IDisposable support.

TickSpec · high confidence

Added test coverage in TickSpec.Tests for parsing escaped pipes, backslashes, and newlines within Gherkin table cells and doc strings, as well as validating the new Rule keyword support and placeholder replacement in items, tags, and examples.

TickSpec.Tests · high confidence

The project has migrated from legacy MSBuild formats to the modern .NET SDK-style project system. The core TickSpec library now targets .NET Standard 2.0 and .NET Framework 4.5.2, and all example projects (including xUnit, NUnit, MSTest, Expecto, and command-line samples) have been restructured to use SDK-style .fsproj/.csproj files targeting .NET 6.0 and .NET Framework 4.5.2. This change updates dependency management to use PackageReference and aligns the build system with current .NET tooling.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 59 → 59 (+0.2)
• Rubric changed (rubric-2026.09.13 → rubric-2026.10.1) — scores are not directly comparable.

• Code Health 99 → 99 (+0.0)
• Architecture 95 → 98 (+3.0)
• Maturity 51 → 51 (+0.0)
• Readiness 54 → 54 (+0.0)
• Security 62 → 61 (-0.5)

• Documentation: no usage examples (README.md)
• Off-boarding risk: anonymized user #1
• The step definitions for stock operations are split between two classes: StockStepDefinitions and StockSteps. While they may contain different steps, the naming convention is inconsistent (StepDefinitions vs Steps) for what appears to be the same logical grouping of BDD steps.
• The type StockItem is defined in two different namespaces (TickSpec.Examples.CSharp and CSharp) with identical names, suggesting potential duplication or namespace collision for the same concept.

• End-of-life runtime: .NET net6.0
• Off-boarding risk: anonymized user #1

• Unchanged — 0 containers · 9 contexts · 6 edges

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

fsprojects/TickSpec was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.