phundrak/sta
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: wire relay API with dependency injection

Browse Source 
- split settings module into per-struct files
- add DatabaseSettings with default in-memory SQLite path
- implement RelayApi struct with GET /relays and POST
  /relays/{id}/toggle
- wire create_relay_controller and create_label_repository into
  Application::build() with mock/real selection via cfg!(test) || CI
- register RelayApi in OpenApiService alongside existing APIs
This commit is contained in:
Lucien Cartier-Tilet
2026-03-04 12:47:21 +01:00
parent fd00d1925b
commit 2eebc52f17
30 changed files with 1170 additions and 670 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CLAUDE.md
View File

@@ -1 +0,0 @@
IMPORTANT: Ensure you’ve thoroughly reviewed the [AGENTS.md](/AGENTS.md) file before beginning any work.

1
CLAUDE.md Symbolic link
View File

@@ -0,0 +1 @@
AGENTS.md

4
backend/Cargo.toml
View File

@@ -37,5 +37,9 @@ tracing-subscriber = { version = "0.3.22", features = ["fmt", "std", "env-filter
[dev-dependencies]
tempfile = "3.15.0"
[[test]]
name = "relay_api_contract"
path = "tests/contract/test_relay_api.rs"
[lints.rust]
unexpected_cfgs = { level = "warn", check-cfg = ['cfg(tarpaulin_include)'] }

10
backend/src/application/use_cases/get_all_relays.rs
View File

@@ -265,9 +265,15 @@ mod tests {
for (index, relay) in result.iter().enumerate() {
let relay_num = index + 1;
if relay_num % 2 == 1 {
assert!(relay.label().is_some(), "Relay {relay_num} should have label");
assert!(
relay.label().is_some(),
"Relay {relay_num} should have label"
);
} else {
assert!(relay.label().is_none(), "Relay {relay_num} should not have label");
assert!(
relay.label().is_none(),
"Relay {relay_num} should not have label"
);
}
}
}

4
backend/src/domain/relay/mod.rs
View File

@@ -202,7 +202,6 @@ mod tests {
assert_eq!(relay1.label(), relay2.label());
}
#[test]
fn test_relay_id_returns_correct_id() {
for id_val in 1..=8 {
@@ -233,7 +232,6 @@ mod tests {
assert_eq!(relay.label().as_str(), "Test Label");
}
#[test]
fn test_relay_toggle_off_to_on() {
let relay_id = RelayId::new(1).unwrap();
@@ -277,7 +275,6 @@ mod tests {
assert_eq!(relay.label(), &label);
}
#[test]
fn test_relay_set_state_to_on() {
let relay_id = RelayId::new(1).unwrap();
@@ -320,7 +317,6 @@ mod tests {
assert_eq!(relay.label(), &label);
}
#[test]
fn test_relay_set_label_changes_label() {
let relay_id = RelayId::new(1).unwrap();

14
backend/src/infrastructure/modbus/client.rs
View File

@@ -44,19 +44,23 @@ impl ModbusRelayController {
/// - The host/port address is invalid
/// - Connection to the Modbus device fails
/// - The device is unreachable
pub async fn new(host: &str, port: u16, slave_id: u8, timeout_secs: u64) -> Result<Self> {
pub async fn new(host: &str, port: u16, slave_id: u8, timeout_secs: u8) -> Result<Self> {
if slave_id != 1 {
tracing::warn!("Device typically uses slave_id=1, got {slave_id}");
}
let socket_addr = format!("{host}:{port}")
.parse()
.map_err(|e| ControllerError::ConnectionError(format!("Invalid address: {e}")))?;
let ctx = tcp::connect_slave(socket_addr, Slave(slave_id))
.await
.map_err(|e| ControllerError::ConnectionError(e.to_string()))?;
let ctx = timeout(
Duration::from_secs(timeout_secs.into()),
tcp::connect_slave(socket_addr, Slave(slave_id)),
)
.await
.map_err(|_| ControllerError::Timeout(timeout_secs.into()))?
.map_err(|e| ControllerError::ConnectionError(e.to_string()))?;
Ok(Self {
ctx: Arc::new(Mutex::new(ctx)),
timeout_duration: Duration::from_secs(timeout_secs),
timeout_duration: Duration::from_secs(timeout_secs.into()),
})
}

106
backend/src/infrastructure/modbus/factory.rs
View File

@@ -4,13 +4,13 @@
//! with graceful degradation and retry logic.
use std::sync::Arc;
use std::time::Duration;
use crate::domain::relay::controller::RelayController;
use crate::settings::ModbusSettings;
// TODO: Uncomment when implementation is added (T039a)
// use super::client::ModbusRelayController;
// use super::mock_controller::MockRelayController;
use super::client::ModbusRelayController;
use super::mock_controller::MockRelayController;
/// Creates a relay controller with retry and fallback logic.
///
@@ -33,15 +33,45 @@ use crate::settings::ModbusSettings;
/// - `MockRelayController` (for testing or when hardware connection fails)
/// - `ModbusRelayController` (for real hardware communication)
pub async fn create_relay_controller(
_settings: &ModbusSettings,
_use_mock: bool,
settings: &ModbusSettings,
use_mock: bool,
) -> Arc<dyn RelayController> {
// TODO: Implement in T039a
unimplemented!("T039a: create_relay_controller factory not yet implemented")
if use_mock {
tracing::info!("Using MockRelayController (test mode)");
return Arc::new(MockRelayController::new());
}
for attempt in 1..=3 {
match ModbusRelayController::new(
&settings.host,
settings.port,
settings.slave_id,
settings.timeout_secs,
)
.await
{
Ok(controller) => {
tracing::info!("Connected to Modbus device on attempt {}", attempt);
return Arc::new(controller);
}
Err(e) => {
tracing::warn!(attempt, error = %e, "Failed to connect to Modbus device");
if attempt < 3 {
tracing::warn!("Retrying in two seconds...");
tokio::time::sleep(Duration::from_secs(2)).await;
}
}
}
}
tracing::error!("Could not connect to Modbus device after three attempts");
tracing::error!("Using MockRelayController as fallback");
tracing::error!("STA will NOT be controlling a real device!");
Arc::new(MockRelayController::new())
}
#[cfg(test)]
mod tests {
use crate::domain::relay::types::RelayId;
use super::*;
use std::time::Duration;
@@ -69,8 +99,7 @@ mod tests {
// THEN: Should return MockRelayController immediately (< 100ms)
assert!(
elapsed < Duration::from_millis(100),
"Mock controller should be created immediately without delay, took {:?}",
elapsed
"Mock controller should be created immediately without delay, took {elapsed:?}"
);
// Verify it's a mock by checking if we can downcast to MockRelayController
@@ -81,7 +110,7 @@ mod tests {
// T039a: Test 2 - Successful connection returns ModbusRelayController
#[tokio::test]
#[ignore] // Requires real Modbus hardware - run with --ignored
#[ignore = "Requires real Modbus hardware"]
async fn test_create_relay_controller_successful_connection() {
// GIVEN: Valid settings for a real Modbus device
let settings = create_test_settings();
@@ -92,7 +121,6 @@ mod tests {
// THEN: Should return ModbusRelayController
// We verify by attempting a real operation
// Note: This test requires actual hardware and should be #[ignore]
use crate::domain::relay::types::RelayId;
let relay_id = RelayId::new(1).unwrap();
let result = controller.read_relay_state(relay_id).await;
@@ -104,95 +132,45 @@ mod tests {
);
}
// T039a: Test 3 - Connection failure after 3 retries returns MockRelayController
#[tokio::test]
async fn test_create_relay_controller_fallback_to_mock_after_retries() {
// GIVEN: Invalid settings that will fail to connect (invalid host)
let settings = ModbusSettings {
host: "192.0.2.1".to_string(), // TEST-NET-1 (reserved, unreachable)
port: 502,
slave_id: 0,
timeout_secs: 1, // Short timeout for faster test
};
// WHEN: create_relay_controller attempts connection
let start = std::time::Instant::now();
let controller = create_relay_controller(&settings, false).await;
let elapsed = start.elapsed();
// THEN: Should fall back to MockRelayController after retries
// Total time should be roughly: 3 retries * (timeout + 2s backoff) ≈ 9-10 seconds
// With 1s timeout: ~9 seconds minimum (1s attempt + 2s wait + 1s attempt + 2s wait + 1s attempt)
assert!(
elapsed >= Duration::from_secs(8),
"Should have retried 3 times with 2s delays, took {:?}",
elapsed
elapsed >= Duration::from_secs(5),
"Should have retried 3 times with 2s delays, took {elapsed:?}",
);
// Verify we can still use the fallback controller
use crate::domain::relay::types::RelayId;
let relay_id = RelayId::new(1).unwrap();
let result = controller.read_relay_state(relay_id).await;
// Mock controller should work even if hardware connection failed
assert!(
result.is_ok() || result.is_err(),
"Controller should be usable (mock or real)"
);
}
// T039a: Test 4 - Retry delays are 2 seconds between attempts
#[tokio::test]
async fn test_create_relay_controller_retry_delays() {
// GIVEN: Invalid settings to force retries
let settings = ModbusSettings {
host: "192.0.2.1".to_string(), // Unreachable address
port: 502,
slave_id: 0,
timeout_secs: 1,
};
// WHEN: create_relay_controller attempts connection
let start = std::time::Instant::now();
let _controller = create_relay_controller(&settings, false).await;
let elapsed = start.elapsed();
// THEN: Should take approximately:
// Attempt 1 (1s timeout) + 2s delay + Attempt 2 (1s) + 2s delay + Attempt 3 (1s)
// = ~7 seconds minimum (allowing some variance)
assert!(
elapsed >= Duration::from_secs(7) && elapsed <= Duration::from_secs(15),
"Retry timing incorrect: expected ~7-15s, got {:?}",
elapsed
"Retry timing incorrect: expected ~7-15s, got {elapsed:?}",
);
}
// T039a: Test 5 - Logs appropriate messages for each connection attempt
#[tokio::test]
async fn test_create_relay_controller_logs_connection_attempts() {
// This test verifies logging behavior
// In a real implementation, we would use a test subscriber to capture logs
// For now, this is a placeholder that will be updated when logging is added
// GIVEN: Invalid settings to trigger logging
let settings = ModbusSettings {
host: "192.0.2.1".to_string(),
port: 502,
slave_id: 0,
timeout_secs: 1,
};
// WHEN: create_relay_controller attempts connection
let _controller = create_relay_controller(&settings, false).await;
// THEN: Should have logged:
// - Info message when using mock mode
// - Warning for each failed retry attempt (3 times)
// - Error message when falling back to mock
// - Info message when successfully connecting
// TODO: Add proper log capture and verification
// For now, we just verify the function completes
// This is acceptable for initial TDD - we'll enhance later
}
}

102
backend/src/infrastructure/persistence/factory.rs
View File

@@ -5,13 +5,15 @@
use std::sync::Arc;
use crate::domain::relay::repository::{RelayLabelRepository, RepositoryError};
use crate::{domain::relay::repository::{RelayLabelRepository, RepositoryError}, infrastructure::persistence::label_repository::MockRelayLabelRepository};
use super::sqlite_repository::SqliteRelayLabelRepository;
/// Creates a relay label repository based on configuration.
///
/// # Parameters
///
/// - `db_path`: Path to SQLite database file (e.g., "relays.db" or ":memory:")
/// - `db_path`: Path to ``SQLite`` database file (e.g., "relays.db" or ":memory:")
/// - `use_mock`: If true, returns `MockRelayLabelRepository` for testing
///
/// # Returns
@@ -23,14 +25,18 @@ use crate::domain::relay::repository::{RelayLabelRepository, RepositoryError};
///
/// Returns `RepositoryError` if:
/// - Database path is invalid or inaccessible
/// - SQLite connection fails
/// - ``SQLite`` connection fails
/// - Database schema migration fails
pub fn create_label_repository(
_db_path: &str,
_use_mock: bool,
pub async fn create_label_repository(
db_path: &str,
use_mock: bool,
) -> Result<Arc<dyn RelayLabelRepository>, RepositoryError> {
// TODO: Implement in T039b
unimplemented!("T039b: create_label_repository factory not yet implemented")
if use_mock {
tracing::info!("Using MockRelayLabelRepository (test mode)");
return Ok(Arc::new(MockRelayLabelRepository::new()));
}
let repo = SqliteRelayLabelRepository::new(db_path).await?;
Ok(Arc::new(repo))
}
#[cfg(test)]
@@ -38,28 +44,14 @@ mod tests {
use super::*;
use crate::domain::relay::types::{RelayId, RelayLabel};
// T039b: Test 1 - use_mock=true returns MockLabelRepository
#[tokio::test]
async fn test_create_label_repository_with_mock_flag() {
// GIVEN: use_mock=true (db_path is ignored in mock mode)
let db_path = ":memory:";
// WHEN: create_label_repository is called with use_mock=true
let result = create_label_repository(db_path, true);
// THEN: Should return MockLabelRepository successfully
assert!(
result.is_ok(),
"Failed to create mock repository"
);
let result = create_label_repository(db_path, true).await;
assert!(result.is_ok(), "Failed to create mock repository");
let repository = result.unwrap();
// Verify it's a mock by testing basic operations
// Mock repository should start empty
let relay_id = RelayId::new(1).unwrap();
let label_result = repository.get_label(relay_id).await;
assert!(
label_result.is_ok(),
"Mock repository should be immediately usable"
@@ -71,56 +63,31 @@ mod tests {
);
}
// T039b: Test 2 - use_mock=false returns SqliteRelayLabelRepository
#[tokio::test]
async fn test_create_label_repository_with_sqlite() {
// GIVEN: Valid in-memory SQLite database path
let db_path = ":memory:";
// WHEN: create_label_repository is called with use_mock=false
let result = create_label_repository(db_path, false);
// THEN: Should return SqliteRelayLabelRepository successfully
assert!(
result.is_ok(),
"Failed to create SQLite repository"
);
let result = create_label_repository(db_path, false).await;
assert!(result.is_ok(), "Failed to create SQLite repository");
let repository = result.unwrap();
// Verify it's working by performing a basic operation
let relay_id = RelayId::new(1).unwrap();
let label = RelayLabel::new("Pump".to_string()).unwrap();
// Should be able to save and get labels
let save_result = repository.save_label(relay_id, label.clone()).await;
assert!(
save_result.is_ok(),
"Failed to save label on SQLite repository"
);
let get_result = repository.get_label(relay_id).await;
assert!(get_result.is_ok(), "Failed to get label");
assert_eq!(get_result.unwrap(), Some(label));
}
// T039b: Test 3 - Invalid db_path returns RepositoryError
#[test]
fn test_create_label_repository_with_invalid_path() {
// GIVEN: Invalid database path (directory that doesn't exist)
#[tokio::test]
async fn test_create_label_repository_with_invalid_path() {
let db_path = "/nonexistent/directory/impossible/path/relays.db";
// WHEN: create_label_repository is called with use_mock=false
let result = create_label_repository(db_path, false);
// THEN: Should return RepositoryError
assert!(
result.is_err(),
"Should fail with invalid database path"
);
// Verify the error is appropriate
let result = create_label_repository(db_path, false).await;
assert!(result.is_err(), "Should fail with invalid database path");
if let Err(error) = result {
#[allow(clippy::match_wildcard_for_single_variants)]
match error {
RepositoryError::DatabaseError(_) => {
// Expected error type - test passes
@@ -130,20 +97,13 @@ mod tests {
}
}
// Additional test: Verify mock and SQLite repositories are independent
#[tokio::test]
async fn test_mock_and_sqlite_repositories_are_independent() {
// GIVEN: Both mock and SQLite repositories
let mock_repo = create_label_repository(":memory:", true).unwrap();
let sqlite_repo = create_label_repository(":memory:", false).unwrap();
let mock_repo = create_label_repository(":memory:", true).await.unwrap();
let sqlite_repo = create_label_repository(":memory:", false).await.unwrap();
let relay_id = RelayId::new(1).unwrap();
let label = RelayLabel::new("Test".to_string()).unwrap();
// WHEN: We save a label in the mock repository
mock_repo.save_label(relay_id, label.clone()).await.unwrap();
// THEN: The SQLite repository should not have that label
let sqlite_result = sqlite_repo.get_label(relay_id).await.unwrap();
assert_eq!(
sqlite_result, None,
@@ -151,23 +111,15 @@ mod tests {
);
}
// Additional test: Verify in-memory SQLite doesn't persist
#[tokio::test]
async fn test_in_memory_sqlite_does_not_persist() {
// GIVEN: An in-memory SQLite database
let relay_id = RelayId::new(1).unwrap();
let label = RelayLabel::new("Temporary".to_string()).unwrap();
// WHEN: We create a repository, save a label, and drop it
{
let repo = create_label_repository(":memory:", false).unwrap();
let repo = create_label_repository(":memory:", false).await.unwrap();
repo.save_label(relay_id, label.clone()).await.unwrap();
} // repo is dropped here
// AND: We create a new in-memory repository
let new_repo = create_label_repository(":memory:", false).unwrap();
// THEN: The label should not exist in the new repository
let new_repo = create_label_repository(":memory:", false).await.unwrap();
let result = new_repo.get_label(relay_id).await.unwrap();
assert_eq!(
result, None,

15
backend/src/infrastructure/persistence/label_repository_tests.rs
View File

@@ -12,11 +12,13 @@
#[cfg(test)]
mod relay_label_repository_contract_tests {
use crate::{domain::relay::{
repository::RelayLabelRepository,
types::{RelayId, RelayLabel},
}, infrastructure::persistence::label_repository::MockRelayLabelRepository};
use crate::{
domain::relay::{
repository::RelayLabelRepository,
types::{RelayId, RelayLabel},
},
infrastructure::persistence::label_repository::MockRelayLabelRepository,
};
#[tokio::test]
pub async fn test_get_label_returns_none_for_non_existent_relay() {
@@ -75,7 +77,6 @@ mod relay_label_repository_contract_tests {
);
}
#[tokio::test]
pub async fn test_save_label_succeeds() {
let repo = MockRelayLabelRepository::new();
@@ -179,7 +180,6 @@ mod relay_label_repository_contract_tests {
assert_eq!(retrieved.unwrap().as_str(), "X", "Label should match");
}
#[tokio::test]
pub async fn test_delete_label_succeeds_for_existing_label() {
let repo = MockRelayLabelRepository::new();
@@ -265,7 +265,6 @@ mod relay_label_repository_contract_tests {
);
}
#[tokio::test]
pub async fn test_get_all_labels_returns_empty_when_no_labels() {
let repo = MockRelayLabelRepository::new();

11
backend/src/lib.rs
View File

@@ -85,7 +85,7 @@ pub mod presentation;
type MaybeListener = Option<poem::listener::TcpListener<String>>;
fn prepare(listener: MaybeListener) -> startup::Application {
async fn prepare(listener: MaybeListener) -> startup::Application {
dotenvy::dotenv().ok();
let settings = settings::Settings::new().expect("Failed to read settings");
if !cfg!(test) {
@@ -98,7 +98,8 @@ fn prepare(listener: MaybeListener) -> startup::Application {
"Using these settings: {:?}",
settings
);
let application = startup::Application::build(settings, listener);
let application = startup::Application::build(settings, listener).await
.expect("Failed to build application");
tracing::event!(
target: "backend",
tracing::Level::INFO,
@@ -124,7 +125,7 @@ fn prepare(listener: MaybeListener) -> startup::Application {
/// an I/O error during runtime (e.g., port already in use, network issues).
#[cfg(not(tarpaulin_include))]
pub async fn run(listener: MaybeListener) -> Result<(), std::io::Error> {
let application = prepare(listener);
let application = prepare(listener).await;
application.make_app().run().await
}
@@ -137,7 +138,7 @@ fn make_random_tcp_listener() -> poem::listener::TcpListener<String> {
}
#[cfg(test)]
fn get_test_app() -> startup::App {
async fn get_test_app() -> startup::App {
let tcp_listener = make_random_tcp_listener();
prepare(Some(tcp_listener)).make_app().into()
prepare(Some(tcp_listener)).await.make_app().into()
}

1
backend/src/presentation/api/mod.rs Normal file
View File

@@ -0,0 +1 @@
pub mod relay_api;

259
backend/src/presentation/api/relay_api.rs Normal file
View File

@@ -0,0 +1,259 @@
use std::sync::Arc;
use poem::Result;
use poem_openapi::{ApiResponse, OpenApi, param::Path, payload::Json};
use crate::{
application::use_cases::{GetAllRelaysUseCase, ToggleRelayUseCase},
domain::relay::{
Relay, controller::RelayController, repository::RelayLabelRepository, types::RelayId,
},
presentation::{dto::relay_dto::RelayDto, error::ApiError},
route::ApiCategory
};
#[derive(ApiResponse)]
enum GetAllRelaysResponse {
#[oai(status = 200)]
Ok(Json<Vec<RelayDto>>),
}
#[derive(ApiResponse)]
enum ToggleRelayResponse {
#[oai(status = 200)]
Ok(Json<RelayDto>),
}
pub struct RelayApi {
relay_controller: Arc<dyn RelayController>,
label_repository: Arc<dyn RelayLabelRepository>,
}
impl RelayApi {
pub fn new(
relay_controller: Arc<dyn RelayController>,
label_repository: Arc<dyn RelayLabelRepository>,
) -> Self {
Self {
relay_controller,
label_repository,
}
}
}
// -- Endpoints ---
#[OpenApi(tag = "ApiCategory::Relays")]
impl RelayApi {
#[oai(path = "/relays", method = "get")]
async fn get_all_relays(&self) -> Result<GetAllRelaysResponse> {
let use_case =
GetAllRelaysUseCase::new(self.relay_controller.clone(), self.label_repository.clone());
let relays = use_case
.execute()
.await
.map_err(|e| poem::Error::from(ApiError::from(e)))?;
let dtos: Vec<_> = relays
.into_iter()
.map(|r| {
let domain_relay =
Relay::with_label(r.id(), r.state(), r.label().unwrap_or_default());
RelayDto::from(domain_relay)
})
.collect();
Ok(GetAllRelaysResponse::Ok(Json(dtos)))
}
#[oai(path = "/relays/:id/toggle", method = "post")]
async fn toggle_relay(&self, id: Path<u8>) -> Result<ToggleRelayResponse> {
let relay_id =
RelayId::new(*id).map_err(|_| poem::Error::from(ApiError::RelayNotFound(*id)))?;
let use_case =
ToggleRelayUseCase::new(self.relay_controller.clone(), self.label_repository.clone());
let relay = use_case
.execute(relay_id)
.await
.map_err(|e| poem::Error::from(ApiError::from(e)))?;
let domain_relay =
Relay::with_label(relay.id(), relay.state(), relay.label().unwrap_or_default());
Ok(ToggleRelayResponse::Ok(Json(RelayDto::from(domain_relay))))
}
}
#[cfg(test)]
mod tests {
use std::sync::Arc;
use poem::http::StatusCode;
use poem_openapi::OpenApiService;
use crate::{
domain::relay::{
controller::RelayController,
repository::RelayLabelRepository,
types::{RelayId, RelayState},
},
infrastructure::{
modbus::mock_controller::MockRelayController,
persistence::label_repository::MockRelayLabelRepository,
},
};
use super::RelayApi;
fn make_relay_api(controller: Arc<MockRelayController>) -> poem::test::TestClient<impl poem::Endpoint> {
let repo = Arc::new(MockRelayLabelRepository::new());
let relay_api = RelayApi::new(controller, repo);
let api_service = OpenApiService::new(relay_api, "test", "1.0");
let app = poem::Route::new().nest("/api", api_service);
poem::test::TestClient::new(app)
}
// -- GET /api/relays --
#[tokio::test]
async fn get_all_relays_returns_200() {
let controller = Arc::new(MockRelayController::new());
let cli = make_relay_api(controller);
let resp = cli.get("/api/relays").send().await;
resp.assert_status_is_ok();
}
#[tokio::test]
async fn get_all_relays_returns_empty_array_when_no_states() {
let controller = Arc::new(MockRelayController::new());
let cli = make_relay_api(controller);
let resp = cli.get("/api/relays").send().await;
resp.assert_status_is_ok();
let body: Vec<serde_json::Value> = resp.json().await.value().deserialize();
assert!(body.is_empty());
}
#[tokio::test]
async fn get_all_relays_returns_all_initialized_relays() {
let controller = Arc::new(MockRelayController::new());
for i in 1u8..=8 {
controller
.write_relay_state(RelayId::new(i).unwrap(), RelayState::Off)
.await
.unwrap();
}
controller
.write_relay_state(RelayId::new(1).unwrap(), RelayState::On)
.await
.unwrap();
let cli = make_relay_api(controller);
let resp = cli.get("/api/relays").send().await;
resp.assert_status_is_ok();
let body: Vec<serde_json::Value> = resp.json().await.value().deserialize();
assert_eq!(body.len(), 8);
assert_eq!(body[0]["id"], 1);
assert_eq!(body[0]["state"], "on");
assert_eq!(body[1]["id"], 2);
assert_eq!(body[1]["state"], "off");
}
// -- POST /api/relays/{id}/toggle --
#[tokio::test]
async fn toggle_relay_with_out_of_range_id_9_returns_404() {
let controller = Arc::new(MockRelayController::new());
let cli = make_relay_api(controller);
let resp = cli.post("/api/relays/9/toggle").send().await;
resp.assert_status(StatusCode::NOT_FOUND);
}
#[tokio::test]
async fn toggle_relay_with_id_0_returns_404() {
let controller = Arc::new(MockRelayController::new());
let cli = make_relay_api(controller);
let resp = cli.post("/api/relays/0/toggle").send().await;
resp.assert_status(StatusCode::NOT_FOUND);
}
#[tokio::test]
async fn toggle_relay_toggles_off_to_on_and_returns_200() {
let controller = Arc::new(MockRelayController::new());
controller
.write_relay_state(RelayId::new(1).unwrap(), RelayState::Off)
.await
.unwrap();
let cli = make_relay_api(controller);
let resp = cli.post("/api/relays/1/toggle").send().await;
resp.assert_status_is_ok();
let body: serde_json::Value = resp.json().await.value().deserialize();
assert_eq!(body["id"], 1);
assert_eq!(body["state"], "on");
}
#[tokio::test]
async fn toggle_relay_toggles_on_to_off_and_returns_200() {
let controller = Arc::new(MockRelayController::new());
controller
.write_relay_state(RelayId::new(3).unwrap(), RelayState::On)
.await
.unwrap();
let cli = make_relay_api(controller);
let resp = cli.post("/api/relays/3/toggle").send().await;
resp.assert_status_is_ok();
let body: serde_json::Value = resp.json().await.value().deserialize();
assert_eq!(body["id"], 3);
assert_eq!(body["state"], "off");
}
#[tokio::test]
async fn toggle_relay_includes_label_in_response() {
use crate::domain::relay::types::RelayLabel;
let controller = Arc::new(MockRelayController::new());
controller
.write_relay_state(RelayId::new(2).unwrap(), RelayState::Off)
.await
.unwrap();
let repo = Arc::new(MockRelayLabelRepository::new());
repo.save_label(RelayId::new(2).unwrap(), RelayLabel::new("Pump".to_string()).unwrap())
.await
.unwrap();
let relay_api = RelayApi::new(controller, repo);
let api_service = OpenApiService::new(relay_api, "test", "1.0");
let app = poem::Route::new().nest("/api", api_service);
let cli = poem::test::TestClient::new(app);
let resp = cli.post("/api/relays/2/toggle").send().await;
resp.assert_status_is_ok();
let body: serde_json::Value = resp.json().await.value().deserialize();
assert_eq!(body["label"], "Pump");
}
// -- Integration tests via get_test_app() --
#[tokio::test]
async fn get_all_relays_endpoint_reachable_via_full_app() {
let app = crate::get_test_app().await;
let cli = poem::test::TestClient::new(app);
let resp = cli.get("/api/relays").send().await;
resp.assert_status_is_ok();
}
#[tokio::test]
async fn toggle_relay_invalid_id_returns_404_via_full_app() {
let app = crate::get_test_app().await;
let cli = poem::test::TestClient::new(app);
let resp = cli.post("/api/relays/9/toggle").send().await;
resp.assert_status(StatusCode::NOT_FOUND);
}
// Posting to a valid relay ID on an empty mock should hit the handler (route found)
// and return 500 because the mock controller has no relay state initialised.
#[tokio::test]
async fn toggle_relay_valid_id_empty_mock_returns_500_via_full_app() {
let app = crate::get_test_app().await;
let cli = poem::test::TestClient::new(app);
let resp = cli.post("/api/relays/1/toggle").send().await;
resp.assert_status(StatusCode::INTERNAL_SERVER_ERROR);
}
}

5
backend/src/presentation/dto/relay_dto.rs
View File

@@ -126,10 +126,7 @@ mod tests {
let dto = RelayDto::from(relay);
let json = serde_json::to_string(&dto).unwrap();
assert_eq!(
json,
r#"{"id":7,"state":"on","label":"Test Relay"}"#
);
assert_eq!(json, r#"{"id":7,"state":"on","label":"Test Relay"}"#);
}
#[test]

26
backend/src/presentation/error.rs
View File

@@ -5,7 +5,12 @@
use poem::{error::ResponseError, http::StatusCode};
use crate::{application::use_cases::{get_all_relays::GetAllRelaysError, toggle_relay::ToggleRelayError}, domain::relay::{controller::ControllerError, repository::RepositoryError, types::RelayLabelError}};
use crate::{
application::use_cases::{get_all_relays::GetAllRelaysError, toggle_relay::ToggleRelayError},
domain::relay::{
controller::ControllerError, repository::RepositoryError, types::RelayLabelError,
},
};
/// Unified error type for all API handlers.
///
@@ -77,8 +82,7 @@ mod tests {
use crate::{
application::use_cases::{
get_all_relays::GetAllRelaysError,
toggle_relay::ToggleRelayError,
get_all_relays::GetAllRelaysError, toggle_relay::ToggleRelayError,
},
domain::relay::{
controller::ControllerError,
@@ -109,13 +113,16 @@ mod tests {
#[test]
fn test_controller_connection_error_returns_503() {
let error = ApiError::ControllerError(ControllerError::ConnectionError("refused".to_string()));
let error =
ApiError::ControllerError(ControllerError::ConnectionError("refused".to_string()));
assert_eq!(error.status(), StatusCode::SERVICE_UNAVAILABLE);
}
#[test]
fn test_controller_modbus_exception_returns_503() {
let error = ApiError::ControllerError(ControllerError::ModbusException("illegal function".to_string()));
let error = ApiError::ControllerError(ControllerError::ModbusException(
"illegal function".to_string(),
));
assert_eq!(error.status(), StatusCode::SERVICE_UNAVAILABLE);
}
@@ -127,13 +134,15 @@ mod tests {
#[test]
fn test_controller_invalid_input_returns_500() {
let error = ApiError::ControllerError(ControllerError::InvalidInput("bad input".to_string()));
let error =
ApiError::ControllerError(ControllerError::InvalidInput("bad input".to_string()));
assert_eq!(error.status(), StatusCode::INTERNAL_SERVER_ERROR);
}
#[test]
fn test_repository_error_returns_500() {
let error = ApiError::RepositoryError(RepositoryError::DatabaseError("db failed".to_string()));
let error =
ApiError::RepositoryError(RepositoryError::DatabaseError("db failed".to_string()));
assert_eq!(error.status(), StatusCode::INTERNAL_SERVER_ERROR);
}
@@ -162,7 +171,8 @@ mod tests {
#[test]
fn test_from_get_all_relays_repository_error_produces_repository_error() {
let source = GetAllRelaysError::Repository(RepositoryError::DatabaseError("err".to_string()));
let source =
GetAllRelaysError::Repository(RepositoryError::DatabaseError("err".to_string()));
let api_error = ApiError::from(source);
assert!(matches!(api_error, ApiError::RepositoryError(_)));
}

2
backend/src/presentation/mod.rs
View File

@@ -100,6 +100,6 @@
/// This module contains DTO structures that are used to serialize domain
/// objects for API responses, providing a clean separation between internal
/// domain models and external API contracts.
pub mod api;
pub mod dto;
pub mod error;

2
backend/src/route/health.rs
View File

@@ -30,7 +30,7 @@ impl HealthApi {
#[tokio::test]
async fn health_check_works() {
let app = crate::get_test_app();
let app = crate::get_test_app().await;
let cli = poem::test::TestClient::new(app);
let resp = cli.get("/api/health").send().await;
resp.assert_status_is_ok();

4
backend/src/route/meta.rs
View File

@@ -59,7 +59,7 @@ impl MetaApi {
mod tests {
#[tokio::test]
async fn meta_endpoint_returns_correct_data() {
let app = crate::get_test_app();
let app = crate::get_test_app().await;
let cli = poem::test::TestClient::new(app);
let resp = cli.get("/api/meta").send().await;
resp.assert_status_is_ok();
@@ -78,7 +78,7 @@ mod tests {
#[tokio::test]
async fn meta_endpoint_returns_200_status() {
let app = crate::get_test_app();
let app = crate::get_test_app().await;
let cli = poem::test::TestClient::new(app);
let resp = cli.get("/api/meta").send().await;
resp.assert_status_is_ok();

3
backend/src/route/mod.rs
View File

@@ -12,9 +12,10 @@ mod meta;
use crate::settings::Settings;
#[derive(Tags)]
enum ApiCategory {
pub enum ApiCategory {
Health,
Meta,
Relays,
}
pub(crate) struct Api {

16
backend/src/settings/application.rs Normal file
View File

@@ -0,0 +1,16 @@
/// Application-specific configuration settings.
#[derive(Debug, serde::Deserialize, Clone, Default)]
pub struct ApplicationSettings {
/// Application name
pub name: String,
/// Application version
pub version: String,
/// Port to bind to
pub port: u16,
/// Host address to bind to
pub host: String,
/// Base URL of the application
pub base_url: String,
/// Protocol (http or https)
pub protocol: String,
}

12
backend/src/settings/database.rs Normal file
View File

@@ -0,0 +1,12 @@
#[derive(Debug, serde::Deserialize, Clone)]
pub struct DatabaseSettings {
pub path: String,
}
impl Default for DatabaseSettings {
fn default() -> Self {
Self {
path: "sqlite::memory:".to_string(),
}
}
}

134
backend/src/settings/environment.rs Normal file
View File

@@ -0,0 +1,134 @@
/// Application environment.
#[derive(Debug, PartialEq, Eq, Default)]
pub enum Environment {
/// Development environment
#[default]
Development,
/// Production environment
Production,
}
impl std::fmt::Display for Environment {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let self_str = match self {
Self::Development => "development",
Self::Production => "production",
};
write!(f, "{self_str}")
}
}
impl TryFrom<String> for Environment {
type Error = String;
fn try_from(value: String) -> Result<Self, Self::Error> {
Self::try_from(value.as_str())
}
}
impl TryFrom<&str> for Environment {
type Error = String;
fn try_from(value: &str) -> Result<Self, Self::Error> {
match value.to_lowercase().as_str() {
"development" | "dev" => Ok(Self::Development),
"production" | "prod" => Ok(Self::Production),
other => Err(format!(
"{other} is not a supported environment. Use either `development` or `production`"
)),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn environment_display_development() {
let env = Environment::Development;
assert_eq!(env.to_string(), "development");
}
#[test]
fn environment_display_production() {
let env = Environment::Production;
assert_eq!(env.to_string(), "production");
}
#[test]
fn environment_from_str_development() {
assert_eq!(
Environment::try_from("development").unwrap(),
Environment::Development
);
assert_eq!(
Environment::try_from("dev").unwrap(),
Environment::Development
);
assert_eq!(
Environment::try_from("Development").unwrap(),
Environment::Development
);
assert_eq!(
Environment::try_from("DEV").unwrap(),
Environment::Development
);
}
#[test]
fn environment_from_str_production() {
assert_eq!(
Environment::try_from("production").unwrap(),
Environment::Production
);
assert_eq!(
Environment::try_from("prod").unwrap(),
Environment::Production
);
assert_eq!(
Environment::try_from("Production").unwrap(),
Environment::Production
);
assert_eq!(
Environment::try_from("PROD").unwrap(),
Environment::Production
);
}
#[test]
fn environment_from_str_invalid() {
let result = Environment::try_from("invalid");
assert!(result.is_err());
assert!(result.unwrap_err().contains("not a supported environment"));
}
#[test]
fn environment_from_string_development() {
assert_eq!(
Environment::try_from("development".to_string()).unwrap(),
Environment::Development
);
}
#[test]
fn environment_from_string_production() {
assert_eq!(
Environment::try_from("production".to_string()).unwrap(),
Environment::Production
);
}
#[test]
fn environment_from_string_invalid() {
let result = Environment::try_from("invalid".to_string());
assert!(result.is_err());
}
#[test]
fn environment_default_is_development() {
let env = Environment::default();
assert_eq!(env, Environment::Development);
}
}

290
backend/src/settings/mod.rs
View File

@@ -7,8 +7,21 @@
//! Settings include application details, Modbus connection parameters, relay configuration,
//! rate limiting, and environment settings.
mod application;
mod cors;
mod database;
mod environment;
mod modbus;
mod rate_limiting;
mod relay;
pub use application::ApplicationSettings;
pub use cors::CorsSettings;
pub use database::DatabaseSettings;
pub use environment::Environment;
pub use modbus::ModbusSettings;
pub use rate_limiting::RateLimitSettings;
pub use relay::RelaySettings;
/// Application configuration settings.
///
@@ -18,15 +31,21 @@ pub struct Settings {
/// Application-specific settings (name, version, host, port, etc.)
pub application: ApplicationSettings,
/// Debug mode flag
#[serde(default)]
pub debug: bool,
/// Frontend URL for CORS configuration
pub frontend_url: String,
/// Database settings
#[serde(default)]
pub database: DatabaseSettings,
/// Rate limiting configuration
#[serde(default)]
pub rate_limit: RateLimitSettings,
/// Modbus configuration
#[serde(default)]
pub modbus: ModbusSettings,
/// Relay configuration
#[serde(default)]
pub relay: RelaySettings,
/// CORS configuration
#[serde(default)]
@@ -78,272 +97,10 @@ impl Settings {
}
}
/// Application-specific configuration settings.
#[derive(Debug, serde::Deserialize, Clone, Default)]
pub struct ApplicationSettings {
/// Application name
pub name: String,
/// Application version
pub version: String,
/// Port to bind to
pub port: u16,
/// Host address to bind to
pub host: String,
/// Base URL of the application
pub base_url: String,
/// Protocol (http or https)
pub protocol: String,
}
/// Application environment.
#[derive(Debug, PartialEq, Eq, Default)]
pub enum Environment {
/// Development environment
#[default]
Development,
/// Production environment
Production,
}
impl std::fmt::Display for Environment {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let self_str = match self {
Self::Development => "development",
Self::Production => "production",
};
write!(f, "{self_str}")
}
}
impl TryFrom<String> for Environment {
type Error = String;
fn try_from(value: String) -> Result<Self, Self::Error> {
Self::try_from(value.as_str())
}
}
impl TryFrom<&str> for Environment {
type Error = String;
fn try_from(value: &str) -> Result<Self, Self::Error> {
match value.to_lowercase().as_str() {
"development" | "dev" => Ok(Self::Development),
"production" | "prod" => Ok(Self::Production),
other => Err(format!(
"{other} is not a supported environment. Use either `development` or `production`"
)),
}
}
}
/// Rate limiting configuration.
#[derive(Debug, serde::Deserialize, Clone)]
pub struct RateLimitSettings {
/// Whether rate limiting is enabled
#[serde(default = "default_rate_limit_enabled")]
pub enabled: bool,
/// Maximum number of requests allowed in the time window (burst size)
#[serde(default = "default_burst_size")]
pub burst_size: u32,
/// Time window in seconds for rate limiting
#[serde(default = "default_per_seconds")]
pub per_seconds: u64,
}
impl Default for RateLimitSettings {
fn default() -> Self {
Self {
enabled: default_rate_limit_enabled(),
burst_size: default_burst_size(),
per_seconds: default_per_seconds(),
}
}
}
const fn default_rate_limit_enabled() -> bool {
true
}
const fn default_burst_size() -> u32 {
100
}
const fn default_per_seconds() -> u64 {
60
}
/// Modbus TCP connection configuration.
///
/// Configures the connection parameters for communicating with the Modbus relay device
/// using Modbus RTU over TCP protocol.
#[derive(Debug, serde::Deserialize, Clone)]
pub struct ModbusSettings {
/// IP address or hostname of the Modbus device
pub host: String,
/// TCP port for Modbus communication (standard Modbus TCP port is 502)
pub port: u16,
/// Modbus slave/device ID (unit identifier)
pub slave_id: u8,
/// Operation timeout in seconds
pub timeout_secs: u8,
}
impl Default for ModbusSettings {
fn default() -> Self {
Self {
host: "192.168.0.200".to_string(),
port: 502,
slave_id: 0,
timeout_secs: 5,
}
}
}
/// Relay control configuration.
///
/// Configures parameters for relay management and labeling.
#[derive(Debug, serde::Deserialize, Clone)]
pub struct RelaySettings {
/// Maximum length for custom relay labels (in characters)
pub label_max_length: u8,
}
impl Default for RelaySettings {
fn default() -> Self {
Self {
label_max_length: 8,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn environment_display_development() {
let env = Environment::Development;
assert_eq!(env.to_string(), "development");
}
#[test]
fn environment_display_production() {
let env = Environment::Production;
assert_eq!(env.to_string(), "production");
}
#[test]
fn environment_from_str_development() {
assert_eq!(
Environment::try_from("development").unwrap(),
Environment::Development
);
assert_eq!(
Environment::try_from("dev").unwrap(),
Environment::Development
);
assert_eq!(
Environment::try_from("Development").unwrap(),
Environment::Development
);
assert_eq!(
Environment::try_from("DEV").unwrap(),
Environment::Development
);
}
#[test]
fn environment_from_str_production() {
assert_eq!(
Environment::try_from("production").unwrap(),
Environment::Production
);
assert_eq!(
Environment::try_from("prod").unwrap(),
Environment::Production
);
assert_eq!(
Environment::try_from("Production").unwrap(),
Environment::Production
);
assert_eq!(
Environment::try_from("PROD").unwrap(),
Environment::Production
);
}
#[test]
fn environment_from_str_invalid() {
let result = Environment::try_from("invalid");
assert!(result.is_err());
assert!(result.unwrap_err().contains("not a supported environment"));
}
#[test]
fn environment_from_string_development() {
assert_eq!(
Environment::try_from("development".to_string()).unwrap(),
Environment::Development
);
}
#[test]
fn environment_from_string_production() {
assert_eq!(
Environment::try_from("production".to_string()).unwrap(),
Environment::Production
);
}
#[test]
fn environment_from_string_invalid() {
let result = Environment::try_from("invalid".to_string());
assert!(result.is_err());
}
#[test]
fn environment_default_is_development() {
let env = Environment::default();
assert_eq!(env, Environment::Development);
}
#[test]
fn rate_limit_settings_default() {
let settings = RateLimitSettings::default();
assert!(settings.enabled);
assert_eq!(settings.burst_size, 100);
assert_eq!(settings.per_seconds, 60);
}
#[test]
fn rate_limit_settings_deserialize_full() {
let json = r#"{"enabled": true, "burst_size": 50, "per_seconds": 30}"#;
let settings: RateLimitSettings = serde_json::from_str(json).unwrap();
assert!(settings.enabled);
assert_eq!(settings.burst_size, 50);
assert_eq!(settings.per_seconds, 30);
}
#[test]
fn rate_limit_settings_deserialize_partial() {
let json = r#"{"enabled": false}"#;
let settings: RateLimitSettings = serde_json::from_str(json).unwrap();
assert!(!settings.enabled);
assert_eq!(settings.burst_size, 100); // default
assert_eq!(settings.per_seconds, 60); // default
}
#[test]
fn rate_limit_settings_deserialize_empty() {
let json = "{}";
let settings: RateLimitSettings = serde_json::from_str(json).unwrap();
assert!(settings.enabled); // default
assert_eq!(settings.burst_size, 100); // default
assert_eq!(settings.per_seconds, 60); // default
}
// T009: Integration test for CorsSettings within Settings struct
#[test]
fn settings_loads_cors_section_from_yaml() {
// Create a temporary settings file with CORS configuration
@@ -369,15 +126,6 @@ cors:
- "http://localhost:5173"
allow_credentials: false
max_age_secs: 3600
modbus:
host: "192.168.0.200"
port: 502
slave_id: 0
timeout_secs: 5
relay:
label_max_length: 50
"#;
// Use serde_yaml to deserialize directly

26
backend/src/settings/modbus.rs Normal file
View File

@@ -0,0 +1,26 @@
/// Modbus TCP connection configuration.
///
/// Configures the connection parameters for communicating with the Modbus relay device
/// using Modbus RTU over TCP protocol.
#[derive(Debug, serde::Deserialize, Clone)]
pub struct ModbusSettings {
/// IP address or hostname of the Modbus device
pub host: String,
/// TCP port for Modbus communication (standard Modbus TCP port is 502)
pub port: u16,
/// Modbus slave/device ID (unit identifier)
pub slave_id: u8,
/// Operation timeout in seconds
pub timeout_secs: u8,
}
impl Default for ModbusSettings {
fn default() -> Self {
Self {
host: "192.168.0.200".to_string(),
port: 502,
slave_id: 0,
timeout_secs: 5,
}
}
}

75
backend/src/settings/rate_limiting.rs Normal file
View File

@@ -0,0 +1,75 @@
/// Rate limiting configuration.
#[derive(Debug, serde::Deserialize, Clone)]
pub struct RateLimitSettings {
/// Whether rate limiting is enabled
#[serde(default = "default_rate_limit_enabled")]
pub enabled: bool,
/// Maximum number of requests allowed in the time window (burst size)
#[serde(default = "default_burst_size")]
pub burst_size: u32,
/// Time window in seconds for rate limiting
#[serde(default = "default_per_seconds")]
pub per_seconds: u64,
}
impl Default for RateLimitSettings {
fn default() -> Self {
Self {
enabled: default_rate_limit_enabled(),
burst_size: default_burst_size(),
per_seconds: default_per_seconds(),
}
}
}
const fn default_rate_limit_enabled() -> bool {
true
}
const fn default_burst_size() -> u32 {
100
}
const fn default_per_seconds() -> u64 {
60
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn rate_limit_settings_default() {
let settings = RateLimitSettings::default();
assert!(settings.enabled);
assert_eq!(settings.burst_size, 100);
assert_eq!(settings.per_seconds, 60);
}
#[test]
fn rate_limit_settings_deserialize_full() {
let json = r#"{"enabled": true, "burst_size": 50, "per_seconds": 30}"#;
let settings: RateLimitSettings = serde_json::from_str(json).unwrap();
assert!(settings.enabled);
assert_eq!(settings.burst_size, 50);
assert_eq!(settings.per_seconds, 30);
}
#[test]
fn rate_limit_settings_deserialize_partial() {
let json = r#"{"enabled": false}"#;
let settings: RateLimitSettings = serde_json::from_str(json).unwrap();
assert!(!settings.enabled);
assert_eq!(settings.burst_size, 100); // default
assert_eq!(settings.per_seconds, 60); // default
}
#[test]
fn rate_limit_settings_deserialize_empty() {
let json = "{}";
let settings: RateLimitSettings = serde_json::from_str(json).unwrap();
assert!(settings.enabled); // default
assert_eq!(settings.burst_size, 100); // default
assert_eq!(settings.per_seconds, 60); // default
}
}

16
backend/src/settings/relay.rs Normal file
View File

@@ -0,0 +1,16 @@
/// Relay control configuration.
///
/// Configures parameters for relay management and labeling.
#[derive(Debug, serde::Deserialize, Clone)]
pub struct RelaySettings {
/// Maximum length for custom relay labels (in characters)
pub label_max_length: u8,
}
impl Default for RelaySettings {
fn default() -> Self {
Self {
label_max_length: 8,
}
}
}

257
backend/src/startup.rs
View File

@@ -10,6 +10,9 @@ use poem::middleware::{AddDataEndpoint, Cors, CorsEndpoint};
use poem::{EndpointExt, Route};
use poem_openapi::OpenApiService;
use crate::infrastructure::modbus::factory::create_relay_controller;
use crate::infrastructure::persistence::factory::create_label_repository;
use crate::presentation::api::relay_api::RelayApi;
use crate::{
middleware::rate_limit::{RateLimit, RateLimitConfig},
route::Api,
@@ -94,17 +97,17 @@ impl From<Application> for RunnableApplication {
}
impl Application {
fn setup_app(settings: &Settings) -> poem::Route {
fn setup_app(settings: &Settings, relay_api: RelayApi) -> poem::Route {
let api_service = OpenApiService::new(
Api::from(settings).apis(),
(Api::from(settings).apis(), relay_api),
settings.application.clone().name,
settings.application.clone().version,
)
.url_prefix("/api");
let ui = api_service.swagger_ui();
poem::Route::new()
.nest("/api", api_service.clone())
.nest("/specs", api_service.spec_endpoint_yaml())
.nest("/api", api_service)
.nest("/", ui)
}
@@ -125,22 +128,31 @@ impl Application {
/// Builds a new application with the given settings and optional TCP listener.
///
/// If no listener is provided, one will be created based on the settings.
#[must_use]
pub fn build(
///
/// # Errors
///
/// Returns an error if dependency injection fails (currently always succeeds).
pub async fn build(
settings: Settings,
tcp_listener: Option<poem::listener::TcpListener<String>>,
) -> Self {
) -> Result<Self, Box<dyn std::error::Error>> {
let use_mock = cfg!(test) || std::env::var("CI").is_ok();
let relay_controller = create_relay_controller(&settings.modbus, use_mock).await;
let label_repository = create_label_repository(&settings.database.path, use_mock).await?;
let relay_api = RelayApi::new(relay_controller, label_repository);
let port = settings.application.port;
let host = settings.application.clone().host;
let app = Self::setup_app(&settings);
let app = Self::setup_app(&settings, relay_api);
let server = Self::setup_server(&settings, tcp_listener);
Self {
Ok(Self {
server,
app,
host,
port,
settings,
}
})
}
/// Converts the application into a runnable application.
@@ -187,63 +199,57 @@ mod tests {
}
}
#[test]
fn application_build_and_host() {
#[tokio::test]
async fn application_build_and_host() {
let settings = create_test_settings();
let app = Application::build(settings.clone(), None);
let app = Application::build(settings.clone(), None).await.unwrap();
assert_eq!(app.host(), settings.application.host);
}
#[test]
fn application_build_and_port() {
#[tokio::test]
async fn application_build_and_port() {
let settings = create_test_settings();
let app = Application::build(settings, None);
let app = Application::build(settings, None).await.unwrap();
assert_eq!(app.port(), 8080);
}
#[test]
fn application_host_returns_correct_value() {
#[tokio::test]
async fn application_host_returns_correct_value() {
let settings = create_test_settings();
let app = Application::build(settings, None);
let app = Application::build(settings, None).await.unwrap();
assert_eq!(app.host(), "127.0.0.1");
}
#[test]
fn application_port_returns_correct_value() {
#[tokio::test]
async fn application_port_returns_correct_value() {
let settings = create_test_settings();
let app = Application::build(settings, None);
let app = Application::build(settings, None).await.unwrap();
assert_eq!(app.port(), 8080);
}
#[test]
fn application_with_custom_listener() {
#[tokio::test]
async fn application_with_custom_listener() {
let settings = create_test_settings();
let tcp_listener =
std::net::TcpListener::bind("127.0.0.1:0").expect("Failed to bind random port");
let port = tcp_listener.local_addr().unwrap().port();
let listener = poem::listener::TcpListener::bind(format!("127.0.0.1:{port}"));
let app = Application::build(settings, Some(listener));
let app = Application::build(settings, Some(listener)).await.unwrap();
assert_eq!(app.host(), "127.0.0.1");
assert_eq!(app.port(), 8080);
}
// T015: Test that CORS middleware is configured from settings
#[test]
fn runnable_application_uses_cors_from_settings() {
// GIVEN: An application with custom CORS settings
#[tokio::test]
async fn runnable_application_uses_cors_from_settings() {
let mut settings = create_test_settings();
settings.cors = crate::settings::CorsSettings {
allowed_origins: vec!["http://localhost:5173".to_string()],
allow_credentials: false,
max_age_secs: 3600,
};
// WHEN: The application is converted to a runnable application
let app = Application::build(settings, None);
let app = Application::build(settings, None).await.unwrap();
let _runnable_app = app.make_app();
// THEN: The middleware chain should use CORS settings from configuration
// Note: This is a structural test - actual CORS behavior is tested in integration tests (T016)
// The fact that this compiles and runs without panic verifies that:
// 1. CORS settings are properly loaded
@@ -251,111 +257,20 @@ mod tests {
// 3. The middleware chain accepts the CORS configuration
}
// ============================================================================
// T039c: Dependency Injection Tests
// ============================================================================
// These tests verify that Application::build() correctly wires dependencies
// with graceful degradation and test mode detection.
// T039c: Test 1 - Application::build() succeeds in test mode
#[test]
fn test_application_build_succeeds_in_test_mode() {
// GIVEN: Settings configured for test mode
// When cfg!(test) is true, Application::build should use mock dependencies
#[tokio::test]
async fn test_application_build_succeeds_in_test_mode() {
let settings = create_test_settings();
// WHEN: Application::build() is called
let result = std::panic::catch_unwind(|| {
Application::build(settings, None)
});
// THEN: Should succeed without panicking
let app = Application::build(settings, None).await;
assert!(
result.is_ok(),
app.is_ok(),
"Application::build() should succeed in test mode"
);
let app = result.unwrap();
// Verify the application is configured correctly
let app = app.unwrap();
assert_eq!(app.port(), 8080);
assert_eq!(app.host(), "127.0.0.1");
// TODO (T039c implementation): After implementation, verify that:
// - Mock controller is used (not real Modbus hardware)
// - Mock label repository is used (not real SQLite)
// - Application can be converted to runnable state
}
// T039c: Test 2 - Application::build() creates correct mock dependencies when CI=true
#[test]
fn test_application_build_uses_mock_dependencies_in_ci() {
// GIVEN: CI environment variable is set
// SAFETY: This test modifies environment variables, which is inherently unsafe
// in a multi-threaded context. However, this is acceptable in tests because:
// 1. Cargo runs tests in parallel by default, but each test gets its own process
// 2. The cleanup happens immediately after use
// 3. This is a controlled test environment
unsafe {
std::env::set_var("CI", "true");
}
let settings = create_test_settings();
// WHEN: Application::build() is called
let result = std::panic::catch_unwind(|| {
Application::build(settings, None)
});
// Clean up environment variable
// SAFETY: Same rationale as set_var above
unsafe {
std::env::remove_var("CI");
}
// THEN: Should succeed and use mock dependencies
assert!(
result.is_ok(),
"Application::build() should succeed in CI environment"
);
let app = result.unwrap();
// Verify the application is configured
assert_eq!(app.port(), 8080);
// TODO (T039c implementation): After implementation, verify that:
// - Mock dependencies are used when CI=true
// - No real hardware connection is attempted
// - Application works without Modbus device or SQLite database
}
// T039c: Test 3 - Application::build() creates real dependencies when not in test mode
#[test]
#[ignore] // This test requires real Modbus hardware and should be run manually
fn test_application_build_uses_real_dependencies_in_production() {
// GIVEN: Production settings with real Modbus device configuration
// This test is #[ignore] because it requires actual hardware
let settings = create_test_settings();
// WHEN: Application::build() is called outside of test/CI environment
// (This would normally happen in production)
let result = std::panic::catch_unwind(|| {
Application::build(settings, None)
});
// THEN: Should attempt to create real dependencies
// In test environment, this will still use mocks due to cfg!(test)
// This test serves as documentation of the expected production behavior
assert!(
result.is_ok(),
"Application::build() should handle dependency creation"
);
// TODO (T039c implementation): After implementation, verify that:
// - Real ModbusRelayController is created when hardware is available
// - Real SqliteRelayLabelRepository is created
// - Graceful fallback to mock if hardware connection fails (FR-023)
let runnable_app = app.make_app();
let _app: App = runnable_app.into();
// Success - the application was built with dependencies and can run
}
// ============================================================================
@@ -364,57 +279,51 @@ mod tests {
// These tests verify that the RelayApi is properly registered in the route
// aggregator with correct OpenAPI tagging.
// T039d: Test 1 - OpenAPI spec includes /api/relays endpoints
#[test]
fn test_openapi_spec_includes_relay_endpoints() {
// GIVEN: An application with all routes configured
// T039d: Test 1 - OpenAPI spec includes /relays endpoints
#[tokio::test]
async fn test_openapi_spec_includes_relay_endpoints() {
let settings = create_test_settings();
let app = Application::build(settings, None);
let _runnable_app = app.make_app();
let app: App = Application::build(settings, None)
.await
.unwrap()
.make_app()
.into();
let cli = poem::test::TestClient::new(app);
// WHEN: The application is built and routes are set up
// (OpenAPI service is created in setup_app)
let resp = cli.get("/specs").send().await;
resp.assert_status_is_ok();
// THEN: OpenAPI spec should include relay endpoints
// TODO (T039d implementation): After implementation, verify that:
// - GET /api/relays endpoint exists in spec
// - POST /api/relays/{id}/toggle endpoint exists in spec
// - POST /api/relays/all/on endpoint exists in spec
// - POST /api/relays/all/off endpoint exists in spec
// - PUT /api/relays/{id}/label endpoint exists in spec
//
// This can be verified by:
// 1. Extracting the OpenAPI spec from the app
// 2. Parsing the spec JSON/YAML
// 3. Checking for the presence of these paths
let spec = resp.0.into_body().into_string().await.unwrap();
// For now, this test passes if the application builds successfully
// Full verification will be added during T039d implementation
assert!(
spec.contains("/relays:"),
"OpenAPI spec should include the /relays path, got:\n{spec}"
);
assert!(
spec.contains("/relays/{id}/toggle:"),
"OpenAPI spec should include the /relays/{{id}}/toggle path, got:\n{spec}"
);
}
// T039d: Test 2 - Swagger UI renders Relays tag
#[test]
fn test_swagger_ui_includes_relays_tag() {
// GIVEN: An application with RelayApi registered
// T039d: Test 2 - OpenAPI spec includes the Relays tag
#[tokio::test]
async fn test_swagger_ui_includes_relays_tag() {
let settings = create_test_settings();
let app = Application::build(settings, None);
let _runnable_app = app.make_app();
let app: App = Application::build(settings, None)
.await
.unwrap()
.make_app()
.into();
let cli = poem::test::TestClient::new(app);
// WHEN: The application is built with OpenAPI service
let resp = cli.get("/specs").send().await;
resp.assert_status_is_ok();
// THEN: Swagger UI should include "Relays" tag
// TODO (T039d implementation): After implementation, verify that:
// - OpenAPI spec includes a "Relays" tag
// - All relay endpoints are grouped under this tag
// - Tag has appropriate description
//
// This can be verified by:
// 1. Extracting the OpenAPI spec
// 2. Checking the "tags" section for "Relays"
// 3. Verifying relay endpoints reference this tag
let spec = resp.0.into_body().into_string().await.unwrap();
// For now, this test passes if the application builds successfully
// Full verification will be added during T039d implementation
assert!(
spec.contains("Relays"),
"OpenAPI spec should include a 'Relays' tag, got:\n{spec}"
);
}
}

271
backend/tests/contract/test_relay_api.rs Normal file
View File

@@ -0,0 +1,271 @@
//! Contract tests for the Relay API HTTP endpoints.
//!
//! - **T048**: `GET /api/relays` contract tests
//! - **T050**: `POST /api/relays/:id/toggle` contract tests
use std::sync::Arc;
use poem::{http::StatusCode, test::TestClient};
use poem_openapi::OpenApiService;
use sta::{
domain::relay::{
controller::RelayController,
repository::RelayLabelRepository,
types::{RelayId, RelayLabel, RelayState},
},
infrastructure::{
modbus::mock_controller::MockRelayController,
persistence::label_repository::MockRelayLabelRepository,
},
presentation::api::relay_api::RelayApi,
};
// -- Helpers --
fn build_test_client(
controller: Arc<MockRelayController>,
repo: Arc<MockRelayLabelRepository>,
) -> TestClient<impl poem::Endpoint> {
let relay_api = RelayApi::new(controller, repo);
let api_service = OpenApiService::new(relay_api, "STA", "0.1");
let app = poem::Route::new().nest("/api", api_service);
TestClient::new(app)
}
/// Creates a controller with all 8 relays initialised to `Off`.
async fn all_relays_off() -> Arc<MockRelayController> {
let controller = Arc::new(MockRelayController::new());
for id in 1u8..=8 {
controller
.write_relay_state(RelayId::new(id).unwrap(), RelayState::Off)
.await
.unwrap();
}
controller
}
// ===========================================================================
// T048: GET /api/relays
// ===========================================================================
/// T048 – Returns 200 OK.
#[tokio::test]
async fn get_all_relays_returns_200() {
let cli = build_test_client(all_relays_off().await, Arc::new(MockRelayLabelRepository::new()));
let resp = cli.get("/api/relays").send().await;
resp.assert_status_is_ok();
}
/// T048 – Returns an array of exactly 8 `RelayDto` objects.
#[tokio::test]
async fn get_all_relays_returns_array_of_8_relay_dtos() {
let cli = build_test_client(all_relays_off().await, Arc::new(MockRelayLabelRepository::new()));
let resp = cli.get("/api/relays").send().await;
resp.assert_status_is_ok();
let body: Vec<serde_json::Value> = resp.json().await.value().deserialize();
assert_eq!(body.len(), 8, "Expected 8 relays, got {}", body.len());
}
/// T048 – Relay IDs are 1 through 8, in ascending order.
#[tokio::test]
async fn get_all_relays_relay_ids_are_1_to_8_in_order() {
let cli = build_test_client(all_relays_off().await, Arc::new(MockRelayLabelRepository::new()));
let resp = cli.get("/api/relays").send().await;
let body: Vec<serde_json::Value> = resp.json().await.value().deserialize();
for (index, relay) in body.iter().enumerate() {
let expected_id = index + 1;
assert_eq!(
relay["id"], expected_id,
"Relay at index {index} should have id {expected_id}"
);
}
}
/// T048 – Every relay has a `state` field that is either `"on"` or `"off"`.
#[tokio::test]
async fn get_all_relays_each_relay_has_valid_state_field() {
let cli = build_test_client(all_relays_off().await, Arc::new(MockRelayLabelRepository::new()));
let resp = cli.get("/api/relays").send().await;
let body: Vec<serde_json::Value> = resp.json().await.value().deserialize();
for relay in &body {
let state = relay["state"].as_str().expect("state should be a string");
assert!(
state == "on" || state == "off",
"state must be 'on' or 'off', got '{state}'"
);
}
}
/// T048 – Every relay has a `label` field (string).
#[tokio::test]
async fn get_all_relays_each_relay_has_label_field() {
let cli = build_test_client(all_relays_off().await, Arc::new(MockRelayLabelRepository::new()));
let resp = cli.get("/api/relays").send().await;
let body: Vec<serde_json::Value> = resp.json().await.value().deserialize();
for relay in &body {
assert!(relay["label"].is_string(), "label should be a string field");
}
}
/// T048 – Relay states in the response match the controller's actual states.
#[tokio::test]
async fn get_all_relays_states_reflect_controller_state() {
let controller = all_relays_off().await;
controller
.write_relay_state(RelayId::new(1).unwrap(), RelayState::On)
.await
.unwrap();
controller
.write_relay_state(RelayId::new(3).unwrap(), RelayState::On)
.await
.unwrap();
let cli = build_test_client(controller, Arc::new(MockRelayLabelRepository::new()));
let resp = cli.get("/api/relays").send().await;
let body: Vec<serde_json::Value> = resp.json().await.value().deserialize();
assert_eq!(body[0]["state"], "on", "Relay 1 should be on");
assert_eq!(body[1]["state"], "off", "Relay 2 should be off");
assert_eq!(body[2]["state"], "on", "Relay 3 should be on");
assert_eq!(body[3]["state"], "off", "Relay 4 should be off");
}
/// T048 – A relay with a persisted label returns that label.
#[tokio::test]
async fn get_all_relays_relay_with_label_returns_label() {
let repo = Arc::new(MockRelayLabelRepository::new());
repo.save_label(
RelayId::new(2).unwrap(),
RelayLabel::new("Water Pump".to_string()).unwrap(),
)
.await
.unwrap();
let cli = build_test_client(all_relays_off().await, repo);
let resp = cli.get("/api/relays").send().await;
let body: Vec<serde_json::Value> = resp.json().await.value().deserialize();
assert_eq!(body[1]["label"], "Water Pump");
}
// ===========================================================================
// T050: POST /api/relays/:id/toggle
// ===========================================================================
/// T050 – Returns 200 OK with a `RelayDto` body.
#[tokio::test]
async fn toggle_relay_returns_200_with_relay_dto() {
let cli = build_test_client(all_relays_off().await, Arc::new(MockRelayLabelRepository::new()));
let resp = cli.post("/api/relays/1/toggle").send().await;
resp.assert_status_is_ok();
let body: serde_json::Value = resp.json().await.value().deserialize();
assert!(body["id"].is_number());
assert!(body["state"].is_string());
assert!(body["label"].is_string());
}
/// T050 – Returns 404 for relay id 0 (below valid range).
#[tokio::test]
async fn toggle_relay_returns_404_for_id_below_range() {
let cli = build_test_client(all_relays_off().await, Arc::new(MockRelayLabelRepository::new()));
let resp = cli.post("/api/relays/0/toggle").send().await;
resp.assert_status(StatusCode::NOT_FOUND);
}
/// T050 – Returns 404 for relay id 9 (above valid range).
#[tokio::test]
async fn toggle_relay_returns_404_for_id_above_range() {
let cli = build_test_client(all_relays_off().await, Arc::new(MockRelayLabelRepository::new()));
let resp = cli.post("/api/relays/9/toggle").send().await;
resp.assert_status(StatusCode::NOT_FOUND);
}
/// T050 – State changes from `Off` to `On` and response reflects new state.
#[tokio::test]
async fn toggle_relay_off_to_on_response_shows_on() {
let cli = build_test_client(all_relays_off().await, Arc::new(MockRelayLabelRepository::new()));
let resp = cli.post("/api/relays/1/toggle").send().await;
resp.assert_status_is_ok();
let body: serde_json::Value = resp.json().await.value().deserialize();
assert_eq!(body["state"], "on");
}
/// T050 – State changes from `On` to `Off` and response reflects new state.
#[tokio::test]
async fn toggle_relay_on_to_off_response_shows_off() {
let controller = Arc::new(MockRelayController::new());
controller
.write_relay_state(RelayId::new(5).unwrap(), RelayState::On)
.await
.unwrap();
let cli = build_test_client(controller, Arc::new(MockRelayLabelRepository::new()));
let resp = cli.post("/api/relays/5/toggle").send().await;
resp.assert_status_is_ok();
let body: serde_json::Value = resp.json().await.value().deserialize();
assert_eq!(body["state"], "off");
}
/// T050 – State actually changes in the underlying controller, not just in the response.
#[tokio::test]
async fn toggle_relay_state_actually_changes_in_controller() {
let controller = all_relays_off().await;
let relay_id = RelayId::new(3).unwrap();
let cli = build_test_client(controller.clone(), Arc::new(MockRelayLabelRepository::new()));
cli.post("/api/relays/3/toggle").send().await;
let state = controller.read_relay_state(relay_id).await.unwrap();
assert_eq!(state, RelayState::On, "Relay 3 should be On in the controller after toggle");
}
/// T050 – Response includes the correct relay id.
#[tokio::test]
async fn toggle_relay_response_includes_correct_relay_id() {
let cli = build_test_client(all_relays_off().await, Arc::new(MockRelayLabelRepository::new()));
let resp = cli.post("/api/relays/4/toggle").send().await;
resp.assert_status_is_ok();
let body: serde_json::Value = resp.json().await.value().deserialize();
assert_eq!(body["id"], 4);
}
/// T050 – Response includes a persisted label.
#[tokio::test]
async fn toggle_relay_response_includes_label_when_set() {
let repo = Arc::new(MockRelayLabelRepository::new());
repo.save_label(
RelayId::new(6).unwrap(),
RelayLabel::new("Heater".to_string()).unwrap(),
)
.await
.unwrap();
let cli = build_test_client(all_relays_off().await, repo);
let resp = cli.post("/api/relays/6/toggle").send().await;
resp.assert_status_is_ok();
let body: serde_json::Value = resp.json().await.value().deserialize();
assert_eq!(body["label"], "Heater");
}

22
backend/tests/cors_test.rs
View File

@@ -13,7 +13,7 @@ use poem::test::TestClient;
use sta::{settings::Settings, startup::Application};
/// Helper function to create a test app with custom CORS settings.
fn get_test_app_with_cors(
async fn get_test_app_with_cors(
allowed_origins: Vec<String>,
allow_credentials: bool,
max_age_secs: i32,
@@ -32,6 +32,8 @@ fn get_test_app_with_cors(
settings.cors.max_age_secs = max_age_secs;
Application::build(settings, Some(listener))
.await
.expect("Failed to build application")
.make_app()
.into()
}
@@ -42,7 +44,7 @@ fn get_test_app_with_cors(
#[tokio::test]
async fn preflight_request_returns_cors_headers() {
// GIVEN: An app with CORS configured for specific origin
let app = get_test_app_with_cors(vec!["http://localhost:5173".to_string()], false, 3600);
let app = get_test_app_with_cors(vec!["http://localhost:5173".to_string()], false, 3600).await;
let client = TestClient::new(app);
// WHEN: A preflight OPTIONS request is sent with Origin header
@@ -82,7 +84,7 @@ async fn preflight_request_returns_cors_headers() {
#[tokio::test]
async fn get_request_with_origin_returns_allow_origin_header() {
// GIVEN: An app with CORS configured for specific origin
let app = get_test_app_with_cors(vec!["http://localhost:5173".to_string()], false, 3600);
let app = get_test_app_with_cors(vec!["http://localhost:5173".to_string()], false, 3600).await;
let client = TestClient::new(app);
// WHEN: A GET request is sent with Origin header
@@ -119,7 +121,7 @@ async fn preflight_response_includes_max_age_from_config() {
vec!["http://localhost:5173".to_string()],
false,
custom_max_age,
);
).await;
let client = TestClient::new(app);
// WHEN: A preflight OPTIONS request is sent
@@ -153,7 +155,7 @@ async fn response_includes_allow_credentials_when_configured() {
vec!["http://localhost:5173".to_string()],
true, // allow_credentials
3600,
);
).await;
let client = TestClient::new(app);
// WHEN: A preflight OPTIONS request is sent
@@ -187,7 +189,7 @@ async fn response_does_not_include_credentials_when_disabled() {
vec!["http://localhost:5173".to_string()],
false, // allow_credentials
3600,
);
).await;
let client = TestClient::new(app);
// WHEN: A preflight OPTIONS request is sent
@@ -217,7 +219,7 @@ async fn response_does_not_include_credentials_when_disabled() {
#[tokio::test]
async fn preflight_response_includes_correct_allowed_methods() {
// GIVEN: An app with CORS configured
let app = get_test_app_with_cors(vec!["http://localhost:5173".to_string()], false, 3600);
let app = get_test_app_with_cors(vec!["http://localhost:5173".to_string()], false, 3600).await;
let client = TestClient::new(app);
// WHEN: A preflight OPTIONS request is sent
@@ -260,7 +262,7 @@ async fn wildcard_origin_works_with_credentials_disabled() {
vec!["*".to_string()],
false, // credentials MUST be false with wildcard
3600,
);
).await;
let client = TestClient::new(app);
// WHEN: A preflight OPTIONS request is sent with any origin
@@ -299,7 +301,7 @@ async fn multiple_origins_are_supported() {
],
false,
3600,
);
).await;
let client = TestClient::new(app);
// WHEN: A request is sent with the first origin
@@ -341,7 +343,7 @@ async fn multiple_origins_are_supported() {
#[tokio::test]
async fn unauthorized_origin_is_rejected() {
// GIVEN: An app with CORS configured for specific origins only
let app = get_test_app_with_cors(vec!["http://localhost:5173".to_string()], false, 3600);
let app = get_test_app_with_cors(vec!["http://localhost:5173".to_string()], false, 3600).await;
let client = TestClient::new(app);
// WHEN: A request is sent with an unauthorized origin

9
backend/tests/sqlite_repository_functional_test.rs
View File

@@ -427,7 +427,10 @@ async fn test_repository_error_handling() {
// Test with invalid relay ID (should be caught by domain validation)
let invalid_relay_id = RelayId::new(9); // This will fail validation
assert!(invalid_relay_id.is_err(), "Invalid relay ID should fail validation");
assert!(
invalid_relay_id.is_err(),
"Invalid relay ID should fail validation"
);
// Test with invalid label (should be caught by domain validation)
let invalid_label = RelayLabel::new("".to_string()); // Empty label
@@ -444,7 +447,7 @@ async fn test_concurrent_operations_are_thread_safe() {
// Since SqliteRelayLabelRepository doesn't implement Clone, we'll test
// sequential operations which still verify the repository handles
// multiple operations correctly
// Save multiple labels sequentially
let relay_id1 = RelayId::new(1).expect("Valid relay ID");
let label1 = RelayLabel::new("Task1".to_string()).expect("Valid label");
@@ -470,4 +473,4 @@ async fn test_concurrent_operations_are_thread_safe() {
.await
.expect("get_all_labels should succeed");
assert_eq!(all_labels.len(), 3, "Should have all 3 labels");
}
}

1
justfile
View File

@@ -30,6 +30,7 @@ release-build:
release-run:
cargo run --release
[env("SQLX_OFFLINE", "1")]
test:
cargo test --all --all-targets

141
specs/001-modbus-relay-control/tasks.org
View File

@@ -1,6 +1,7 @@
#+title: Implementation Tasks: Modbus Relay Control System
#+author: Lucien Cartier-Tilet
#+email: lucien@phundrak.com
#+startup: content align hideblocks
#+options: ^:nil
#+LATEX_CLASS_OPTIONS: [a4paper,10pt]
#+LATEX_HEADER: \makeatletter \@ifpackageloaded{geometry}{\geometry{margin=2cm}}{\usepackage[margin=2cm]{geometry}} \makeatother
@@ -586,7 +587,7 @@ CLOSED: [2026-01-22 jeu. 00:02]
--------------
** STARTED Phase 4: US1 - Monitor & Toggle Relay States (MVP) (2 days) [2/5]
** STARTED Phase 4: US1 - Monitor & Toggle Relay States (MVP) (2 days) [3/5]
- State "STARTED" from "TODO" [2026-01-23 ven. 20:20]
*Goal*: View current state of all 8 relays + toggle individual relay on/off
@@ -616,9 +617,9 @@ CLOSED: [2026-01-23 ven. 20:42]
- *File*: =src/application/use_cases/get_all_relays.rs=
- *Complexity*: Low | *Uncertainty*: Low
*** DONE Presentation Layer (Backend API) [2/2]
CLOSED: [2026-03-01 dim. 11:07]
- State "DONE" from "STARTED" [2026-03-01 dim. 11:07]
*** DONE Presentation Layer (Backend API) [3/3]
CLOSED: [2026-05-14 jeu. 18:43]
- State "DONE" from "TODO" [2026-05-14 jeu. 18:43]
- State "STARTED" from "TODO" [2026-01-23 ven. 20:42]
- [X] *T045* [US1] [TDD] Define =RelayDto= in presentation layer
- Fields: =id= (=u8=), =state= ("on"/"off"), =label= (=Option=)
@@ -630,15 +631,94 @@ CLOSED: [2026-03-01 dim. 11:07]
- Implement =poem::error::ResponseError=
- *File*: =src/presentation/error.rs=
- *Complexity*: Low | *Uncertainty*: Low
- [X] *T047* [US1] [TDD] Create =RelayApi= struct with dependency injection
- Create =RelayApi= struct that holds dependencies:
- =relay_controller: Arc<dyn RelayController>=
- =label_repository: Arc<dyn RelayLabelRepository>=
- Implement constructor: =RelayApi::new(controller, repository) -> Self=
- Add =#[derive(Clone)]= to allow sharing across poem-openapi
- *File*: =src/presentation/api/relay_api.rs= or =src/route/relay.rs=
- *Complexity*: Low | *Uncertainty*: Low
*TDD Checklist*:
- [ ] Test: =RelayApi::new()= creates instance with provided dependencies
- [ ] Test: =RelayApi= can be cloned (required for poem-openapi)
- [ ] Test: Constructor stores both controller and repository
*Pseudocode*:
#+begin_src rust
use std::sync::Arc;
use crate::domain::relay::{
controller::RelayController,
repository::RelayLabelRepository,
};
/// API handler for relay control endpoints.
///
/// This struct holds the dependencies needed for relay operations
/// and implements the poem-openapi handlers.
#[derive(Clone)]
pub struct RelayApi {
relay_controller: Arc<dyn RelayController>,
label_repository: Arc<dyn RelayLabelRepository>,
}
impl RelayApi {
/// Creates a new RelayApi with the provided dependencies.
///
/// # Arguments
///
/// * `relay_controller` - Controller for reading/writing relay states
/// * `label_repository` - Repository for managing relay labels
pub fn new(
relay_controller: Arc<dyn RelayController>,
label_repository: Arc<dyn RelayLabelRepository>,
) -> Self {
Self {
relay_controller,
label_repository,
}
}
}6 lerolero 7
#[cfg(test)]
mod tests {
use super::*;
use crate::infrastructure::modbus::MockRelayController;
use crate::infrastructure::persistence::MockLabelRepository;
#[test]
fn test_relay_api_new_creates_instance() {
// GIVEN: Mock dependencies
let controller = Arc::new(MockRelayController::new());
let repository = Arc::new(MockLabelRepository::new());
// WHEN: Creating RelayApi
let api = RelayApi::new(controller.clone(), repository.clone());
// THEN: Instance is created successfully
// Verify by checking that we can clone it (required for poem-openapi)
let _cloned_api = api.clone();
}
}
#+end_src
*Note*: After this task, T048-T051 will add endpoint methods to this struct.
--------------
*** TODO T039: Dependency Injection Setup (DECOMPOSED) [0/8]
*** DONE T039: Dependency Injection Setup (DECOMPOSED) [8/8]
CLOSED: [2026-05-14 jeu. 20:09]
- State "DONE" from "STARTED" [2026-05-14 jeu. 20:09]
- State "STARTED" from "TODO" [2026-03-06 ven. 22:11]
- Complexity :: High → Broken into 4 sub-tasks
- Uncertainty :: Medium
- Rationale :: Graceful degradation (FR-023), conditional mock/real controller
- Prerequisites :: T047 (RelayApi struct) must be complete before T039c
- [ ] *T039a* [US1] [TDD] Create =ModbusRelayController= factory with retry and fallback
- [X] *T039a* [US1] [TDD] Create =ModbusRelayController= factory with retry and fallback
- Factory function: ~create_relay_controller(settings, use_mock) => Arc~
- Retry 3 times with 2s backoff on connection failure
@@ -694,13 +774,12 @@ CLOSED: [2026-03-01 dim. 11:07]
*TDD Checklist*:
- [ ] Test: use_mock=true returns =MockRelayController= immediately
- [ ] Test: Successful connection returns =ModbusRelayController=
- [ ] Test: Connection failure after 3 retries returns =MockRelayController=
- [ ] Test: Retry delays are 2 seconds between attempts
- [ ] Test: Logs appropriate messages for each connection attempt
- [ ] *T039b* [US4] [TDD] Create =RelayLabelRepositor=y factory
- [X] Test: ~use_mock=true~ returns =MockRelayController= immediately
- [X] Test: Successful connection returns =ModbusRelayController=
- [X] Test: Connection failure after 3 retries returns =MockRelayController=
- [X] Test: Retry delays are 2 seconds between attempts
- [X] Test: Logs appropriate messages for each connection attempt
- [X] *T039b* [US4] [TDD] Create =RelayLabelRepository= factory
- Factory function: ~create_label_repository(db_path, use_mock) => Arc~
- If use_mock: return =MockLabelRepository=
@@ -727,17 +806,19 @@ CLOSED: [2026-03-01 dim. 11:07]
*TDD Checklist*:
- [ ] Test: use_mock=true returns =MockLabelRepository=
- [ ] Test: use_mock=false returns =SQLiteLabelRepository=
- [ ] Test: Invalid =db_path= returns =RepositoryError=
- [ ] *T039c* [US1] [TDD] Wire dependencies in =Application::build()=
- [X] Test: use_mock=true returns =MockLabelRepository=
- [X] Test: use_mock=false returns =SQLiteLabelRepository=
- [X] Test: Invalid =db_path= returns =RepositoryError=
- [X] *T039c* [US1] [TDD] Wire dependencies in =Application::build()=
- *Prerequisites*: T047 must be complete (RelayApi struct created)
- Determine test mode: ~cfg!(test) || env::var("CI").is_ok()~
- Call =create_relay_controller()= and =create_label_repository()=
- Pass dependencies to =RelayApi::new()=
- Create =RelayApi= instance with dependencies (requires T047)
- Pass =RelayApi= to OpenAPI service
- *File*: =src/startup.rs=
- *Complexity*: Medium | *Uncertainty*: Low
- *Note*: Tests for T039c have been written (they currently pass trivially)
*Pseudocode*:
@@ -772,12 +853,10 @@ CLOSED: [2026-03-01 dim. 11:07]
*TDD Checklist*:
- [ ] Test: =Application::build()= succeeds in test mode
- [ ] Test: =Application::build()= creates correct mock dependencies when CI=true
- [ ] Test: =Application::build()= creates real dependencies when not in test mode
- [ ] *T039d* [US1] [TDD] Register =RelayApi= in route aggregator
- [X] Test: =Application::build()= succeeds in test mode
- [X] Test: =Application::build()= creates correct mock dependencies when CI=true
- [X] Test: =Application::build()= creates real dependencies when not in test mode
- [X] *T039d* [US1] [TDD] Register =RelayApi= in route aggregator
- Add =RelayApi= to OpenAPI service
- Tag: "Relays"
- *File*: =src/startup.rs=
@@ -785,28 +864,28 @@ CLOSED: [2026-03-01 dim. 11:07]
*TDD Checklist*:
- [ ] Test: OpenAPI spec includes =/api/relays= endpoints
- [ ] Test: Swagger UI renders =Relays= tag
- [X] Test: OpenAPI spec includes =/api/relays= endpoints
- [X] Test: Swagger UI renders =Relays= tag
--------------
- [ ] *T048* [US1] [TDD] Write contract tests for =GET /api/relays=
- [X] *T048* [US1] [TDD] Write contract tests for =GET /api/relays=
- Test: Returns 200 with array of 8 =RelayDto=
- Test: Each relay has id 1-8, state, and optional label
- *File*: =tests/contract/test_relay_api.rs=
- *Complexity*: Low | *Uncertainty*: Low
- [ ] *T049* [US1] [TDD] Implement =GET /api/relays= endpoint
- [X] *T049* [US1] [TDD] Implement =GET /api/relays= endpoint
- ~#[oai(path = "/relays", method = "get")]~
- Call =GetAllRelaysUseCase=, map to =RelayDto=
- *File*: =src/presentation/api/relay_api.rs=
- *Complexity*: Low | *Uncertainty*: Low
- [ ] *T050* [US1] [TDD] Write contract tests for =POST /api/relays/{id}/toggle=
- [X] *T050* [US1] [TDD] Write contract tests for =POST /api/relays/{id}/toggle=
- Test: Returns 200 with updated =RelayDto=
- Test: Returns 404 for id < 1 or id > 8
- Test: State actually changes in controller
- *File*: =tests/contract/test_relay_api.rs=
- *Complexity*: Low | *Uncertainty*: Low
- [ ] *T051* [US1] [TDD] Implement =POST /api/relays/{id}/toggle= endpoint
- [X] *T051* [US1] [TDD] Implement =POST /api/relays/{id}/toggle= endpoint
- ~#[oai(path = "/relays/:id/toggle", method = "post")]~
- Parse id, call =ToggleRelayUseCase=, return updated state
- *File*: =src/presentation/api/relay_api.rs=