Context

gistfile1.txt

public class AccountSpecifications
{
    const decimal perTransactionFee = 0.99m;
    
    public Specification when_withdrawing_money()
    {
        var currentBalance = 13.0m;
        
        return new ActionSpecification<AccountContext>
        {
           On = () => new AccountContext {
                        Account = new Account(currentBalance),
                        Command = new WithdrawCommand
                                      {
                                          Amount = 12.00m
                                      }
                      },
           When = account => account.Handle(cmd),
           Expect =
           {
               account => account.Balance == (currentBalance - cmd.Amount) - perTransactionFee,
               account => account.CloseToZeroBalance
           },
        };
    }

    public class AccountContext {
      public Command Command;
      public Account Account;
    }
}

To be clear on the ability to use it with just command. you can pretty easily write your own template to support this or could just drop in a dynamic :)

If you look in the other sepcification templates (which are just examples btw its expected that you may run your own) you will notice operations called transformedby you could do this there... or you could just do this

CommandContext {
dynamic sut;
Command command;
}

yeah I know not the most beautiful do you really need strong typing here?

Anyway, having specs defined as fields leads to inconvenient developer experience with test runners

Strong-typing? Why not? :)

If you want strong typing just make your own template (like what ActionSpecification does).

For runners I know all about fields :) I built all that support into mighty moose for simple.testing and for machine.specs

btw for a reference see:

https://github.com/gregoryyoung/Simple.Testing/blob/master/src/Simple.Testing.ClientFramework/SpecificationTemplates.cs

At the end of the day its just doing Expect(When(Given())) you can change what the pipeline types are along the way (the templates just give strong typing to it as a template)

ok, I'll have a look. Tnx!