[BUG] BeUniqueSquadNumber validator rejects all PUT requests for existing players

[nanotaboada]

Description

The BeUniqueSquadNumber validation rule in PlayerRequestModelValidator is applied to both POST and PUT requests without discrimination. On PUT, the player being updated already exists in the database, so the uniqueness check always fails — causing every update to return 400 Bad Request with "SquadNumber must be unique." before any business logic executes.

Steps to Reproduce

1. Start the API with a seeded database (any existing player, e.g. squad number 10)
2. Send PUT /players/squadNumber/10 with a valid request body containing "squadNumber": 10
3. Observe 400 Bad Request — "SquadNumber must be unique."
4. The player is never updated

Expected Behavior

PUT /players/squadNumber/10 with a matching body should update the player and return 204 No Content.

Actual Behavior

400 Bad Request is returned with FluentValidation error "SquadNumber must be unique." because BeUniqueSquadNumber finds the existing player in the DB and returns false.

Execution order in PlayerController.PutAsync (lines 197–257):

1. validator.ValidateAsync(player) is called at line 202 — before the route/body mismatch check
2. BeUniqueSquadNumber calls FindBySquadNumberAsync(squadNumber) → finds the existing player → returns false
3. validation.IsValid is false → controller returns 400 at line 214
4. Update never executes

Environment

• .NET SDK version: 10.0
• .NET Core version: net10.0 (FluentValidation 12.1.1, AutoMapper 16.1.1)
• OS: macOS 15.0 / Ubuntu 24.04 / Windows 11

Additional Context

Why the existing unit tests do not catch this bug

Two compounding factors hide the bug from the test suite:

1. Controller unit tests mock the validator
PlayerMocks.InitControllerMocks() returns a Mock<IValidator<PlayerRequestModel>>. Every PUT test manually stubs .ValidateAsync() to return an empty ValidationResult (no errors). The real BeUniqueSquadNumber logic never executes in any controller test.

2. Validator unit tests only cover POST (create) scenarios
PlayerValidatorTests.cs does exercise the real validator, including the uniqueness rule — but all fixtures use MakeRequestModelForCreate(). There is no test for the PUT scenario: "validating a player whose squad number already exists in the DB." That is precisely the case where the bug manifests.

There are also no integration tests that wire the real validator to a real (or in-memory) database and exercise the full PUT pipeline end-to-end, which would have caught this immediately.

The bug lives in the gap between the two isolated unit test layers. The fix should include a new validator test:
ValidateAsync_SquadNumber_BelongsToPlayerBeingUpdated_ReturnsNoErrors to prevent regression.

Possible Solutions

Two approaches were considered:

Option A — FluentValidation Rule Sets ✅ Chosen

Use FluentValidation's built-in rule sets to scope rules by operation. All rules are organized into explicit "Create" and "Update" rule sets; BeUniqueSquadNumber is included only in "Create".

• POST validates with opts.IncludeRuleSets("Create")
• PUT validates with opts.IncludeRuleSets("Update")

Why chosen: Minimal footprint (3 files), no model or service signature changes, explicit CRUD-named rule sets serve as documentation of intent — valuable for an educational codebase. The "Update" rule set also provides a ready home for any future update-specific rules (e.g. squad number immutability).

Files affected:

• Validators/PlayerRequestModelValidator.cs — split all rules into RuleSet("Create") and RuleSet("Update"); BeUniqueSquadNumber only in "Create"
• Controllers/PlayerController.cs — PostAsync and PutAsync pass explicit rule set options
• Tests/Unit/PlayerValidatorTests.cs — update existing tests to specify rule sets; add ValidateAsync_SquadNumber_BelongsToPlayerBeingUpdated_ReturnsNoErrors

Option B — Split Models

Split PlayerRequestModel into two purpose-specific models with separate validators:

Model	Used by	Validator
PlayerCreateModel	POST	PlayerCreateModelValidator — includes BeUniqueSquadNumber
PlayerUpdateModel	PUT	PlayerUpdateModelValidator — omits BeUniqueSquadNumber

Why not chosen: Requires changes to 6+ files (Models, Validators, Controller, Service, Mappings, Tests). Introduces model and mapping duplication for no immediate benefit — the two models are structurally identical. Adds complexity that can be avoided with rule sets.

Files affected:

