# RunScoreStoreContract > 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.runscorestorecontract/ > Summary: RunScoreStoreContract: Behavior tests for the IRunScoreStore contract.

Namespace Tracon.Testing.Contracts.Storage · Assembly Tracon.Testing.Contracts.Xunit.dll

Behavior tests for the [IRunScoreStore](/api/tracon.irunscorestore/) contract. ```csharp public abstract class RunScoreStoreContract : TenantIsolationContract, IAsyncLifetime, IAsyncDisposable ```

Inheritance: object ← StoreCancellationContract<IRunScoreStore> ← TenantIsolationContract<IRunScoreStore> ← RunScoreStoreContract
Implements: IAsyncLifetime, IAsyncDisposable
Inherited Members: TenantIsolationContract<IRunScoreStore>.TenantA, TenantIsolationContract<IRunScoreStore>.TenantB, TenantIsolationContract<IRunScoreStore>.UseAmbientTenant(MutableTenantContext), TenantIsolationContract<IRunScoreStore>.SeedAsync(string, string, CancellationToken), TenantIsolationContract<IRunScoreStore>.ExistsAsync(string, object), TenantIsolationContract<IRunScoreStore>.CountAsync(string, CancellationToken), TenantIsolationContract<IRunScoreStore>.TryDeleteAsync(string, object), TenantIsolationContract<IRunScoreStore>.TryOverwriteAsync(string, string), TenantIsolationContract<IRunScoreStore>.CancellableReadAsync(CancellationToken), TenantIsolationContract<IRunScoreStore>.CancellableWriteAsync(CancellationToken), TenantIsolationContract<IRunScoreStore>.WroteAnythingAsync(), TenantIsolationContract<IRunScoreStore>.Tenant_cannot_read_another_tenants_record(), TenantIsolationContract<IRunScoreStore>.Tenant_reads_its_own_record(), TenantIsolationContract<IRunScoreStore>.Tenant_does_not_see_another_tenants_record_in_the_list(), TenantIsolationContract<IRunScoreStore>.Tenant_cannot_delete_another_tenants_record(), TenantIsolationContract<IRunScoreStore>.Same_name_lives_independently_across_two_tenants(), TenantIsolationContract<IRunScoreStore>.AmbientTenant, StoreCancellationContract<IRunScoreStore>.CreateStoreAsync(), StoreCancellationContract<IRunScoreStore>.InitializeAsync(), StoreCancellationContract<IRunScoreStore>.DisposeAsync(), StoreCancellationContract<IRunScoreStore>.OnDisposeAsync(), StoreCancellationContract<IRunScoreStore>.CancellableReadAsync(CancellationToken), StoreCancellationContract<IRunScoreStore>.CancellableWriteAsync(CancellationToken), StoreCancellationContract<IRunScoreStore>.WroteAnythingAsync(), StoreCancellationContract<IRunScoreStore>.Canceled_token_throws_on_read(), StoreCancellationContract<IRunScoreStore>.The_write_this_contract_checks_can_be_read_back(), StoreCancellationContract<IRunScoreStore>.Canceled_token_throws_on_write_and_leaves_no_trace(), StoreCancellationContract<IRunScoreStore>.Store, object.GetType(), object.MemberwiseClone(), object.ToString(), object.Equals(object?), object.Equals(object?, object?), object.ReferenceEquals(object?, object?), object.GetHashCode()

