sift-query-core 0.1.0

Backend-independent query model and strict parameter parser for SiftQuery
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

use super::*;

// ---------------------------------------------------------------------------
// validate()
// ---------------------------------------------------------------------------

#[test]
fn validate_accepts_a_well_formed_scalar_entity() {
    assert_eq!(meta("User", "app_user u", ONE_FIELD).validate(), Ok(()));
}

#[test]
fn validate_rejects_blank_names_and_sources() {
    for (entity_name, from) in [("", "app_user u"), ("User", ""), ("User", "   ")] {
        let error = meta(entity_name, from, ONE_FIELD).validate().unwrap_err();
        assert_eq!(
            error,
            ConfigError::Invalid("entity_name and from must not be empty".to_owned())
        );
    }
}

#[test]
fn validate_requires_contiguous_field_ids() {
    static GAP: &[FieldMeta] = &[
        FieldMeta {
            id: FieldId(0),
            public_name: "id",
            column: "t.id",
            result_alias: Some("id"),
            value_type: ValueType::I64,
            kind: FieldKind::Scalar,
            filterable: true,
            selectable: true,
            sortable: true,
            operators: OperatorSet(&[Operator::Eq]),
        },
        FieldMeta {
            id: FieldId(5),
            public_name: "name",
            column: "t.name",
            result_alias: Some("name"),
            value_type: ValueType::Text,
            kind: FieldKind::Scalar,
            filterable: true,
            selectable: true,
            sortable: true,
            operators: OperatorSet(&[Operator::Eq]),
        },
    ];
    assert_eq!(
        meta("User", "app_user u", GAP).validate().unwrap_err(),
        ConfigError::Invalid("field name has non-contiguous FieldId 5".to_owned())
    );
}

#[test]
fn validate_rejects_scalar_columns_on_grouped_entities() {
    static GROUPED: &[FieldMeta] = &[
        FieldMeta {
            id: FieldId(0),
            public_name: "courseId",
            column: "s.course_id",
            result_alias: Some("courseId"),
            value_type: ValueType::I64,
            kind: FieldKind::GroupKey,
            filterable: true,
            selectable: true,
            sortable: true,
            operators: OperatorSet(&[Operator::Eq]),
        },
        FieldMeta {
            id: FieldId(1),
            public_name: "score",
            column: "s.score",
            result_alias: Some("score"),
            value_type: ValueType::I32,
            kind: FieldKind::Scalar,
            filterable: true,
            selectable: true,
            sortable: true,
            operators: OperatorSet(&[Operator::Eq]),
        },
    ];
    assert_eq!(
        meta("Score", "student_score s", GROUPED)
            .validate()
            .unwrap_err(),
        ConfigError::Invalid("grouped entities cannot return Scalar fields".to_owned())
    );
}

#[test]
fn validate_allows_filter_only_scalars_on_grouped_entities() {
    static GROUPED: &[FieldMeta] = &[
        FieldMeta {
            id: FieldId(0),
            public_name: "courseId",
            column: "s.course_id",
            result_alias: Some("courseId"),
            value_type: ValueType::I64,
            kind: FieldKind::GroupKey,
            filterable: true,
            selectable: true,
            sortable: true,
            operators: OperatorSet(&[Operator::Eq]),
        },
        FieldMeta {
            id: FieldId(1),
            public_name: "tenant",
            column: "s.tenant_id",
            result_alias: None,
            value_type: ValueType::I64,
            kind: FieldKind::FilterOnly,
            filterable: true,
            selectable: false,
            sortable: false,
            operators: OperatorSet(&[Operator::Eq]),
        },
    ];
    assert_eq!(meta("Score", "student_score s", GROUPED).validate(), Ok(()));
}