• Models/PlayerRequestModel.cs → split into PlayerCreateModel.cs / PlayerUpdateModel.cs
• Validators/PlayerRequestModelValidator.cs → split into PlayerCreateModelValidator.cs / PlayerUpdateModelValidator.cs
• Controllers/PlayerController.cs — update POST and PUT action signatures
• Services/PlayerService.cs — update method signatures
• Mappings/PlayerMappingProfile.cs — add mappings for new models
• Tests/ — add ValidateAsync_SquadNumber_BelongsToPlayerBeingUpdated_ReturnsNoErrors validator test

[coderabbitai]

🔗 Related PRs

#208 - feature/identifiers [merged]
#352 - refactor: consolidate player data into single source of truth (#210) [merged]
#397 - feat(validation): add DateOfBirth rules and fix Birth null mapping [merged]
#399 - refactor(tests): rename test methods to Microsoft naming standard [merged]
#420 - refactor(api)!: add /squadNumber/ path segment to routes [merged]

---

📝 Issue Planner

_{Check the box below or use the @coderabbitai plan command to generate an implementation plan and prompts that you can use with your favorite coding assistant.}

• Create Plan

---

🧪 Issue enrichment is currently in open beta.

You can configure auto-planning by selecting labels in the issue_enrichment configuration.

To disable automatic issue enrichment, add the following to your .coderabbit.yaml:

issue_enrichment:
  auto_enrich:
    enabled: false

💬 Have feedback or questions? Drop into our discord!

[coderabbitai]

Coding Plan

Summary

• Split PlayerRequestModel into PlayerCreateModel (POST) and PlayerUpdateModel (PUT) to enable purpose-specific validation
• Create separate validators where only PlayerCreateModelValidator includes the BeUniqueSquadNumber async rule, fixing the bug where PUT requests were incorrectly rejected
• Propagate model changes through service interfaces, controller signatures, and AutoMapper mappings
• Add regression test ValidateAsync_SquadNumber_BelongsToPlayerBeingUpdated_ReturnsNoErrors to prevent future recurrence

Implementation Steps

Phase 1: Model and Validator Split

This phase addresses the root cause by separating the shared request model into create-specific and update-specific variants, each with appropriate validation rules.

Task 1: Create PlayerCreateModel

Introduce a dedicated model for POST requests that is structurally identical to the current PlayerRequestModel.

• Create src/Dotnet.Samples.AspNetCore.WebApi/Models/PlayerCreateModel.cs with the same 8 properties as PlayerRequestModel: FirstName?, MiddleName?, LastName?, DateOfBirth?, SquadNumber (required), AbbrPosition?, Team?, League?
• Use the same namespace Dotnet.Samples.AspNetCore.WebApi.Models

Task 2: Create PlayerUpdateModel

Introduce a dedicated model for PUT requests with identical structure to the create model.

• Create src/Dotnet.Samples.AspNetCore.WebApi/Models/PlayerUpdateModel.cs with the same 8 properties
• Use the same namespace Dotnet.Samples.AspNetCore.WebApi.Models

Task 3: Create PlayerCreateModelValidator

Move all existing validation rules including BeUniqueSquadNumber to the create-specific validator.

• Create src/Dotnet.Samples.AspNetCore.WebApi/Validators/PlayerCreateModelValidator.cs
• Extend AbstractValidator<PlayerCreateModel> with constructor accepting IPlayerRepository and optional TimeProvider
• Include all rules from current validator: FirstName NotEmpty, LastName NotEmpty, SquadNumber NotEmpty/GreaterThan(0)/MustAsync(BeUniqueSquadNumber), AbbrPosition NotEmpty/Must(Position.IsValidAbbr), DateOfBirth conditional past-date validation
• Copy the BeUniqueSquadNumber private method implementation

Task 4: Create PlayerUpdateModelValidator

Create the update-specific validator that omits the uniqueness check.

• Create src/Dotnet.Samples.AspNetCore.WebApi/Validators/PlayerUpdateModelValidator.cs
• Extend AbstractValidator<PlayerUpdateModel> with constructor accepting optional TimeProvider (no repository needed)
• Include all rules EXCEPT BeUniqueSquadNumber: FirstName NotEmpty, LastName NotEmpty, SquadNumber NotEmpty/GreaterThan(0), AbbrPosition NotEmpty/Must(Position.IsValidAbbr), DateOfBirth conditional validation
• The route/body squad number mismatch check remains in the controller (already exists at line 220)

