agentic-flow 1.9.0 → 1.9.2

package/agentic-flow/examples/crispr-cas13-pipeline/crates/api-service/tests/api_test.rs

@@ -1,306 +0,0 @@
-// Unit tests for API service - endpoint handlers and integration
-#[cfg(test)]
-mod api_service_tests {
-    use super::*;
-
-    // Health and status endpoint tests
-    #[test]
-    fn test_health_check_endpoint() {
-        // TODO: Test /health endpoint
-        // Expected: 200 OK with health status JSON
-        // Verify response includes service version and uptime
-        assert!(true, "Placeholder - implement when health endpoint exists");
-    }
-
-    #[test]
-    fn test_metrics_endpoint() {
-        // TODO: Test /metrics endpoint
-        // Expected: Prometheus-formatted metrics
-        // Verify includes request counts, latencies, errors
-        assert!(true, "Placeholder - implement when metrics endpoint exists");
-    }
-
-    // Job submission endpoints
-    #[test]
-    fn test_create_analysis_job() {
-        // TODO: Test POST /api/v1/jobs endpoint
-        // Given: valid job submission JSON
-        // Expected: 201 Created with job ID
-        // Verify job appears in database
-        assert!(true, "Placeholder - implement when jobs endpoint exists");
-    }
-
-    #[test]
-    fn test_create_job_validation() {
-        // TODO: Test job submission validation
-        // Given: invalid job parameters (missing required fields)
-        // Expected: 400 Bad Request with error details
-        // Verify validation error messages are helpful
-        assert!(true, "Placeholder - implement when validation exists");
-    }
-
-    #[test]
-    fn test_create_job_authentication() {
-        // TODO: Test job submission requires authentication
-        // Given: request without auth token
-        // Expected: 401 Unauthorized
-        // Verify JWT token validation works
-        assert!(true, "Placeholder - implement when auth exists");
-    }
-
-    #[test]
-    fn test_job_submission_rate_limiting() {
-        // TODO: Test rate limiting on job submission
-        // Given: > 10 requests per minute from same user
-        // Expected: 429 Too Many Requests
-        // Verify rate limit resets after time window
-        assert!(true, "Placeholder - implement when rate limiting exists");
-    }
-
-    // Job query endpoints
-    #[test]
-    fn test_get_job_status() {
-        // TODO: Test GET /api/v1/jobs/{job_id} endpoint
-        // Given: existing job ID
-        // Expected: 200 OK with job status details
-        // Verify status field (pending/running/completed/failed)
-        assert!(true, "Placeholder - implement when job query exists");
-    }
-
-    #[test]
-    fn test_get_nonexistent_job() {
-        // TODO: Test querying non-existent job
-        // Given: invalid or random UUID
-        // Expected: 404 Not Found
-        // Verify error message is clear
-        assert!(true, "Placeholder - implement when job query exists");
-    }
-
-    #[test]
-    fn test_list_jobs_pagination() {
-        // TODO: Test GET /api/v1/jobs with pagination
-        // Given: query params ?page=1&limit=20
-        // Expected: paginated job list with next/prev links
-        // Verify total count and page metadata
-        assert!(true, "Placeholder - implement when job listing exists");
-    }
-
-    #[test]
-    fn test_filter_jobs_by_status() {
-        // TODO: Test filtering jobs by status
-        // Given: query param ?status=completed
-        // Expected: only completed jobs returned
-        // Verify filter combinations work
-        assert!(true, "Placeholder - implement when filtering exists");
-    }
-
-    // Results retrieval endpoints
-    #[test]
-    fn test_get_alignment_results() {
-        // TODO: Test GET /api/v1/jobs/{job_id}/alignments
-        // Given: completed job with alignment results
-        // Expected: 200 OK with alignment data JSON/CSV
-        // Verify pagination for large result sets
-        assert!(true, "Placeholder - implement when results endpoint exists");
-    }
-
-    #[test]
-    fn test_get_offtarget_results() {
-        // TODO: Test GET /api/v1/jobs/{job_id}/offtargets
-        // Given: completed job with off-target predictions
-        // Expected: 200 OK with scored off-target sites
-        // Verify sorting by score (descending)
-        assert!(
-            true,
-            "Placeholder - implement when offtarget endpoint exists"
-        );
-    }
-
-    #[test]
-    fn test_get_immune_analysis_results() {
-        // TODO: Test GET /api/v1/jobs/{job_id}/immune-analysis
-        // Given: completed immune analysis job
-        // Expected: 200 OK with differential expression results
-        // Verify includes fold-changes and p-values
-        assert!(true, "Placeholder - implement when immune endpoint exists");
-    }
-
-    #[test]
-    fn test_download_results_csv() {
-        // TODO: Test results download in CSV format
-        // Given: Accept: text/csv header
-        // Expected: CSV formatted results file
-        // Verify Content-Disposition header for download
-        assert!(true, "Placeholder - implement when CSV export exists");
-    }
-
-    #[test]
-    fn test_download_results_json() {
-        // TODO: Test results download in JSON format
-        // Given: Accept: application/json header
-        // Expected: JSON formatted results
-        // Verify streaming for large result sets
-        assert!(true, "Placeholder - implement when JSON export exists");
-    }
-
-    // WebSocket tests
-    #[test]
-    fn test_websocket_connection() {
-        // TODO: Test WebSocket connection establishment
-        // Given: ws://localhost:8080/ws/jobs/{job_id}
-        // Expected: successful WebSocket upgrade
-        // Verify connection authenticated
-        assert!(true, "Placeholder - implement when WebSocket exists");
-    }
-
-    #[test]
-    fn test_websocket_job_updates() {
-        // TODO: Test real-time job status updates
-        // Given: WebSocket connected to running job
-        // Expected: receives status update messages
-        // Verify message format and timing
-        assert!(true, "Placeholder - implement when WebSocket exists");
-    }
-
-    #[test]
-    fn test_websocket_disconnect_handling() {
-        // TODO: Test WebSocket disconnect and reconnect
-        // Given: client disconnects and reconnects
-        // Expected: no message loss, catches up on missed updates
-        // Verify graceful connection closure
-        assert!(true, "Placeholder - implement when WebSocket exists");
-    }
-
-    // Error handling tests
-    #[test]
-    fn test_internal_server_error_handling() {
-        // TODO: Test 500 Internal Server Error handling
-        // Given: database connection failure or internal error
-        // Expected: 500 response with error ID for tracking
-        // Verify sensitive details not leaked in response
-        assert!(true, "Placeholder - implement when error handling exists");
-    }
-
-    #[test]
-    fn test_malformed_request_handling() {
-        // TODO: Test handling of malformed JSON requests
-        // Given: invalid JSON in POST body
-        // Expected: 400 Bad Request with parse error
-        // Verify doesn't crash server
-        assert!(true, "Placeholder - implement when validation exists");
-    }
-
-    #[test]
-    fn test_request_timeout_handling() {
-        // TODO: Test request timeout enforcement
-        // Given: long-running endpoint exceeds timeout
-        // Expected: 504 Gateway Timeout
-        // Verify timeout is configurable
-        assert!(true, "Placeholder - implement when timeouts exist");
-    }
-
-    // Security tests
-    #[test]
-    fn test_cors_configuration() {
-        // TODO: Test CORS headers configuration
-        // Given: request from allowed origin
-        // Expected: correct Access-Control-Allow-Origin headers
-        // Verify preflight OPTIONS requests handled
-        assert!(true, "Placeholder - implement when CORS configured");
-    }
-
-    #[test]
-    fn test_sql_injection_prevention() {
-        // TODO: Test SQL injection prevention
-        // Given: malicious SQL in query parameters
-        // Expected: parameterized queries prevent injection
-        // Verify input sanitization works
-        assert!(true, "Placeholder - implement with sqlx");
-    }
-
-    #[test]
-    fn test_xss_prevention() {
-        // TODO: Test XSS (Cross-Site Scripting) prevention
-        // Given: script tags in user input
-        // Expected: input escaped or rejected
-        // Verify HTML/JS not executed
-        assert!(true, "Placeholder - implement when input handling exists");
-    }
-
-    #[test]
-    fn test_authentication_token_validation() {
-        // TODO: Test JWT token validation
-        // Given: expired or invalid JWT token
-        // Expected: 401 Unauthorized
-        // Verify token signature verification
-        assert!(true, "Placeholder - implement when JWT auth exists");
-    }
-
-    // Performance tests
-    #[test]
-    fn test_concurrent_request_handling() {
-        // TODO: Test handling of concurrent requests
-        // Given: 100 simultaneous requests
-        // Expected: all requests handled successfully
-        // Target: <100ms p95 latency
-        assert!(true, "Placeholder - implement when API exists");
-    }
-
-    #[test]
-    fn test_database_connection_pooling() {
-        // TODO: Test database connection pool efficiency
-        // Given: multiple concurrent database queries
-        // Expected: connection pool handles load without exhaustion
-        // Verify pool size and timeout configuration
-        assert!(true, "Placeholder - implement when DB pool exists");
-    }
-
-    #[test]
-    fn test_large_payload_handling() {
-        // TODO: Test handling of large request/response payloads
-        // Given: 10 MB JSON response
-        // Expected: streaming response without memory spike
-        // Verify request size limits enforced
-        assert!(true, "Placeholder - implement when API exists");
-    }
-}
-
-// Integration tests with mock services
-#[cfg(test)]
-mod api_integration_tests {
-    use super::*;
-
-    #[test]
-    fn test_end_to_end_job_flow() {
-        // TODO: Test complete job lifecycle
-        // 1. Submit job via POST /api/v1/jobs
-        // 2. Poll job status until completed
-        // 3. Retrieve results via GET /api/v1/jobs/{id}/results
-        // Verify entire flow works end-to-end
-        assert!(true, "Placeholder - implement when full API exists");
-    }
-
-    #[test]
-    fn test_database_integration() {
-        // TODO: Test PostgreSQL database integration
-        // Verify CRUD operations on jobs table
-        // Test transaction handling
-        assert!(true, "Placeholder - implement when DB layer exists");
-    }
-
-    #[test]
-    fn test_kafka_integration() {
-        // TODO: Test Kafka message queue integration
-        // Verify job submission publishes message
-        // Test consumer receives job messages
-        assert!(true, "Placeholder - implement when Kafka integrated");
-    }
-
-    #[test]
-    fn test_redis_cache_integration() {
-        // TODO: Test Redis caching layer
-        // Verify frequently accessed data cached
-        // Test cache invalidation on updates
-        assert!(true, "Placeholder - implement when Redis integrated");
-    }
-}

