entertainarr-adapter-http 0.1.1

HTTP adapter for entertainarr
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

crate::create_kind!(TaskKind, "tasks");

pub type TaskEntity = super::Entity<u64, TaskKind>;

#[cfg_attr(feature = "facet", derive(facet::Facet))]
#[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize, serde::Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TaskDocument {
    pub id: u64,
    #[serde(rename = "type")]
    pub kind: TaskKind,
    pub attributes: TaskAttributes,
}

#[cfg_attr(feature = "facet", derive(facet::Facet))]
#[cfg_attr(feature = "facet", repr(C))]
#[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize, serde::Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TaskAttributes {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub after: Option<chrono::DateTime<chrono::Utc>>,
    pub status: TaskStatus,
    #[serde(flatten)]
    pub payload: TaskPayload,
    pub retries: u8,
    pub max_retries: u8,
    pub created_at: chrono::DateTime<chrono::Utc>,
    pub updated_at: chrono::DateTime<chrono::Utc>,
}

#[cfg_attr(feature = "facet", derive(facet::Facet))]
#[cfg_attr(feature = "facet", repr(C))]
#[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize, serde::Serialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum TaskStatus {
    Pending,
    Running,
    Completed,
    Failed { message: Option<String> },
}

#[cfg_attr(feature = "facet", derive(facet::Facet))]
#[cfg_attr(feature = "facet", repr(C))]
#[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize, serde::Serialize)]
#[serde(tag = "targetKind", rename_all = "camelCase")]
pub enum TaskPayload {
    Podcast(super::podcast_task::PodcastTask),
    Noop,
}

#[cfg(test)]
mod tests {
    use chrono::DateTime;

    use crate::entity::task::{TaskAttributes, TaskDocument};

    #[test]
    fn should_serialize_task_document_pending_synchronize() {
        let task = TaskDocument {
            id: 1,
            kind: Default::default(),
            attributes: TaskAttributes {
                after: None,
                status: super::TaskStatus::Pending,
                payload: super::TaskPayload::Podcast(
                    crate::entity::podcast_task::PodcastTask::Synchronize { podcast_id: 42 },
                ),
                retries: 0,
                max_retries: 10,
                created_at: DateTime::from_timestamp(0, 0).unwrap(),
                updated_at: DateTime::from_timestamp(0, 0).unwrap(),
            },
        };
        let output = serde_json::to_string(&task).unwrap();
        assert_eq!(
            output,
            r#"{"id":1,"type":"tasks","attributes":{"status":{"type":"pending"},"targetKind":"podcast","method":"synchronize","targetId":42,"retries":0,"maxRetries":10,"createdAt":"1970-01-01T00:00:00Z","updatedAt":"1970-01-01T00:00:00Z"}}"#
        );
    }

    #[test]
    fn should_serialize_task_document_failed_synchronize() {
        let task = TaskDocument {
            id: 1,
            kind: Default::default(),
            attributes: TaskAttributes {
                after: None,
                status: super::TaskStatus::Failed {
                    message: Some("Oops".to_string()),
                },
                payload: super::TaskPayload::Podcast(
                    crate::entity::podcast_task::PodcastTask::SynchronizeAll,
                ),
                retries: 0,
                max_retries: 10,
                created_at: DateTime::from_timestamp(0, 0).unwrap(),
                updated_at: DateTime::from_timestamp(0, 0).unwrap(),
            },
        };
        let output = serde_json::to_string(&task).unwrap();
        assert_eq!(
            output,
            r#"{"id":1,"type":"tasks","attributes":{"status":{"type":"failed","message":"Oops"},"targetKind":"podcast","method":"synchronizeAll","retries":0,"maxRetries":10,"createdAt":"1970-01-01T00:00:00Z","updatedAt":"1970-01-01T00:00:00Z"}}"#
        );
    }

    #[test]
    fn should_serialize_task_document_running_noop() {
        let task = TaskDocument {
            id: 1,
            kind: Default::default(),
            attributes: TaskAttributes {
                after: None,
                status: super::TaskStatus::Running,
                payload: super::TaskPayload::Noop,
                retries: 0,
                max_retries: 10,
                created_at: DateTime::from_timestamp(0, 0).unwrap(),
                updated_at: DateTime::from_timestamp(0, 0).unwrap(),
            },
        };
        let output = serde_json::to_string(&task).unwrap();
        assert_eq!(
            output,
            r#"{"id":1,"type":"tasks","attributes":{"status":{"type":"running"},"targetKind":"noop","retries":0,"maxRetries":10,"createdAt":"1970-01-01T00:00:00Z","updatedAt":"1970-01-01T00:00:00Z"}}"#
        );
    }
}