WIP

Client-side SDK for checking feature flag state against the flags API,
with unit tests mocking HttpMessageHandler.

MicCheck.slnx

@@ -3,7 +3,6 @@
     <File Path=".editorconfig" />
     <File Path=".gitignore" />
     <File Path="CLAUDE.md" />
-    <File Path="docker-compose.yml" />
     <File Path="readme.md" />
   </Folder>
   <Folder Name="/src/">
@@ -13,10 +12,12 @@
     </Project>
     <Project Path="src/api/MicCheck.Api/MicCheck.Api.csproj" />
     <Project Path="src/MicCheck.AppHost/MicCheck.AppHost.csproj" />
+    <Project Path="src/MicCheck.Client/MicCheck.Client.csproj" />
     <Project Path="src/MicCheck.ServiceDefaults/MicCheck.ServiceDefaults.csproj" />
   </Folder>
   <Folder Name="/tests/">
     <Project Path="tests/api/MicCheck.Api.Tests.Unit/MicCheck.Api.Tests.Unit.csproj" />
     <Project Path="tests/api/MicCheck.Api.Tests.Integration/MicCheck.Api.Tests.Integration.csproj" />
+    <Project Path="tests/client/MicCheck.Client.Tests.Unit/MicCheck.Client.Tests.Unit.csproj" />
   </Folder>
 </Solution>

dev-build.sh

@@ -3,27 +3,19 @@ set -e
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
-build_api() {
-  echo "Building API..."
-  dotnet publish "$SCRIPT_DIR/src/api/MicCheck.Api/MicCheck.Api.csproj" -c Release -o "$SCRIPT_DIR/src/api/MicCheck.Api/publish"
-  docker compose -f "$SCRIPT_DIR/docker-compose.yml" restart api
-  echo "API done."
-}
+echo "Building solution..."
+dotnet build "$SCRIPT_DIR/MicCheck.slnx"
 
-build_admin() {
-  echo "Building admin..."
-  npm --prefix "$SCRIPT_DIR/src/admin" ci --silent
-  npm --prefix "$SCRIPT_DIR/src/admin" run build
-  docker compose -f "$SCRIPT_DIR/docker-compose.yml" restart admin
-  echo "Admin done."
-}
+echo "Installing admin dependencies..."
+npm --prefix "$SCRIPT_DIR/src/admin" ci --silent
 
-case "${1:-all}" in
-  api)   build_api ;;
-  admin) build_admin ;;
-  all)   build_api && build_admin ;;
-  *)
-    echo "Usage: $0 [api|admin|all]"
-    exit 1
-    ;;
-esac
+echo "Building admin..."
+npm --prefix "$SCRIPT_DIR/src/admin" run build
+
+echo "Running .NET unit tests..."
+dotnet test "$SCRIPT_DIR/tests/api/MicCheck.Api.Tests.Unit/MicCheck.Api.Tests.Unit.csproj"
+
+echo "Running Jest tests..."
+npm --prefix "$SCRIPT_DIR/src/admin" test
+
+echo "Build and tests complete."

docs/system-design.md

