#[cfg(test)]
mod tests {
    use gradecoin::schema::*;
    use serde_test::{assert_tokens, Token};
    use chrono::NaiveDate;

    #[test]
    fn claims_serialize_correctly() {
        let claims = Claims {
            tha: "hashed_string".to_owned(),
            iat: 0,
            exp: 100,
        };
        assert_tokens(
            &claims,
            &[
                Token::Struct{name: "Claims", len: 3},
                Token::String("tha"),
                Token::String("hashed_string"),
                Token::String("iat"),
                Token::U64(0),
                Token::String("exp"),
                Token::U64(100),
                Token::StructEnd,
            ]
        )
    }

    #[test]
    fn claims_deserialize_correctly() {
        let data = r#"{"tha":"hashed_string","iat":0,"exp":100}"#;
        let claims: Claims = serde_json::from_str(data).unwrap();
        let expected_claims = Claims {
            tha: "hashed_string".to_owned(),
            iat: 0,
            exp: 100,
        };
        assert_eq!(claims, expected_claims);
    }

    #[test]
    fn transaction_serialize_correctly() {
        let transaction = Transaction {
            by: "source".to_owned(),
            source: "source".to_owned(),
            target: "target".to_owned(),
            amount: 0,
            timestamp: NaiveDate::from_ymd(2021, 4, 2).and_hms(4, 2, 42),
        };

        assert_tokens(
            &transaction,
            &[
                Token::Struct{name: "Transaction", len: 5},
                Token::String("by"),
                Token::String("source"),
                Token::String("source"),
                Token::String("source"),
                Token::String("target"),
                Token::String("target"),
                Token::String("amount"),
                Token::I32(0),
                Token::String("timestamp"),
                Token::String("2021-04-02T04:02:42"),
                Token::StructEnd,
            ]
        )
    }

    #[test]
    fn transaction_deserialize_correctly() {
        let data = r#"{"by":"source","source":"source","target":"target","amount":0,"timestamp":"2021-04-02T04:02:42"}"#;
        let transaction: Transaction = serde_json::from_str(data).unwrap();
        let expected_transaction = Transaction {
            by: "source".to_owned(),
            source: "source".to_owned(),
            target: "target".to_owned(),
            amount: 0,
            timestamp: NaiveDate::from_ymd(2021, 4, 2).and_hms(4, 2, 42),
        };

        assert_eq!(transaction, expected_transaction);
    }

    #[test]
    fn block_serialize_correctly() {
        let block = Block {
            transaction_list: vec!["transaction1".to_owned()],
            nonce: 0,
            timestamp: NaiveDate::from_ymd(2021, 4, 2).and_hms(4, 2, 42),
            hash: "hash".to_owned()
        };

        assert_tokens(
            &block,
            &[
                Token::Struct{name: "Block", len: 4},
                Token::String("transaction_list"),
                Token::Seq {len: Some(1)},
                Token::String("transaction1"),
                Token::SeqEnd,
                Token::String("nonce"),
                Token::U32(0),
                Token::String("timestamp"),
                Token::String("2021-04-02T04:02:42"),
                Token::String("hash"),
                Token::String("hash"),
                Token::StructEnd,
            ]
        )
    }

    #[test]
    fn block_deserialize_correctly() {
        let expected_block = Block {
            transaction_list: vec!["transaction1".to_owned()],
            nonce: 0,
            timestamp: NaiveDate::from_ymd(2021, 4, 2).and_hms(4, 2, 42),
            hash: "hash".to_owned()
        };
        let data = r#"{"transaction_list":["transaction1"],"nonce":0,"timestamp":"2021-04-02T04:02:42","hash":"hash"}"#;
        let block: Block = serde_json::from_str(data).unwrap();

        assert_eq!(block, expected_block);

    }