package/agentic-flow/examples/crispr-cas13-pipeline/crates/data-models/Cargo.toml

@@ -1,17 +0,0 @@
-[package]
-name = "data-models"
-version = "0.1.0"
-edition = "2021"
-authors = ["CRISPR-Cas13 Team"]
-description = "Shared data structures for CRISPR-Cas13 pipeline"
-license = "MIT"
-
-[dependencies]
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-uuid = { version = "1.10", features = ["v4", "serde"] }
-chrono = { version = "0.4", features = ["serde"] }
-thiserror = "1.0"
-
-[dev-dependencies]
-proptest = "1.5"

package/agentic-flow/examples/crispr-cas13-pipeline/crates/data-models/src/error.rs

@@ -1,31 +0,0 @@
-//! Error types for data models
-
-use thiserror::Error;
-
-/// Result type for data model operations
-pub type Result<T> = std::result::Result<T, DataModelError>;
-
-/// Errors that can occur when working with data models
-#[derive(Debug, Error)]
-pub enum DataModelError {
-    #[error("Invalid sequence: {0}")]
-    InvalidSequence(String),
-
-    #[error("Invalid quality score: {0}")]
-    InvalidQualityScore(String),
-
-    #[error("Serialization error: {0}")]
-    SerializationError(#[from] serde_json::Error),
-
-    #[error("Invalid coordinate: {0}")]
-    InvalidCoordinate(String),
-
-    #[error("Missing required field: {0}")]
-    MissingField(String),
-
-    #[error("Invalid range: start={start}, end={end}")]
-    InvalidRange { start: u64, end: u64 },
-
-    #[error("Parse error: {0}")]
-    ParseError(String),
-}

package/agentic-flow/examples/crispr-cas13-pipeline/crates/data-models/src/expression.rs

@@ -1,313 +0,0 @@
-//! Gene expression analysis data models
-
-use crate::error::DataModelError;
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use uuid::Uuid;
-
-/// Represents gene expression data for a single sample
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ExpressionSample {
-    /// Unique sample identifier
-    pub id: Uuid,
-    /// Sample name
-    pub name: String,
-    /// Experimental condition
-    pub condition: String,
-    /// Replicate number
-    pub replicate: u32,
-    /// Raw read counts per gene
-    pub counts: HashMap<String, u64>,
-    /// Normalized expression values (e.g., TPM, FPKM)
-    pub normalized: HashMap<String, f64>,
-    /// Sample metadata
-    pub metadata: SampleMetadata,
-}
-
-impl ExpressionSample {
-    /// Create a new expression sample
-    pub fn new(name: String, condition: String, replicate: u32) -> Self {
-        Self {
-            id: Uuid::new_v4(),
-            name,
-            condition,
-            replicate,
-            counts: HashMap::new(),
-            normalized: HashMap::new(),
-            metadata: SampleMetadata::default(),
-        }
-    }
-
-    /// Get total read count
-    pub fn total_counts(&self) -> u64 {
-        self.counts.values().sum()
-    }
-
-    /// Get number of detected genes (count > 0)
-    pub fn detected_genes(&self) -> usize {
-        self.counts.values().filter(|&&c| c > 0).count()
-    }
-
-    /// Add raw count for a gene
-    pub fn add_count(&mut self, gene_id: String, count: u64) {
-        self.counts.insert(gene_id, count);
-    }
-
-    /// Add normalized expression for a gene
-    pub fn add_normalized(&mut self, gene_id: String, value: f64) {
-        self.normalized.insert(gene_id, value);
-    }
-}
-
-/// Sample metadata
-#[derive(Debug, Clone, Serialize, Deserialize, Default)]
-pub struct SampleMetadata {
-    /// Sequencing depth
-    pub sequencing_depth: u64,
-    /// Library preparation protocol
-    pub library_protocol: Option<String>,
-    /// Sample collection date
-    pub collection_date: Option<chrono::DateTime<chrono::Utc>>,
-    /// Additional custom metadata
-    pub custom: HashMap<String, String>,
-}
-
-/// Differential expression analysis result for a single gene
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct DifferentialExpression {
-    /// Gene identifier
-    pub gene_id: String,
-    /// Gene symbol/name
-    pub gene_name: Option<String>,
-    /// Log2 fold change
-    pub log2_fold_change: f64,
-    /// Standard error of log2 fold change
-    pub log2_fold_change_se: f64,
-    /// Base mean expression across all samples
-    pub base_mean: f64,
-    /// Wald test statistic
-    pub wald_statistic: f64,
-    /// P-value
-    pub pvalue: f64,
-    /// Adjusted p-value (FDR)
-    pub padj: f64,
-}
-
-impl DifferentialExpression {
-    /// Check if gene is significantly differentially expressed
-    pub fn is_significant(&self, padj_threshold: f64, lfc_threshold: f64) -> bool {
-        self.padj < padj_threshold && self.log2_fold_change.abs() > lfc_threshold
-    }
-
-    /// Check if gene is up-regulated
-    pub fn is_upregulated(&self, padj_threshold: f64, lfc_threshold: f64) -> bool {
-        self.is_significant(padj_threshold, lfc_threshold) && self.log2_fold_change > 0.0
-    }
-
-    /// Check if gene is down-regulated
-    pub fn is_downregulated(&self, padj_threshold: f64, lfc_threshold: f64) -> bool {
-        self.is_significant(padj_threshold, lfc_threshold) && self.log2_fold_change < 0.0
-    }
-
-    /// Get regulation direction as string
-    pub fn regulation_direction(&self, padj_threshold: f64, lfc_threshold: f64) -> String {
-        if self.is_upregulated(padj_threshold, lfc_threshold) {
-            "up".to_string()
-        } else if self.is_downregulated(padj_threshold, lfc_threshold) {
-            "down".to_string()
-        } else {
-            "not_significant".to_string()
-        }
-    }
-}
-
-/// Complete differential expression analysis results
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct DifferentialExpressionAnalysis {
-    /// Analysis identifier
-    pub id: Uuid,
-    /// Control condition name
-    pub control_condition: String,
-    /// Treatment condition name
-    pub treatment_condition: String,
-    /// Results for each gene
-    pub results: Vec<DifferentialExpression>,
-    /// Analysis parameters
-    pub parameters: AnalysisParameters,
-    /// Analysis timestamp
-    pub timestamp: chrono::DateTime<chrono::Utc>,
-}
-
-impl DifferentialExpressionAnalysis {
-    /// Get significantly differentially expressed genes
-    pub fn significant_genes(
-        &self,
-        padj_threshold: f64,
-        lfc_threshold: f64,
-    ) -> Vec<&DifferentialExpression> {
-        self.results
-            .iter()
-            .filter(|de| de.is_significant(padj_threshold, lfc_threshold))
-            .collect()
-    }
-
-    /// Count up-regulated genes
-    pub fn upregulated_count(&self, padj_threshold: f64, lfc_threshold: f64) -> usize {
-        self.results
-            .iter()
-            .filter(|de| de.is_upregulated(padj_threshold, lfc_threshold))
-            .count()
-    }
-
-    /// Count down-regulated genes
-    pub fn downregulated_count(&self, padj_threshold: f64, lfc_threshold: f64) -> usize {
-        self.results
-            .iter()
-            .filter(|de| de.is_downregulated(padj_threshold, lfc_threshold))
-            .count()
-    }
-}
-
-/// Parameters for differential expression analysis
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AnalysisParameters {
-    /// Statistical test used
-    pub test_type: String,
-    /// FDR method
-    pub fdr_method: String,
-    /// Minimum counts threshold
-    pub min_counts: u64,
-    /// Alpha level for hypothesis testing
-    pub alpha: f64,
-}
-
-impl Default for AnalysisParameters {
-    fn default() -> Self {
-        Self {
-            test_type: "Wald".to_string(),
-            fdr_method: "BH".to_string(),
-            min_counts: 10,
-            alpha: 0.05,
-        }
-    }
-}
-
-/// Immune pathway enrichment result
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct PathwayEnrichment {
-    /// Pathway identifier
-    pub pathway_id: String,
-    /// Pathway name
-    pub pathway_name: String,
-    /// Pathway database (e.g., KEGG, Reactome, GO)
-    pub database: String,
-    /// Number of genes in pathway
-    pub pathway_size: usize,
-    /// Number of DE genes in pathway
-    pub de_genes_in_pathway: usize,
-    /// List of DE gene IDs in pathway
-    pub gene_ids: Vec<String>,
-    /// Enrichment p-value
-    pub pvalue: f64,
-    /// Adjusted p-value
-    pub padj: f64,
-    /// Enrichment score
-    pub enrichment_score: f64,
-}
-
-impl PathwayEnrichment {
-    /// Check if pathway is significantly enriched
-    pub fn is_significant(&self, padj_threshold: f64) -> bool {
-        self.padj < padj_threshold
-    }
-
-    /// Calculate gene ratio
-    pub fn gene_ratio(&self) -> f64 {
-        self.de_genes_in_pathway as f64 / self.pathway_size as f64
-    }
-}
-
-/// Complete pathway enrichment analysis
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct PathwayAnalysis {
-    /// Analysis identifier
-    pub id: Uuid,
-    /// Differential expression analysis reference
-    pub de_analysis_id: Uuid,
-    /// Enrichment results
-    pub pathways: Vec<PathwayEnrichment>,
-    /// Analysis timestamp
-    pub timestamp: chrono::DateTime<chrono::Utc>,
-}
-
-impl PathwayAnalysis {
-    /// Get significantly enriched pathways
-    pub fn significant_pathways(&self, padj_threshold: f64) -> Vec<&PathwayEnrichment> {
-        self.pathways
-            .iter()
-            .filter(|p| p.is_significant(padj_threshold))
-            .collect()
-    }
-
-    /// Get top N enriched pathways by score
-    pub fn top_pathways(&self, n: usize) -> Vec<&PathwayEnrichment> {
-        let mut sorted = self.pathways.iter().collect::<Vec<_>>();
-        sorted.sort_by(|a, b| {
-            b.enrichment_score
-                .partial_cmp(&a.enrichment_score)
-                .unwrap_or(std::cmp::Ordering::Equal)
-        });
-        sorted.into_iter().take(n).collect()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_expression_sample() {
-        let mut sample = ExpressionSample::new("sample1".to_string(), "control".to_string(), 1);
-        sample.add_count("GENE1".to_string(), 100);
-        sample.add_count("GENE2".to_string(), 200);
-
-        assert_eq!(sample.total_counts(), 300);
-        assert_eq!(sample.detected_genes(), 2);
-    }
-
-    #[test]
-    fn test_differential_expression_significance() {
-        let de = DifferentialExpression {
-            gene_id: "GENE1".to_string(),
-            gene_name: Some("TestGene".to_string()),
-            log2_fold_change: 2.5,
-            log2_fold_change_se: 0.3,
-            base_mean: 100.0,
-            wald_statistic: 8.33,
-            pvalue: 1e-10,
-            padj: 1e-8,
-        };
-
-        assert!(de.is_significant(0.05, 1.0));
-        assert!(de.is_upregulated(0.05, 1.0));
-        assert!(!de.is_downregulated(0.05, 1.0));
-    }
-
-    #[test]
-    fn test_pathway_enrichment() {
-        let pathway = PathwayEnrichment {
-            pathway_id: "PATH:001".to_string(),
-            pathway_name: "Immune Response".to_string(),
-            database: "KEGG".to_string(),
-            pathway_size: 100,
-            de_genes_in_pathway: 15,
-            gene_ids: vec!["GENE1".to_string(), "GENE2".to_string()],
-            pvalue: 0.001,
-            padj: 0.01,
-            enrichment_score: 3.5,
-        };
-
-        assert!(pathway.is_significant(0.05));
-        assert_eq!(pathway.gene_ratio(), 0.15);
-    }
-}

package/agentic-flow/examples/crispr-cas13-pipeline/crates/data-models/src/lib.rs

@@ -1,27 +0,0 @@
-//! # Data Models
-//!
-//! Shared data structures for the CRISPR-Cas13 bioinformatics pipeline.
-//! This crate provides common types used across all pipeline components.
-
-pub mod error;
-pub mod expression;
-pub mod metadata;
-pub mod sequencing;
-pub mod targets;
-
-pub use error::{DataModelError, Result};
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_result_type_alias() {
-        let ok_result: Result<i32> = Ok(42);
-        assert!(ok_result.is_ok());
-        assert_eq!(ok_result.unwrap(), 42);
-
-        let err_result: Result<i32> = Err(DataModelError::ValidationError("test error".to_string()));
-        assert!(err_result.is_err());
-    }
-}