diff --git a/tests/TeamBuilder.Tests/Application/EventServiceTests.cs b/tests/TeamBuilder.Tests/Application/EventServiceTests.cs
index 20e621b..33eb1ea 100644
--- a/tests/TeamBuilder.Tests/Application/EventServiceTests.cs
+++ b/tests/TeamBuilder.Tests/Application/EventServiceTests.cs
@@ -30,12 +30,12 @@ public async Task CreateAsync_ShouldCreateEvent_Successfully()
         var hostId = Guid.NewGuid();
         var createDto = new CreateEventDto
         {
-            Name = "Test Event",
-            Description = "A test event",
-            EventDateUtc = DateTime.UtcNow.AddDays(7),
+            Name = "Grand Tournament",
+            Description = "Annual championship",
+            EventDateUtc = DateTime.UtcNow.AddDays(30),
             Category = "Gaming",
             Region = "NA",
-            MaxParticipants = 20
+            MaxParticipants = 64
         };
 
         // Act
@@ -43,30 +43,38 @@ public async Task CreateAsync_ShouldCreateEvent_Successfully()
 
         // Assert
         result.Should().NotBeNull();
-        result.Name.Should().Be("Test Event");
-        result.Description.Should().Be("A test event");
+        result.Name.Should().Be("Grand Tournament");
+        result.Description.Should().Be("Annual championship");
         result.Status.Should().Be(EventStatus.Planned);
         result.HostId.Should().Be(hostId);
         result.CurrentParticipantCount.Should().Be(0);
-        result.MaxParticipants.Should().Be(20);
+        result.MaxParticipants.Should().Be(64);
 
         var eventInDb = await _context.Events.FindAsync(result.Id);
         eventInDb.Should().NotBeNull();
