Merge pull request #20 from cuteolaf/test/platform-server

test(platform-server): add comprehensive unit tests

Author: echobt

crates/platform-server/src/data_api.rs

@@ -266,3 +266,78 @@ pub async fn get_snapshot(
         total_stake,
     }))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_now_returns_timestamp() {
+        let timestamp = now();
+        // Should be a reasonable Unix timestamp (after 2020)
+        assert!(timestamp > 1577836800); // Jan 1, 2020
+        // Should be less than far future (year 2100)
+        assert!(timestamp < 4102444800); // Jan 1, 2100
+    }
+
+    #[test]
+    fn test_now_increases() {
+        let t1 = now();
+        std::thread::sleep(std::time::Duration::from_millis(10));
+        let t2 = now();
+        assert!(t2 >= t1);
+    }
+
+    #[test]
+    fn test_list_tasks_query_default_limit() {
+        let query = ListTasksQuery { limit: None };
+        assert_eq!(query.limit, None);
+    }
+
+    #[test]
+    fn test_list_tasks_query_with_limit() {
+        let query = ListTasksQuery { limit: Some(50) };
+        assert_eq!(query.limit, Some(50));
+    }
+
+    #[test]
+    fn test_snapshot_query_default_epoch() {
+        let query = SnapshotQuery { epoch: None };
+        assert_eq!(query.epoch, None);
+    }
+
+    #[test]
+    fn test_snapshot_query_with_epoch() {
+        let query = SnapshotQuery { epoch: Some(100) };
+        assert_eq!(query.epoch, Some(100));
+    }
+
+    #[test]
+    fn test_snapshot_response_serialization() {
+        let response = SnapshotResponse {
+            epoch: 10,
+            snapshot_time: 1234567890,
+            leaderboard: vec![],
+            validators: vec![],
+            total_stake: 1000,
+        };
+
+        let json = serde_json::to_string(&response).unwrap();
+        assert!(json.contains("\"epoch\":10"));
+        assert!(json.contains("\"total_stake\":1000"));
+    }
+
+    #[test]
+    fn test_renew_request_deserialization() {
+        let json = r#"{
+            "validator_hotkey": "test_validator",
+            "signature": "test_sig",
+            "ttl_seconds": 300
+        }"#;
+
+        let request: RenewRequest = serde_json::from_str(json).unwrap();
+        assert_eq!(request.validator_hotkey, "test_validator");
+        assert_eq!(request.signature, "test_sig");
+        assert_eq!(request.ttl_seconds, 300);
+    }
+}

crates/platform-server/src/db/mod.rs

@@ -54,3 +54,21 @@ async fn create_pool(database_url: &str) -> Result<DbPool> {
     let pool = cfg.create_pool(Some(Runtime::Tokio1), NoTls)?;
     Ok(pool)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_db_pool_type() {
+        // Test that DbPool is correctly aliased to Pool
+        let rt = tokio::runtime::Runtime::new().unwrap();
+        rt.block_on(async {
+            let pool_result = create_pool("postgresql://localhost/test").await;
+            if let Ok(_pool) = pool_result {
+                // Pool type should match DbPool
+                let _typed: DbPool = _pool;
+            }
+        });
+    }
+}

crates/platform-server/src/db/schema.rs

@@ -218,3 +218,91 @@ INSERT INTO network_state (key, value) VALUES
     ('challenge_id', '')
 ON CONFLICT (key) DO NOTHING;
 "#;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_schema_sql_contains_tables() {