Task 5: Remove Original PlayerRequestModel and Validator

Clean up the now-obsolete shared model and validator.

• Delete src/Dotnet.Samples.AspNetCore.WebApi/Models/PlayerRequestModel.cs
• Delete src/Dotnet.Samples.AspNetCore.WebApi/Validators/PlayerRequestModelValidator.cs

🤖 Prompt for AI agents

This phase splits the shared `PlayerRequestModel` and its validator into create-
and update-specific variants, which is the root cause fix for the bug where PUT
requests were incorrectly rejected.

**Create `PlayerCreateModel`**
- File: `src/Dotnet.Samples.AspNetCore.WebApi/Models/PlayerCreateModel.cs`
- Namespace: `Dotnet.Samples.AspNetCore.WebApi.Models`
- Include the same 8 properties as the existing `PlayerRequestModel`:
`FirstName?`, `MiddleName?`, `LastName?`, `DateOfBirth?`, `SquadNumber`
(required), `AbbrPosition?`, `Team?`, `League?`

**Create `PlayerUpdateModel`**
- File: `src/Dotnet.Samples.AspNetCore.WebApi/Models/PlayerUpdateModel.cs`
- Namespace: `Dotnet.Samples.AspNetCore.WebApi.Models`
- Identical 8-property structure to `PlayerCreateModel`

**Create `PlayerCreateModelValidator`**
- File:
`src/Dotnet.Samples.AspNetCore.WebApi/Validators/PlayerCreateModelValidator.cs`
- Extend `AbstractValidator<PlayerCreateModel>`
- Constructor accepts `IPlayerRepository` and optional `TimeProvider`
- Include all validation rules from the current `PlayerRequestModelValidator`:
  - `FirstName`: NotEmpty
  - `LastName`: NotEmpty
  - `SquadNumber`: NotEmpty, GreaterThan(0), MustAsync(BeUniqueSquadNumber)
  - `AbbrPosition`: NotEmpty, Must(Position.IsValidAbbr)
  - `DateOfBirth`: conditional past-date validation
- Copy the `BeUniqueSquadNumber` private method implementation verbatim

**Create `PlayerUpdateModelValidator`**
- File:
`src/Dotnet.Samples.AspNetCore.WebApi/Validators/PlayerUpdateModelValidator.cs`
- Extend `AbstractValidator<PlayerUpdateModel>`
- Constructor accepts optional `TimeProvider` only — **no repository
dependency**
- Include all rules **except** `BeUniqueSquadNumber`:
  - `FirstName`: NotEmpty
  - `LastName`: NotEmpty
  - `SquadNumber`: NotEmpty, GreaterThan(0)
  - `AbbrPosition`: NotEmpty, Must(Position.IsValidAbbr)
  - `DateOfBirth`: conditional validation
- Do not add any uniqueness check; the route/body squad number mismatch check
stays in the controller

**Delete obsolete files**
- Delete `src/Dotnet.Samples.AspNetCore.WebApi/Models/PlayerRequestModel.cs`
- Delete
`src/Dotnet.Samples.AspNetCore.WebApi/Validators/PlayerRequestModelValidator.cs`

Phase 2: Service, Controller, and Mapping Updates

This phase propagates the model split through the service layer, controller, and AutoMapper configuration.

Task 1: Update IPlayerService Interface

Modify method signatures to use the purpose-specific models.

• Update src/Dotnet.Samples.AspNetCore.WebApi/Services/IPlayerService.cs
• Change CreateAsync(PlayerRequestModel) to CreateAsync(PlayerCreateModel)
• Change UpdateAsync(PlayerRequestModel) to UpdateAsync(PlayerUpdateModel)

Task 2: Update PlayerService Implementation

Align the service implementation with the updated interface.

• Update src/Dotnet.Samples.AspNetCore.WebApi/Services/PlayerService.cs
• Change CreateAsync parameter type from PlayerRequestModel to PlayerCreateModel
• Change UpdateAsync parameter type from PlayerRequestModel to PlayerUpdateModel
• Update any internal references to use the correct model types

Task 3: Update PlayerController

Wire the controller to use the correct model and validator for each action.