## Remarks The in-memory store and the three SQL providers must pass the same scenarios. Critical rule: when the same author writes the same [RunScore.Name](/api/tracon.runscore/#Tracon_RunScore_Name) onto the same target (a run or a message) a second time, the row is **updated**, not duplicated -- a different name opens a new row, and neither rule applies when the author is empty (an anonymous setup). ## Constructors ### RunScoreStoreContract\(\) ```csharp protected RunScoreStoreContract() ``` ## Methods ### A\_categorical\_score\_carrying\_a\_numeric\_value\_is\_REJECTED\(\) ```csharp [Fact] public Task A_categorical_score_carrying_a_numeric_value_is_REJECTED() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### A\_categorical\_score\_is\_stored\_as\_text\(\) ```csharp [Fact] public Task A_categorical_score_is_stored_as_text() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### A\_decimal\_value\_is\_NOT\_rounded\(\) ```csharp [Fact] public Task A_decimal_value_is_NOT_rounded() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### A\_null\_value\_is\_counted\_but\_does\_not\_enter\_the\_average\(\) ```csharp [Fact] public Task A_null_value_is_counted_but_does_not_enter_the_average() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### A\_null\_value\_means\_NO\_MEASUREMENT\_not\_zero\(\) ```csharp [Fact] public Task A_null_value_means_NO_MEASUREMENT_not_zero() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### A\_numeric\_score\_carrying\_a\_text\_value\_is\_REJECTED\(\) ```csharp [Fact] public Task A_numeric_score_carrying_a_text_value_is_REJECTED() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### A\_score\_with\_no\_evaluator\_version\_reads\_back\_as\_null\(\) ```csharp [Fact] public Task A_score_with_no_evaluator_version_reads_back_as_null() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) #### Remarks The shape every row written before the version column existed has, and the shape every human and API score keeps. NULL means no VERSION WAS RESOLVED — it is not "version zero" and it must not make the read throw. ### A\_whole\_number\_value\_is\_read\_back\_as\_a\_number\_not\_an\_integer\(\) ```csharp [Fact] public Task A_whole_number_value_is_read_back_as_a_number_not_an_integer() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### An\_empty\_match\_returns\_empty\_lists\_not\_null\(\) ```csharp [Fact] public Task An_empty_match_returns_empty_lists_not_null() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### An\_empty\_string\_Author\_is\_excluded\_from\_the\_author\_breakdown\_like\_no\_author\(\) ```csharp [Fact] public Task An_empty_string_Author_is_excluded_from_the_author_breakdown_like_no_author() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### An\_empty\_string\_MessageId\_is\_treated\_the\_same\_as\_no\_message\(\) ```csharp [Fact] public Task An_empty_string_MessageId_is_treated_the_same_as_no_message() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### An\_evaluator\_version\_AT\_the\_bound\_is\_accepted\(\) ```csharp [Fact] public Task An_evaluator_version_AT_the_bound_is_accepted() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) #### Remarks The bound itself stays writable — an off-by-one here would reject legal versions. ### An\_evaluator\_version\_round\_trips\(\) ```csharp [Fact] public Task An_evaluator_version_round_trips() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) #### Remarks The real risk this case guards is an ordinal shift. A SQL store reads the row by bare ordinal, so a column slotted into the middle of the select list instead of appended to it moves every field after it. The shift is silent wherever the neighbouring types agree, which is why this asserts the other fields as well and not just the version. ### An\_illegal\_name\_is\_REJECTED\(string\) ```csharp [Theory] [InlineData(new object?[] { "has space" })] [InlineData(new object?[] { "" })] [InlineData(new object?[] { "naïve" })] [InlineData(new object?[] { "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" })] public Task An_illegal_name_is_REJECTED(string name) ``` #### Parameters `name` [string](https://learn.microsoft.com/dotnet/api/system.string) #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### An\_over\_long\_evaluator\_version\_is\_REJECTED\(\) ```csharp [Fact] public Task An_over_long_evaluator_version_is_REJECTED() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) #### Remarks The bound is a stored-column bound, so every store enforces it, not just the SQL ones. A judge supplies this value; without the bound a third-party judge would decide how much of a customer's table one score row occupies. ### Another\_tenants\_score\_cannot\_be\_deleted\(\) ```csharp [Fact] public Task Another_tenants_score_cannot_be_deleted() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### Another\_tenants\_score\_is\_not\_visible\(\) ```csharp [Fact] public Task Another_tenants_score_is_not_visible() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### Another\_tenants\_score\_never\_enters\_the\_summary\(\) ```csharp [Fact] public Task Another_tenants_score_never_enters_the_summary() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### Author\_breakdown\_excludes\_scores\_with\_no\_author\(\) ```csharp [Fact] public Task Author_breakdown_excludes_scores_with_no_author() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### Categorical\_scores\_report\_category\_counts\_not\_an\_average\(\) ```csharp [Fact] public Task Categorical_scores_report_category_counts_not_an_average() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### Category\_cardinality\_beyond\_MaxRows\_is\_truncated\_and\_reported\(\) ```csharp [Fact] public Task Category_cardinality_beyond_MaxRows_is_truncated_and_reported() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### Concurrent\_writes\_of\_the\_SAME\_name\_leave\_exactly\_one\_row\(\) ```csharp [Fact] public Task Concurrent_writes_of_the_SAME_name_leave_exactly_one_row() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) #### Remarks A uniqueness key that does not match shows up first as a race: two writers each miss the other's row and both insert. ### Concurrent\_writes\_with\_null\_and\_empty\_MessageId\_leave\_exactly\_one\_row\(\) ```csharp [Fact] public Task Concurrent_writes_with_null_and_empty_MessageId_leave_exactly_one_row() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) #### Remarks A NULL [RunScore.MessageId](/api/tracon.runscore/#Tracon_RunScore_MessageId) and an empty ONE both mean "the whole run" ([RunScoreStoreContract.Score_with_no_message_id_belongs_to_the_whole_run](/api/tracon.testing.contracts.storage.runscorestorecontract/#Tracon_Testing_Contracts_Storage_RunScoreStoreContract_Score_with_no_message_id_belongs_to_the_whole_run)), so a concurrent write of one shape racing a write of the OTHER shape must still collapse to a single row -- not two, one per shape. ### 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. ### Deleting\_a\_nonexistent\_score\_returns\_false\(\) ```csharp [Fact] public Task Deleting_a_nonexistent_score_returns_false() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### Different\_authors\_score\_the\_same\_target\_independently\(\) ```csharp [Fact] public Task Different_authors_score_the_same_target_independently() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### Different\_kinds\_of\_the\_same\_name\_are\_not\_averaged\_together\(\) ```csharp [Fact] public Task Different_kinds_of_the_same_name_are_not_averaged_together() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### Different\_messages\_are\_scored\_independently\(\) ```csharp [Fact] public Task Different_messages_are_scored_independently() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### Empty\_author\_makes\_EVERY\_call\_open\_a\_new\_row\(\) ```csharp [Fact] public Task Empty_author_makes_EVERY_call_open_a_new_row() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### 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. ### Hour\_buckets\_group\_scores\_within\_the\_same\_hour\(\) ```csharp [Fact] public Task Hour_buckets_group_scores_within_the_same_hour() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### MessageId\_is\_never\_a\_breakdown\_dimension\(\) ```csharp [Fact] public Task MessageId_is_never_a_breakdown_dimension() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### Repeated\_writes\_of\_the\_SAME\_name\_leave\_exactly\_one\_row\(\) ```csharp [Fact] public Task Repeated_writes_of_the_SAME_name_leave_exactly_one_row() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### Rescoring\_with\_a\_NEWER\_evaluator\_replaces\_the\_stored\_version\(\) ```csharp [Fact] public Task Rescoring_with_a_NEWER_evaluator_replaces_the_stored_version() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) #### Remarks An upgraded evaluator writes the same (author, name) pair again. The row is updated, and the version has to move with it — a stale version on an updated score is exactly the confusion the column exists to remove. ### Same\_author\_scoring\_the\_same\_target\_twice\_UPDATES\_the\_row\(\) ```csharp [Fact] public Task Same_author_scoring_the_same_target_twice_UPDATES_the_row() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### Same\_author\_scoring\_the\_same\_target\_under\_a\_DIFFERENT\_name\_opens\_a\_new\_row\(\) ```csharp [Fact] public Task Same_author_scoring_the_same_target_under_a_DIFFERENT_name_opens_a_new_row() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### Score\_is\_deleted\(\) ```csharp [Fact] public Task Score_is_deleted() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### Score\_with\_no\_message\_id\_belongs\_to\_the\_whole\_run\(\) ```csharp [Fact] public Task Score_with_no_message_id_belongs_to_the_whole_run() ``` #### Returns [Task](https://learn.microsoft.com/dotnet/api/system.threading.tasks.task) ### Scores\_are\_grouped\_into\_time\_buckets\_and\_empty\_buckets\_are\_omitted\(\) ```csharp [Fact] public Task Scores_are_grouped_into_time_buckets_and_empty_buckets_are_omitted() ``` #### 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