+        // Verify that the schema SQL contains all expected table definitions
+        assert!(SCHEMA_SQL.contains("CREATE TABLE IF NOT EXISTS validators"));
+        assert!(SCHEMA_SQL.contains("CREATE TABLE IF NOT EXISTS challenge_config"));
+        assert!(SCHEMA_SQL.contains("CREATE TABLE IF NOT EXISTS submissions"));
+        assert!(SCHEMA_SQL.contains("CREATE TABLE IF NOT EXISTS evaluations"));
+        assert!(SCHEMA_SQL.contains("CREATE TABLE IF NOT EXISTS leaderboard"));
+        assert!(SCHEMA_SQL.contains("CREATE TABLE IF NOT EXISTS task_leases"));
+        assert!(SCHEMA_SQL.contains("CREATE TABLE IF NOT EXISTS events"));
+        assert!(SCHEMA_SQL.contains("CREATE TABLE IF NOT EXISTS network_state"));
+        assert!(SCHEMA_SQL.contains("CREATE TABLE IF NOT EXISTS challenges"));
+        assert!(SCHEMA_SQL.contains("CREATE TABLE IF NOT EXISTS evaluation_jobs"));
+    }
+
+    #[test]
+    fn test_schema_sql_contains_indexes() {
+        // Verify that the schema SQL contains index definitions
+        assert!(SCHEMA_SQL.contains("CREATE INDEX IF NOT EXISTS idx_submissions_miner"));
+        assert!(SCHEMA_SQL.contains("CREATE INDEX IF NOT EXISTS idx_submissions_epoch"));
+        assert!(SCHEMA_SQL.contains("CREATE INDEX IF NOT EXISTS idx_evaluations_agent"));
+        assert!(SCHEMA_SQL.contains("CREATE INDEX IF NOT EXISTS idx_leaderboard_rank"));
+        assert!(SCHEMA_SQL.contains("CREATE INDEX IF NOT EXISTS idx_task_leases_validator"));
+        assert!(SCHEMA_SQL.contains("CREATE INDEX IF NOT EXISTS idx_events_type"));
+        assert!(SCHEMA_SQL.contains("CREATE INDEX IF NOT EXISTS idx_challenges_status"));
+        assert!(SCHEMA_SQL.contains("CREATE INDEX IF NOT EXISTS idx_jobs_status"));
+    }
+
+    #[test]
+    fn test_schema_sql_contains_initial_data() {
+        // Verify initial network state data
+        assert!(SCHEMA_SQL.contains("INSERT INTO network_state"));
+        assert!(SCHEMA_SQL.contains("current_epoch"));
+        assert!(SCHEMA_SQL.contains("current_block"));
+        assert!(SCHEMA_SQL.contains("total_stake"));
+        assert!(SCHEMA_SQL.contains("challenge_id"));
+    }
+
+    #[test]
+    fn test_schema_sql_contains_foreign_keys() {
+        // Verify foreign key relationships
+        assert!(SCHEMA_SQL.contains("REFERENCES submissions(id)"));
+    }
+
+    #[test]
+    fn test_schema_sql_contains_unique_constraints() {
+        // Verify unique constraints
+        assert!(SCHEMA_SQL.contains("UNIQUE(submission_id, validator_hotkey)"));
+        assert!(SCHEMA_SQL.contains("agent_hash VARCHAR(128) NOT NULL UNIQUE"));
+    }
+
+    #[test]
+    fn test_schema_sql_default_values() {
+        // Verify default values are set correctly with specific column checks
+        assert!(SCHEMA_SQL.contains("status VARCHAR(32) DEFAULT 'pending'"));
+        assert!(SCHEMA_SQL.contains("status VARCHAR(32) DEFAULT 'active'"));
+        assert!(SCHEMA_SQL.contains("is_active BOOLEAN DEFAULT TRUE"));
+        assert!(SCHEMA_SQL.contains("stake BIGINT NOT NULL DEFAULT 0"));
+        assert!(SCHEMA_SQL.contains("gpu_required BOOLEAN DEFAULT FALSE"));
+        assert!(SCHEMA_SQL.contains("is_healthy BOOLEAN DEFAULT FALSE"));
+        assert!(SCHEMA_SQL.contains("DEFAULT NOW()"));
+    }
+
+    #[test]
+    fn test_schema_sql_jsonb_fields() {
+        // Verify JSONB columns exist for flexible data
+        assert!(SCHEMA_SQL.contains("module_whitelist JSONB"));
+        assert!(SCHEMA_SQL.contains("model_whitelist JSONB"));
+        assert!(SCHEMA_SQL.contains("pricing_config JSONB"));
+        assert!(SCHEMA_SQL.contains("evaluation_config JSONB"));
+        assert!(SCHEMA_SQL.contains("task_results JSONB"));
+        assert!(SCHEMA_SQL.contains("payload JSONB"));
+    }
+
+    #[test]
+    fn test_schema_sql_timestamp_fields() {
+        // Verify timestamp fields are properly defined
+        assert!(SCHEMA_SQL.contains("created_at TIMESTAMPTZ"));
+        assert!(SCHEMA_SQL.contains("updated_at TIMESTAMPTZ"));
+        assert!(SCHEMA_SQL.contains("expires_at TIMESTAMPTZ"));
+        assert!(SCHEMA_SQL.contains("last_seen TIMESTAMPTZ"));
+    }
+}