hevy 0.1.0

An async Rust client library for the Hevy public API (https://api.hevyapp.com/docs/)
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

mod common;

use common::{client_for, mock_server};
use hevy::{CreateExerciseTemplateRequest, EquipmentCategory, MuscleGroup, NewCustomExercise, CustomExerciseType};
use serde_json::json;
use wiremock::matchers::{method, path, query_param};
use wiremock::{Mock, ResponseTemplate};

fn sample_template_json() -> serde_json::Value {
    json!({
        "id": "b459cba5-cd6d-463c-abd6-54f8eafcadcb",
        "title": "Bench Press (Barbell)",
        "type": "weight_reps",
        "primary_muscle_group": "chest",
        "secondary_muscle_groups": ["shoulders", "triceps"],
        "equipment_category": "barbell",
        "is_custom": false,
    })
}

#[tokio::test]
async fn list_exercise_templates() {
    let server = mock_server().await;
    let client = client_for(&server);

    Mock::given(method("GET"))
        .and(path("/v1/exercise_templates"))
        .and(query_param("page", "1"))
        .and(query_param("pageSize", "20"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "page": 1,
            "page_count": 3,
            "exercise_templates": [sample_template_json()],
        })))
        .mount(&server)
        .await;

    let page = client
        .list_exercise_templates(Some(1), Some(20))
        .await
        .unwrap();

    assert_eq!(page.page_count, 3);
    assert_eq!(page.exercise_templates[0].title, "Bench Press (Barbell)");
    assert_eq!(
        page.exercise_templates[0].equipment_category,
        Some(EquipmentCategory::Barbell)
    );
}

#[tokio::test]
async fn get_exercise_template_by_id() {
    let server = mock_server().await;
    let client = client_for(&server);

    Mock::given(method("GET"))
        .and(path("/v1/exercise_templates/05293BCA"))
        .respond_with(ResponseTemplate::new(200).set_body_json(sample_template_json()))
        .mount(&server)
        .await;

    let template = client.get_exercise_template("05293BCA").await.unwrap();
    assert_eq!(template.primary_muscle_group, "chest");
    assert!(!template.is_custom);
}

#[tokio::test]
async fn create_exercise_template_returns_new_id() {
    let server = mock_server().await;
    let client = client_for(&server);

    Mock::given(method("POST"))
        .and(path("/v1/exercise_templates"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({ "id": 123 })))
        .mount(&server)
        .await;

    let exercise = NewCustomExercise::new(
        "Bench Press",
        CustomExerciseType::WeightReps,
        EquipmentCategory::Barbell,
        MuscleGroup::Chest,
    )
    .with_other_muscles([MuscleGroup::Biceps, MuscleGroup::Triceps]);

    let id = client
        .create_exercise_template(&CreateExerciseTemplateRequest::new(exercise))
        .await
        .unwrap();

    assert_eq!(id, 123);
}

#[tokio::test]
async fn create_exercise_template_over_limit_returns_error() {
    let server = mock_server().await;
    let client = client_for(&server);

    Mock::given(method("POST"))
        .and(path("/v1/exercise_templates"))
        .respond_with(ResponseTemplate::new(403).set_body_json(json!({
            "error": "exceeds-custom-exercise-limit"
        })))
        .mount(&server)
        .await;

    let exercise = NewCustomExercise::new(
        "Bench Press",
        CustomExerciseType::WeightReps,
        EquipmentCategory::Barbell,
        MuscleGroup::Chest,
    );

    let err = client
        .create_exercise_template(&CreateExerciseTemplateRequest::new(exercise))
        .await
        .unwrap_err();

    match err {
        hevy::HevyError::Api { status, message } => {
            assert_eq!(status, 403);
            assert_eq!(message, "exceeds-custom-exercise-limit");
        }
        other => panic!("expected HevyError::Api, got {other:?}"),
    }
}