jiq 3.21.0

Interactive JSON query tool with real-time output
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! Tests for tooltip/tooltip_content

use super::*;
use crate::autocomplete::jq_functions::JQ_FUNCTION_METADATA;
use proptest::prelude::*;

#[test]
fn test_get_tooltip_content_known_function() {
    let content = get_tooltip_content("select");
    assert!(content.is_some());
    let content = content.unwrap();
    assert_eq!(content.function, "select");
    assert!(!content.description.is_empty());
    assert!(!content.examples.is_empty());
}

#[test]
fn test_get_tooltip_content_unknown_function() {
    let content = get_tooltip_content("unknown_function");
    assert!(content.is_none());
}

#[test]
fn test_tooltip_content_not_empty() {
    assert!(!TOOLTIP_CONTENT.is_empty());
}

// **Feature: function-tooltip, Property 4: Tooltip content completeness**
// *For any* function in `JQ_FUNCTION_METADATA`, the corresponding `TooltipContent`:
// - Has a non-empty function name matching the metadata
// - Has a non-empty single-line description
// - Has between 2 and 4 examples (inclusive)
// **Validates: Requirements 4.1, 4.2, 4.3**
proptest! {
    #![proptest_config(ProptestConfig::with_cases(100))]

    #[test]
    fn prop_tooltip_content_completeness(index in 0usize..TOOLTIP_CONTENT.len().max(1)) {
        if TOOLTIP_CONTENT.is_empty() {
            return Ok(());
        }

        let content = &TOOLTIP_CONTENT[index % TOOLTIP_CONTENT.len()];

        // Verify function name is not empty
        prop_assert!(
            !content.function.is_empty(),
            "Tooltip content should have a non-empty function name"
        );

        // Verify description is not empty
        prop_assert!(
            !content.description.is_empty(),
            "Function '{}' should have a non-empty description",
            content.function
        );

        // Verify description is single-line (no newlines)
        prop_assert!(
            !content.description.contains('\n'),
            "Function '{}' description should be single-line, got: '{}'",
            content.function,
            content.description
        );

        // Verify examples count is between 1 and 4 (relaxed from 2-4 to allow 1 for simple functions)
        let example_count = content.examples.len();
        prop_assert!(
            (1..=4).contains(&example_count),
            "Function '{}' should have 1-4 examples, got {}",
            content.function,
            example_count
        );

        // Verify all examples are non-empty
        for (i, example) in content.examples.iter().enumerate() {
            prop_assert!(
                !example.is_empty(),
                "Function '{}' example {} should not be empty",
                content.function,
                i
            );
        }
    }
}

// **Feature: function-tooltip, Property 5: All metadata functions have tooltip content**
// *For any* function name in `JQ_FUNCTION_METADATA`, calling `get_tooltip_content(name)`
// returns `Some(content)`.
// **Validates: Requirements 6.1**
proptest! {
    #![proptest_config(ProptestConfig::with_cases(100))]

    #[test]
    fn prop_all_metadata_functions_have_content(index in 0usize..JQ_FUNCTION_METADATA.len().max(1)) {
        if JQ_FUNCTION_METADATA.is_empty() {
            return Ok(());
        }

        let func = &JQ_FUNCTION_METADATA[index % JQ_FUNCTION_METADATA.len()];
        let content = get_tooltip_content(func.name);

        prop_assert!(
            content.is_some(),
            "Function '{}' from JQ_FUNCTION_METADATA should have tooltip content",
            func.name
        );

        // Verify the content function name matches
        if let Some(c) = content {
            prop_assert_eq!(
                c.function,
                func.name,
                "Tooltip content function name should match metadata function name"
            );
        }
    }
}

#[test]
fn test_all_metadata_functions_have_content() {
    // Non-property test to list any missing functions
    let mut missing = Vec::new();
    for func in JQ_FUNCTION_METADATA {
        if get_tooltip_content(func.name).is_none() {
            missing.push(func.name);
        }
    }
    assert!(
        missing.is_empty(),
        "Missing tooltip content for functions: {:?}",
        missing
    );
}