force 0.2.0

Production-ready Salesforce Platform API client with REST and Bulk API 2.0 support
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

//! Regression tests for Bulk API batch size validation.
//!
//! Ensures that `process_csv_batches` and `SmartIngest` correctly handle invalid batch sizes.

#![cfg(feature = "bulk")]
#![allow(clippy::unwrap_used)]
#![allow(clippy::expect_used)]

use async_trait::async_trait;
use force::api::bulk::JobOperation;
use force::api::bulk::{process_csv_batches, serialize_to_csv};
use force::auth::{AccessToken, Authenticator, TokenResponse};
use force::client::builder;
use force::error::Result;
use serde::{Deserialize, Serialize};
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};

// Custom Authenticator for testing since MockAuthenticator is internal
#[derive(Debug)]
struct TestAuthenticator {
    instance_url: String,
}

#[async_trait]
impl Authenticator for TestAuthenticator {
    async fn authenticate(&self) -> Result<AccessToken> {
        Ok(AccessToken::from_response(TokenResponse {
            access_token: "test_token".to_string(),
            instance_url: self.instance_url.clone(),
            token_type: "Bearer".to_string(),
            issued_at: "1000".to_string(),
            signature: "sig".to_string(),
            expires_in: None,
            refresh_token: None,
        }))
    }

    async fn refresh(&self) -> Result<AccessToken> {
        self.authenticate().await
    }
}

#[derive(Serialize, Deserialize, Debug, Clone)]
struct Record {
    id: String,
}

#[test]
fn test_process_csv_batches_errors_on_zero_batch_size() {
    let records = vec![Record {
        id: "1".to_string(),
    }];
    let mut csv_data = Vec::new();
    serialize_to_csv(&records, &mut csv_data).unwrap();

    // Convert to slice for reading
    let reader = &csv_data[..];

    // This should error if batch_size is 0
    let result = process_csv_batches::<Record, _, _>(reader, 0, |_| Ok(()));

    // CURRENT BEHAVIOR: Ok(()) (Silent failure to process)
    // DESIRED BEHAVIOR: Err(ForceError::InvalidInput)
    assert!(
        result.is_err(),
        "Expected error for batch_size 0, but got Ok"
    );
}

#[tokio::test]
async fn test_smart_ingest_errors_on_zero_batch_size() {
    let mock_server = MockServer::start().await;
    let auth = TestAuthenticator {
        instance_url: mock_server.uri(),
    };

    let client = builder().authenticate(auth).build().await.unwrap();

    let handler = client.bulk();

    let records = vec![Record {
        id: "1".to_string(),
    }];
    let stream = futures::stream::iter(records);

    // Mock failure to catch if it proceeds to HTTP call
    Mock::given(method("POST"))
        .and(path("/services/data/v60.0/jobs/ingest"))
        .respond_with(ResponseTemplate::new(500))
        .mount(&mock_server)
        .await;

    let result = handler
        .smart_ingest("Account", JobOperation::Insert)
        .batch_size(0)
        .execute_stream(stream)
        .await;

    // CURRENT BEHAVIOR: Tries to execute (and fails on mock)
    // DESIRED BEHAVIOR: Err(ForceError::InvalidInput) with specific message

    match result {
        Err(force::error::ForceError::InvalidInput(msg)) => {
            assert!(
                msg.contains("Batch size must be greater than 0"),
                "Unexpected error message: {msg}"
            );
        }
        Err(e) => panic!("Expected InvalidInput error (batch size 0), got {e:?}"),
        Ok(_) => panic!("Expected error, got Ok"),
    }
}