-        eventInDb!.Name.Should().Be("Test Event");
+        eventInDb!.Name.Should().Be("Grand Tournament");
     }
 
     [Fact]
     public async Task CreateAsync_ShouldLinkToTeam_WhenTeamIdProvided()
     {
         // Arrange
-        var team = new Team { Id = Guid.NewGuid(), Name = "Test Team", MaxMembers = 10, CurrentMemberCount = 0 };
+        var team = new Team
+        {
+            Id = Guid.NewGuid(),
+            Name = "Alpha Squad",
+            MaxMembers = 10,
+            CurrentMemberCount = 0
+        };
+
         _context.Teams.Add(team);
         await _context.SaveChangesAsync();
 
         var createDto = new CreateEventDto
         {
-            Name = "Team Event",
-            EventDateUtc = DateTime.UtcNow.AddDays(5),
+            Name = "Team Scrim",
+            EventDateUtc = DateTime.UtcNow.AddDays(7),
+            MaxParticipants = 10,
             TeamId = team.Id
         };
 
@@ -85,11 +93,12 @@ public async Task GetByIdAsync_ShouldReturnEvent_WhenExists()
         {
             Id = Guid.NewGuid(),
             Name = "Existing Event",
-            EventDateUtc = DateTime.UtcNow.AddDays(3),
+            EventDateUtc = DateTime.UtcNow.AddDays(5),
             Status = EventStatus.Open,
-            MaxParticipants = 10,
+            MaxParticipants = 20,
             CurrentParticipantCount = 0
         };
+
         _context.Events.Add(teamEvent);
         await _context.SaveChangesAsync();
 
@@ -117,8 +126,20 @@ public async Task GetByIdAsync_ShouldReturnNull_WhenNotExists()
     public async Task GetByIdAsync_ShouldIncludeTeamAndHost_WhenPresent()
     {
         // Arrange
-        var team = new Team { Id = Guid.NewGuid(), Name = "Event Team", MaxMembers = 5, CurrentMemberCount = 0 };
-        var host = new Player { Id = Guid.NewGuid(), Username = "HostPlayer" };
+        var team = new Team
+        {
+            Id = Guid.NewGuid(),
+            Name = "Event Team",
+            MaxMembers = 5,
+            CurrentMemberCount = 0
+        };
+
+        var host = new Player
+        {
+            Id = Guid.NewGuid(),
+            Username = "HostPlayer"
+        };
+
         _context.Teams.Add(team);
         _context.Players.Add(host);
 
@@ -133,6 +154,7 @@ public async Task GetByIdAsync_ShouldIncludeTeamAndHost_WhenPresent()
             TeamId = team.Id,
             HostId = host.Id
         };
+
         _context.Events.Add(teamEvent);
         await _context.SaveChangesAsync();
 
@@ -152,6 +174,7 @@ public async Task GetAllAsync_ShouldReturnPaginatedResults()
     {
         // Arrange
         var baseDate = DateTime.UtcNow;
+
         for (int i = 0; i < 15; i++)
         {
             _context.Events.Add(new TeamEvent
@@ -164,6 +187,7 @@ public async Task GetAllAsync_ShouldReturnPaginatedResults()
                 CurrentParticipantCount = 0
             });
         }
+
         await _context.SaveChangesAsync();
 
         // Act
@@ -183,6 +207,7 @@ public async Task GetAllAsync_ShouldReturnSecondPage_Correctly()
     {
         // Arrange
         var baseDate = DateTime.UtcNow;
+
         for (int i = 0; i < 15; i++)
         {
             _context.Events.Add(new TeamEvent
@@ -195,6 +220,7 @@ public async Task GetAllAsync_ShouldReturnSecondPage_Correctly()
                 CurrentParticipantCount = 0
             });
         }
+
         await _context.SaveChangesAsync();
 
         // Act
@@ -212,10 +238,35 @@ public async Task GetAllAsync_ShouldFilterByCategory()
     {
         // Arrange
         _context.Events.AddRange(
-            new TeamEvent { Id = Guid.NewGuid(), Name = "Gaming Event", EventDateUtc = DateTime.UtcNow.AddDays(1), Status = EventStatus.Planned, MaxParticipants = 10, Category = "Gaming" },
-            new TeamEvent { Id = Guid.NewGuid(), Name = "Sports Event", EventDateUtc = DateTime.UtcNow.AddDays(2), Status = EventStatus.Planned, MaxParticipants = 10, Category = "Sports" },
-            new TeamEvent { Id = Guid.NewGuid(), Name = "Gaming Event 2", EventDateUtc = DateTime.UtcNow.AddDays(3), Status = EventStatus.Planned, MaxParticipants = 10, Category = "Gaming" }
+            new TeamEvent
+            {
+                Id = Guid.NewGuid(),
+                Name = "Gaming Event",
+                EventDateUtc = DateTime.UtcNow.AddDays(1),
+                Status = EventStatus.Planned,
+                MaxParticipants = 10,
+                Category = "Gaming"
+            },
+            new TeamEvent
+            {
+                Id = Guid.NewGuid(),
+                Name = "Sports Event",
+                EventDateUtc = DateTime.UtcNow.AddDays(2),
+                Status = EventStatus.Planned,
+                MaxParticipants = 10,
+                Category = "Sports"
+            },
+            new TeamEvent
+            {
+                Id = Guid.NewGuid(),
+                Name = "Gaming Event 2",
+                EventDateUtc = DateTime.UtcNow.AddDays(3),
+                Status = EventStatus.Planned,
+                MaxParticipants = 10,
+                Category = "Gaming"
+            }
         );
+
         await _context.SaveChangesAsync();
 
         // Act
@@ -232,10 +283,35 @@ public async Task GetAllAsync_ShouldFilterByRegion()
     {
         // Arrange
         _context.Events.AddRange(
-            new TeamEvent { Id = Guid.NewGuid(), Name = "NA Event", EventDateUtc = DateTime.UtcNow.AddDays(1), Status = EventStatus.Planned, MaxParticipants = 10, Region = "NA" },
-            new TeamEvent { Id = Guid.NewGuid(), Name = "EU Event", EventDateUtc = DateTime.UtcNow.AddDays(2), Status = EventStatus.Planned, MaxParticipants = 10, Region = "EU" },
-            new TeamEvent { Id = Guid.NewGuid(), Name = "NA Event 2", EventDateUtc = DateTime.UtcNow.AddDays(3), Status = EventStatus.Planned, MaxParticipants = 10, Region = "NA" }
+            new TeamEvent
+            {
+                Id = Guid.NewGuid(),
+                Name = "NA Event",
+                EventDateUtc = DateTime.UtcNow.AddDays(1),
+                Status = EventStatus.Planned,
+                MaxParticipants = 10,
+                Region = "NA"
+            },
+            new TeamEvent
+            {
+                Id = Guid.NewGuid(),
+                Name = "EU Event",
+                EventDateUtc = DateTime.UtcNow.AddDays(2),
+                Status = EventStatus.Planned,
+                MaxParticipants = 10,
+                Region = "EU"
+            },
+            new TeamEvent
+            {
+                Id = Guid.NewGuid(),
+                Name = "NA Event 2",
+                EventDateUtc = DateTime.UtcNow.AddDays(3),
+                Status = EventStatus.Planned,
+                MaxParticipants = 10,
+                Region = "NA"
+            }
         );
+
         await _context.SaveChangesAsync();
 
         // Act
@@ -251,10 +327,32 @@ public async Task GetAllAsync_ShouldFilterByStatus()
     {
         // Arrange
         _context.Events.AddRange(
-            new TeamEvent { Id = Guid.NewGuid(), Name = "Open Event", EventDateUtc = DateTime.UtcNow.AddDays(1), Status = EventStatus.Open, MaxParticipants = 10 },
-            new TeamEvent { Id = Guid.NewGuid(), Name = "Planned Event", EventDateUtc = DateTime.UtcNow.AddDays(2), Status = EventStatus.Planned, MaxParticipants = 10 },
-            new TeamEvent { Id = Guid.NewGuid(), Name = "Cancelled Event", EventDateUtc = DateTime.UtcNow.AddDays(3), Status = EventStatus.Cancelled, MaxParticipants = 10 }
+            new TeamEvent
+            {
+                Id = Guid.NewGuid(),
+                Name = "Open Event",
+                EventDateUtc = DateTime.UtcNow.AddDays(1),
+                Status = EventStatus.Open,
+                MaxParticipants = 10
+            },
+            new TeamEvent
+            {
+                Id = Guid.NewGuid(),
+                Name = "Planned Event",
+                EventDateUtc = DateTime.UtcNow.AddDays(2),
+                Status = EventStatus.Planned,
+                MaxParticipants = 10
+            },
+            new TeamEvent
+            {
+                Id = Guid.NewGuid(),
+                Name = "Cancelled Event",
+                EventDateUtc = DateTime.UtcNow.AddDays(3),
+                Status = EventStatus.Cancelled,
+                MaxParticipants = 10
+            }
         );
+
         await _context.SaveChangesAsync();
 
         // Act
@@ -270,18 +368,43 @@ public async Task GetAllAsync_ShouldOrderByEventDate_Ascending()
     {
         // Arrange
         var baseDate = DateTime.UtcNow;
+
         _context.Events.AddRange(
-            new TeamEvent { Id = Guid.NewGuid(), Name = "Third", EventDateUtc = baseDate.AddDays(3), Status = EventStatus.Planned, MaxParticipants = 10 },
-            new TeamEvent { Id = Guid.NewGuid(), Name = "First", EventDateUtc = baseDate.AddDays(1), Status = EventStatus.Planned, MaxParticipants = 10 },
-            new TeamEvent { Id = Guid.NewGuid(), Name = "Second", EventDateUtc = baseDate.AddDays(2), Status = EventStatus.Planned, MaxParticipants = 10 }
+            new TeamEvent
+            {
+                Id = Guid.NewGuid(),
+                Name = "Third",
+                EventDateUtc = baseDate.AddDays(3),
+                Status = EventStatus.Planned,
+                MaxParticipants = 10
+            },
+            new TeamEvent
+            {
+                Id = Guid.NewGuid(),
+                Name = "First",
+                EventDateUtc = baseDate.AddDays(1),
+                Status = EventStatus.Planned,
+                MaxParticipants = 10
+            },
+            new TeamEvent
+            {
+                Id = Guid.NewGuid(),
+                Name = "Second",
+                EventDateUtc = baseDate.AddDays(2),
+                Status = EventStatus.Planned,
+                MaxParticipants = 10
+            }
         );
+
         await _context.SaveChangesAsync();
 
         // Act
         var result = await _eventService.GetAllAsync(1, 20);
 
         // Assert
-        result.Items.Select(e => e.Name).Should().ContainInOrder("First", "Second", "Third");
+        result.Items.Select(e => e.Name)
+            .Should()
+            .ContainInOrder("First", "Second", "Third");
     }
 
     [Fact]
@@ -289,14 +412,46 @@ public async Task GetAllAsync_ShouldCombineFilters_CategoryAndRegion()
     {
         // Arrange
         _context.Events.AddRange(
-            new TeamEvent { Id = Guid.NewGuid(), Name = "Gaming NA", EventDateUtc = DateTime.UtcNow.AddDays(1), Status = EventStatus.Planned, MaxParticipants = 10, Category = "Gaming", Region = "NA" },
-            new TeamEvent { Id = Guid.NewGuid(), Name = "Gaming EU", EventDateUtc = DateTime.UtcNow.AddDays(2), Status = EventStatus.Planned, MaxParticipants = 10, Category = "Gaming", Region = "EU" },
-            new TeamEvent { Id = Guid.NewGuid(), Name = "Sports NA", EventDateUtc = DateTime.UtcNow.AddDays(3), Status = EventStatus.Planned, MaxParticipants = 10, Category = "Sports", Region = "NA" }
+            new TeamEvent
+            {
+                Id = Guid.NewGuid(),
+                Name = "Gaming NA",
+                EventDateUtc = DateTime.UtcNow.AddDays(1),
+                Status = EventStatus.Planned,
+                MaxParticipants = 10,
+                Category = "Gaming",
+                Region = "NA"
+            },
+            new TeamEvent
+            {
+                Id = Guid.NewGuid(),
+                Name = "Gaming EU",
+                EventDateUtc = DateTime.UtcNow.AddDays(2),
+                Status = EventStatus.Planned,
+                MaxParticipants = 10,
+                Category = "Gaming",
+                Region = "EU"
+            },
+            new TeamEvent
+            {
+                Id = Guid.NewGuid(),
+                Name = "Sports NA",
+                EventDateUtc = DateTime.UtcNow.AddDays(3),
+                Status = EventStatus.Planned,
+                MaxParticipants = 10,
+                Category = "Sports",
+                Region = "NA"
+            }
         );
+
         await _context.SaveChangesAsync();
 
         // Act
-        var result = await _eventService.GetAllAsync(1, 20, category: "Gaming", region: "NA");
+        var result = await _eventService.GetAllAsync(
+            1,
+            20,
+            category: "Gaming",
+            region: "NA");
 
         // Assert
         result.Items.Should().HaveCount(1);
@@ -316,6 +471,7 @@ public async Task GetAllAsync_ShouldReturnEmpty_WhenNoEventsMatch()
             MaxParticipants = 10,
             Region = "NA"
         });
+
         await _context.SaveChangesAsync();
 
         // Act
@@ -339,6 +495,7 @@ public async Task UpdateAsync_ShouldUpdateEvent_Successfully()
             MaxParticipants = 10,
             CurrentParticipantCount = 0
         };
+
         _context.Events.Add(teamEvent);
         await _context.SaveChangesAsync();
 
@@ -393,10 +550,11 @@ public async Task UpdateAsync_ShouldNotUpdateName_WhenWhitespaceProvided()
             MaxParticipants = 10,
             CurrentParticipantCount = 0
         };
+
         _context.Events.Add(teamEvent);
         await _context.SaveChangesAsync();
 
-        var updateDto = new UpdateEventDto { Name = "   " }; // whitespace — should be skipped
+        var updateDto = new UpdateEventDto { Name = "   " };
 
         // Act
         var result = await _eventService.UpdateAsync(teamEvent.Id, updateDto);
@@ -420,13 +578,13 @@ public async Task UpdateAsync_ShouldOnlyUpdateProvidedFields()
             MaxParticipants = 10,
             CurrentParticipantCount = 0
         };
