parse-rs 0.2.0

A modern and asynchronous Rust SDK for interacting with Parse Server backends
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

mod query_test_utils;

#[cfg(test)]
mod equality_ops_tests {
    use super::query_test_utils::shared::*; // Import all from shared
    use parse_rs::query::ParseQuery; // Specific to query tests
                                     // use parse_rs::error::ParseError; // Not strictly needed if only using ParseQuery methods that don't return Result directly in asserts
    use uuid::Uuid; // For unique class names

    #[tokio::test]
    async fn test_query_equal_to() {
        let client = setup_client();
        let class_name = format!("TestEqualityOps_{}", Uuid::new_v4().simple());
        cleanup_test_class(&client, &class_name).await;

        let score1 = create_test_score(&client, &class_name, 100, "PlayerEq1", Some(false), None)
            .await
            .unwrap();
        let score2 = create_test_score(
            &client,
            &class_name,
            200,
            "PlayerEq2",
            Some(true),
            Some(vec!["skillA".to_string()]),
        )
        .await
        .unwrap();
        let _score3 = create_test_score(&client, &class_name, 100, "PlayerEq3", Some(false), None)
            .await
            .unwrap();

        // Test equal_to for player_name
        let mut query_player = ParseQuery::new(&class_name);
        query_player.equal_to("player_name", "PlayerEq2");
        let results_player: Vec<GameScore> = query_player
            .find(&client)
            .await
            .expect("Query equal_to player_name failed");
        assert_eq!(results_player.len(), 1);
        assert_eq!(results_player[0], score2);

        // Test equal_to for score
        let mut query_score = ParseQuery::new(&class_name);
        query_score.equal_to("score", 100);
        let results_score: Vec<GameScore> = query_score
            .find(&client)
            .await
            .expect("Query equal_to score failed");
        assert_eq!(
            results_score.len(),
            2,
            "Expected two players with score 100"
        );
        assert!(results_score.contains(&score1));
        assert!(results_score.iter().any(|s| s.player_name == "PlayerEq3"));

        // Test equal_to for boolean
        let mut query_cheat = ParseQuery::new(&class_name);
        query_cheat.equal_to("cheat_mode", true);
        let results_cheat: Vec<GameScore> = query_cheat
            .find(&client)
            .await
            .expect("Query equal_to cheat_mode failed");
        assert_eq!(results_cheat.len(), 1);
        assert_eq!(results_cheat[0], score2);

        cleanup_test_class(&client, &class_name).await;
    }

    #[tokio::test]
    async fn test_query_not_equal_to() {
        let client = setup_client();
        let class_name = format!("TestEqualityOps_{}", Uuid::new_v4().simple());
        cleanup_test_class(&client, &class_name).await;

        let score1 = create_test_score(&client, &class_name, 100, "PlayerNeq1", Some(false), None)
            .await
            .unwrap();
        let score2 = create_test_score(&client, &class_name, 200, "PlayerNeq2", Some(true), None)
            .await
            .unwrap();
        let _score3 = create_test_score(&client, &class_name, 100, "PlayerNeq3", Some(false), None)
            .await
            .unwrap();

        // Test not_equal_to for player_name
        let mut query_player = ParseQuery::new(&class_name);
        query_player.not_equal_to("player_name", "PlayerNeq2");
        let results_player: Vec<GameScore> = query_player
            .find(&client)
            .await
            .expect("Query not_equal_to player_name failed");
        assert_eq!(
            results_player.len(),
            2,
            "Expected two players not named PlayerNeq2"
        );
        assert!(results_player.contains(&score1));
        assert!(results_player.iter().any(|s| s.player_name == "PlayerNeq3"));
        assert!(!results_player.contains(&score2));

        // Test not_equal_to for score
        let mut query_score = ParseQuery::new(&class_name);
        query_score.not_equal_to("score", 100);
        let results_score: Vec<GameScore> = query_score
            .find(&client)
            .await
            .expect("Query not_equal_to score failed");
        assert_eq!(
            results_score.len(),
            1,
            "Expected one player with score not 100"
        );
        assert_eq!(results_score[0], score2);

        // Test not_equal_to for boolean
        let mut query_cheat = ParseQuery::new(&class_name);
        query_cheat.not_equal_to("cheat_mode", true);
        let results_cheat: Vec<GameScore> = query_cheat
            .find(&client)
            .await
            .expect("Query not_equal_to cheat_mode failed");
        assert_eq!(
            results_cheat.len(),
            2,
            "Expected two players with cheat_mode not true (i.e. false or null)"
        );
        assert!(results_cheat.contains(&score1));
        assert!(results_cheat.iter().any(|s| s.player_name == "PlayerNeq3"));

        cleanup_test_class(&client, &class_name).await;
    }
}