ci: replace separate workflows with unified Sentinel Gate

.github/workflows/gate.yml

@@ -0,0 +1,26 @@
+name: Sentinel Gate
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+jobs:
+  gate:
+    name: Sentinel Gate
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      checks: write
+      pull-requests: write
+      issues: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: synapse-sentinel/gate@v1
+        with:
+          check: certify
+          coverage-threshold: 100
+          auto-merge: true
+          coverage-comment: true
+          github-token: ${{ secrets.GITHUB_TOKEN }}

tests/Enums/DirectionEnumTest.php

@@ -0,0 +1,51 @@
+<?php
+
+use JordanPartridge\GithubClient\Enums\Direction;
+
+describe('Direction enum', function () {
+    it('has ASC case with correct value', function () {
+        expect(Direction::ASC->value)->toBe('asc');
+    });
+
+    it('has DESC case with correct value', function () {
+        expect(Direction::DESC->value)->toBe('desc');
+    });
+
+    it('has exactly two cases', function () {
+        expect(Direction::cases())
+            ->toHaveCount(2)
+            ->and(array_column(Direction::cases(), 'name'))
+            ->toContain('ASC', 'DESC');
+    });
+
+    it('can be created from valid string values', function () {
+        expect(Direction::from('asc'))->toBe(Direction::ASC)
+            ->and(Direction::from('desc'))->toBe(Direction::DESC);
+    });
+
+    it('throws ValueError for invalid string value', function () {
+        expect(fn () => Direction::from('invalid'))
+            ->toThrow(ValueError::class);
+    });
+
+    it('returns null for invalid value with tryFrom', function () {
+        expect(Direction::tryFrom('invalid'))->toBeNull()
+            ->and(Direction::tryFrom('ASC'))->toBeNull()
+            ->and(Direction::tryFrom('DESC'))->toBeNull();
+    });
+
+    it('can be used in match expressions', function () {
+        $result = match (Direction::ASC) {
+            Direction::ASC => 'ascending',
+            Direction::DESC => 'descending',
+        };
+
+        expect($result)->toBe('ascending');
+    });
+
+    it('works with array functions', function () {
+        $values = array_map(fn (Direction $d) => $d->value, Direction::cases());
+
+        expect($values)->toBe(['asc', 'desc']);
+    });
+});

tests/Enums/Issues/IssueSortEnumTest.php

@@ -0,0 +1,62 @@
+<?php
+
+use JordanPartridge\GithubClient\Enums\Issues\Sort;
+
+describe('Issues Sort enum', function () {
+    it('has CREATED case with correct value', function () {
+        expect(Sort::CREATED->value)->toBe('created');
+    });
+
+    it('has UPDATED case with correct value', function () {
+        expect(Sort::UPDATED->value)->toBe('updated');
+    });
+
+    it('has COMMENTS case with correct value', function () {
+        expect(Sort::COMMENTS->value)->toBe('comments');
+    });
+
+    it('has exactly three cases', function () {
+        expect(Sort::cases())
+            ->toHaveCount(3)
+            ->and(array_column(Sort::cases(), 'name'))
+            ->toContain('CREATED', 'UPDATED', 'COMMENTS');
+    });
+
+    it('can be created from valid string values', function () {
+        expect(Sort::from('created'))->toBe(Sort::CREATED)
+            ->and(Sort::from('updated'))->toBe(Sort::UPDATED)
+            ->and(Sort::from('comments'))->toBe(Sort::COMMENTS);
+    });
+
+    it('throws ValueError for invalid string value', function () {
+        expect(fn () => Sort::from('invalid'))
+            ->toThrow(ValueError::class);
+    });
+
+    it('returns null for invalid value with tryFrom', function () {
+        expect(Sort::tryFrom('invalid'))->toBeNull()
+            ->and(Sort::tryFrom('CREATED'))->toBeNull()
+            ->and(Sort::tryFrom('pushed'))->toBeNull();
+    });
+
+    it('can be used in match expressions', function () {
+        $getSortLabel = fn (Sort $sort) => match ($sort) {
+            Sort::CREATED => 'Sort by creation date',
+            Sort::UPDATED => 'Sort by last update',
+            Sort::COMMENTS => 'Sort by comment count',
+        };
+
+        expect($getSortLabel(Sort::CREATED))->toBe('Sort by creation date')
+            ->and($getSortLabel(Sort::COMMENTS))->toBe('Sort by comment count');
+    });
+
+    it('works with array functions', function () {
+        $values = array_map(fn (Sort $s) => $s->value, Sort::cases());
+
+        expect($values)->toBe(['created', 'updated', 'comments']);
+    });
+
+    it('is distinct from main Sort enum', function () {
+        expect(Sort::class)->toBe('JordanPartridge\GithubClient\Enums\Issues\Sort');
+    });
+});

tests/Enums/Issues/IssueStateEnumTest.php

@@ -0,0 +1,72 @@
+<?php
+
+use JordanPartridge\GithubClient\Enums\Issues\State;
+
+describe('Issues State enum', function () {
+    it('has OPEN case with correct value', function () {
+        expect(State::OPEN->value)->toBe('open');
+    });
+
+    it('has CLOSED case with correct value', function () {
+        expect(State::CLOSED->value)->toBe('closed');
+    });
+
+    it('has ALL case with correct value', function () {
+        expect(State::ALL->value)->toBe('all');
+    });
+
+    it('has exactly three cases', function () {
+        expect(State::cases())
+            ->toHaveCount(3)
+            ->and(array_column(State::cases(), 'name'))
+            ->toContain('OPEN', 'CLOSED', 'ALL');
+    });
+
+    it('can be created from valid string values', function () {
+        expect(State::from('open'))->toBe(State::OPEN)
+            ->and(State::from('closed'))->toBe(State::CLOSED)
+            ->and(State::from('all'))->toBe(State::ALL);
+    });
+
+    it('throws ValueError for invalid string value', function () {
+        expect(fn () => State::from('invalid'))
+            ->toThrow(ValueError::class);
+    });
+
+    it('returns null for invalid value with tryFrom', function () {
+        expect(State::tryFrom('invalid'))->toBeNull()
+            ->and(State::tryFrom('OPEN'))->toBeNull()
+            ->and(State::tryFrom('pending'))->toBeNull();
+    });
+
+    it('can be used in match expressions', function () {
+        $getStateDescription = fn (State $state) => match ($state) {
+            State::OPEN => 'Open issues only',
+            State::CLOSED => 'Closed issues only',
+            State::ALL => 'All issues',
+        };
+
+        expect($getStateDescription(State::OPEN))->toBe('Open issues only')
+            ->and($getStateDescription(State::ALL))->toBe('All issues');
+    });
+
+    it('works with array functions', function () {
+        $values = array_map(fn (State $s) => $s->value, State::cases());
+
+        expect($values)->toBe(['open', 'closed', 'all']);
+    });
+
+    it('is distinct from Pulls State enum', function () {
+        expect(State::class)->toBe('JordanPartridge\GithubClient\Enums\Issues\State');
+    });
+
+    it('can filter to only active states', function () {
+        $activeStates = array_filter(
+            State::cases(),
+            fn (State $state) => $state !== State::ALL,
+        );
+
+        expect($activeStates)->toHaveCount(2)
+            ->and(array_column($activeStates, 'value'))->toContain('open', 'closed');
+    });
+});