+
         _context.Events.Add(teamEvent);
         await _context.SaveChangesAsync();
 
         var updateDto = new UpdateEventDto
         {
             Name = "Updated Name"
-            // All other fields left null - should not change
         };
 
         // Act
@@ -452,6 +610,7 @@ public async Task UpdateAsync_ShouldCancelEvent_Successfully()
             MaxParticipants = 10,
             CurrentParticipantCount = 3
         };
+
         _context.Events.Add(teamEvent);
         await _context.SaveChangesAsync();
 
@@ -477,6 +636,7 @@ public async Task DeleteAsync_ShouldDeleteEvent_Successfully()
             MaxParticipants = 10,
             CurrentParticipantCount = 0
         };
+
         _context.Events.Add(teamEvent);
         await _context.SaveChangesAsync();
 
@@ -503,4 +663,4 @@ public void Dispose()
     {
         _context.Dispose();
     }
-}
+}
\ No newline at end of file
diff --git a/tests/TeamBuilder.Tests/Application/JoinRequestServiceTests.cs b/tests/TeamBuilder.Tests/Application/JoinRequestServiceTests.cs
index d9c9234..0709329 100644
--- a/tests/TeamBuilder.Tests/Application/JoinRequestServiceTests.cs
+++ b/tests/TeamBuilder.Tests/Application/JoinRequestServiceTests.cs
@@ -224,11 +224,42 @@ await Assert.ThrowsAsync<InvalidOperationException>(
     }
 
     [Fact]
-    public async Task GetByIdAsync_ShouldReturnJoinRequest_WhenExists()
+    public async Task GetByTeamIdAsync_ShouldReturnFilteredRequests()
     {
         // Arrange
         var team = new Team { Id = Guid.NewGuid(), Name = "Test Team", MaxMembers = 5 };
-        var player = new Player { Id = Guid.NewGuid(), Username = "TestPlayer" };
+        _context.Teams.Add(team);
+
+        for (int i = 0; i < 10; i++)
+        {
+            var player = new Player { Id = Guid.NewGuid(), Username = $"Player{i}" };
+            _context.Players.Add(player);
+
+            _context.JoinRequests.Add(new JoinRequest
+            {
+                Id = Guid.NewGuid(),
+                TeamId = team.Id,
+                PlayerId = player.Id,
+                Status = i < 5 ? RequestStatus.Pending : RequestStatus.Approved,
+                RequestedAtUtc = DateTime.UtcNow.AddDays(-i)
+            });
+        }
+        await _context.SaveChangesAsync();
+
+        // Act
+        var result = await _joinRequestService.GetByTeamIdAsync(team.Id, 1, 20, RequestStatus.Pending);
+
+        // Assert
+        result.Items.Should().HaveCount(5);
+        result.Items.Should().OnlyContain(jr => jr.Status == RequestStatus.Pending);
+    }
+
+    [Fact]
+    public async Task GetByIdAsync_ShouldReturnJoinRequest_WhenExists()
+    {
+        // Arrange
+        var team = new Team { Id = Guid.NewGuid(), Name = "Team", MaxMembers = 5 };
+        var player = new Player { Id = Guid.NewGuid(), Username = "Requester" };
         _context.Teams.Add(team);
         _context.Players.Add(player);
 
@@ -238,7 +269,7 @@ public async Task GetByIdAsync_ShouldReturnJoinRequest_WhenExists()
             TeamId = team.Id,
             PlayerId = player.Id,
             Status = RequestStatus.Pending,
-            Message = "Please let me in",
+            Message = "Let me in",
             RequestedAtUtc = DateTime.UtcNow
         };
         _context.JoinRequests.Add(joinRequest);
@@ -250,12 +281,10 @@ public async Task GetByIdAsync_ShouldReturnJoinRequest_WhenExists()
         // Assert
         result.Should().NotBeNull();
         result!.Id.Should().Be(joinRequest.Id);
-        result.TeamId.Should().Be(team.Id);
-        result.PlayerId.Should().Be(player.Id);
         result.Status.Should().Be(RequestStatus.Pending);
-        result.Message.Should().Be("Please let me in");
-        result.TeamName.Should().Be("Test Team");
-        result.PlayerUsername.Should().Be("TestPlayer");
+        result.Message.Should().Be("Let me in");
+        result.TeamName.Should().Be("Team");
+        result.PlayerUsername.Should().Be("Requester");
     }
 
     [Fact]
@@ -269,48 +298,13 @@ public async Task GetByIdAsync_ShouldReturnNull_WhenNotExists()
     }
 
     [Fact]
-    public async Task GetByPlayerIdAsync_ShouldReturnPaginatedRequests()
-    {
-        // Arrange
-        var player = new Player { Id = Guid.NewGuid(), Username = "TestPlayer" };
-        _context.Players.Add(player);
-
-        for (int i = 0; i < 5; i++)
-        {
-            var team = new Team { Id = Guid.NewGuid(), Name = $"Team{i}", MaxMembers = 5 };
-            _context.Teams.Add(team);
-            _context.JoinRequests.Add(new JoinRequest
-            {
-                Id = Guid.NewGuid(),
-                TeamId = team.Id,
-                PlayerId = player.Id,
-                Status = RequestStatus.Pending,
-                RequestedAtUtc = DateTime.UtcNow.AddMinutes(-i)
-            });
-        }
-        await _context.SaveChangesAsync();
-
-        // Act
-        var result = await _joinRequestService.GetByPlayerIdAsync(player.Id, 1, 3);
-
-        // Assert
-        result.Should().NotBeNull();
-        result.Items.Should().HaveCount(3);
-        result.TotalCount.Should().Be(5);
-        result.TotalPages.Should().Be(2);
-        result.HasNextPage.Should().BeTrue();
-        result.HasPreviousPage.Should().BeFalse();
-        result.Items.Should().OnlyContain(jr => jr.PlayerId == player.Id);
-    }
-
-    [Fact]
-    public async Task GetByPlayerIdAsync_ShouldFilterByStatus()
+    public async Task GetByPlayerIdAsync_ShouldReturnFilteredRequests()
     {
         // Arrange
-        var player = new Player { Id = Guid.NewGuid(), Username = "TestPlayer" };
+        var player = new Player { Id = Guid.NewGuid(), Username = "ActiveRequester" };
         _context.Players.Add(player);
 
-        for (int i = 0; i < 6; i++)
+        for (int i = 0; i < 4; i++)
         {
             var team = new Team { Id = Guid.NewGuid(), Name = $"Team{i}", MaxMembers = 5 };
             _context.Teams.Add(team);
@@ -319,8 +313,8 @@ public async Task GetByPlayerIdAsync_ShouldFilterByStatus()
                 Id = Guid.NewGuid(),
                 TeamId = team.Id,
                 PlayerId = player.Id,
-                Status = i < 4 ? RequestStatus.Pending : RequestStatus.Approved,
-                RequestedAtUtc = DateTime.UtcNow.AddMinutes(-i)
+                Status = i < 2 ? RequestStatus.Pending : RequestStatus.Rejected,
+                RequestedAtUtc = DateTime.UtcNow.AddDays(-i)
             });
         }
         await _context.SaveChangesAsync();