• Update src/Dotnet.Samples.AspNetCore.WebApi/Controllers/PlayerController.cs
• Modify constructor to inject both IValidator<PlayerCreateModel> and IValidator<PlayerUpdateModel> (rename to _createValidator and _updateValidator or similar)
• Update PostAsync (line 37): change [FromBody] PlayerRequestModel player to [FromBody] PlayerCreateModel player, use create validator
• Update PutAsync (line 197): change [FromBody] PlayerRequestModel player to [FromBody] PlayerUpdateModel player, use update validator

Task 4: Update PlayerMappingProfile

Add AutoMapper mappings for the new model types.

• Update src/Dotnet.Samples.AspNetCore.WebApi/Mappings/PlayerMappingProfile.cs
• Add CreateMap<PlayerCreateModel, Player>() with same configuration as current PlayerRequestModel → Player mapping (resolve Position from AbbrPosition, ignore Starting11)
• Add CreateMap<PlayerUpdateModel, Player>() with identical configuration
• Remove the original PlayerRequestModel → Player mapping

🤖 Prompt for AI agents

This phase propagates the model split from Phase 1 through the service
interface, service implementation, controller, and AutoMapper profile.

**Update `IPlayerService`**
- File: `src/Dotnet.Samples.AspNetCore.WebApi/Services/IPlayerService.cs`
- Change `CreateAsync(PlayerRequestModel)` → `CreateAsync(PlayerCreateModel)`
- Change `UpdateAsync(PlayerRequestModel)` → `UpdateAsync(PlayerUpdateModel)`

**Update `PlayerService`**
- File: `src/Dotnet.Samples.AspNetCore.WebApi/Services/PlayerService.cs`
- Change `CreateAsync` parameter type from `PlayerRequestModel` to
`PlayerCreateModel`
- Change `UpdateAsync` parameter type from `PlayerRequestModel` to
`PlayerUpdateModel`
- Update any internal references to use the correct model types

**Update `PlayerController`**
- File: `src/Dotnet.Samples.AspNetCore.WebApi/Controllers/PlayerController.cs`
- Update constructor to inject both `IValidator<PlayerCreateModel>` and
`IValidator<PlayerUpdateModel>`; store them as separate fields (e.g.,
`_createValidator` and `_updateValidator`)
- In `PostAsync` (line 37): change `[FromBody] PlayerRequestModel player` to
`[FromBody] PlayerCreateModel player` and use `_createValidator`
- In `PutAsync` (line 197): change `[FromBody] PlayerRequestModel player` to
`[FromBody] PlayerUpdateModel player` and use `_updateValidator`

**Update `PlayerMappingProfile`**
- File: `src/Dotnet.Samples.AspNetCore.WebApi/Mappings/PlayerMappingProfile.cs`
- Add `CreateMap<PlayerCreateModel, Player>()` with the same configuration as
the existing `PlayerRequestModel → Player` mapping (resolve Position from
AbbrPosition, ignore Starting11)
- Add `CreateMap<PlayerUpdateModel, Player>()` with identical configuration
- Remove the original `PlayerRequestModel → Player` mapping

Phase 3: Test Updates

This phase updates test utilities and adds the regression test specified in the ticket.

Task 1: Update PlayerFakes Test Utilities

Modify fake data factories to produce the new model types.

• Update test/Dotnet.Samples.AspNetCore.WebApi.Tests/Utilities/PlayerFakes.cs
• Rename MakeRequestModelForCreate() to return PlayerCreateModel instead of PlayerRequestModel
• Rename MakeRequestModelForUpdate(int squadNumber) to return PlayerUpdateModel instead of PlayerRequestModel
• Update MakeRequestModelForRetrieve if it exists and is used by update factory

Task 2: Update PlayerMocks Test Utilities

Update mock factory to return validators for the new model types.

• Update test/Dotnet.Samples.AspNetCore.WebApi.Tests/Utilities/PlayerMocks.cs
• Modify InitControllerMocks() to return Mock<IValidator<PlayerCreateModel>> and Mock<IValidator<PlayerUpdateModel>> instead of single Mock<IValidator<PlayerRequestModel>>
• Update tuple return type to include both validators

Task 3: Create PlayerCreateModelValidator Tests

Migrate existing validator tests to target the create validator.