@@ -0,0 +1,59 @@
+# System Design — QA Physical Architecture
+
+Physical deployment topology for the QA environment. Source: `deploy/qa/docker-compose.qa.yml`, `scripts/ci/*.sh`, `.github/workflows/ci.yml`.
+
+```mermaid
+flowchart TB
+    subgraph CI["Self-hosted CI runner (qa)"]
+        Pipeline["deploy-qa.sh / smoke-qa.sh"]
+    end
+
+    subgraph Registry["Gitea Container Registry"]
+        ApiImage["miccheck-api:qa"]
+        AdminImage["miccheck-admin:qa"]
+    end
+
+    subgraph QAHost["QA Docker host — network: miccheck-qa-net (bridge)"]
+        subgraph AdminC["admin container<br/>nginx:1.27-alpine"]
+            Nginx["nginx<br/>serves Vue SPA<br/>proxies /api/, /health"]
+        end
+
+        subgraph ApiC["api container<br/>aspnet:10.0"]
+            Api["MicCheck.Api<br/>ASPNETCORE_URLS=http://+:8080"]
+        end
+
+        subgraph DbC["db container<br/>postgres:16-alpine"]
+            Db[("miccheck DB")]
+        end
+    end
+
+    Browser["Browser / QA tester"]
+
+    Pipeline -->|docker build/push| Registry
+    Registry -->|pull :qa| AdminC
+    Registry -->|pull :qa| ApiC
+
+    Browser -->|":3001 (QA_ADMIN_PORT)"| Nginx
+    Nginx -->|"http://api:8080 (internal)"| Api
+    Api -->|"Host=db;5432 (internal)"| Db
+
+    Pipeline -.->|"127.0.0.1:55432 (bridge-gateway bound)"| Db
+```
+
+## Components
+
+| Component | Image | Exposure | Notes |
+|---|---|---|---|
+| `admin` | `nginx:1.27-alpine` (built from `src/admin/Dockerfile.ci`, `node:22-alpine` build stage) | `${QA_ADMIN_PORT:-3001}:80` published on host | Serves Vue/Vite SPA; nginx (`src/admin/nginx.conf`) reverse-proxies `/api/` and `/health` to `api:8080` |
+| `api` | `mcr.microsoft.com/dotnet/aspnet:10.0` (built from `src/api/MicCheck.Api/Dockerfile.ci`, `sdk:10.0` build stage) | no published host port — internal only, reached via `admin`'s nginx proxy | `ASPNETCORE_URLS=http://+:8080`; JWT config (`Jwt__SecretKey`/`Issuer=MicCheck`/`Audience=MicCheck`) from `JWT_SECRET_KEY` secret; healthcheck `curl localhost:8080/health` |
+| `db` | `postgres:16-alpine` | `${DB_BIND_HOST:-127.0.0.1}:55432 → 5432`, bound to docker bridge gateway IP (not `0.0.0.0`) — reachable only from sibling CI containers, not off-box | DB `miccheck`, user `miccheck`, password from `POSTGRES_PASSWORD` secret; volume `miccheck-qa-pgdata` |
+
+All three services run on an isolated bridge network `miccheck-qa-net` (project `miccheck-qa`), separate from the local dev Aspire stack.
+
+## Deploy flow
+
+1. `build-and-push` job builds `api` and `admin` images, tags with git SHA and `qa`, pushes to Gitea registry as `$REGISTRY/$REGISTRY_OWNER/miccheck-api` / `miccheck-admin`.
+2. `deploy-qa` job (self-hosted runner, `main` branch only) pulls `:qa` images and runs `docker-compose.qa.yml` via `deploy-qa.sh`.
+3. `smoke-qa` job hits the deployed stack (`smoke-qa.sh`) to verify health.
+
+Secrets used: `REGISTRY`, `REGISTRY_OWNER`, `REGISTRY_USER`, `REGISTRY_TOKEN`, `JWT_SECRET_KEY`, `POSTGRES_PASSWORD`. Vars: `QA_ADMIN_PORT`.

readme.md

