conproxy 0.2.1

Cache proxy server for heterogeneous RAG/vector search backends with cascade, scope, and MCP
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use crate::helpers::client::E2eClient;
use crate::helpers::constants::{category_enabled, Suite};
use crate::helpers::report::TestReport;
use crate::run_test;

pub fn run(client: &E2eClient, suite: Suite, report: &mut TestReport) {
    if !category_enabled("operational") {
        return;
    }

    // Test 20: Readiness probe
    run_test!(report, "operational", "Readiness probe", {
        let (status, body) = client.ready();
        assert_eq!(status, 200);
        assert!(!body["ready"].is_null(), "Missing ready field");
    });

    // Test 21: Cache integrity
    run_test!(report, "operational", "Cache integrity", {
        let status = client.get_status("/cache/integrity");
        assert!(
            status == 200 || status == 404,
            "Expected 200 or 404, got {status}"
        );
    });

    // Test 22: Cache upstreams
    run_test!(report, "operational", "Cache upstreams", {
        let status = client.get_status("/cache/upstreams");
        assert!(
            status == 200 || status == 404,
            "Expected 200 or 404, got {status}"
        );
    });

    // Test 23: Cache evict (nonexistent pattern)
    run_test!(report, "operational", "Cache evict", {
        let (status, _) = client.cache_evict("nonexistent");
        assert!(
            [200, 204, 400, 404].contains(&status),
            "Expected 200/204/400/404, got {status}"
        );
    });

    // Test 24: Query stats
    run_test!(report, "operational", "Query stats", {
        let status = client.get_status("/stats/queries");
        assert!(
            status == 200 || status == 404,
            "Expected 200 or 404, got {status}"
        );
    });

    // Test 25: Current context
    run_test!(report, "operational", "Current context", {
        let status = client.get_status("/contexts/current");
        assert!(
            status == 200 || status == 404,
            "Expected 200 or 404, got {status}"
        );
    });

    // Test 27: Admin pause
    run_test!(report, "operational", "Admin pause", {
        let (status, body) = client.admin_pause();
        assert_eq!(status, 200);
        assert_eq!(body["status"].as_str(), Some("paused"));
    });

    // Verify queries rejected while paused
    run_test!(report, "operational", "Pause: query rejected (503)", {
        let (status, _) = client.query("paused test");
        assert_eq!(status, 503, "Expected 503 while paused, got {status}");
    });

    // Health still works while paused
    run_test!(report, "operational", "Pause: health still up", {
        let (status, _) = client.health();
        assert_eq!(status, 200);
    });

    // Resume
    run_test!(report, "operational", "Admin resume", {
        let (status, body) = client.admin_resume();
        assert_eq!(status, 200);
        assert_eq!(body["status"].as_str(), Some("resumed"));
    });

    // Verify queries work after resume (not qdrant — text upstreams only)
    if suite.has_text_upstreams() {
        run_test!(report, "operational", "Resume: query works", {
            let (status, body) = client.query("resume test");
            assert_eq!(status, 200);
            assert!(body["results"].is_array(), "Missing results after resume");
        });
    }

    // Test 28: Client tracking
    run_test!(report, "operational", "Client list", {
        let status = client.get_status("/clients");
        assert!(
            status == 200 || status == 404,
            "Expected 200 or 404, got {status}"
        );
    });

    // Test 29: Audit log
    run_test!(report, "operational", "Audit log", {
        let status = client.get_status("/audit");
        assert!(
            status == 200 || status == 404,
            "Expected 200 or 404, got {status}"
        );
    });
}