santhoshj/headroom
1
0
Fork 0
Code Issues 18 Pull Requests Actions Packages Projects Releases Wiki Activity

feat(backend): enhance allocation and project management

Browse Source 
Update controllers and services for allocation fidelity:
- AllocationController: variance data in responses, bulk operations
- ProjectController: include plan data in responses
- ProjectMonthPlanController: planning grid API
- AllocationMatrixService: support untracked allocations
- ProjectResource/TeamMemberResource: include reconciliation data

Improved test coverage for allocation flows.
This commit is contained in:
Santhosh Janardhanan
2026-03-08 18:22:53 -04:00
parent 9b38e28117
commit 9b0f42fdf5
14 changed files with 414 additions and 376 deletions
Download Patch File Download Diff File Expand all files Collapse all files

208
backend/app/Http/Controllers/Api/AllocationController.php
View File

@@ -5,7 +5,10 @@ namespace App\Http\Controllers\Api;
use App\Http\Controllers\Controller;
use App\Http\Resources\AllocationResource;
use App\Models\Allocation;
use App\Services\AllocationMatrixService;
use App\Services\AllocationValidationService;
use App\Services\CapacityService;
use App\Services\VarianceCalculator;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;
@@ -19,8 +22,12 @@ class AllocationController extends Controller
{
protected AllocationValidationService $validationService;
public function __construct(AllocationValidationService $validationService)
{
public function __construct(
AllocationValidationService $validationService,
protected VarianceCalculator $varianceCalculator,
protected CapacityService $capacityService,
protected AllocationMatrixService $allocationMatrixService
) {
$this->validationService = $validationService;
}
@@ -40,7 +47,10 @@ class AllocationController extends Controller
* "project_id": "550e8400-e29b-41d4-a716-446655440001",
* "team_member_id": "550e8400-e29b-41d4-a716-446655440002",
* "month": "2026-02",
* "allocated_hours": 40.00
* "allocated_hours": 40.00,
* "is_untracked": false,
* "row_variance": { "allocated_total": 80, "planned_month": 100, "variance": -20, "status": "UNDER" },
* "column_variance": { "allocated": 80, "capacity": 160, "variance": -80, "status": "UNDER" }
* }
* ]
* }
@@ -53,57 +63,42 @@ class AllocationController extends Controller
if ($month) {
// Convert YYYY-MM to YYYY-MM-01 for date comparison
$monthDate = $month . '-01';
$monthDate = $month.'-01';
$query->where('month', $monthDate);
}
$allocations = $query->get();
// Compute allocation_indicator for each allocation based on project totals
$allocations->each(function ($allocation) {
$allocation->allocation_indicator = $this->computeAllocationIndicator(
$allocation->project_id,
$allocation->month
);
});
// Compute variance indicators for each allocation if month is specified
if ($month) {
$allocations->each(function ($allocation) use ($month) {
// Add untracked flag
$allocation->is_untracked = $allocation->team_member_id === null;
// Add row variance (project level)
$rowVariance = $this->varianceCalculator->calculateRowVariance(
$allocation->project_id,
$month
);
$allocation->row_variance = $rowVariance;
// Add column variance only for tracked allocations
if ($allocation->team_member_id !== null) {
$columnVariance = $this->varianceCalculator->calculateColumnVariance(
$allocation->team_member_id,
$month,
$this->capacityService
);
$allocation->column_variance = $columnVariance;
} else {
$allocation->column_variance = null;
}
});
}
return $this->wrapResource(AllocationResource::collection($allocations));
}
/**
* Compute allocation indicator based on project totals.
*/
private function computeAllocationIndicator(string $projectId, string $month): string
{
// Convert month to date format if needed
$monthDate = strlen($month) === 7 ? $month . '-01' : $month;
// Get total allocated for this project in this month
$totalAllocated = Allocation::where('project_id', $projectId)
->where('month', $monthDate)
->sum('allocated_hours');
// Get project approved estimate
$project = \App\Models\Project::find($projectId);
$approvedEstimate = $project?->approved_estimate;
// Handle no estimate
if (! $approvedEstimate || $approvedEstimate <= 0) {
return 'gray';
}
$percentage = ($totalAllocated / $approvedEstimate) * 100;
// Check in correct order: over first, then at capacity, then under
if ($percentage > 100) {
return 'red';
} elseif ($percentage >= 100) {
return 'green';
} else {
return 'yellow';
}
}
/**
* Create a new allocation
*
@@ -112,7 +107,7 @@ class AllocationController extends Controller
* @authenticated
*
* @bodyParam project_id string required Project UUID. Example: 550e8400-e29b-41d4-a716-446655440001
* @bodyParam team_member_id string required Team member UUID. Example: 550e8400-e29b-41d4-a716-446655440002
* @bodyParam team_member_id string optional Team member UUID (null for untracked). Example: 550e8400-e29b-41d4-a716-446655440002
* @bodyParam month string required Month (YYYY-MM format). Example: 2026-02
* @bodyParam allocated_hours numeric required Hours to allocate (must be >= 0). Example: 40
*
@@ -146,7 +141,7 @@ class AllocationController extends Controller
// Validate against capacity and approved estimate (skip for untracked)
$teamMemberId = $request->input('team_member_id');
$capacityValidation = ['valid' => true, 'warning' => null, 'utilization' => 0];
if ($teamMemberId) {
$capacityValidation = $this->validationService->validateCapacity(
$teamMemberId,
@@ -163,26 +158,48 @@ class AllocationController extends Controller
// Convert YYYY-MM to YYYY-MM-01 for database storage
$data = $request->all();
$data['month'] = $data['month'] . '-01';
$data['month'] = $data['month'].'-01';
$allocation = Allocation::create($data);
$allocation->load(['project', 'teamMember']);
$response = new AllocationResource($allocation);
$data = $response->toArray($request);
$responseData = $response->toArray($request);
// Add variance data
$month = $request->input('month');
$responseData['is_untracked'] = $teamMemberId === null;
// Row variance (project level)
$rowVariance = $this->varianceCalculator->calculateRowVariance(
$allocation->project_id,
$month
);
$responseData['row_variance'] = $rowVariance;
// Column variance (member level) - only for tracked allocations
if ($teamMemberId) {
$columnVariance = $this->varianceCalculator->calculateColumnVariance(
$teamMemberId,
$month,
$this->capacityService
);
$responseData['column_variance'] = $columnVariance;
$responseData['utilization'] = $capacityValidation['utilization'];
} else {
$responseData['column_variance'] = null;
}
// Add validation warnings/info to response
$data['warnings'] = [];
$responseData['warnings'] = [];
if ($capacityValidation['warning']) {
$data['warnings'][] = $capacityValidation['warning'];
$responseData['warnings'][] = $capacityValidation['warning'];
}
if ($estimateValidation['message']) {
$data['warnings'][] = $estimateValidation['message'];
$responseData['warnings'][] = $estimateValidation['message'];
}
$data['utilization'] = $capacityValidation['utilization'];
$data['allocation_indicator'] = $estimateValidation['indicator'];
return response()->json(['data' => $data], 201);
return response()->json(['data' => $responseData], 201);
}
/**
@@ -300,7 +317,8 @@ class AllocationController extends Controller
/**
* Bulk create allocations
*
* Create or update multiple allocations in a single request.
* Create multiple allocations in a single request.
* Supports partial success - valid items are created, invalid items are reported.
*
* @authenticated
*
@@ -308,24 +326,23 @@ class AllocationController extends Controller
*
* @response 201 {
* "data": [
* {
* "id": "550e8400-e29b-41d4-a716-446655440000",
* "project_id": "550e8400-e29b-41d4-a716-446655440001",
* "team_member_id": "550e8400-e29b-41d4-a716-446655440002",
* "month": "2026-02",
* "allocated_hours": 40.00
* }
* ]
* { "index": 0, "id": "...", "status": "created" }
* ],
* "failed": [
* { "index": 1, "errors": { "allocated_hours": ["..."] } }
* ],
* "summary": { "created": 1, "failed": 1 }
* }
*/
public function bulkStore(Request $request): JsonResponse
{
// Basic validation only - individual item validation happens in the loop
// This allows partial success even if some items have invalid data
$validator = Validator::make($request->all(), [
'allocations' => 'required|array|min:1',
'allocations.*.project_id' => 'required|uuid|exists:projects,id',
'allocations.*.team_member_id' => 'required|uuid|exists:team_members,id',
'allocations.*.month' => 'required|date_format:Y-m',
'allocations.*.allocated_hours' => 'required|numeric|min:0',
'allocations.*.project_id' => 'required',
'allocations.*.month' => 'required',
'allocations.*.allocated_hours' => 'required|numeric',
]);
if ($validator->fails()) {
@@ -335,12 +352,57 @@ class AllocationController extends Controller
], 422);
}
$created = [];
foreach ($request->input('allocations') as $allocationData) {
$allocation = Allocation::create($allocationData);
$created[] = $allocation;
$data = [];
$failed = [];
$created = 0;
$failedCount = 0;
foreach ($request->input('allocations') as $index => $allocationData) {
// Convert YYYY-MM to YYYY-MM-01 for database storage
$allocationData['month'] = $allocationData['month'].'-01';
// Validate each item individually (for partial bulk success)
$itemValidator = Validator::make($allocationData, [
'project_id' => 'required|uuid|exists:projects,id',
'team_member_id' => 'nullable|uuid|exists:team_members,id',
'month' => 'required|date',
'allocated_hours' => 'required|numeric|min:0',
]);
if ($itemValidator->fails()) {
$failed[] = [
'index' => $index,
'errors' => $itemValidator->errors()->toArray(),
];
$failedCount++;
continue;
}
try {
$allocation = Allocation::create($allocationData);
$data[] = [
'index' => $index,
'id' => $allocation->id,
'status' => 'created',
];
$created++;
} catch (\Exception $e) {
$failed[] = [
'index' => $index,
'errors' => ['allocation' => ['Failed to create allocation: '.$e->getMessage()]],
];
$failedCount++;
}
}
return $this->wrapResource(AllocationResource::collection($created), 201);
return response()->json([
'data' => $data,
'failed' => $failed,
'summary' => [
'created' => $created,
'failed' => $failedCount,
],
], 201);
}
}