• Create test/Dotnet.Samples.AspNetCore.WebApi.Tests/Unit/PlayerCreateModelValidatorTests.cs (or rename existing file)
• Migrate all existing tests from PlayerValidatorTests.cs since they all test create scenarios
• Ensure ValidateAsync_SquadNumberNotUnique_ReturnsValidationError test remains to verify BeUniqueSquadNumber works for creates
• Update test factory method to use PlayerCreateModel

Task 4: Create PlayerUpdateModelValidator Tests

Add tests for the update validator including the regression test.

• Create test/Dotnet.Samples.AspNetCore.WebApi.Tests/Unit/PlayerUpdateModelValidatorTests.cs
• Add tests for all shared rules: FirstName/LastName NotEmpty, SquadNumber validation (NotEmpty, GreaterThan(0)), AbbrPosition validation, DateOfBirth conditional validation
• Add the regression test specified in ticket: ValidateAsync_SquadNumber_BelongsToPlayerBeingUpdated_ReturnsNoErrors — validates that a request with a squad number that exists in the database passes validation (since update validator has no uniqueness check)

Task 5: Update PlayerControllerTests

Update controller tests to use the new model types and validator mocks.

• Update test/Dotnet.Samples.AspNetCore.WebApi.Tests/Unit/PlayerControllerTests.cs
• Update POST tests to use PlayerCreateModel and Mock<IValidator<PlayerCreateModel>>
• Update PUT tests to use PlayerUpdateModel and Mock<IValidator<PlayerUpdateModel>>
• Update controller instantiation to inject both validators
• Verify all existing test scenarios still pass with new types

Task 6: Delete Original Validator Tests

Remove the obsolete test file after migration.

• Delete test/Dotnet.Samples.AspNetCore.WebApi.Tests/Unit/PlayerValidatorTests.cs after confirming all tests migrated to new files

🤖 Prompt for AI agents

This phase updates all test utilities and test files to align with the new model
and validator types introduced in Phases 1 and 2, and adds the regression test
for the original bug.

**Update `PlayerFakes`**
- File: `test/Dotnet.Samples.AspNetCore.WebApi.Tests/Utilities/PlayerFakes.cs`
- Change `MakeRequestModelForCreate()` to return `PlayerCreateModel` instead of
`PlayerRequestModel`
- Change `MakeRequestModelForUpdate(int squadNumber)` to return
`PlayerUpdateModel` instead of `PlayerRequestModel`
- Update `MakeRequestModelForRetrieve` if it exists and is used by the update
factory

**Update `PlayerMocks`**
- File: `test/Dotnet.Samples.AspNetCore.WebApi.Tests/Utilities/PlayerMocks.cs`
- Update `InitControllerMocks()` to return both
`Mock<IValidator<PlayerCreateModel>>` and `Mock<IValidator<PlayerUpdateModel>>`
instead of a single `Mock<IValidator<PlayerRequestModel>>`
- Update the tuple return type accordingly

**Create `PlayerCreateModelValidatorTests`**
- File:
`test/Dotnet.Samples.AspNetCore.WebApi.Tests/Unit/PlayerCreateModelValidatorTests.cs`
- Migrate all existing tests from `PlayerValidatorTests.cs` (all test create
scenarios)
- Retain the `ValidateAsync_SquadNumberNotUnique_ReturnsValidationError` test to
verify `BeUniqueSquadNumber` works on creates
- Update factory method references to use `PlayerCreateModel`

**Create `PlayerUpdateModelValidatorTests`**
- File:
`test/Dotnet.Samples.AspNetCore.WebApi.Tests/Unit/PlayerUpdateModelValidatorTests.cs`
- Add tests covering all shared validation rules: FirstName/LastName NotEmpty,
SquadNumber (NotEmpty, GreaterThan(0)), AbbrPosition, DateOfBirth conditional
validation
- Add the key regression test:
`ValidateAsync_SquadNumber_BelongsToPlayerBeingUpdated_ReturnsNoErrors` —
validates that a request with a squad number already present in the database
passes validation (confirming no uniqueness check in the update validator)

**Update `PlayerControllerTests`**
- File:
`test/Dotnet.Samples.AspNetCore.WebApi.Tests/Unit/PlayerControllerTests.cs`
- Update POST tests to use `PlayerCreateModel` and
`Mock<IValidator<PlayerCreateModel>>`
- Update PUT tests to use `PlayerUpdateModel` and
`Mock<IValidator<PlayerUpdateModel>>`
- Update controller instantiation to inject both validators