    #[test]
    fn block_serialize_when_vec_emptpy() {
        let block = Block {
            transaction_list: vec![],
            nonce: 0,
            timestamp: NaiveDate::from_ymd(2021, 4, 2).and_hms(4, 2, 42),
            hash: "hash".to_owned()
        };

        let json = serde_json::to_string(&block).unwrap();
        assert_eq!(json, r#"{"nonce":0,"timestamp":"2021-04-02T04:02:42","hash":"hash"}"#)
    }

    #[test]
    fn naked_block_serialize_correctly() {
        let naked_block = NakedBlock {
            transaction_list: vec!["transaction1".to_owned()],
            nonce: 0,
            timestamp: NaiveDate::from_ymd(2021, 4, 2).and_hms(4, 2, 42),
        };

        assert_tokens(
            &naked_block,
            &[
                Token::Struct{name: "NakedBlock", len: 3},
                Token::String("transaction_list"),
                Token::Seq {len: Some(1)},
                Token::String("transaction1"),
                Token::SeqEnd,
                Token::String("nonce"),
                Token::U32(0),
                Token::String("timestamp"),
                Token::String("2021-04-02T04:02:42"),
                Token::StructEnd,
            ]
        )
    }

    #[test]
    fn naked_block_deserialize_correctly() {
        let expected_naked_block = NakedBlock {
            transaction_list: vec!["transaction1".to_owned()],
            nonce: 0,
            timestamp: NaiveDate::from_ymd(2021, 4, 2).and_hms(4, 2, 42),
        };
        let data = r#"{"transaction_list":["transaction1"],"nonce":0,"timestamp":"2021-04-02T04:02:42"}"#;
        let naked_block: NakedBlock = serde_json::from_str(data).unwrap();

        assert_eq!(naked_block, expected_naked_block);

    }

    #[test]
    fn naked_block_serialize_when_vec_emptpy() {
        let naked_block = NakedBlock {
            transaction_list: vec![],
            nonce: 0,
            timestamp: NaiveDate::from_ymd(2021, 4, 2).and_hms(4, 2, 42),
        };

        let json = serde_json::to_string(&naked_block).unwrap();
        assert_eq!(json, r#"{"nonce":0,"timestamp":"2021-04-02T04:02:42"}"#)
    }

    #[test]
    fn user_serialize_correctly() {
        let user = User {
            user_id: MetuId::new("e254275".to_owned(), "DtNX1qk4YF4saRH".to_owned()).unwrap(),
            public_key: "public_key".to_owned(),
            balance: 0
        };

        assert_tokens(
            &user,
            &[
                Token::Struct{name: "User", len: 3},
                Token::String("user_id"),
                Token::Struct {name: "MetuId", len: 2},
                Token::String("id"),
                Token::String("e254275"),
                Token::String("passwd"),
                Token::String("DtNX1qk4YF4saRH"),
                Token::StructEnd,
                Token::String("public_key"),
                Token::String("public_key"),
                Token::String("balance"),
                Token::I32(0),
                Token::StructEnd,
            ]
        )
    }

    #[test]
    fn user_deserialize_correctly() {
        let expected_user = User {
            user_id: MetuId::new("e254275".to_owned(), "DtNX1qk4YF4saRH".to_owned()).unwrap(),
            public_key: "public_key".to_owned(),
            balance: 0
        };
        let data = r#"{"user_id":{"id":"e254275","passwd":"DtNX1qk4YF4saRH"},"public_key":"public_key","balance":0}"#;
        let user: User = serde_json::from_str(data).unwrap();

        assert_eq!(user, expected_user);

    }

    #[test]
    fn metu_id_serialize_correctly() {
        let metu_id = MetuId::new ("e254275".to_owned(), "DtNX1qk4YF4saRH".to_owned()).unwrap();

        assert_tokens(
            &metu_id,
            &[
                Token::Struct{name: "MetuId", len: 2},
                Token::String("id"),
                Token::String("e254275"),
                Token::String("passwd"),
                Token::String("DtNX1qk4YF4saRH"),
                Token::StructEnd,
            ]
        )
    }

    #[test]
    fn metu_id_deserialize_correctly() {
        let expected_metu_id = MetuId::new ("e254275".to_owned(), "DtNX1qk4YF4saRH".to_owned()).unwrap();
        let data = r#"{"id":"e254275","passwd":"DtNX1qk4YF4saRH"}"#;
        let metu_id: MetuId = serde_json::from_str(data).unwrap();

        assert_eq!(metu_id, expected_metu_id);
    }

    #[test]
    fn auth_request_serialize_correctly() {
        let auth_request = AuthRequest {
            student_id: "e254275".to_owned(),
            passwd: "DtNX1qk4YF4saRH".to_owned(),
            public_key: "public_key".to_owned()
        };

        assert_tokens(
            &auth_request,
            &[
                Token::Struct{name: "AuthRequest", len: 3},
                Token::String("student_id"),
                Token::String("e254275"),
                Token::String("passwd"),
                Token::String("DtNX1qk4YF4saRH"),
                Token::String("public_key"),
                Token::String("public_key"),
                Token::StructEnd,
            ]
        )
    }

    #[test]
    fn auth_request_deserialize_correctly() {
        let expected_auth_request = AuthRequest {
            student_id: "e254275".to_owned(),
            passwd: "DtNX1qk4YF4saRH".to_owned(),
            public_key: "public_key".to_owned()
        };
        let data = r#"{"student_id":"e254275","passwd":"DtNX1qk4YF4saRH","public_key":"public_key"}"#;
        let auth_request: AuthRequest = serde_json::from_str(data).unwrap();

        assert_eq!(auth_request, expected_auth_request);

    }














}