メニュー
How to define operations with Apply and Execute methods - use this skill when creating spec operations or understanding the Apply/Execute pattern
デフォルトでは、最初にソースを確認する Prompt が選択されています。直接コマンドに切り替えるか、ローカルコピーをダウンロードすることもできます。
インストールを決める前に、SKILL.md と SkillsMP に表示されている付属ファイルをお読みください。
Codex または Claude でインストール この Prompt をコピーして Codex、Claude、または他のアシスタントに貼り付けると、Skill ページを確認してインストールできます。
直接コマンドでは確認用 Prompt が省略されます。実行前にソースを確認してください。
npx skills add https://github.com/microsoft/accordant --skill accordant-operationsコマンドは1行のまま表示されます。コピー前に横へスクロールして全体を確認してください。
ローカルで確認しますか？SkillsMP が現在取得できるファイルをダウンロードできます。
Testing systems not written in .NET - trace-based conformance testing, JSON test plan export, and executing from any language. Use when the user's system is in Python, Go, Java, Rust, C++, or any non-.NET language, or when they ask about trace validation or exporting test cases.
How to test for race conditions using concurrent tests and linearizability - use this skill when testing concurrent operations or finding race condition bugs
Quick reference and cheatsheet for Accordant API - use this skill for quick syntax lookup or code snippets
SKILL.md を表示中
SOC 職業分類に基づく
| name | accordant-operations |
| description | How to define operations with Apply and Execute methods - use this skill when creating spec operations or understanding the Apply/Execute pattern |
An operation represents an atomic action your system can perform. Each operation has two parts:
For simple specs, define operations inline:
var spec = new Spec<BankState>();
spec.Operation<string, ApiResult<decimal>>("CreateAccount", (accountId, state) =>
{
// Apply logic here
if (state.Accounts.ContainsKey(accountId))
return Expect.That<ApiResult<decimal>>(r => r.IsConflict).SameState();
return Expect.That<ApiResult<decimal>>(r => r.IsSuccess && r.Data == 0)
.ThenState<BankState>(s => s.Accounts[accountId] = 0);
});
Connect spec operations to real system calls:
spec.ExecuteWith<BankApiClient>()
.Bind<string, ApiResult<decimal>>("CreateAccount",
(client, accountId) => client.CreateAccount(accountId).Result)
.Bind<(, ), ApiResult<>>(,
(client, req) => client.Withdraw(req.Item1, req.Item2).Result);
For complex operations, use classes:
public class WithdrawOperation : Operation<WithdrawRequest, ApiResult<decimal>, BankState>
{
public override ExpectedOutcomes Apply(WithdrawRequest request, BankState state)
{
if (!state.Accounts.TryGetValue(request.AccountId, out var balance))
return Expect.That<ApiResult<decimal>>(r => r.IsNotFound).SameState();
if (balance < request.Amount)
return Expect.That<ApiResult<decimal>>(r => r.IsBadRequest).SameState();
var newBalance = balance - request.Amount;
return Expect.That<ApiResult<decimal>>(r => r.IsSuccess && r.Data == newBalance)
.ThenState<BankState>(s => s.Accounts[request.AccountId] = newBalance);
}
public override async Task<ApiResult<decimal>> ExecuteAsync(
WithdrawRequest request,
TestingContext context)
{
var client = context.Get<BankApiClient>();
return await client.WithdrawAsync(request.AccountId, request.Amount);
}
}
Apply defines expected behavior. Given a request and state, return ExpectedOutcomes:
spec.Operation<(string AccountId, decimal Amount), ApiResult<decimal>>("Deposit", (request, state) =>
{
// Check preconditions first (guard clauses)
if (!state.Accounts.TryGetValue(request.AccountId, out var balance))
return Expect.That<ApiResult<decimal>>(r => r.IsNotFound).SameState();
// Happy path last
var newBalance = balance + request.Amount;
return Expect.That<ApiResult<decimal>>(r => r.IsSuccess && r.Data == newBalance)
.ThenState<BankState>(s => s.Accounts[request.AccountId] = newBalance);
});
Key points:
Expect.That<int>(r => r == 42)
Expect.That<ApiResult<decimal>>(
r => r.IsSuccess && r.Data == expectedBalance,
$"Should return 200 OK with balance {expectedBalance}")
Explanations appear in test failure output — crucial for debugging.
For complex validations with detailed error messages:
Expect.That<User>(response =>
{
if (response.Name != expectedName)
return ValidationResult.Invalid($"Name was '{response.Name}', expected '{expectedName}'");
if (response.Email == null)
return ValidationResult.Invalid("Email was null");
return ValidationResult.Valid();
})
.SameState()// Error cases
return Expect.That<ApiResult<User>>(r => r.IsNotFound).SameState();
// Read-only operations
return Expect.That<ApiResult<User>>(r => r.IsSuccess).SameState();
.ThenState()return Expect.That<ApiResult<decimal>>(r => r.IsSuccess && r.Data == newBalance)
.ThenState<BankState>(nextState => nextState.Accounts[accountId] = newBalance);
When state depends on server-generated values:
return Expect.That<ApiResult<Order>>(r => r.IsSuccess && !string.IsNullOrEmpty(r.Data.OrderId))
.ThenState<AppState>(
(ApiResult<Order> response, AppState nextState) =>
nextState.Orders[response.Data.OrderId] = new OrderState { /* ... */ },
mock: () => new ApiResult<Order>
{
Data = new Order { OrderId = Guid.NewGuid().ToString() },
StatusCode = 201
});
When more than one outcome is valid (timeouts, non-determinism):
spec.Operation<string, ApiResult<decimal>>("CreateAccount", (accountId, state) =>
{
if (state.Accounts.ContainsKey(accountId))
return Expect.That<ApiResult<decimal>>(r => r.IsConflict).SameState();
return Expect.OneOf(
// Success
Expect.That<ApiResult<decimal>>(r => r.IsSuccess && r.Data == 0)
.ThenState<BankState>(s => s.Accounts[accountId] = 0),
// Timeout - request lost
Expect.That<ApiResult<decimal>>(r => r.IsTimeout)
.SameState(),
// Timeout - response lost (account was created)
Expect.That<ApiResult<decimal>>(r => r.IsTimeout)
.ThenState<BankState>(s => s.Accounts[accountId] = 0)
);
});
When operations should throw:
spec.Operation<string, Unit>("DeleteUser", (userId, state) =>
{
if (!state.Users.ContainsKey(userId))
return Expect.Throws<NotFoundException>("User not found").SameState();
if (state.Users[userId].HasPendingOrders)
return Expect.Throws<BusinessRuleException>("Cannot delete user with pending orders").SameState();
return Expect.That<Unit>(r => true)
.ThenState<AppState>(s => s.Users.Remove(userId));
});
Use Unit as the response type for void operations.
Weak (catches fewer bugs):
Expect.That<ApiResult<User>>(r => r.IsSuccess) // Only checks status
Strong (catches more bugs):
Expect.That<ApiResult<User>>(
r => r.IsSuccess &&
r.Data.Id == expectedId &&
r.Data.Name == expectedName &&
r.Data.Email == expectedEmail)
The stronger your predicates, the more bugs you'll catch.
spec.Operation<TransferRequest, ApiResult<decimal>>("Transfer", (req, state) =>
{
// Guards first
if (!state.Accounts.ContainsKey(req.FromAccount))
return Expect.That<ApiResult<decimal>>(r => r.IsNotFound, "Source not found").SameState();
if (!state.Accounts.ContainsKey(req.ToAccount))
return Expect.That<ApiResult<decimal>>(r => r.IsNotFound, "Target not found").SameState();
var balance = state.Accounts[req.FromAccount];
if (balance < req.Amount)
return Expect.That<ApiResult<decimal>>(r => r.IsBadRequest, "Insufficient funds").SameState();
// Happy path last
var newFromBalance = balance - req.Amount;
var newToBalance = state.Accounts[req.ToAccount] + req.Amount;
return Expect.That<ApiResult<decimal>>(r => r.IsSuccess && r.Data == newFromBalance)
.ThenState<BankState>(s => {
s.Accounts[req.FromAccount] = newFromBalance;
s.Accounts[req.ToAccount] = newToBalance;
});
});