# NonTokenUsageContract > Tracon documentation. Tracon is a .NET package family that adds a control > plane on Microsoft Agent Framework, published as NuGet packages that run > inside your own ASP.NET Core application. > > Page: https://tracon.dev/api/tracon.testing.contracts.storage.nontokenusagecontract/ > Summary: NonTokenUsageContract: Behavior tests for the IRunStore non-token usage contract: the items a workflow function node reports.
Namespace Tracon.Testing.Contracts.Storage ยท Assembly Tracon.Testing.Contracts.Xunit.dll
Behavior tests for the [IRunStore](/api/tracon.irunstore/) non-token usage contract: the items a workflow function node reports. ```csharp public abstract class NonTokenUsageContract : TenantIsolationContract, IAsyncLifetime, IAsyncDisposable ```
Inheritance
object โ† StoreCancellationContract<IRunStore> โ† TenantIsolationContract<IRunStore> โ† NonTokenUsageContract
Implements
IAsyncLifetime, IAsyncDisposable
Inherited Members
TenantIsolationContract<IRunStore>.TenantA, TenantIsolationContract<IRunStore>.TenantB, TenantIsolationContract<IRunStore>.UseAmbientTenant(MutableTenantContext), TenantIsolationContract<IRunStore>.SeedAsync(string, string, CancellationToken), TenantIsolationContract<IRunStore>.ExistsAsync(string, object), TenantIsolationContract<IRunStore>.CountAsync(string, CancellationToken), TenantIsolationContract<IRunStore>.TryDeleteAsync(string, object), TenantIsolationContract<IRunStore>.TryOverwriteAsync(string, string), TenantIsolationContract<IRunStore>.CancellableReadAsync(CancellationToken), TenantIsolationContract<IRunStore>.CancellableWriteAsync(CancellationToken), TenantIsolationContract<IRunStore>.WroteAnythingAsync(), TenantIsolationContract<IRunStore>.Tenant_cannot_read_another_tenants_record(), TenantIsolationContract<IRunStore>.Tenant_reads_its_own_record(), TenantIsolationContract<IRunStore>.Tenant_does_not_see_another_tenants_record_in_the_list(), TenantIsolationContract<IRunStore>.Tenant_cannot_delete_another_tenants_record(), TenantIsolationContract<IRunStore>.Same_name_lives_independently_across_two_tenants(), TenantIsolationContract<IRunStore>.AmbientTenant, StoreCancellationContract<IRunStore>.CreateStoreAsync(), StoreCancellationContract<IRunStore>.InitializeAsync(), StoreCancellationContract<IRunStore>.DisposeAsync(), StoreCancellationContract<IRunStore>.OnDisposeAsync(), StoreCancellationContract<IRunStore>.CancellableReadAsync(CancellationToken), StoreCancellationContract<IRunStore>.CancellableWriteAsync(CancellationToken), StoreCancellationContract<IRunStore>.WroteAnythingAsync(), StoreCancellationContract<IRunStore>.Canceled_token_throws_on_read(), StoreCancellationContract<IRunStore>.The_write_this_contract_checks_can_be_read_back(), StoreCancellationContract<IRunStore>.Canceled_token_throws_on_write_and_leaves_no_trace(), StoreCancellationContract<IRunStore>.Store, object.GetType(), object.MemberwiseClone(), object.ToString(), object.Equals(object?), object.Equals(object?, object?), object.ReferenceEquals(object?, object?), object.GetHashCode()
## Remarks Every implementation must pass the same scenarios. The items hang off a run, so isolation is established through the run's tenant, the same way a tool invocation's is. The run's *total* ([RunRecord.NonTokenCost](/api/tracon.runrecord/#Tracon_RunRecord_NonTokenCost)) is a different surface: it is a snapshot written with [IRunStore.CompleteRunAsync](/api/tracon.irunstore/#Tracon_IRunStore_CompleteRunAsync_Tracon_RunCompletion_System_Threading_CancellationToken_) and [RunStoreContract](/api/tracon.testing.contracts.storage.runstorecontract/) covers it. ## Constructors ### NonTokenUsageContract\(\) ```csharp protected NonTokenUsageContract() ``` ## Methods ### A\_run\_lists\_its\_own\_items\_and\_not\_its\_childrens\(\) ```csharp [Fact] public Task A_run_lists_its_own_items_and_not_its_childrens() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### A\_run\_that\_reported\_nothing\_or\_does\_not\_exist\_lists\_nothing\(\) ```csharp [Fact] public Task A_run_that_reported_nothing_or_does_not_exist_lists_nothing() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### An\_item\_for\_a\_run\_that\_was\_never\_opened\_leaves\_nothing\(\) ```csharp [Fact] public Task An_item_for_a_run_that_was_never_opened_leaves_nothing() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### An\_item\_stamped\_with\_another\_tenant\_is\_refused\_and\_leaves\_nothing\(\) ```csharp [Fact] public Task An_item_stamped_with_another_tenant_is_refused_and_leaves_nothing() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### An\_item\_with\_no\_amount\_comes\_back\_with\_no\_amount\_not\_zero\(\) ```csharp [Fact] public Task An_item_with_no_amount_comes_back_with_no_amount_not_zero() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### CancellableReadAsync\(CancellationToken\) Calls one **read** method of the store with the given token. ```csharp protected override ValueTask CancellableReadAsync(CancellationToken cancellationToken) ``` #### Parameters `cancellationToken` [CancellationToken](https://learn.microsoft.com/dotnet/api/system.threading.cancellationtoken) The token the store must observe. #### Returns [ValueTask](https://learn.microsoft.com/dotnet/api/system.threading.tasks.valuetask) The completion task; any result is discarded. #### Remarks The listing hook is the read: it needs no key, so it can be called on an untouched store. A contract whose store has no listing endpoint -- and whose [TenantIsolationContract.CountAsync](/api/tracon.testing.contracts.storage/) therefore makes no store call at all on an empty store -- overrides this with its own read. ### CancellableWriteAsync\(CancellationToken\) Calls one **write** method of the store with the given token. ```csharp protected override ValueTask CancellableWriteAsync(CancellationToken cancellationToken) ``` #### Parameters `cancellationToken` [CancellationToken](https://learn.microsoft.com/dotnet/api/system.threading.cancellationtoken) The token the store must observe. #### Returns [ValueTask](https://learn.microsoft.com/dotnet/api/system.threading.tasks.valuetask) The completion task. #### Remarks The write must be one [StoreCancellationContract.WroteAnythingAsync](/api/tracon.testing.contracts.storage/) can see. A write this contract cannot read back proves nothing about side effects, which is why [StoreCancellationContract.The_write_this_contract_checks_can_be_read_back](/api/tracon.testing.contracts.storage/) runs the same pair with a live token and requires the read to find it. ### CountAsync\(string, CancellationToken\) Reports how many records the given tenant sees through the listing endpoint. ```csharp protected override ValueTask CountAsync(string tenantId, CancellationToken cancellationToken) ``` #### Parameters `tenantId` [string](https://learn.microsoft.com/dotnet/api/system.string) The reading tenant. `cancellationToken` [CancellationToken](https://learn.microsoft.com/dotnet/api/system.threading.cancellationtoken) The token every store call inside the hook must be handed; see [TenantIsolationContract.SeedAsync](/api/tracon.testing.contracts.storage/). #### Returns [ValueTask](https://learn.microsoft.com/dotnet/api/system.threading.tasks.valuetask\-1)<[int](https://learn.microsoft.com/dotnet/api/system.int32)\> The number of records seen. ### ExistsAsync\(string, object\) Reports whether the record is visible from the given tenant's viewpoint. ```csharp protected override ValueTask ExistsAsync(string tenantId, object key) ``` #### Parameters `tenantId` [string](https://learn.microsoft.com/dotnet/api/system.string) The reading tenant. `key` [object](https://learn.microsoft.com/dotnet/api/system.object) The key returned by [TenantIsolationContract.SeedAsync](/api/tracon.testing.contracts.storage/). #### Returns [ValueTask](https://learn.microsoft.com/dotnet/api/system.threading.tasks.valuetask\-1)<[bool](https://learn.microsoft.com/dotnet/api/system.boolean)\> [true](https://learn.microsoft.com/dotnet/csharp/language-reference/builtin-types/bool) if the record is visible. ### Item\_fields\_round\_trip\(\) ```csharp [Fact] public Task Item_fields_round_trip() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### Items\_come\_back\_in\_the\_order\_they\_were\_reported\(\) ```csharp [Fact] public Task Items_come_back_in_the_order_they_were_reported() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### SeedAsync\(string, string, CancellationToken\) Writes a sample record for the given tenant. ```csharp protected override ValueTask SeedAsync(string tenantId, string name, CancellationToken cancellationToken) ``` #### Parameters `tenantId` [string](https://learn.microsoft.com/dotnet/api/system.string) The tenant that owns the record. `name` [string](https://learn.microsoft.com/dotnet/api/system.string) The name distinguishing the record. The same name may be used by two tenants. `cancellationToken` [CancellationToken](https://learn.microsoft.com/dotnet/api/system.threading.cancellationtoken) The token every store call inside the hook must be handed. The cancellation contract calls this hook with a token that is already cancelled, so a hook that drops the token reports a store as sound when it is not. #### Returns [ValueTask](https://learn.microsoft.com/dotnet/api/system.threading.tasks.valuetask\-1)<[object](https://learn.microsoft.com/dotnet/api/system.object)\> The key to use for reading the record back. ### The\_largest\_quantity\_and\_amount\_a\_run\_accepts\_fit\_the\_columns\(\) ```csharp [Fact] public Task The_largest_quantity_and_amount_a_run_accepts_fit_the_columns() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task)