菜单
Common patterns in Accordant - response-dependent state, request derivations, error handling, and HTTP integration
默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。
决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/microsoft/accordant --skill accordant-patterns命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
基于 SOC 职业分类
正在显示 SKILL.md
| name | accordant-patterns |
| description | Common patterns in Accordant - response-dependent state, request derivations, error handling, and HTTP integration |
This skill covers frequently-used patterns when building Accordant specs.
When state depends on server-generated values (IDs, timestamps, ETags):
spec.Operation<CreateOrderRequest, ApiResult<Order>>("CreateOrder", (request, state) =>
{
return Expect.That<ApiResult<Order>>(
r => r.IsSuccess && !string.IsNullOrEmpty(r.Data.OrderId))
.ThenState<AppState>(
// Lambda receives response AND a pre-cloned nextState
(ApiResult<Order> response, AppState nextState) =>
nextState.Orders[response.Data.OrderId] = new OrderState
{
Product = request.Product,
Status = OrderStatus.Created
},
// Mock for test generation (no real system running)
mock: () => new ApiResult<Order>
{
Data = new Order
{
OrderId = Guid.NewGuid().ToString(),
Product = request.Product
},
StatusCode = 201
});
});
During test generation, there's no real server. The mock provides a plausible response so Accordant can explore the state space. At test execution, the mock is ignored — real responses are used.
spec.Operation<, ApiResult<Order>>(, (orderId, state) =>
{
(!state.Orders.TryGetValue(orderId, order))
Expect.That<ApiResult<Order>>(r => r.IsNotFound).SameState();
Expect.That<ApiResult<Order>>(
r => r.IsSuccess &&
r.Data.OrderId == orderId &&
r.Data.Product == order.Product &&
r.Data.Status == order.Status)
.SameState();
});
When one operation's request needs data from another operation's response:
// CreateTodo returns a server-generated TodoId
// GetTodo needs that TodoId
spec.ConfigureDerivations("GetTodo",
Derive.From<CreateTodoRequest, CreateTodoResponse, string>("CreateTodo")
.When((createReq, createResp) => createResp.IsSuccess)
.As((createReq, createResp) => createResp.TodoId));
If the client controls all IDs (not server-generated), no derivation needed:
// Client picks the key
await api.CreateItem("my-key", "my-value");
await api.GetItem("my-key"); // No derivation needed - we know the key
Derivations are only needed when you must extract values from responses.
A common pattern for HTTP responses:
public class ApiResult<T>
{
public T? Data { get; set; }
public int StatusCode { get; set; }
public bool IsSuccess => StatusCode >= 200 && StatusCode < 300;
public bool IsNotFound => StatusCode == 404;
public bool IsConflict => StatusCode == 409;
public bool IsBadRequest => StatusCode == 400;
}
spec.ExecuteWith<HttpClient>()
.BindAsync<string, ApiResult<User>>("GetUser", async (client, userId) =>
{
var response = await client.GetAsync($"/api/users/{userId}");
return new ApiResult<User>
{
StatusCode = (int)response.StatusCode,
Data = response.IsSuccessStatusCode
? await response.Content.ReadFromJsonAsync<User>()
: null
};
});
public class BankApiClient
{
private readonly HttpClient _client;
public async Task<ApiResult<decimal>> CreateAccount(string accountId)
{
var response = await _client.PutAsync($"/accounts/{accountId}", null);
return await ParseResponse<decimal>(response);
}
public async Task<ApiResult<decimal>> Withdraw(string accountId, decimal amount)
{
var content = JsonContent.Create(new { amount });
var response = await _client.PostAsync($"/accounts/{accountId}/withdraw", content);
return await ParseResponse<decimal>(response);
}
}
// Bind
spec.ExecuteWith<BankApiClient>()
.Bind<string, ApiResult<decimal>>("CreateAccount", (c, id) => c.CreateAccount(id).Result)
.Bind<(string, decimal), ApiResult<decimal>>("Withdraw", (c, r) => c.Withdraw(r.Item1, r.Item2).Result);
spec.Operation<string, ApiResult<User>>("GetUser", (userId, state) =>
{
if (!state.Users.ContainsKey(userId))
return Expect.That<ApiResult<User>>(r => r.IsNotFound, "User not found").SameState();
var user = state.Users[userId];
return Expect.That<ApiResult<User>>(r => r.IsSuccess && r.Data.Name == user.Name).SameState();
});
spec.Operation<string, Unit>("DeleteUser", (userId, state) =>
{
if (!state.Users.ContainsKey(userId))
return Expect.Throws<NotFoundException>("User not found").SameState();
return Expect.That<Unit>(r => true)
.ThenState<AppState>(s => s.Users.Remove(userId));
});
spec.Operation<TransferRequest, ApiResult<decimal>>("Transfer", (req, state) =>
{
// Check each error condition
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();
if (state.Accounts[req.FromAccount] < req.Amount)
return Expect.That<ApiResult<decimal>>(r => r.IsBadRequest, "Insufficient funds").SameState();
// Success path
var newBalance = state.Accounts[req.FromAccount] - req.Amount;
return Expect.That<ApiResult<decimal>>(r => r.IsSuccess && r.Data == newBalance)
.ThenState<AppState>(s => {
s.Accounts[req.FromAccount] = newBalance;
s.Accounts[req.ToAccount] += req.Amount;
});
});
When you can't tell if an operation succeeded (timeout, network error):
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 never reached server
Expect.That<ApiResult<decimal>>(r => r.IsTimeout)
.SameState(),
// Timeout - server processed it, response lost
Expect.That<ApiResult<decimal>>(r => r.IsTimeout)
.ThenState<BankState>(s => s.Accounts[accountId] = 0)
);
});
Both timeout outcomes are valid — you don't know which actually happened until you check.
Expect.That<User>(response =>
{
try
{
response.Should().BeEquivalentTo(expectedUser, options => options
.Excluding(x => x.CreatedAt)
.Excluding(x => x.UpdatedAt));
return ValidationResult.Valid();
}
catch (Exception ex)
{
return ValidationResult.Invalid(ex.Message);
}
})
Expect.That<OrderResponse>(response =>
{
var errors = new List<string>();
if (response.OrderId == null)
errors.Add("OrderId was null");
if (response.Items.Count != expectedCount)
errors.Add($"Expected {expectedCount} items, got {response.Items.Count}");
if (response.Total != expectedTotal)
errors.Add($"Expected total {expectedTotal}, got {response.Total}");
return errors.Count == 0
? ValidationResult.Valid()
: ValidationResult.Invalid(string.Join("; ", errors));
})
For operations with multiple parameters:
// Define with tuple
spec.Operation<(string AccountId, decimal Amount), ApiResult<decimal>>("Withdraw", (request, state) =>
{
var (accountId, amount) = request; // Destructure
// ... logic using accountId and amount
});
// Create inputs
var inputs = new InputSet
{
spec.GetOperation<(string, decimal), ApiResult<decimal>>("Withdraw")
.With(("alice", 50m), "Withdraw 50 from alice"),
};
// Bind execution
spec.ExecuteWith<BankApiClient>()
.Bind<(string, decimal), ApiResult<decimal>>("Withdraw",
(client, req) => client.Withdraw(req.Item1, req.Item2).Result);
var knownIds = new[] { "alice", "bob", "9am", "10am" };
var results = await spec.RunTests(context, initialState, testCases, new TestExecutionOptions
{
BeforeEachAsync = async _ =>
{
foreach (var id in knownIds)
{
try { await client.Delete(id); }
catch { /* Ignore 404 */ }
}
}
});
var results = await spec.RunTests(context, initialState, testCases, new TestExecutionOptions
{
BeforeEachAsync = async _ =>
{
await _testContainer.ResetAsync();
}
});
var testRunId = Guid.NewGuid().ToString("N")[..8];
var inputs = new InputSet
{
createOp.With($"user-{testRunId}-1", "Create user 1"),
createOp.With($"user-{testRunId}-2", "Create user 2"),
};