@@ -329,28 +323,12 @@ public async Task GetByPlayerIdAsync_ShouldFilterByStatus()
         var result = await _joinRequestService.GetByPlayerIdAsync(player.Id, 1, 20, RequestStatus.Pending);
 
         // Assert
-        result.Items.Should().HaveCount(4);
+        result.Items.Should().HaveCount(2);
         result.Items.Should().OnlyContain(jr => jr.Status == RequestStatus.Pending);
     }
 
     [Fact]
-    public async Task GetByPlayerIdAsync_ShouldReturnEmpty_WhenPlayerHasNoRequests()
-    {
-        // Arrange
-        var player = new Player { Id = Guid.NewGuid(), Username = "Loner" };
-        _context.Players.Add(player);
-        await _context.SaveChangesAsync();
-
-        // Act
-        var result = await _joinRequestService.GetByPlayerIdAsync(player.Id, 1, 20);
-
-        // Assert
-        result.Items.Should().BeEmpty();
-        result.TotalCount.Should().Be(0);
-    }
-
-    [Fact]
-    public async Task ProcessAsync_ShouldReturnNull_WhenRequestNotFound()
+    public async Task ProcessAsync_ShouldReturnNull_WhenJoinRequestNotFound()
     {
         // Arrange
         var processDto = new ProcessJoinRequestDto { Status = RequestStatus.Approved };
@@ -363,128 +341,32 @@ public async Task ProcessAsync_ShouldReturnNull_WhenRequestNotFound()
     }
 
     [Fact]
-    public async Task CreateAsync_ShouldSucceed_WhenPreviousRequestWasRejected()
-    {
-        // Arrange — a prior Rejected request must NOT block a new Pending one
-        var team = new Team { Id = Guid.NewGuid(), Name = "Test Team", MaxMembers = 5 };
-        var player = new Player { Id = Guid.NewGuid(), Username = "TestPlayer" };
-        _context.Teams.Add(team);
-        _context.Players.Add(player);
-
-        _context.JoinRequests.Add(new JoinRequest
-        {
-            Id = Guid.NewGuid(),
-            TeamId = team.Id,
-            PlayerId = player.Id,
-            Status = RequestStatus.Rejected,
-            RequestedAtUtc = DateTime.UtcNow.AddDays(-1),
-            ProcessedAtUtc = DateTime.UtcNow.AddDays(-1)
-        });
-        await _context.SaveChangesAsync();
-
-        var createDto = new CreateJoinRequestDto { TeamId = team.Id, Message = "Trying again" };
-
-        // Act
-        var result = await _joinRequestService.CreateAsync(createDto, player.Id);
-
-        // Assert
-        result.Should().NotBeNull();
-        result.Status.Should().Be(RequestStatus.Pending);
-        result.Message.Should().Be("Trying again");
-    }
-
-    [Fact]
-    public async Task CreateAsync_ShouldSucceed_WhenPreviousRequestWasCancelled()
-    {
-        // Arrange — a prior Cancelled request must NOT block a new Pending one
-        var team = new Team { Id = Guid.NewGuid(), Name = "Test Team", MaxMembers = 5 };
-        var player = new Player { Id = Guid.NewGuid(), Username = "TestPlayer" };
-        _context.Teams.Add(team);
-        _context.Players.Add(player);
-
-        _context.JoinRequests.Add(new JoinRequest
-        {
-            Id = Guid.NewGuid(),
-            TeamId = team.Id,
-            PlayerId = player.Id,
-            Status = RequestStatus.Cancelled,
-            RequestedAtUtc = DateTime.UtcNow.AddDays(-1)
-        });
-        await _context.SaveChangesAsync();
-
-        var createDto = new CreateJoinRequestDto { TeamId = team.Id };
-
-        // Act
-        var result = await _joinRequestService.CreateAsync(createDto, player.Id);
-
-        // Assert
-        result.Should().NotBeNull();
-        result.Status.Should().Be(RequestStatus.Pending);
-    }
-
-    [Fact]
-    public async Task GetByTeamIdAsync_ShouldReturnFilteredRequests()
-    {
-        // Arrange
-        var team = new Team { Id = Guid.NewGuid(), Name = "Test Team", MaxMembers = 5 };
-        _context.Teams.Add(team);
-
-        for (int i = 0; i < 10; i++)
-        {
-            var player = new Player { Id = Guid.NewGuid(), Username = $"Player{i}" };
-            _context.Players.Add(player);
-
-            _context.JoinRequests.Add(new JoinRequest
-            {
-                Id = Guid.NewGuid(),
-                TeamId = team.Id,
-                PlayerId = player.Id,
-                Status = i < 5 ? RequestStatus.Pending : RequestStatus.Approved,
-                RequestedAtUtc = DateTime.UtcNow.AddDays(-i)
-            });
-        }
-        await _context.SaveChangesAsync();
-
-        // Act
-        var result = await _joinRequestService.GetByTeamIdAsync(team.Id, 1, 20, RequestStatus.Pending);
-
-        // Assert
-        result.Items.Should().HaveCount(5);
-        result.Items.Should().OnlyContain(jr => jr.Status == RequestStatus.Pending);
-    }
-
-    [Fact]
-    public async Task GetByTeamIdAsync_ShouldReturnPaginatedResults()
+    public async Task GetByPlayerIdAsync_ShouldReturnAllRequests_WhenNoStatusFilter()
     {
         // Arrange
-        var team = new Team { Id = Guid.NewGuid(), Name = "Test Team", MaxMembers = 20 };
-        _context.Teams.Add(team);
+        var player = new Player { Id = Guid.NewGuid(), Username = "MultiStatusPlayer" };
+        _context.Players.Add(player);
 
-        for (int i = 0; i < 7; i++)
+        foreach (var status in new[] { RequestStatus.Pending, RequestStatus.Approved, RequestStatus.Rejected })
         {
-            var player = new Player { Id = Guid.NewGuid(), Username = $"PlayerT{i}" };
-            _context.Players.Add(player);
+            var team = new Team { Id = Guid.NewGuid(), Name = $"Team-{status}", MaxMembers = 5 };
+            _context.Teams.Add(team);
             _context.JoinRequests.Add(new JoinRequest
             {
                 Id = Guid.NewGuid(),
                 TeamId = team.Id,
                 PlayerId = player.Id,
-                Status = RequestStatus.Pending,
-                RequestedAtUtc = DateTime.UtcNow.AddMinutes(-i)
+                Status = status,
+                RequestedAtUtc = DateTime.UtcNow
             });
         }
         await _context.SaveChangesAsync();
 
         // Act
-        var result = await _joinRequestService.GetByTeamIdAsync(team.Id, 1, 5);
+        var result = await _joinRequestService.GetByPlayerIdAsync(player.Id, 1, 20);
 
         // Assert
-        result.Items.Should().HaveCount(5);
-        result.TotalCount.Should().Be(7);
-        result.TotalPages.Should().Be(2);
-        result.HasNextPage.Should().BeTrue();
-        result.HasPreviousPage.Should().BeFalse();
-        result.Items.Should().OnlyContain(jr => jr.TeamId == team.Id);
+        result.TotalCount.Should().Be(3);
     }
 
     public void Dispose()
