// Verifying that our API spec is in sync with the implementation // Manually generated from the OpenAPI spec but it should still flag when we get out of sync and need to update. use primitive_types::U512; use quantus_miner::*; use resonance_miner_api::*; // Use the shared API types use serde_json::json; use warp::test::request; use warp::Filter; // For sending custom/invalid JSON // Helper function to setup the routes with a fresh state for each test fn setup_routes() -> ( MiningState, impl Filter + Clone, ) { let state = MiningState::new(); let state_clone = state.clone(); let state_filter = warp::any().map(move || state_clone.clone()); let mine_route = warp::post() .and(warp::path("mine")) .and(warp::body::json::()) // Expect valid MiningRequest .and(state_filter.clone()) .and_then(handle_mine_request); let result_route = warp::get() .and(warp::path("result")) .and(warp::path::param::()) .and(state_filter.clone()) .and_then(handle_result_request); let cancel_route = warp::post() .and(warp::path("cancel")) .and(warp::path::param::()) .and(state_filter.clone()) .and_then(handle_cancel_request); let routes = mine_route.or(result_route).or(cancel_route); (state, routes) } // --- /mine Endpoint Tests --- #[tokio::test] async fn spec_mine_valid_request() { let (_state, routes) = setup_routes(); let valid_req = MiningRequest { job_id: "job-valid-1".to_string(), mining_hash: "a".repeat(64), distance_threshold: "12345".to_string(), nonce_start: "0".repeat(128), nonce_end: "f".repeat(128), }; let resp = request() .method("POST") .path("/mine") .json(&valid_req) .reply(&routes) .await; // Spec: 200 OK, response matches MiningResponseAccepted assert_eq!( resp.status(), 200, "Spec requires 200 OK for valid /mine request" ); let body: MiningResponse = serde_json::from_slice(resp.body()) .expect("Valid response should deserialize to MiningResponse"); assert_eq!( body.status, ApiResponseStatus::Accepted, "Spec requires status 'accepted'" ); assert_eq!(body.job_id, valid_req.job_id); assert!( body.message.is_none(), "Spec shows no message field for success" ); } #[tokio::test] async fn spec_mine_duplicate_job_id() { let (state, routes) = setup_routes(); let valid_req = MiningRequest { job_id: "job-duplicate-1".to_string(), mining_hash: "b".repeat(64), distance_threshold: "54321".to_string(), nonce_start: "1".repeat(128), nonce_end: "e".repeat(128), }; // Add the job first let job = MiningJob::new( hex::decode(valid_req.mining_hash.clone()) .unwrap() .try_into() .unwrap(), U512::from_dec_str(&valid_req.distance_threshold).unwrap(), U512::from_str_radix(&valid_req.nonce_start, 16).unwrap(), U512::from_str_radix(&valid_req.nonce_end, 16).unwrap(), ); state.add_job(valid_req.job_id.clone(), job).await.unwrap(); // Try to submit again let resp = request() .method("POST") .path("/mine") .json(&valid_req) .reply(&routes) .await; // Spec: 409 Conflict, response matches MiningResponseError assert_eq!( resp.status(), 409, "Spec requires 409 Conflict for duplicate job ID" ); let body: MiningResponse = serde_json::from_slice(resp.body()) .expect("Valid error response should deserialize to MiningResponse"); assert_eq!( body.status, ApiResponseStatus::Error, "Spec requires status 'error'" ); assert!( body.message.is_some(), "Spec requires message field for error" ); assert!(body.message.unwrap().contains("Job already exists")); assert_eq!(body.job_id, valid_req.job_id); } // Test cases for invalid formats (hash length, nonce length, difficulty non-numeric) // These should ideally result in 400 Bad Request #[tokio::test] async fn spec_mine_invalid_hash_format() { let (_state, routes) = setup_routes(); let invalid_req = json!({ "job_id": "job-invalid-hash", "mining_hash": "a".repeat(63), // Too short "distance_threshold": "1000", "nonce_start": "0".repeat(128), "nonce_end": "f".repeat(128) }); let resp = request() .method("POST") .path("/mine") .json(&invalid_req) .reply(&routes) .await; // Spec: 400 Bad Request, response matches MiningResponseError assert_eq!( resp.status(), 400, "Spec requires 400 Bad Request for invalid hash format" ); let body: MiningResponse = serde_json::from_slice(resp.body()).expect("Error response should deserialize"); assert_eq!(body.status, ApiResponseStatus::Error); assert!(body.message.is_some()); assert!(body .message .unwrap() .contains("mining_hash must be 64 hex characters")); } // Add similar tests for invalid nonce_start, nonce_end, difficulty format... #[tokio::test] async fn spec_mine_missing_required_field() { let (_state, routes) = setup_routes(); // Missing 'difficulty' let invalid_req = json!({ "job_id": "job-missing-field", "mining_hash": "c".repeat(64), "nonce_start": "0".repeat(128), "nonce_end": "f".repeat(128) }); let resp = request() .method("POST") .path("/mine") .json(&invalid_req) .reply(&routes) .await; // Warp's default JSON body deserialization handles missing fields // It should return 400 Bad Request based on warp::body::json() assert_eq!( resp.status(), 400, "Spec requires 400 Bad Request for missing required field" ); // The body might be a plain text error from Warp, not necessarily our JSON structure // We can check if the body indicates a deserialization error let body_bytes = resp.body(); let body_string = String::from_utf8_lossy(body_bytes); assert!( body_string.contains("Failed to deserialize") || body_string.contains("missing field"), "Response body should indicate deserialization failure" ); } // --- /result/{job_id} Endpoint Tests --- #[tokio::test] async fn spec_result_job_running() { let (state, routes) = setup_routes(); let job_id = "job-running-1".to_string(); // Add a job let job = MiningJob::new([1u8; 32], U512::from(1000), U512::from(0), U512::from(1000)); state.add_job(job_id.clone(), job).await.unwrap(); let resp = request() .method("GET") .path(&format!("/result/{}", job_id)) .reply(&routes) .await; // Spec: 200 OK, response matches MiningResult with status 'running' assert_eq!(resp.status(), 200); let body: MiningResult = serde_json::from_slice(resp.body()).expect("Should deserialize to MiningResult"); assert_eq!(body.status, ApiResponseStatus::Running); assert_eq!(body.job_id, job_id); assert!(body.nonce.is_none()); // Should be none initially assert!(body.work.is_none()); // No work yet // hash_count and elapsed_time should be present // assert_eq!(body.hash_count, 0); // Initial state // assert!(body.elapsed_time >= 0.0); } // Add tests for spec_result_job_completed, spec_result_job_failed (need to manipulate state) // Need to carefully simulate a completed/failed state or run miner loop briefly #[tokio::test] async fn spec_result_job_not_found() { let (_state, routes) = setup_routes(); let job_id = "job-not-found-1"; let resp = request() .method("GET") .path(&format!("/result/{}", job_id)) .reply(&routes) .await; // Spec: 404 Not Found, response matches MiningResultNotFound assert_eq!(resp.status(), 404); let body: MiningResult = serde_json::from_slice(resp.body()) .expect("Should deserialize to MiningResult (NotFound variant)"); assert_eq!(body.status, ApiResponseStatus::NotFound); assert_eq!(body.job_id, job_id); assert!(body.nonce.is_none()); assert!(body.work.is_none()); assert_eq!(body.hash_count, 0); assert_eq!(body.elapsed_time, 0.0); } // --- /cancel/{job_id} Endpoint Tests --- #[tokio::test] async fn spec_cancel_existing_job() { let (state, routes) = setup_routes(); let job_id = "job-cancel-1".to_string(); let job = MiningJob::new([2u8; 32], U512::from(1000), U512::from(0), U512::from(1000)); state.add_job(job_id.clone(), job).await.unwrap(); let resp = request() .method("POST") .path(&format!("/cancel/{}", job_id)) .reply(&routes) .await; // Spec: 200 OK, response matches MiningResponseCancelled assert_eq!(resp.status(), 200); let body: MiningResponse = serde_json::from_slice(resp.body()).expect("Should deserialize to MiningResponse"); assert_eq!(body.status, ApiResponseStatus::Cancelled); assert_eq!(body.job_id, job_id); assert!(body.message.is_none()); // Verify job is actually cancelled let job = state.get_job(&job_id).await.unwrap(); assert_eq!(job.status, JobStatus::Cancelled); } #[tokio::test] async fn spec_cancel_non_existent_job() { let (_state, routes) = setup_routes(); let job_id = "job-cancel-not-found-1"; let resp = request() .method("POST") .path(&format!("/cancel/{}", job_id)) .reply(&routes) .await; // Spec: 404 Not Found, response matches MiningResponseNotFound assert_eq!(resp.status(), 404); let body: MiningResponse = serde_json::from_slice(resp.body()) .expect("Should deserialize to MiningResponse (NotFound variant)"); assert_eq!(body.status, ApiResponseStatus::NotFound); assert_eq!(body.job_id, job_id); assert!(body.message.is_some()); } // Removed placeholder test