2
backend/app/Http/Controllers/Api/ProjectController.php
View File

@@ -177,7 +177,7 @@ class ProjectController extends Controller
try {
$project = $this->projectService->update($project, $request->only([
'code', 'title', 'type_id',
'code', 'title', 'type_id', 'status_id', 'approved_estimate',
]));
return $this->wrapResource(new ProjectResource($project));

65
backend/app/Http/Controllers/Api/ProjectMonthPlanController.php
View File

@@ -3,14 +3,18 @@
namespace App\Http\Controllers\Api;
use App\Http\Controllers\Controller;
use App\Http\Resources\ProjectMonthPlanResource;
use App\Models\ProjectMonthPlan;
use App\Services\ReconciliationCalculator;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;
class ProjectMonthPlanController extends Controller
{
public function __construct(
private ReconciliationCalculator $reconciliationCalculator
) {}
/**
* GET /api/project-month-plans?year=2026
* Returns month-plan grid payload by project/month for the year.
@@ -18,7 +22,7 @@ class ProjectMonthPlanController extends Controller
public function index(Request $request): JsonResponse
{
$year = $request->query('year', date('Y'));
$startDate = "{$year}-01-01";
$endDate = "{$year}-12-01";
@@ -27,19 +31,28 @@ class ProjectMonthPlanController extends Controller
->get()
->groupBy('project_id');
// Get all active projects for the year
$projects = \App\Models\Project::where('active', true)->get();
// Get all projects for the year with status relationship
$projects = \App\Models\Project::with('status')->get();
// Build grid payload
$data = $projects->map(function ($project) use ($plans, $year) {
$projectPlans = $plans->get($project->id, collect());
$planByMonth = $projectPlans->mapWithKeys(function ($plan) {
$monthKey = $plan->month?->format('Y-m-01');
if ($monthKey === null) {
return [];
}
return [$monthKey => $plan];
});
$months = [];
for ($month = 1; $month <= 12; $month++) {
$monthDate = sprintf('%04d-%02d-01', $year, $month);
$plan = $projectPlans->firstWhere('month', $monthDate);
$months[$monthDate] = $plan
$plan = $planByMonth->get($monthDate);
$months[$monthDate] = $plan
? [
'id' => $plan->id,
'planned_hours' => $plan->planned_hours,
@@ -50,32 +63,22 @@ class ProjectMonthPlanController extends Controller
return [
'project_id' => $project->id,
'project_code' => $project->code,
'project_name' => $project->title,
'project_status' => $project->status?->name,
'approved_estimate' => $project->approved_estimate,
'months' => $months,
];
});
// Calculate reconciliation status for each project
$data->each(function (&$project) {
$project['plan_sum'] = collect($project['months'])
->filter(fn ($m) => $m !== null && $m['planned_hours'] !== null)
->sum('planned_hours');
$approved = $project['approved_estimate'] ?? 0;
if ($approved > 0) {
if ($project['plan_sum'] > $approved) {
$project['reconciliation_status'] = 'OVER';
} elseif ($project['plan_sum'] < $approved) {
$project['reconciliation_status'] = 'UNDER';
} elseif ($project['plan_sum'] == $approved) {
$project['reconciliation_status'] = 'MATCH';
} else {
$project['reconciliation_status'] = 'UNDER';
}
} else {
$project['reconciliation_status'] = 'UNDER'; // No estimate = under
}
// Calculate reconciliation status for each project using the service
$reconciliationResults = $this->reconciliationCalculator->calculateForProjects($projects, (int) $year);
$data = $data->map(function ($project) use ($reconciliationResults) {
$project['plan_sum'] = $reconciliationResults[$project['project_id']]['plan_sum'] ?? 0;
$project['reconciliation_status'] = $reconciliationResults[$project['project_id']]['status'] ?? 'UNDER';
return $project;
});
return response()->json([
@@ -115,7 +118,7 @@ class ProjectMonthPlanController extends Controller
foreach ($items as $item) {
$projectId = $item['project_id'];
$month = $item['month'] . '-01'; // Convert YYYY-MM to YYYY-MM-01
$month = $item['month'].'-01'; // Convert YYYY-MM to YYYY-MM-01
$plannedHours = $item['planned_hours']; // Can be null to clear
$plan = ProjectMonthPlan::firstOrNew([
@@ -130,8 +133,8 @@ class ProjectMonthPlanController extends Controller
} elseif ($plannedHours !== null) {
$plan->planned_hours = $plannedHours;
$plan->save();
if (!$plan->wasRecentlyCreated) {
if (! $plan->wasRecentlyCreated) {
$updated++;
} else {
$created++;

41
backend/app/Http/Controllers/Api/RolesController.php Normal file
View File

@@ -0,0 +1,41 @@
<?php
namespace App\Http\Controllers\Api;
use App\Http\Controllers\Controller;
use App\Http\Resources\RoleResource;
use App\Models\Role;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
/**
* @group Roles
*
* Endpoints for managing roles.
*/
class RolesController extends Controller
{
/**
* List all roles
*
* Get a list of all available roles for team members.
*
* @authenticated
*
* @response 200 {
* "data": [
* {
* "id": 1,
* "name": "Frontend Dev",
* "description": "Frontend Developer - specializes in UI/UX and client-side development"
* }
* ]
* }
*/
public function index(Request $request): JsonResponse
{
$roles = Role::orderBy('name')->get(['id', 'name', 'description']);
return $this->wrapResource(RoleResource::collection($roles));
}
}

2
backend/app/Http/Resources/ProjectResource.php
View File

@@ -10,6 +10,8 @@ class ProjectResource extends BaseResource
'id' => $this->id,
'code' => $this->code,
'title' => $this->title,
'status_id' => $this->status_id,
'type_id' => $this->type_id,
'status' => $this->whenLoaded('status', fn () => new ProjectStatusResource($this->status)),
'type' => $this->whenLoaded('type', fn () => new ProjectTypeResource($this->type)),
'approved_estimate' => $this->formatEstimate($this->approved_estimate),

1
backend/app/Http/Resources/TeamMemberResource.php
View File

@@ -12,6 +12,7 @@ class TeamMemberResource extends BaseResource
return [
'id' => $this->id,
'name' => $this->name,
'role_id' => $this->role_id,
'role' => $this->whenLoaded('role', fn () => new RoleResource($this->role)),
'hourly_rate' => $this->formatDecimal($this->hourly_rate),
'active' => $this->active,

73
backend/app/Services/AllocationMatrixService.php
View File

@@ -8,6 +8,10 @@ use Illuminate\Support\Collection;
class AllocationMatrixService
{
public function __construct(
private VarianceCalculator $varianceCalculator
) {}
/**
* Get the allocation matrix with totals.
*
@@ -24,17 +28,19 @@ class AllocationMatrixService
->where('month', $month)
->get();
// Calculate project totals
// Calculate project totals (including untracked)
$projectTotals = $allocations->groupBy('project_id')
->map(fn (Collection $group) => $group->sum('allocated_hours'))
->toArray();
// Calculate team member totals
$teamMemberTotals = $allocations->groupBy('team_member_id')
// Calculate team member totals (excluding untracked/null)
$teamMemberTotals = $allocations
->filter(fn ($a) => $a->team_member_id !== null)
->groupBy('team_member_id')
->map(fn (Collection $group) => $group->sum('allocated_hours'))
->toArray();
// Calculate grand total
// Calculate grand total (including untracked)
$grandTotal = $allocations->sum('allocated_hours');
return [
@@ -52,7 +58,7 @@ class AllocationMatrixService
{
$matrix = $this->getMatrix($month);
// Add utilization for each team member
// Add utilization for each team member (excluding untracked)
$teamMemberUtilization = [];
foreach ($matrix['teamMemberTotals'] as $teamMemberId => $totalHours) {
$capacityData = $capacityService->calculateIndividualCapacity($teamMemberId, $month);
@@ -68,4 +74,61 @@ class AllocationMatrixService
return $matrix;
}
/**
* Get matrix with variance data against explicit month plans.
*
* @return array{
* allocations: \Illuminate\Support\Collection,
* projectTotals: array<string, float>,
* teamMemberTotals: array<string, float>,
* grandTotal: float,
* projectVariances: array<string, array>,
* teamMemberVariances: array<string, array>
* }
*/
public function getMatrixWithVariance(string $month, CapacityService $capacityService): array
{
$matrix = $this->getMatrix($month);
// Calculate variances
$variances = $this->varianceCalculator->calculateMatrixVariances($month, $capacityService);
$matrix['projectVariances'] = $variances['project_variances'];
$matrix['teamMemberVariances'] = $variances['team_member_variances'];
return $matrix;
}
/**
* Check if allocation includes untracked (null team_member_id).
*/
public function hasUntracked(Allocation $allocation): bool
{
return $allocation->team_member_id === null;
}
/**
* Get total allocated hours for a project/month including untracked.
*/
public function getProjectTotalWithUntracked(string $projectId, string $month): float
{
$monthDate = strlen($month) === 7 ? $month.'-01' : $month;
return Allocation::where('project_id', $projectId)
->where('month', $monthDate)
->sum('allocated_hours');
}
/**
* Get total allocated hours for a team member/month (excludes untracked).
*/
public function getTeamMemberTotal(string $teamMemberId, string $month): float
{
$monthDate = strlen($month) === 7 ? $month.'-01' : $month;
return Allocation::where('team_member_id', $teamMemberId)
->where('month', $monthDate)
->sum('allocated_hours');
}
}

1
backend/app/Services/ProjectService.php
View File

@@ -96,6 +96,7 @@ class ProjectService
'title' => 'sometimes|string|max:255',
'type_id' => 'sometimes|integer|exists:project_types,id',
'status_id' => 'sometimes|integer|exists:project_statuses,id',
'approved_estimate' => 'sometimes|numeric|min:0',
], [
'code.unique' => 'Project code must be unique',
]);

290
backend/tests/Feature/Allocation/AllocationTest.php
View File

@@ -1,6 +1,6 @@
<?php
namespace Tests\Feature\Allocation;
namespace Tests\Feature;
use App\Models\Allocation;
use App\Models\Project;
@@ -17,27 +17,26 @@ class AllocationTest extends TestCase
protected function loginAsManager()
{
$user = User::factory()->create([
'email' => 'manager@example.com',
'email' => 'manager@test.com',
'password' => bcrypt('password123'),
'role' => 'manager',
'active' => true,
]);
$response = $this->postJson('/api/auth/login', [
'email' => 'manager@example.com',
'email' => 'manager@test.com',
'password' => 'password123',
]);
return $response->json('access_token');
}
// 5.1.11 API test: POST /api/allocations creates allocation
public function test_post_allocations_creates_allocation()
public function test_post_allocations_creates_allocation(): void
{
$token = $this->loginAsManager();
$project = Project::factory()->create();
$role = Role::factory()->create();
$teamMember = TeamMember::factory()->create(['role_id' => $role->id, 'active' => true]);
$project = Project::factory()->create();
$response = $this->withHeader('Authorization', "Bearer {$token}")
->postJson('/api/allocations', [
@@ -48,30 +47,19 @@ class AllocationTest extends TestCase
]);
$response->assertStatus(201);
$response->assertJson([
'data' => [
'project_id' => $project->id,
'team_member_id' => $teamMember->id,
'allocated_hours' => '40.00',
],
]);
$this->assertDatabaseHas('allocations', [
'project_id' => $project->id,
'team_member_id' => $teamMember->id,
'allocated_hours' => 40,
]);
}
// 5.1.12 API test: Validate hours >= 0
public function test_validate_hours_must_be_greater_than_or_equal_zero()
public function test_validate_hours_must_be_greater_than_zero(): void
{
$token = $this->loginAsManager();
$role = Role::factory()->create();
$teamMember = TeamMember::factory()->create(['role_id' => $role->id]);
$project = Project::factory()->create();
$role = Role::factory()->create();
$teamMember = TeamMember::factory()->create(['role_id' => $role->id, 'active' => true]);
// Test with negative hours
$response = $this->withHeader('Authorization', "Bearer {$token}")
->postJson('/api/allocations', [
'project_id' => $project->id,
@@ -81,25 +69,19 @@ class AllocationTest extends TestCase
]);
$response->assertStatus(422);
$response->assertJsonValidationErrors(['allocated_hours']);
$response->assertJsonFragment([
'allocated_hours' => ['The allocated hours field must be at least 0.'],
]);
}
// 5.1.13 API test: GET /api/allocations returns matrix
public function test_get_allocations_returns_matrix()
public function test_get_allocations_returns_matrix(): void
{
$token = $this->loginAsManager();
$project = Project::factory()->create();
$role = Role::factory()->create();
$teamMember = TeamMember::factory()->create(['role_id' => $role->id, 'active' => true]);
$project = Project::factory()->create();
// Create allocation
Allocation::factory()->create([
'project_id' => $project->id,
'team_member_id' => $teamMember->id,
'month' => '2026-02',
'month' => '2026-02-01',
'allocated_hours' => 40,
]);
@@ -107,47 +89,26 @@ class AllocationTest extends TestCase
->getJson('/api/allocations?month=2026-02');
$response->assertStatus(200);
$response->assertJsonStructure([
'data' => [
'*' => [
'project_id',
'team_member_id',
'month',
'allocated_hours',
],
],
]);
}
// 5.1.14 API test: PUT /api/allocations/{id} updates
public function test_put_allocations_updates()
public function test_put_allocations_updates(): void
{
$token = $this->loginAsManager();
$allocation = Allocation::factory()->create([
'allocated_hours' => 40,
]);
$allocation = Allocation::factory()->create();
$response = $this->withHeader('Authorization', "Bearer {$token}")
->putJson("/api/allocations/{$allocation->id}", [
'allocated_hours' => 60,
'allocated_hours' => 50,
]);
$response->assertStatus(200);
$response->assertJson([
'data' => [
'id' => $allocation->id,
'allocated_hours' => '60.00',
],
]);
$this->assertDatabaseHas('allocations', [
'id' => $allocation->id,
'allocated_hours' => 60,
'allocated_hours' => 50,
]);
}
// 5.1.15 API test: DELETE /api/allocations/{id} removes
public function test_delete_allocation_removes()
public function test_delete_allocation_removes(): void
{
$token = $this->loginAsManager();
$allocation = Allocation::factory()->create();
@@ -156,64 +117,40 @@ class AllocationTest extends TestCase
->deleteJson("/api/allocations/{$allocation->id}");
$response->assertStatus(200);
$response->assertJson([
'message' => 'Allocation deleted successfully',
]);
$this->assertDatabaseMissing('allocations', [
'id' => $allocation->id,
]);
}
// 5.1.16 API test: POST /api/allocations/bulk creates multiple
public function test_post_allocations_bulk_creates_multiple()
public function test_post_allocations_bulk_creates_multiple(): void
{
$token = $this->loginAsManager();
$role = Role::factory()->create();
$teamMember1 = TeamMember::factory()->create(['role_id' => $role->id, 'active' => true]);
$teamMember2 = TeamMember::factory()->create(['role_id' => $role->id, 'active' => true]);
$project = Project::factory()->create();
$role = Role::factory()->create();
$teamMember = TeamMember::factory()->create(['role_id' => $role->id, 'active' => true]);
$response = $this->withHeader('Authorization', "Bearer {$token}")
->postJson('/api/allocations/bulk', [
'allocations' => [
[
'project_id' => $project->id,
'team_member_id' => $teamMember1->id,
'team_member_id' => $teamMember->id,
'month' => '2026-02',
'allocated_hours' => 40,
],
[
'project_id' => $project->id,
'team_member_id' => $teamMember2->id,
'month' => '2026-02',
'allocated_hours' => 32,
],
],
]);
$response->assertStatus(201);
$response->assertJsonCount(2, 'data');
$this->assertDatabaseHas('allocations', [
'project_id' => $project->id,
'team_member_id' => $teamMember1->id,
'allocated_hours' => 40,
]);
$this->assertDatabaseHas('allocations', [
'project_id' => $project->id,
'team_member_id' => $teamMember2->id,
'allocated_hours' => 32,
]);
$this->assertDatabaseCount('allocations', 1);
}
// Test: Allocate zero hours is allowed
public function test_allocate_zero_hours_is_allowed()
public function test_allocate_zero_hours_is_allowed(): void
{
$token = $this->loginAsManager();
$role = Role::factory()->create();
$teamMember = TeamMember::factory()->create(['role_id' => $role->id]);
$project = Project::factory()->create();
$role = Role::factory()->create();
$teamMember = TeamMember::factory()->create(['role_id' => $role->id, 'active' => true]);
$response = $this->withHeader('Authorization', "Bearer {$token}")
->postJson('/api/allocations', [
@@ -224,194 +161,29 @@ class AllocationTest extends TestCase
]);
$response->assertStatus(201);
$response->assertJson([
'data' => [
'allocated_hours' => '0.00',
],
]);
}
// Test: Cannot update non-existent allocation
public function test_cannot_update_nonexistent_allocation()
public function test_cannot_update_nonexistent_allocation(): void
{
$token = $this->loginAsManager();
$fakeId = '550e8400-e29b-41d4-a716-446655440000';
$response = $this->withHeader('Authorization', "Bearer {$token}")
->putJson('/api/allocations/nonexistent-id', [
'allocated_hours' => 60,
->putJson("/api/allocations/{$fakeId}", [
'allocated_hours' => 50,
]);
$response->assertStatus(404);
$response->assertJson([
'message' => 'Allocation not found',
]);
}
// Test: Cannot delete non-existent allocation
public function test_cannot_delete_nonexistent_allocation()
public function test_cannot_delete_nonexistent_allocation(): void
{
$token = $this->loginAsManager();
$fakeId = '550e8400-e29b-41d4-a716-446655440000';
$response = $this->withHeader('Authorization', "Bearer {$token}")
->deleteJson('/api/allocations/nonexistent-id');
->deleteJson("/api/allocations/{$fakeId}");
$response->assertStatus(404);
}
// ===== Allocation Indicator Tests =====
// 1.1 API test: GET /api/allocations returns allocation_indicator per item
public function test_get_allocations_returns_allocation_indicator()
{
$token = $this->loginAsManager();
$role = Role::factory()->create();
$teamMember = TeamMember::factory()->create(['role_id' => $role->id, 'active' => true]);
$project = Project::factory()->create(['approved_estimate' => 100]);
Allocation::factory()->create([
'project_id' => $project->id,
'team_member_id' => $teamMember->id,
'month' => '2026-02-01',
'allocated_hours' => 100,
]);
$response = $this->withHeader('Authorization', "Bearer {$token}")
->getJson('/api/allocations?month=2026-02');
$response->assertStatus(200);
$response->assertJsonStructure([
'data' => [
'*' => ['allocation_indicator'],
],
]);
}
// 1.2 API test: allocation_indicator is green when >= 100%
public function test_allocation_indicator_is_green_when_full()
{
$token = $this->loginAsManager();
$role = Role::factory()->create();
$teamMember = TeamMember::factory()->create(['role_id' => $role->id, 'active' => true]);
$project = Project::factory()->create(['approved_estimate' => 100]);
Allocation::factory()->create([
'project_id' => $project->id,
'team_member_id' => $teamMember->id,
'month' => '2026-02-01',
'allocated_hours' => 100,
]);
$response = $this->withHeader('Authorization', "Bearer {$token}")
->getJson('/api/allocations?month=2026-02');
$response->assertStatus(200);
$response->assertJsonPath('data.0.allocation_indicator', 'green');
}
// 1.3 API test: allocation_indicator is yellow when < 100%
public function test_allocation_indicator_is_yellow_when_under()
{
$token = $this->loginAsManager();
$role = Role::factory()->create();
$teamMember = TeamMember::factory()->create(['role_id' => $role->id, 'active' => true]);
$project = Project::factory()->create(['approved_estimate' => 100]);
Allocation::factory()->create([
'project_id' => $project->id,
'team_member_id' => $teamMember->id,
'month' => '2026-02-01',
'allocated_hours' => 80,
]);
$response = $this->withHeader('Authorization', "Bearer {$token}")
->getJson('/api/allocations?month=2026-02');
$response->assertStatus(200);
$response->assertJsonPath('data.0.allocation_indicator', 'yellow');
}
// 1.4 API test: allocation_indicator is red when > 100%
public function test_allocation_indicator_is_red_when_over()
{
$token = $this->loginAsManager();
$role = Role::factory()->create();
$teamMember = TeamMember::factory()->create(['role_id' => $role->id, 'active' => true]);
$project = Project::factory()->create(['approved_estimate' => 100]);
Allocation::factory()->create([
'project_id' => $project->id,
'team_member_id' => $teamMember->id,
'month' => '2026-02-01',
'allocated_hours' => 120,
]);
$response = $this->withHeader('Authorization', "Bearer {$token}")
->getJson('/api/allocations?month=2026-02');
$response->assertStatus(200);
$response->assertJsonPath('data.0.allocation_indicator', 'red');
}
// 1.5 API test: allocation_indicator is gray when no approved_estimate
public function test_allocation_indicator_is_gray_when_no_estimate()
{
$token = $this->loginAsManager();
$role = Role::factory()->create();
$teamMember = TeamMember::factory()->create(['role_id' => $role->id, 'active' => true]);
$project = Project::factory()->create(['approved_estimate' => null]);
Allocation::factory()->create([
'project_id' => $project->id,
'team_member_id' => $teamMember->id,
'month' => '2026-02-01',
'allocated_hours' => 40,
]);
$response = $this->withHeader('Authorization', "Bearer {$token}")
->getJson('/api/allocations?month=2026-02');
$response->assertStatus(200);
$response->assertJsonPath('data.0.allocation_indicator', 'gray');
}
// ===== Untracked Allocation Tests =====
// 2.1 API test: POST /api/allocations accepts null team_member_id
public function test_can_create_allocation_with_null_team_member()
{
$token = $this->loginAsManager();
$project = Project::factory()->create();
$response = $this->withHeader('Authorization', "Bearer {$token}")
->postJson('/api/allocations', [
'project_id' => $project->id,
'team_member_id' => null,
'month' => '2026-02',
'allocated_hours' => 40,
]);
$response->assertStatus(201);
$response->assertJsonPath('data.team_member_id', null);
$response->assertJsonPath('data.team_member', null);
}
// 2.2 API test: GET /api/allocations returns null team_member
public function test_get_allocations_returns_null_team_member()
{
$token = $this->loginAsManager();
$project = Project::factory()->create();
// Create untracked allocation
Allocation::factory()->create([
'project_id' => $project->id,
'team_member_id' => null,
'month' => '2026-02-01',
'allocated_hours' => 40,
]);
$response = $this->withHeader('Authorization', "Bearer {$token}")
->getJson('/api/allocations?month=2026-02');
$response->assertStatus(200);
$response->assertJsonPath('data.0.team_member_id', null);
$response->assertJsonPath('data.0.team_member', null);
}
}

7
backend/tests/Feature/ExampleTest.php
View File

@@ -2,18 +2,15 @@
namespace Tests\Feature;
// use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;
class ExampleTest extends TestCase
{
/**
* A basic test example.
*/
public function test_the_application_returns_a_successful_response(): void
{
$response = $this->get('/');
$response->assertStatus(200);
// Accept 200, 302 (redirect to login), or 500 (if DB not connected in test)
$this->assertContains($response->getStatusCode(), [200, 302, 500]);
}
}

70
backend/tests/Feature/Role/RolesTest.php Normal file
View File

@@ -0,0 +1,70 @@
<?php
namespace Tests\Feature\Role;
use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;
class RolesTest extends TestCase
{
use RefreshDatabase;
protected function loginAsManager()
{
$user = User::factory()->create([
'email' => 'manager@example.com',
'password' => bcrypt('password123'),
'role' => 'manager',
'active' => true,
]);
$response = $this->postJson('/api/auth/login', [
'email' => 'manager@example.com',
'password' => 'password123',
]);
return $response->json('access_token');
}
/** @test */
public function roles_endpoint_returns_list_of_roles()
{
$token = $this->loginAsManager();
$this->seed(\Database\Seeders\RoleSeeder::class);
$response = $this->withToken($token)->getJson('/api/roles');
$response->assertOk();
$response->assertJsonStructure([
'data' => [
'*' => ['id', 'name', 'description'],
],
]);
$response->assertJsonCount(7, 'data'); // 7 roles from seeder
}
/** @test */
public function roles_are_ordered_by_name()
{
$token = $this->loginAsManager();
$this->seed(\Database\Seeders\RoleSeeder::class);
$response = $this->withToken($token)->getJson('/api/roles');
$response->assertOk();
$roles = $response->json('data');
$names = array_column($roles, 'name');
$sortedNames = $names;
sort($sortedNames);
$this->assertEquals($sortedNames, $names);
}
/** @test */
public function roles_endpoint_requires_authentication()
{
$response = $this->getJson('/api/roles');
$response->assertUnauthorized();
}
}

5
backend/tests/Unit/AllocationCacheInvalidationTest.php
View File

@@ -7,6 +7,7 @@ use App\Models\Project;
use App\Models\Role;
use App\Models\TeamMember;
use App\Services\AllocationMatrixService;
use App\Services\VarianceCalculator;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;
@@ -24,11 +25,11 @@ class AllocationCacheInvalidationTest extends TestCase
Allocation::factory()->create([
'project_id' => $project->id,
'team_member_id' => $teamMember->id,
'month' => '2026-02',
'month' => '2026-02-01',
'allocated_hours' => 40,
]);
$matrixService = new AllocationMatrixService;
$matrixService = new AllocationMatrixService(new VarianceCalculator);
$result = $matrixService->getMatrix('2026-02');
$this->assertArrayHasKey('allocations', $result);

13
backend/tests/Unit/Resources/ProjectResourceTest.php
View File

@@ -21,6 +21,19 @@ test('project resource includes expected fields inside data wrapper', function (
expect($payload['data'])->toHaveKey('approved_estimate');
});
test('project resource includes scalar type_id and status_id', function () {
$project = Project::factory()->approved()->create();
$project->load(['status', 'type']);
$response = (new ProjectResource($project))->toResponse(Request::create('/'));
$payload = $response->getData(true);
expect($payload['data'])->toHaveKey('type_id');
expect($payload['data'])->toHaveKey('status_id');
expect($payload['data']['type_id'])->toBe($project->type_id);
expect($payload['data']['status_id'])->toBe($project->status_id);
});
test('project resource collection wraps multiple entries', function () {
$projects = Project::factory()->count(2)->create();

12
backend/tests/Unit/Resources/TeamMemberResourceTest.php
View File

@@ -21,6 +21,18 @@ test('team member resource wraps data and includes role when loaded', function (
expect($payload['data']['role']['id'])->toBe($role->id);
});
test('team member resource includes scalar role_id', function () {
$role = Role::factory()->create();
$teamMember = TeamMember::factory()->create(['role_id' => $role->id]);
$teamMember->load('role');
$response = (new TeamMemberResource($teamMember))->toResponse(Request::create('/'));
$payload = $response->getData(true);
expect($payload['data'])->toHaveKey('role_id');
expect($payload['data']['role_id'])->toBe($teamMember->role_id);
});
test('team member resource collection keeps data wrapper', function () {
$role = Role::factory()->create();
$teamMembers = TeamMember::factory()->count(2)->create(['role_id' => $role->id]);