diff --git a/tests/TeamBuilder.Tests/Application/PlayerServiceTests.cs b/tests/TeamBuilder.Tests/Application/PlayerServiceTests.cs
index 16a89ea..49ed26b 100644
--- a/tests/TeamBuilder.Tests/Application/PlayerServiceTests.cs
+++ b/tests/TeamBuilder.Tests/Application/PlayerServiceTests.cs
@@ -93,19 +93,41 @@ public async Task GetByUsernameAsync_ShouldReturnPlayer_WhenExists()
     }
 
     [Fact]
-    public async Task GetByIdAsync_ShouldReturnPlayer_WhenExists()
+    public async Task UpdateAsync_ShouldUpdatePlayer_Successfully()
     {
         // Arrange
         var player = new Player
         {
             Id = Guid.NewGuid(),
-            Username = "LookupPlayer",
-            Email = "lookup@example.com",
-            Region = "EU"
+            Username = "TestUser",
+            Email = "old@example.com"
         };
         _context.Players.Add(player);
         await _context.SaveChangesAsync();
 
+        var updateDto = new UpdatePlayerDto
+        {
+            Email = "new@example.com",
+            DisplayName = "New Display Name"
+        };
+
+        // Act
+        var result = await _playerService.UpdateAsync(player.Id, updateDto);
+
+        // Assert
+        result.Should().NotBeNull();
+        result!.Email.Should().Be("new@example.com");
+        result.DisplayName.Should().Be("New Display Name");
+    }
+
+    [Fact]
+    public async Task GetByIdAsync_ShouldReturnPlayer_WhenExists()
+    {
+        // Arrange
+        var player = new Player { Id = Guid.NewGuid(), Username = "LookupPlayer" };
+        _context.Players.Add(player);
+        await _context.SaveChangesAsync();
+
         // Act
         var result = await _playerService.GetByIdAsync(player.Id);
 
@@ -113,7 +135,6 @@ public async Task GetByIdAsync_ShouldReturnPlayer_WhenExists()
         result.Should().NotBeNull();
         result!.Id.Should().Be(player.Id);
         result.Username.Should().Be("LookupPlayer");
-        result.Email.Should().Be("lookup@example.com");
     }
 
     [Fact]