**Delete obsolete test file**
- Delete
`test/Dotnet.Samples.AspNetCore.WebApi.Tests/Unit/PlayerValidatorTests.cs` after
confirming all tests have been migrated

Research

This is an ASP.NET Core Web API following a layered architecture with Models, Validators (FluentValidation), Controllers, Services, and Repositories. The project uses AutoMapper for object mapping, FluentValidation for request validation with DI-injected validators, and follows interface-based service patterns. Tests are organized into Unit tests and Utilities (Fakes, Mocks, Stubs) with xUnit and Moq.

---

🚀 Next Steps

🤖 All AI agent prompts combined

Task: 1

This phase splits the shared `PlayerRequestModel` and its validator into create-
and update-specific variants, which is the root cause fix for the bug where PUT
requests were incorrectly rejected.

**Create `PlayerCreateModel`**
- File: `src/Dotnet.Samples.AspNetCore.WebApi/Models/PlayerCreateModel.cs`
- Namespace: `Dotnet.Samples.AspNetCore.WebApi.Models`
- Include the same 8 properties as the existing `PlayerRequestModel`:
`FirstName?`, `MiddleName?`, `LastName?`, `DateOfBirth?`, `SquadNumber`
(required), `AbbrPosition?`, `Team?`, `League?`

**Create `PlayerUpdateModel`**
- File: `src/Dotnet.Samples.AspNetCore.WebApi/Models/PlayerUpdateModel.cs`
- Namespace: `Dotnet.Samples.AspNetCore.WebApi.Models`
- Identical 8-property structure to `PlayerCreateModel`

**Create `PlayerCreateModelValidator`**
- File:
`src/Dotnet.Samples.AspNetCore.WebApi/Validators/PlayerCreateModelValidator.cs`
- Extend `AbstractValidator<PlayerCreateModel>`
- Constructor accepts `IPlayerRepository` and optional `TimeProvider`
- Include all validation rules from the current `PlayerRequestModelValidator`:
  - `FirstName`: NotEmpty
  - `LastName`: NotEmpty
  - `SquadNumber`: NotEmpty, GreaterThan(0), MustAsync(BeUniqueSquadNumber)
  - `AbbrPosition`: NotEmpty, Must(Position.IsValidAbbr)
  - `DateOfBirth`: conditional past-date validation
- Copy the `BeUniqueSquadNumber` private method implementation verbatim

**Create `PlayerUpdateModelValidator`**
- File:
`src/Dotnet.Samples.AspNetCore.WebApi/Validators/PlayerUpdateModelValidator.cs`
- Extend `AbstractValidator<PlayerUpdateModel>`
- Constructor accepts optional `TimeProvider` only — **no repository
dependency**
- Include all rules **except** `BeUniqueSquadNumber`:
  - `FirstName`: NotEmpty
  - `LastName`: NotEmpty
  - `SquadNumber`: NotEmpty, GreaterThan(0)
  - `AbbrPosition`: NotEmpty, Must(Position.IsValidAbbr)
  - `DateOfBirth`: conditional validation
- Do not add any uniqueness check; the route/body squad number mismatch check
stays in the controller

**Delete obsolete files**
- Delete `src/Dotnet.Samples.AspNetCore.WebApi/Models/PlayerRequestModel.cs`
- Delete
`src/Dotnet.Samples.AspNetCore.WebApi/Validators/PlayerRequestModelValidator.cs`
===============================================================================

Task: 2

This phase propagates the model split from Phase 1 through the service
interface, service implementation, controller, and AutoMapper profile.

**Update `IPlayerService`**
- File: `src/Dotnet.Samples.AspNetCore.WebApi/Services/IPlayerService.cs`
- Change `CreateAsync(PlayerRequestModel)` → `CreateAsync(PlayerCreateModel)`
- Change `UpdateAsync(PlayerRequestModel)` → `UpdateAsync(PlayerUpdateModel)`

**Update `PlayerService`**
- File: `src/Dotnet.Samples.AspNetCore.WebApi/Services/PlayerService.cs`
- Change `CreateAsync` parameter type from `PlayerRequestModel` to
`PlayerCreateModel`
- Change `UpdateAsync` parameter type from `PlayerRequestModel` to
`PlayerUpdateModel`
- Update any internal references to use the correct model types

