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

#[macro_use]
extern crate query_params;
#[macro_use]
extern crate serde_json;

pub mod client;
pub mod key_value_stores;
pub mod datasets;
pub mod request;
pub mod utils;
pub mod generic_types;

use crate::client::{ApifyClient, IdOrName, ApifyClientError};
use crate::datasets::{Dataset};
use crate::generic_types::{NoContent};

// These are integration tests that call Apify APIs

// They require an API token in test/test_token.txt file as plain string

#[cfg(test)]
mod test {
    use super::*;

    // Simple await macro for tests

    macro_rules! await_test {
        ($e:expr) => {
            tokio_test::block_on($e)
        };
    }

    // You must have token in test/test_token.txt file as plain string

    fn create_client () -> ApifyClient {
        let path = std::env::current_dir().unwrap();
        println!("The current directory is {}", path.display());
        let token = std::fs::read_to_string("test/test_token.txt");
        println!("{:?}", token);
        let my_client = ApifyClient::new(token.ok());
        my_client
    }    

    // Helper functions for sending the actual requests

    // Needed because we need to clean up after each test

    fn create_dataset (client: &ApifyClient, name: &str) -> Dataset {
        let dataset = await_test!(client.create_dataset(name).send()).unwrap();
        dataset
    }

    fn delete_dataset (client: &ApifyClient, id_or_name: &IdOrName) -> NoContent {
        let no_content = await_test!(client.delete_dataset(id_or_name).send()).unwrap();
        no_content
    }

    fn get_dataset (client: &ApifyClient, id_or_name: &IdOrName) -> Result<Dataset, ApifyClientError> {
        let maybe_dataset = await_test!(client.get_dataset(id_or_name).send());
        maybe_dataset
    }

    // This is done as one mega test to limit number of API calls when cleaning

    // but perhaps there is a better way

    #[test]
    fn create_and_get_and_delete_dataset () {
        let client = create_client();
        let name = "RUST-TEST-CREATE";

        let dataset = create_dataset(&client, name);
        assert_eq!(dataset.name.unwrap(), name);

        let dataset_id = dataset.id.clone();

        let maybe_dataset = get_dataset(&client, &IdOrName::Id(dataset_id.clone()));
        assert_eq!(maybe_dataset.unwrap().name.unwrap(), name);

        let no_content = delete_dataset(&client, &IdOrName::Id(dataset.id));
        assert_eq!(no_content, NoContent::new());

        let maybe_dataset = get_dataset(&client, &IdOrName::Id(dataset_id));
        assert!(maybe_dataset.is_err());
        assert_eq!(maybe_dataset.unwrap_err(), ApifyClientError::NotFound("Dataset was not found".to_string()));
    }
    
    #[test]
    fn list_datasets_test () {
        let client = create_client();
        let name = "RUST-TEST-LIST";

        let dataset = create_dataset(&client, name);
        let dataset_id = dataset.id;
        
        let maybe_pagination_list = await_test!(client.list_datasets().limit(10).send());
        assert!(maybe_pagination_list.is_ok());
        assert!(maybe_pagination_list.unwrap().items.iter().find(|dataset| dataset.id == dataset_id.clone()).is_some());

        delete_dataset(&client, &IdOrName::Id(dataset_id.clone()));

        let maybe_pagination_list = await_test!(client.list_datasets().limit(10).send());
        assert!(maybe_pagination_list.is_ok());
        assert!(maybe_pagination_list.unwrap().items.iter().find(|dataset| dataset.id == dataset_id).is_none());
    }

    #[test] 
    fn put_items () {
        /*
        // PUT ITEMS

        let item1 = serde_json::json!({ "obj": 1 });
        let item2 = serde_json::json!({ "obj": 2 });
        let v = vec![item1, item2];
        let put_result = my_client.put_items(&dataset_id, &v).send().await;
        println!("Put result: {:?}", put_result);
        */
    }
}