@@ -29,10 +29,11 @@ Code in the API is organized by feature area (e.g. `Features`, `Segments`, `Iden
 
 ## Running locally
 
-`docker-compose.yml` provides supporting services. `MicCheck.AppHost` (.NET Aspire) orchestrates the API and admin app for local development.
+`MicCheck.AppHost` (.NET Aspire) orchestrates the API, admin app, and supporting services for local development.
 
 ```sh
 ./dev-build.sh
+aspire run --project src/MicCheck.AppHost
 ```
 
 ## Testing

src/MicCheck.Client/Common/Guard.cs

@@ -0,0 +1,40 @@
+namespace MicCheck.Common;
+
+internal static class Guard
+{
+    public static void Null<T>(T t, string parameterName) where T : class
+    {
+        if (t is null)
+            throw new ArgumentNullException(parameterName, $"{nameof(parameterName)} can not be null");
+    }
+
+    public static void Empty(string value, string parameterName)
+    {
+        if (string.IsNullOrWhiteSpace(value))
+            throw new ArgumentException($"{parameterName} can not be empty", parameterName);
+    }
+
+    public static void Empty<T>(IEnumerable<T> collection, string parameterName)
+    {
+        if (collection == null || !collection.Any())
+            throw new ArgumentException($"{parameterName} can not be empty", parameterName);
+    }
+
+    public static void Negative(int value, string parameterName)
+    {
+        if (value < 0)
+            throw new ArgumentOutOfRangeException(parameterName, $"{parameterName} must be a positive number or zero");
+    }
+
+    public static void NegativeOrZero(int value, string parameterName)
+    {
+        if (value <= 0)
+            throw new ArgumentOutOfRangeException(parameterName, $"{nameof(parameterName)} must be a positive number greater then zero");
+    }
+
+    public static void Default<T>(T value, string parameterName)
+    {
+        if (EqualityComparer<T>.Default.Equals(value, default))
+            throw new ArgumentException($"{parameterName} can not be a default value", parameterName);
+    }
+}

src/MicCheck.Client/FeatureClient.cs

@@ -0,0 +1,22 @@
+using System.Net.Http.Json;
+using MicCheck.Common;
+
+namespace MicCheck;
+
+public class FeatureClient(HttpClient httpClient) : IFeatureClient
+{
+    public async Task<bool> IsEnabledAsync(string featureName, bool defaultValue = false, CancellationToken cancellationToken = default)
+    {
+        Guard.Empty(featureName, nameof(featureName));
+
+        var flags = await httpClient.GetFromJsonAsync<List<FlagResult>>("api/v1/flags", cancellationToken);
+        var match = flags?.FirstOrDefault(flag => string.Equals(flag.Feature.Name, featureName, StringComparison.OrdinalIgnoreCase));
+
+        return match?.Enabled ?? defaultValue;
+    }
+}
+
+public interface IFeatureClient
+{
+    Task<bool> IsEnabledAsync(string featureName, bool defaultValue = false, CancellationToken cancellationToken = default);
+}

src/MicCheck.Client/FlagResult.cs

@@ -0,0 +1,5 @@
+namespace MicCheck;
+
+public record FlagResult(int Id, FeatureSummary Feature, bool Enabled, string? FeatureStateValue);
+
+public record FeatureSummary(int Id, string Name, string Type);

src/MicCheck.Client/MicCheck.Client.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <LangVersion>latest</LangVersion>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <RootNamespace>MicCheck</RootNamespace>
+  </PropertyGroup>
+
+</Project>

src/api/MicCheck.Api/Environments/EnvironmentsController.cs

@@ -1,5 +1,8 @@
 using MicCheck.Api.Common.Security.Authorization;
 using MicCheck.Api.Common;
+using MicCheck.Api.Features;
+using MicCheck.Api.Identities;
+using MicCheck.Api.Segments;
 using MicCheck.Api.Webhooks;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
@@ -146,9 +149,9 @@ public class EnvironmentsController(EnvironmentService environmentService, Webho
     }
 
     [HttpGet("api/v1/environment/{apiKey}/identities")]
-    public async Task<ActionResult<PaginatedResponse<Identities.AdminIdentityResponse>>> ListIdentities(
+    public async Task<ActionResult<PaginatedResponse<AdminIdentityResponse>>> ListIdentities(
         string apiKey,
-        [FromServices] Identities.AdminIdentityService adminIdentityService,
+        [FromServices] AdminIdentityService adminIdentityService,
         [FromQuery] int page = 1,
         [FromQuery] int pageSize = 20,
         CancellationToken ct = default)
@@ -158,15 +161,15 @@ public class EnvironmentsController(EnvironmentService environmentService, Webho
         if (environment is null) return NotFound();
 
         var result = await adminIdentityService.ListAsync(environment.Id, page, pageSize, ct);
-        var results = result.Items.Select(Identities.AdminIdentityResponse.From).ToList();
-        return Ok(new PaginatedResponse<Identities.AdminIdentityResponse>(result.Total, null, null, results));
+        var results = result.Items.Select(AdminIdentityResponse.From).ToList();
+        return Ok(new PaginatedResponse<AdminIdentityResponse>(result.Total, null, null, results));
     }
 
     [HttpPost("api/v1/environment/{apiKey}/identities")]
-    public async Task<ActionResult<Identities.AdminIdentityResponse>> CreateIdentity(
+    public async Task<ActionResult<AdminIdentityResponse>> CreateIdentity(
         string apiKey,
-        [FromBody] Identities.CreateIdentityRequest request,
-        [FromServices] Identities.AdminIdentityService adminIdentityService,
+        [FromBody] CreateIdentityRequest request,
+        [FromServices] AdminIdentityService adminIdentityService,
         CancellationToken ct)
     {
         var environment = await environmentService.FindByApiKeyAsync(apiKey, ct);
@@ -177,13 +180,13 @@ public class EnvironmentsController(EnvironmentService environmentService, Webho
             return Conflict(new { error = "An identity with this identifier already exists in the environment." });
 
         return CreatedAtAction(nameof(GetIdentity), new { apiKey, id = identity.Id },
-            Identities.AdminIdentityResponse.From(identity));
+            AdminIdentityResponse.From(identity));
     }
 
     [HttpGet("api/v1/environment/{apiKey}/identity/{id}")]
-    public async Task<ActionResult<Identities.AdminIdentityResponse>> GetIdentity(
+    public async Task<ActionResult<AdminIdentityResponse>> GetIdentity(
         string apiKey, int id,
-        [FromServices] Identities.AdminIdentityService adminIdentityService,
+        [FromServices] AdminIdentityService adminIdentityService,
         CancellationToken ct)
     {
         var environment = await environmentService.FindByApiKeyAsync(apiKey, ct);
@@ -191,13 +194,13 @@ public class EnvironmentsController(EnvironmentService environmentService, Webho
 
         var identity = await adminIdentityService.FindByIdAsync(id, environment.Id, ct);
         if (identity is null) return NotFound();
-        return Ok(Identities.AdminIdentityResponse.From(identity));
+        return Ok(AdminIdentityResponse.From(identity));
     }
 
     [HttpDelete("api/v1/environment/{apiKey}/identity/{id}")]
     public async Task<IActionResult> DeleteIdentity(
         string apiKey, int id,
-        [FromServices] Identities.AdminIdentityService adminIdentityService,
+        [FromServices] AdminIdentityService adminIdentityService,
         CancellationToken ct)
     {
         var environment = await environmentService.FindByApiKeyAsync(apiKey, ct);
@@ -211,10 +214,10 @@ public class EnvironmentsController(EnvironmentService environmentService, Webho
     }
 
     [HttpPut("api/v1/environment/{apiKey}/identity/{id}/trait/{key}")]
-    public async Task<ActionResult<Identities.TraitResponse>> UpsertIdentityTrait(
+    public async Task<ActionResult<TraitResponse>> UpsertIdentityTrait(
         string apiKey, int id, string key,
-        [FromBody] Identities.UpsertTraitRequest request,
-        [FromServices] Identities.AdminIdentityService adminIdentityService,
+        [FromBody] UpsertTraitRequest request,
+        [FromServices] AdminIdentityService adminIdentityService,
         CancellationToken ct)
     {
         var environment = await environmentService.FindByApiKeyAsync(apiKey, ct);
@@ -228,7 +231,7 @@ public class EnvironmentsController(EnvironmentService environmentService, Webho
     [HttpDelete("api/v1/environment/{apiKey}/identity/{id}/trait/{key}")]
     public async Task<IActionResult> DeleteIdentityTrait(
         string apiKey, int id, string key,
-        [FromServices] Identities.AdminIdentityService adminIdentityService,
+        [FromServices] AdminIdentityService adminIdentityService,
         CancellationToken ct)
     {
         var environment = await environmentService.FindByApiKeyAsync(apiKey, ct);
@@ -240,9 +243,9 @@ public class EnvironmentsController(EnvironmentService environmentService, Webho
     }
 
     [HttpGet("api/v1/environment/{apiKey}/identity/{id}/featurestates")]
-    public async Task<ActionResult<IReadOnlyList<Features.FeatureStateResponse>>> GetIdentityFeatureStates(
+    public async Task<ActionResult<IReadOnlyList<FeatureStateResponse>>> GetIdentityFeatureStates(
         string apiKey, int id,
-        [FromServices] Identities.AdminIdentityService adminIdentityService,
+        [FromServices] AdminIdentityService adminIdentityService,
         CancellationToken ct)
     {
         var environment = await environmentService.FindByApiKeyAsync(apiKey, ct);
@@ -252,14 +255,14 @@ public class EnvironmentsController(EnvironmentService environmentService, Webho
         if (identity is null) return NotFound();
 
         var states = await adminIdentityService.GetFeatureStatesAsync(id, environment.Id, ct);
-        return Ok(states.Select(Features.FeatureStateResponse.From).ToList());
+        return Ok(states.Select(FeatureStateResponse.From).ToList());
     }
 
     [HttpPut("api/v1/environment/{apiKey}/identity/{id}/featurestate/{featureId}")]
-    public async Task<ActionResult<Features.FeatureStateResponse>> SetIdentityFeatureState(
+    public async Task<ActionResult<FeatureStateResponse>> SetIdentityFeatureState(
         string apiKey, int id, int featureId,
-        Features.UpdateFeatureStateRequest request,
-        [FromServices] Identities.AdminIdentityService adminIdentityService,
+        UpdateFeatureStateRequest request,
+        [FromServices] AdminIdentityService adminIdentityService,
         CancellationToken ct)
     {
         var environment = await environmentService.FindByApiKeyAsync(apiKey, ct);
@@ -269,13 +272,13 @@ public class EnvironmentsController(EnvironmentService environmentService, Webho
         if (identity is null) return NotFound();
 
         var state = await adminIdentityService.SetFeatureStateAsync(id, environment.Id, featureId, request.Enabled, request.Value, ct);
-        return Ok(Features.FeatureStateResponse.From(state));
+        return Ok(FeatureStateResponse.From(state));
     }
 
     [HttpDelete("api/v1/environment/{apiKey}/identity/{id}/featurestate/{featureId}")]
     public async Task<IActionResult> DeleteIdentityFeatureState(
         string apiKey, int id, int featureId,
-        [FromServices] Identities.AdminIdentityService adminIdentityService,
+        [FromServices] AdminIdentityService adminIdentityService,
         CancellationToken ct)
     {
         var environment = await environmentService.FindByApiKeyAsync(apiKey, ct);
@@ -289,22 +292,22 @@ public class EnvironmentsController(EnvironmentService environmentService, Webho
     }
 
     [HttpGet("api/v1/environment/{apiKey}/featurestates")]
-    public async Task<ActionResult<IReadOnlyList<Features.FeatureStateResponse>>> ListFeatureStates(
+    public async Task<ActionResult<IReadOnlyList<FeatureStateResponse>>> ListFeatureStates(
         string apiKey,
-        [FromServices] Features.FeatureStateService featureStateService,
+        [FromServices] FeatureStateService featureStateService,
         CancellationToken ct)
     {
         var environment = await environmentService.FindByApiKeyAsync(apiKey, ct);
         if (environment is null) return NotFound();
 
         var states = await featureStateService.ListByEnvironmentAsync(environment.Id, ct);
-        return Ok(states.Select(Features.FeatureStateResponse.From).ToList());
+        return Ok(states.Select(FeatureStateResponse.From).ToList());
     }
 
     [HttpGet("api/v1/environment/{apiKey}/featurestate/{id}")]
-    public async Task<ActionResult<Features.FeatureStateResponse>> GetFeatureState(
+    public async Task<ActionResult<FeatureStateResponse>> GetFeatureState(
         string apiKey, int id,
-        [FromServices] Features.FeatureStateService featureStateService,
+        [FromServices] FeatureStateService featureStateService,
         CancellationToken ct)
     {
         var environment = await environmentService.FindByApiKeyAsync(apiKey, ct);
@@ -312,14 +315,14 @@ public class EnvironmentsController(EnvironmentService environmentService, Webho
 
         var state = await featureStateService.FindByIdAsync(id, environment.Id, ct);
         if (state is null) return NotFound();
-        return Ok(Features.FeatureStateResponse.From(state));
+        return Ok(FeatureStateResponse.From(state));
     }
 
     [HttpPut("api/v1/environment/{apiKey}/featurestate/{id}")]
-    public async Task<ActionResult<Features.FeatureStateResponse>> UpdateFeatureState(
+    public async Task<ActionResult<FeatureStateResponse>> UpdateFeatureState(
         string apiKey, int id,
-        Features.UpdateFeatureStateRequest request,
-        [FromServices] Features.FeatureStateService featureStateService,
+        UpdateFeatureStateRequest request,
+        [FromServices] FeatureStateService featureStateService,
         CancellationToken ct)
     {
         var environment = await environmentService.FindByApiKeyAsync(apiKey, ct);
@@ -329,14 +332,14 @@ public class EnvironmentsController(EnvironmentService environmentService, Webho
         if (state is null) return NotFound();
 
         var updated = await featureStateService.UpdateAsync(id, request.Enabled, request.Value, ct);
-        return Ok(Features.FeatureStateResponse.From(updated));
+        return Ok(FeatureStateResponse.From(updated));
     }
 
     [HttpPatch("api/v1/environment/{apiKey}/featurestate/{id}")]
-    public async Task<ActionResult<Features.FeatureStateResponse>> PatchFeatureState(
+    public async Task<ActionResult<FeatureStateResponse>> PatchFeatureState(
         string apiKey, int id,
-        Features.PatchFeatureStateRequest request,
-        [FromServices] Features.FeatureStateService featureStateService,
+        PatchFeatureStateRequest request,
+        [FromServices] FeatureStateService featureStateService,
         CancellationToken ct)
     {
         var environment = await environmentService.FindByApiKeyAsync(apiKey, ct);
@@ -346,15 +349,15 @@ public class EnvironmentsController(EnvironmentService environmentService, Webho
         if (state is null) return NotFound();
 
         var updated = await featureStateService.PatchAsync(id, request.Enabled, request.Value, ct);
-        return Ok(Features.FeatureStateResponse.From(updated));
+        return Ok(FeatureStateResponse.From(updated));
     }
 
     // ─── Feature Segments ────────────────────────────────────────────────────
 
     [HttpGet("api/v1/environment/{apiKey}/feature/{featureId}/segments")]
-    public async Task<ActionResult<IReadOnlyList<Features.FeatureSegmentResponse>>> ListFeatureSegments(
+    public async Task<ActionResult<IReadOnlyList<FeatureSegmentResponse>>> ListFeatureSegments(
         string apiKey, int featureId,
-        [FromServices] Features.FeatureSegmentService featureSegmentService,
+        [FromServices] FeatureSegmentService featureSegmentService,
         CancellationToken ct)
     {
         var environment = await environmentService.FindByApiKeyAsync(apiKey, ct);
@@ -365,10 +368,10 @@ public class EnvironmentsController(EnvironmentService environmentService, Webho
     }
 
     [HttpPost("api/v1/environment/{apiKey}/feature/{featureId}/segments")]
-    public async Task<ActionResult<Features.FeatureSegmentResponse>> CreateFeatureSegment(
+    public async Task<ActionResult<FeatureSegmentResponse>> CreateFeatureSegment(
         string apiKey, int featureId,
-        Features.CreateFeatureSegmentRequest request,
-        [FromServices] Features.FeatureSegmentService featureSegmentService,
+        CreateFeatureSegmentRequest request,
+        [FromServices] FeatureSegmentService featureSegmentService,
         CancellationToken ct)
     {
         var environment = await environmentService.FindByApiKeyAsync(apiKey, ct);
@@ -388,10 +391,10 @@ public class EnvironmentsController(EnvironmentService environmentService, Webho
     }
 
     [HttpPut("api/v1/environment/{apiKey}/feature/{featureId}/segment/{id}")]
-    public async Task<ActionResult<Features.FeatureSegmentResponse>> UpdateFeatureSegment(
+    public async Task<ActionResult<FeatureSegmentResponse>> UpdateFeatureSegment(
         string apiKey, int featureId, int id,
-        Features.UpdateFeatureSegmentRequest request,
-        [FromServices] Features.FeatureSegmentService featureSegmentService,
+        UpdateFeatureSegmentRequest request,
+        [FromServices] FeatureSegmentService featureSegmentService,
         CancellationToken ct)
     {
         var environment = await environmentService.FindByApiKeyAsync(apiKey, ct);
@@ -405,7 +408,7 @@ public class EnvironmentsController(EnvironmentService environmentService, Webho
     [HttpDelete("api/v1/environment/{apiKey}/feature/{featureId}/segment/{id}")]
     public async Task<IActionResult> DeleteFeatureSegment(
         string apiKey, int featureId, int id,
-        [FromServices] Features.FeatureSegmentService featureSegmentService,
+        [FromServices] FeatureSegmentService featureSegmentService,
         CancellationToken ct)
     {
         var environment = await environmentService.FindByApiKeyAsync(apiKey, ct);
@@ -418,11 +421,11 @@ public class EnvironmentsController(EnvironmentService environmentService, Webho
     // ─── Identity Segments ───────────────────────────────────────────────────
 
     [HttpGet("api/v1/environment/{apiKey}/identity/{id}/segments")]
-    public async Task<ActionResult<IReadOnlyList<Segments.SegmentSummaryResponse>>> GetIdentitySegments(
+    public async Task<ActionResult<IReadOnlyList<SegmentSummaryResponse>>> GetIdentitySegments(
         string apiKey, int id,
-        [FromServices] Identities.AdminIdentityService adminIdentityService,
-        [FromServices] Segments.SegmentService segmentService,
-        [FromServices] Segments.SegmentEvaluator segmentEvaluator,
+        [FromServices] AdminIdentityService adminIdentityService,
+        [FromServices] SegmentService segmentService,
+        [FromServices] SegmentEvaluator segmentEvaluator,
         CancellationToken ct)
     {
         var environment = await environmentService.FindByApiKeyAsync(apiKey, ct);
@@ -434,7 +437,7 @@ public class EnvironmentsController(EnvironmentService environmentService, Webho
         var segments = await segmentService.ListByProjectAsync(environment.ProjectId, ct);
         var matching = segments
             .Where(s => segmentEvaluator.Evaluate(s, identity.Traits.ToList(), identity.Identifier))
-            .Select(s => new Segments.SegmentSummaryResponse(s.Id, s.Name))
+            .Select(s => new SegmentSummaryResponse(s.Id, s.Name))
             .ToList();
 
         return Ok(matching);

tests/client/MicCheck.Client.Tests.Unit/FeatureClientTests.cs

@@ -0,0 +1,79 @@
+using System.Net;
+using System.Text;
+using Moq;
+using Moq.Protected;
+using NUnit.Framework;
+
+namespace MicCheck.Client.Tests.Unit;
+
+[TestFixture]
+public class FeatureClientTests
+{
+    [Test]
+    public async Task WhenFeatureIsEnabled_ThenIsEnabledAsyncReturnsTrue()
+    {
+        var client = CreateClient(HttpStatusCode.OK, """
+            [{"id":1,"feature":{"id":1,"name":"my-feature","type":"STANDARD"},"enabled":true,"featureStateValue":null}]
+            """);
+
+        var result = await client.IsEnabledAsync("my-feature");
+
+        Assert.That(result, Is.True);
+    }
+
+    [Test]
+    public async Task WhenFeatureIsDisabled_ThenIsEnabledAsyncReturnsFalse()
+    {
+        var client = CreateClient(HttpStatusCode.OK, """
+            [{"id":1,"feature":{"id":1,"name":"my-feature","type":"STANDARD"},"enabled":false,"featureStateValue":null}]
+            """);
+
+        var result = await client.IsEnabledAsync("my-feature");
+
+        Assert.That(result, Is.False);
+    }
+
+    [Test]
+    public async Task WhenFeatureNameDiffersOnlyByCase_ThenIsEnabledAsyncStillMatches()
+    {
+        var client = CreateClient(HttpStatusCode.OK, """
+            [{"id":1,"feature":{"id":1,"name":"My-Feature","type":"STANDARD"},"enabled":true,"featureStateValue":null}]
+            """);
+
+        var result = await client.IsEnabledAsync("my-feature");
+
+        Assert.That(result, Is.True);
+    }
+
+    [Test]
+    public async Task WhenFeatureIsNotFound_ThenIsEnabledAsyncReturnsProvidedDefaultValue()
+    {
+        var client = CreateClient(HttpStatusCode.OK, "[]");
+
+        var result = await client.IsEnabledAsync("missing-feature", defaultValue: true);
+
+        Assert.That(result, Is.True);
+    }
+
+    [Test]
+    public void WhenFeatureNameIsEmpty_ThenIsEnabledAsyncThrowsArgumentException()
+    {
+        var client = CreateClient(HttpStatusCode.OK, "[]");
+
+        Assert.That(async () => await client.IsEnabledAsync(" "), Throws.ArgumentException);
+    }
+
+    private static FeatureClient CreateClient(HttpStatusCode responseStatus, string responseBody)
+    {
+        var handler = new Mock<HttpMessageHandler>();
+        handler.Protected()
+            .Setup<Task<HttpResponseMessage>>("SendAsync", ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>())
+            .ReturnsAsync(new HttpResponseMessage(responseStatus)
+            {
+                Content = new StringContent(responseBody, Encoding.UTF8, "application/json")
+            });
+
+        var httpClient = new HttpClient(handler.Object) { BaseAddress = new Uri("https://example.com") };
+        return new FeatureClient(httpClient);
+    }
+}

tests/client/MicCheck.Client.Tests.Unit/MicCheck.Client.Tests.Unit.csproj

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <LangVersion>latest</LangVersion>
+    <IsPackable>false</IsPackable>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.4" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.3.0" />
+    <PackageReference Include="Moq" Version="4.20.72" />
+    <PackageReference Include="NUnit" Version="4.5.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="6.2.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../../../src/MicCheck.Client/MicCheck.Client.csproj" />
+  </ItemGroup>
+
+</Project>