**Update `PlayerController`**
- File: `src/Dotnet.Samples.AspNetCore.WebApi/Controllers/PlayerController.cs`
- Update constructor to inject both `IValidator<PlayerCreateModel>` and
`IValidator<PlayerUpdateModel>`; store them as separate fields (e.g.,
`_createValidator` and `_updateValidator`)
- In `PostAsync` (line 37): change `[FromBody] PlayerRequestModel player` to
`[FromBody] PlayerCreateModel player` and use `_createValidator`
- In `PutAsync` (line 197): change `[FromBody] PlayerRequestModel player` to
`[FromBody] PlayerUpdateModel player` and use `_updateValidator`

**Update `PlayerMappingProfile`**
- File: `src/Dotnet.Samples.AspNetCore.WebApi/Mappings/PlayerMappingProfile.cs`
- Add `CreateMap<PlayerCreateModel, Player>()` with the same configuration as
the existing `PlayerRequestModel → Player` mapping (resolve Position from
AbbrPosition, ignore Starting11)
- Add `CreateMap<PlayerUpdateModel, Player>()` with identical configuration
- Remove the original `PlayerRequestModel → Player` mapping
===============================================================================

Task: 3

This phase updates all test utilities and test files to align with the new model
and validator types introduced in Phases 1 and 2, and adds the regression test
for the original bug.

**Update `PlayerFakes`**
- File: `test/Dotnet.Samples.AspNetCore.WebApi.Tests/Utilities/PlayerFakes.cs`
- Change `MakeRequestModelForCreate()` to return `PlayerCreateModel` instead of
`PlayerRequestModel`
- Change `MakeRequestModelForUpdate(int squadNumber)` to return
`PlayerUpdateModel` instead of `PlayerRequestModel`
- Update `MakeRequestModelForRetrieve` if it exists and is used by the update
factory

**Update `PlayerMocks`**
- File: `test/Dotnet.Samples.AspNetCore.WebApi.Tests/Utilities/PlayerMocks.cs`
- Update `InitControllerMocks()` to return both
`Mock<IValidator<PlayerCreateModel>>` and `Mock<IValidator<PlayerUpdateModel>>`
instead of a single `Mock<IValidator<PlayerRequestModel>>`
- Update the tuple return type accordingly

**Create `PlayerCreateModelValidatorTests`**
- File:
`test/Dotnet.Samples.AspNetCore.WebApi.Tests/Unit/PlayerCreateModelValidatorTests.cs`
- Migrate all existing tests from `PlayerValidatorTests.cs` (all test create
scenarios)
- Retain the `ValidateAsync_SquadNumberNotUnique_ReturnsValidationError` test to
verify `BeUniqueSquadNumber` works on creates
- Update factory method references to use `PlayerCreateModel`

**Create `PlayerUpdateModelValidatorTests`**
- File:
`test/Dotnet.Samples.AspNetCore.WebApi.Tests/Unit/PlayerUpdateModelValidatorTests.cs`
- Add tests covering all shared validation rules: FirstName/LastName NotEmpty,
SquadNumber (NotEmpty, GreaterThan(0)), AbbrPosition, DateOfBirth conditional
validation
- Add the key regression test:
`ValidateAsync_SquadNumber_BelongsToPlayerBeingUpdated_ReturnsNoErrors` —
validates that a request with a squad number already present in the database
passes validation (confirming no uniqueness check in the update validator)

**Update `PlayerControllerTests`**
- File:
`test/Dotnet.Samples.AspNetCore.WebApi.Tests/Unit/PlayerControllerTests.cs`
- Update POST tests to use `PlayerCreateModel` and
`Mock<IValidator<PlayerCreateModel>>`
- Update PUT tests to use `PlayerUpdateModel` and
`Mock<IValidator<PlayerUpdateModel>>`
- Update controller instantiation to inject both validators

**Delete obsolete test file**
- Delete
`test/Dotnet.Samples.AspNetCore.WebApi.Tests/Unit/PlayerValidatorTests.cs` after
confirming all tests have been migrated

💡 Iterate on the plan with: @coderabbitai <feedback>

Example Feedback
- `@coderabbitai` You can skip phase 3. Add a simple unit test case for phase 2.
- `@coderabbitai` For design choice 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!