@@ -130,7 +151,7 @@ public async Task GetByIdAsync_ShouldReturnNull_WhenNotExists()
     public async Task GetByUsernameAsync_ShouldReturnNull_WhenNotExists()
     {
         // Act
-        var result = await _playerService.GetByUsernameAsync("NonExistentUser");
+        var result = await _playerService.GetByUsernameAsync("ghost_user");
 
         // Assert
         result.Should().BeNull();
@@ -140,19 +161,16 @@ public async Task GetByUsernameAsync_ShouldReturnNull_WhenNotExists()
     public async Task GetAllAsync_ShouldReturnPaginatedResults()
     {
         // Arrange
-        for (int i = 0; i < 12; i++)
-        {
-            _context.Players.Add(new Player { Id = Guid.NewGuid(), Username = $"Player{i}", Region = "NA" });
-        }
+        for (int i = 0; i < 15; i++)
+            _context.Players.Add(new Player { Id = Guid.NewGuid(), Username = $"Player{i}" });
         await _context.SaveChangesAsync();
 
         // Act
         var result = await _playerService.GetAllAsync(page: 1, pageSize: 10);
 
         // Assert
-        result.Should().NotBeNull();
         result.Items.Should().HaveCount(10);
-        result.TotalCount.Should().Be(12);
+        result.TotalCount.Should().Be(15);
         result.TotalPages.Should().Be(2);
         result.HasNextPage.Should().BeTrue();
         result.HasPreviousPage.Should().BeFalse();
@@ -162,90 +180,51 @@ public async Task GetAllAsync_ShouldReturnPaginatedResults()
     public async Task GetAllAsync_ShouldFilterByRegion()
     {
         // Arrange
-        _context.Players.AddRange(
-            new Player { Id = Guid.NewGuid(), Username = "NAPlayer1", Region = "NA" },
-            new Player { Id = Guid.NewGuid(), Username = "EUPlayer1", Region = "EU" },
-            new Player { Id = Guid.NewGuid(), Username = "NAPlayer2", Region = "NA" }
-        );
+        _context.Players.Add(new Player { Id = Guid.NewGuid(), Username = "NaPlayer1", Region = "NA" });
+        _context.Players.Add(new Player { Id = Guid.NewGuid(), Username = "EuPlayer1", Region = "EU" });
+        _context.Players.Add(new Player { Id = Guid.NewGuid(), Username = "NaPlayer2", Region = "NA" });
         await _context.SaveChangesAsync();
 
         // Act
-        var result = await _playerService.GetAllAsync(1, 20, region: "NA");
+        var result = await _playerService.GetAllAsync(1, 10, region: "NA");
 
         // Assert
-        result.Items.Should().HaveCount(2);
-        result.Items.Should().OnlyContain(p => p.Region == "NA");
         result.TotalCount.Should().Be(2);
+        result.Items.Should().OnlyContain(p => p.Region == "NA");
     }
 
     [Fact]
-    public async Task GetAllAsync_ShouldReturnSecondPage_Correctly()
-    {
-        // Arrange
-        for (int i = 0; i < 15; i++)
-        {
-            _context.Players.Add(new Player { Id = Guid.NewGuid(), Username = $"Player{i:D2}" });
-        }
-        await _context.SaveChangesAsync();
-
-        // Act
-        var result = await _playerService.GetAllAsync(page: 2, pageSize: 10);
-
-        // Assert
-        result.Items.Should().HaveCount(5);
-        result.Page.Should().Be(2);
-        result.HasPreviousPage.Should().BeTrue();
-        result.HasNextPage.Should().BeFalse();
-    }
-
-    [Fact]
-    public async Task GetAllAsync_ShouldReturnEmpty_WhenNoPlayersInRegion()
+    public async Task DeleteAsync_ShouldDeletePlayer_Successfully()
     {
         // Arrange
-        _context.Players.Add(new Player { Id = Guid.NewGuid(), Username = "NAPlayer", Region = "NA" });
+        var player = new Player { Id = Guid.NewGuid(), Username = "DeleteMe" };
+        _context.Players.Add(player);
         await _context.SaveChangesAsync();
 
         // Act
-        var result = await _playerService.GetAllAsync(1, 20, region: "SEA");
+        var result = await _playerService.DeleteAsync(player.Id);
 
         // Assert
-        result.Items.Should().BeEmpty();
-        result.TotalCount.Should().Be(0);
+        result.Should().BeTrue();
+        var deleted = await _context.Players.FindAsync(player.Id);
+        deleted.Should().BeNull();
     }
 
     [Fact]
-    public async Task UpdateAsync_ShouldUpdatePlayer_Successfully()
+    public async Task DeleteAsync_ShouldReturnFalse_WhenNotExists()
     {
-        // Arrange
-        var player = new Player
-        {
-            Id = Guid.NewGuid(),
-            Username = "TestUser",
-            Email = "old@example.com"
-        };
-        _context.Players.Add(player);
-        await _context.SaveChangesAsync();
-
-        var updateDto = new UpdatePlayerDto
-        {
-            Email = "new@example.com",
-            DisplayName = "New Display Name"
-        };
-
         // Act
-        var result = await _playerService.UpdateAsync(player.Id, updateDto);
+        var result = await _playerService.DeleteAsync(Guid.NewGuid());
 
         // Assert
-        result.Should().NotBeNull();
-        result!.Email.Should().Be("new@example.com");
-        result.DisplayName.Should().Be("New Display Name");
+        result.Should().BeFalse();
     }
 
     [Fact]
-    public async Task UpdateAsync_ShouldReturnNull_WhenNotExists()
+    public async Task UpdateAsync_ShouldReturnNull_WhenNotFound()
     {
         // Arrange
-        var updateDto = new UpdatePlayerDto { DisplayName = "Ghost" };
+        var updateDto = new UpdatePlayerDto { Email = "ghost@example.com" };
 
         // Act
         var result = await _playerService.UpdateAsync(Guid.NewGuid(), updateDto);
@@ -254,91 +233,6 @@ public async Task UpdateAsync_ShouldReturnNull_WhenNotExists()
         result.Should().BeNull();
     }
 
-    [Fact]
-    public async Task UpdateAsync_ShouldOnlyUpdateProvidedFields()
-    {
-        // Arrange
-        var player = new Player
-        {
-            Id = Guid.NewGuid(),
-            Username = "TestUser",
-            Email = "original@example.com",
-            Bio = "Original bio",
-            Region = "NA"
-        };
-        _context.Players.Add(player);
-        await _context.SaveChangesAsync();
-
-        var updateDto = new UpdatePlayerDto
-        {
-            DisplayName = "Only This Changes"
-            // Email, Bio, Region left null - should not change
-        };
-
-        // Act
-        var result = await _playerService.UpdateAsync(player.Id, updateDto);
-
-        // Assert
-        result!.DisplayName.Should().Be("Only This Changes");
-        result.Email.Should().Be("original@example.com");
-        result.Bio.Should().Be("Original bio");
-        result.Region.Should().Be("NA");
-    }
-
-    [Fact]
-    public async Task CreateAsync_ShouldMapAllFields_WhenProvided()
-    {
-        // Arrange
-        var createDto = new CreatePlayerDto
-        {
-            Username = "FullPlayer",
-            Email = "full@example.com",
-            DisplayName = "Full Player",
-            Bio = "My bio",
-            Region = "EU",
-            AvatarUrl = "https://example.com/avatar.png"
-        };
-
-        // Act
-        var result = await _playerService.CreateAsync(createDto);
-
-        // Assert
-        result.Should().NotBeNull();
-        result.Username.Should().Be("FullPlayer");
-        result.Email.Should().Be("full@example.com");
-        result.DisplayName.Should().Be("Full Player");
-        result.Bio.Should().Be("My bio");
-        result.Region.Should().Be("EU");
-        result.AvatarUrl.Should().Be("https://example.com/avatar.png");
-    }
-
-    [Fact]
-    public async Task DeleteAsync_ShouldDeletePlayer_Successfully()
-    {
-        // Arrange
-        var player = new Player { Id = Guid.NewGuid(), Username = "PlayerToDelete" };
-        _context.Players.Add(player);
-        await _context.SaveChangesAsync();
-
-        // Act
-        var result = await _playerService.DeleteAsync(player.Id);
-
-        // Assert
-        result.Should().BeTrue();
-        var deletedPlayer = await _context.Players.FindAsync(player.Id);
-        deletedPlayer.Should().BeNull();
-    }
-
-    [Fact]
-    public async Task DeleteAsync_ShouldReturnFalse_WhenNotExists()
-    {
-        // Act
-        var result = await _playerService.DeleteAsync(Guid.NewGuid());
-
-        // Assert
-        result.Should().BeFalse();
-    }
-
     public void Dispose()
     {
         _context.Dispose();
diff --git a/tests/TeamBuilder.Tests/Application/RosterImportServiceTests.cs b/tests/TeamBuilder.Tests/Application/RosterImportServiceTests.cs
index db4b2ab..ae34f71 100644
--- a/tests/TeamBuilder.Tests/Application/RosterImportServiceTests.cs
+++ b/tests/TeamBuilder.Tests/Application/RosterImportServiceTests.cs
@@ -135,31 +135,6 @@ public async Task GetAllAsync_ShouldFilterByProcessedStatus()
         result.Items.Should().OnlyContain(ri => ri.IsProcessed);
     }
 
-    [Fact]
-    public async Task GetAllAsync_ShouldFilterByUnprocessedStatus()
-    {
-        // Arrange
-        for (int i = 0; i < 10; i++)
-        {
-            _context.RosterImports.Add(new RosterImport
-            {
-                Id = Guid.NewGuid(),
-                SourceName = $"Source{i}",
-                SourceType = "CSV",
-                RawData = "test",
-                IsProcessed = i < 3
-            });
-        }
-        await _context.SaveChangesAsync();
-
-        // Act
-        var result = await _rosterImportService.GetAllAsync(1, 20, isProcessed: false);
-
-        // Assert
-        result.Items.Should().HaveCount(7);
-        result.Items.Should().OnlyContain(ri => !ri.IsProcessed);
-    }
-
     [Fact]
     public async Task ProcessAsync_ShouldMarkAsProcessed_AndCreatePlayers()
     {
@@ -245,7 +220,7 @@ public async Task DeleteAsync_ShouldReturnFalse_WhenNotExists()
     }
 
     [Fact]
-    public async Task ProcessAsync_ShouldReturnNull_WhenNotExists()
+    public async Task ProcessAsync_ShouldReturnNull_WhenNotFound()
     {
         // Act
         var result = await _rosterImportService.ProcessAsync(Guid.NewGuid(), Guid.NewGuid());
@@ -255,35 +230,46 @@ public async Task ProcessAsync_ShouldReturnNull_WhenNotExists()
     }
 
     [Fact]
-    public async Task ProcessAsync_ShouldNotDuplicatePlayers_WhenUsernameAlreadyExists()
+    public async Task ProcessAsync_ShouldSkipExistingPlayers_NoDuplicates()
     {
-        // Arrange — player already in db
-        _context.Players.Add(new Player { Id = Guid.NewGuid(), Username = "ExistingPlayer", DisplayName = "ExistingPlayer" });
+        // Arrange - pre-create one of the players in the CSV
+        var existingPlayer = new Player { Id = Guid.NewGuid(), Username = "ExistingPlayer" };
+        _context.Players.Add(existingPlayer);
+
         var rosterImport = new RosterImport
         {
             Id = Guid.NewGuid(),
-            SourceName = "Source",
+            SourceName = "MixedSource",
             SourceType = "CSV",
-            RawData = "Name,Role\nExistingPlayer,Tank\nNewPlayer,DPS",
+            RawData = "Name,Role\nExistingPlayer,Tank\nBrandNewPlayer,DPS",
             IsProcessed = false
         };
         _context.RosterImports.Add(rosterImport);
         await _context.SaveChangesAsync();
 
+        var playerCountBefore = await _context.Players.CountAsync();
+
         // Act
         var result = await _rosterImportService.ProcessAsync(rosterImport.Id, Guid.NewGuid());
 
-        // Assert — only NewPlayer was created (1 new), ExistingPlayer not duplicated
+        // Assert
         result.Should().NotBeNull();
-        result!.ProcessingNotes.Should().Contain("1");
-        var playersNamed = await _context.Players.CountAsync(p => p.Username == "ExistingPlayer");
-        playersNamed.Should().Be(1);
+        result!.IsProcessed.Should().BeTrue();
+
+        // Only one new player (BrandNewPlayer), ExistingPlayer was skipped
+        var playerCountAfter = await _context.Players.CountAsync();
+        playerCountAfter.Should().Be(playerCountBefore + 1);
+
+        var duplicateCheck = await _context.Players
+            .Where(p => p.Username == "ExistingPlayer")
+            .CountAsync();
+        duplicateCheck.Should().Be(1);
     }
 
     [Fact]
-    public async Task ProcessAsync_ShouldProcessZeroEntries_WhenOnlyHeaderPresent()
+    public async Task ProcessAsync_ShouldHandleHeaderOnlyData()
     {
-        // Arrange — CSV with header only, no data rows
+        // Arrange
         var rosterImport = new RosterImport
         {
             Id = Guid.NewGuid(),
@@ -302,31 +288,23 @@ public async Task ProcessAsync_ShouldProcessZeroEntries_WhenOnlyHeaderPresent()
         result.Should().NotBeNull();
         result!.IsProcessed.Should().BeTrue();
         result.ProcessingNotes.Should().Contain("0");
-        var playerCount = await _context.Players.CountAsync();
-        playerCount.Should().Be(0);
     }
 
     [Fact]
-    public async Task ProcessAsync_ShouldUseFirstColumnAsUsername_ForMultiColumnRows()
+    public async Task GetAllAsync_ShouldReturnUnprocessedImports_WhenFilteredByFalse()
     {
         // Arrange
-        var rosterImport = new RosterImport
-        {
-            Id = Guid.NewGuid(),
-            SourceName = "MultiCol",
-            SourceType = "CSV",
-            RawData = "Name,Role,Notes\nPlayerA,Healer,Main healer",
-            IsProcessed = false
-        };
-        _context.RosterImports.Add(rosterImport);
+        _context.RosterImports.Add(new RosterImport { Id = Guid.NewGuid(), SourceName = "Processed", SourceType = "CSV", RawData = "data", IsProcessed = true });
+        _context.RosterImports.Add(new RosterImport { Id = Guid.NewGuid(), SourceName = "Unprocessed1", SourceType = "CSV", RawData = "data", IsProcessed = false });
+        _context.RosterImports.Add(new RosterImport { Id = Guid.NewGuid(), SourceName = "Unprocessed2", SourceType = "CSV", RawData = "data", IsProcessed = false });
         await _context.SaveChangesAsync();
 
         // Act
-        await _rosterImportService.ProcessAsync(rosterImport.Id, Guid.NewGuid());
+        var result = await _rosterImportService.GetAllAsync(1, 20, isProcessed: false);
 
         // Assert
-        var player = await _context.Players.FirstOrDefaultAsync(p => p.Username == "PlayerA");
-        player.Should().NotBeNull();
+        result.TotalCount.Should().Be(2);
+        result.Items.Should().OnlyContain(ri => !ri.IsProcessed);
     }
 
     public void Dispose()
diff --git a/tests/TeamBuilder.Tests/Application/TeamServiceTests.cs b/tests/TeamBuilder.Tests/Application/TeamServiceTests.cs
index 0e9475b..83653eb 100644
--- a/tests/TeamBuilder.Tests/Application/TeamServiceTests.cs
+++ b/tests/TeamBuilder.Tests/Application/TeamServiceTests.cs
@@ -176,49 +176,20 @@ public async Task GetAllAsync_ShouldReturnPaginatedResults()
         result.HasPreviousPage.Should().BeFalse();
     }
 
-    [Fact]
-    public async Task GetAllAsync_ShouldReturnSecondPage_Correctly()
-    {
-        // Arrange
-        for (int i = 0; i < 15; i++)
-        {
-            _context.Teams.Add(new Team
-            {
-                Id = Guid.NewGuid(),
-                Name = $"Team {i:D2}",
-                MaxMembers = 10,
-                Status = TeamStatus.Active,
-                CurrentMemberCount = 0
-            });
-        }
-        await _context.SaveChangesAsync();
-
-        // Act
-        var result = await _teamService.GetAllAsync(page: 2, pageSize: 10);
-
-        // Assert
-        result.Items.Should().HaveCount(5);
-        result.Page.Should().Be(2);
-        result.HasPreviousPage.Should().BeTrue();
-        result.HasNextPage.Should().BeFalse();
-    }
-
     [Fact]
     public async Task GetAllAsync_ShouldFilterByCategory()
     {
         // Arrange
-        _context.Teams.AddRange(
-            new Team { Id = Guid.NewGuid(), Name = "Gaming Team", MaxMembers = 5, CurrentMemberCount = 0, Status = TeamStatus.Recruiting, Category = "Gaming" },
-            new Team { Id = Guid.NewGuid(), Name = "Sports Team", MaxMembers = 5, CurrentMemberCount = 0, Status = TeamStatus.Recruiting, Category = "Sports" },
-            new Team { Id = Guid.NewGuid(), Name = "Gaming Team 2", MaxMembers = 5, CurrentMemberCount = 0, Status = TeamStatus.Recruiting, Category = "Gaming" }
-        );
+        _context.Teams.Add(new Team { Id = Guid.NewGuid(), Name = "Gaming Team", Category = "Gaming", MaxMembers = 5 });
+        _context.Teams.Add(new Team { Id = Guid.NewGuid(), Name = "Sports Team", Category = "Sports", MaxMembers = 5 });
+        _context.Teams.Add(new Team { Id = Guid.NewGuid(), Name = "Gaming Team 2", Category = "Gaming", MaxMembers = 5 });
         await _context.SaveChangesAsync();
 
         // Act
-        var result = await _teamService.GetAllAsync(1, 20, category: "Gaming");
+        var result = await _teamService.GetAllAsync(1, 10, category: "Gaming");
 
         // Assert
-        result.Items.Should().HaveCount(2);
+        result.TotalCount.Should().Be(2);
         result.Items.Should().OnlyContain(t => t.Category == "Gaming");
     }
 
@@ -226,75 +197,37 @@ public async Task GetAllAsync_ShouldFilterByCategory()
     public async Task GetAllAsync_ShouldFilterByRegion()
     {
         // Arrange
-        _context.Teams.AddRange(
-            new Team { Id = Guid.NewGuid(), Name = "NA Team", MaxMembers = 5, CurrentMemberCount = 0, Status = TeamStatus.Recruiting, Region = "NA" },
-            new Team { Id = Guid.NewGuid(), Name = "EU Team", MaxMembers = 5, CurrentMemberCount = 0, Status = TeamStatus.Recruiting, Region = "EU" }
-        );
+        _context.Teams.Add(new Team { Id = Guid.NewGuid(), Name = "NA Team", Region = "NA", MaxMembers = 5 });
+        _context.Teams.Add(new Team { Id = Guid.NewGuid(), Name = "EU Team", Region = "EU", MaxMembers = 5 });
         await _context.SaveChangesAsync();
 
         // Act
-        var result = await _teamService.GetAllAsync(1, 20, region: "NA");
+        var result = await _teamService.GetAllAsync(1, 10, region: "EU");
 
         // Assert
-        result.Items.Should().HaveCount(1);
-        result.Items.First().Region.Should().Be("NA");
+        result.TotalCount.Should().Be(1);
+        result.Items.Single().Region.Should().Be("EU");
     }
 
     [Fact]
     public async Task GetAllAsync_ShouldFilterByStatus()
     {
         // Arrange
-        _context.Teams.AddRange(
-            new Team { Id = Guid.NewGuid(), Name = "Recruiting Team", MaxMembers = 5, CurrentMemberCount = 0, Status = TeamStatus.Recruiting },
-            new Team { Id = Guid.NewGuid(), Name = "Full Team", MaxMembers = 5, CurrentMemberCount = 5, Status = TeamStatus.Full },
-            new Team { Id = Guid.NewGuid(), Name = "Active Team", MaxMembers = 5, CurrentMemberCount = 2, Status = TeamStatus.Active }
-        );
-        await _context.SaveChangesAsync();
-
-        // Act
-        var result = await _teamService.GetAllAsync(1, 20, status: TeamStatus.Recruiting);
-
-        // Assert
-        result.Items.Should().HaveCount(1);
-        result.Items.First().Status.Should().Be(TeamStatus.Recruiting);
-    }
-
-    [Fact]
-    public async Task GetAllAsync_ShouldReturnEmpty_WhenNoTeamsMatch()
-    {
-        // Arrange
-        _context.Teams.Add(new Team { Id = Guid.NewGuid(), Name = "NA Team", MaxMembers = 5, CurrentMemberCount = 0, Status = TeamStatus.Active, Region = "NA" });
+        _context.Teams.Add(new Team { Id = Guid.NewGuid(), Name = "Active Team", Status = TeamStatus.Active, MaxMembers = 5 });
+        _context.Teams.Add(new Team { Id = Guid.NewGuid(), Name = "Recruiting Team", Status = TeamStatus.Recruiting, MaxMembers = 5 });
+        _context.Teams.Add(new Team { Id = Guid.NewGuid(), Name = "Full Team", Status = TeamStatus.Full, MaxMembers = 5 });
         await _context.SaveChangesAsync();
 
         // Act
-        var result = await _teamService.GetAllAsync(1, 20, region: "SEA");
+        var result = await _teamService.GetAllAsync(1, 10, status: TeamStatus.Recruiting);
 
         // Assert
-        result.Items.Should().BeEmpty();
-        result.TotalCount.Should().Be(0);
+        result.TotalCount.Should().Be(1);
+        result.Items.Single().Status.Should().Be(TeamStatus.Recruiting);
     }
 
     [Fact]
-    public async Task GetAllAsync_ShouldCombineFilters_CategoryAndRegion()
-    {
-        // Arrange
-        _context.Teams.AddRange(
-            new Team { Id = Guid.NewGuid(), Name = "Gaming NA", MaxMembers = 5, CurrentMemberCount = 0, Status = TeamStatus.Recruiting, Category = "Gaming", Region = "NA" },
-            new Team { Id = Guid.NewGuid(), Name = "Gaming EU", MaxMembers = 5, CurrentMemberCount = 0, Status = TeamStatus.Recruiting, Category = "Gaming", Region = "EU" },
-            new Team { Id = Guid.NewGuid(), Name = "Sports NA", MaxMembers = 5, CurrentMemberCount = 0, Status = TeamStatus.Recruiting, Category = "Sports", Region = "NA" }
-        );
-        await _context.SaveChangesAsync();
-
-        // Act
-        var result = await _teamService.GetAllAsync(1, 20, category: "Gaming", region: "NA");
-
-        // Assert
-        result.Items.Should().HaveCount(1);
-        result.Items.First().Name.Should().Be("Gaming NA");
-    }
-
-    [Fact]
-    public async Task UpdateAsync_ShouldReturnNull_WhenNotExists()
+    public async Task UpdateAsync_ShouldReturnNull_WhenNotFound()
     {
         // Arrange
         var updateDto = new UpdateTeamDto { Name = "Ghost Team" };
@@ -307,42 +240,7 @@ public async Task UpdateAsync_ShouldReturnNull_WhenNotExists()
     }
 
     [Fact]
-    public async Task UpdateAsync_ShouldOnlyUpdateProvidedFields()
-    {
-        // Arrange
-        var team = new Team
-        {
-            Id = Guid.NewGuid(),
-            Name = "Original Name",
-            Description = "Original Description",
-            MaxMembers = 10,
-            Status = TeamStatus.Recruiting,
-            CurrentMemberCount = 0,
-            Region = "NA",
-            Category = "Gaming"
-        };
-        _context.Teams.Add(team);
-        await _context.SaveChangesAsync();
-
-        var updateDto = new UpdateTeamDto
-        {
-            Name = "Updated Name"
-            // All other fields null - should not change
-        };
-
-        // Act
-        var result = await _teamService.UpdateAsync(team.Id, updateDto);
-
-        // Assert
-        result!.Name.Should().Be("Updated Name");
-        result.Description.Should().Be("Original Description");
-        result.Status.Should().Be(TeamStatus.Recruiting);
-        result.Region.Should().Be("NA");
-        result.Category.Should().Be("Gaming");
-    }
-
-    [Fact]
-    public async Task DeleteAsync_ShouldReturnFalse_WhenNotExists()
+    public async Task DeleteAsync_ShouldReturnFalse_WhenNotFound()
     {
         // Act
         var result = await _teamService.DeleteAsync(Guid.NewGuid());
@@ -351,73 +249,6 @@ public async Task DeleteAsync_ShouldReturnFalse_WhenNotExists()
         result.Should().BeFalse();
     }
 
-    [Fact]
-    public async Task CreateAsync_ShouldDefaultStatus_ToRecruiting()
-    {
-        // Arrange
-        var createDto = new CreateTeamDto { Name = "New Team", MaxMembers = 5 };
-
-        // Act
-        var result = await _teamService.CreateAsync(createDto, Guid.NewGuid());
-
-        // Assert
-        result.Status.Should().Be(TeamStatus.Recruiting);
-        result.CurrentMemberCount.Should().Be(0);
-    }
-
-    [Fact]
-    public async Task GetByIdAsync_ShouldIncludeOwnerUsername_WhenOwnerExists()
-    {
-        // Arrange
-        var owner = new Player { Id = Guid.NewGuid(), Username = "TeamOwner" };
-        _context.Players.Add(owner);
-
-        var team = new Team
-        {
-            Id = Guid.NewGuid(),
-            Name = "Owned Team",
-            MaxMembers = 5,
-            Status = TeamStatus.Recruiting,
-            CurrentMemberCount = 0,
-            OwnerId = owner.Id,
-            Owner = owner
-        };
-        _context.Teams.Add(team);
-        await _context.SaveChangesAsync();
-
-        // Act
-        var result = await _teamService.GetByIdAsync(team.Id);
-
-        // Assert
-        result.Should().NotBeNull();
-        result!.OwnerUsername.Should().Be("TeamOwner");
-        result.OwnerId.Should().Be(owner.Id);
-    }
-
-    [Fact]
-    public async Task UpdateAsync_ShouldNotUpdateName_WhenWhitespaceProvided()
-    {
-        // Arrange
-        var team = new Team
-        {
-            Id = Guid.NewGuid(),
-            Name = "Original Name",
-            MaxMembers = 5,
-            Status = TeamStatus.Recruiting,
-            CurrentMemberCount = 0
-        };
-        _context.Teams.Add(team);
-        await _context.SaveChangesAsync();
-
-        var updateDto = new UpdateTeamDto { Name = "   " }; // whitespace — should be skipped
-
-        // Act
-        var result = await _teamService.UpdateAsync(team.Id, updateDto);
-
-        // Assert
-        result!.Name.Should().Be("Original Name");
-    }
-
     public void Dispose()
     {
         _context.Dispose();