solrstice 0.15.0

A Solr 8+ client
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use crate::structures::{BaseTestsBuildup, ErrrorTestsSetup, FunctionalityTestsBuildup};
use log::{Metadata, Record};
use serial_test::serial;
use solrstice::Error;
use solrstice::LoggingPolicy;
use solrstice::SolrServerContextBuilder;
use solrstice::{AsyncSolrCloudClient, SelectQuery};
use std::sync::{Arc, Mutex, OnceLock};

struct TestLogger {
    pub messages: Arc<Mutex<Vec<String>>>,
}

impl log::Log for TestLogger {
    fn enabled(&self, metadata: &Metadata) -> bool {
        metadata.level() <= log::Level::Debug
    }

    fn log(&self, record: &Record) {
        if self.enabled(record.metadata()) {
            let mut messages = self.messages.lock().unwrap();
            messages.push(format!("{} - {}", record.level(), record.args()));
        }
    }

    fn flush(&self) {}
}

static LOGGER_MESSAGES: OnceLock<Arc<Mutex<Vec<String>>>> = OnceLock::new();

pub fn init_logger() -> Arc<Mutex<Vec<String>>> {
    let messages = Arc::new(Mutex::new(Vec::new()));
    let logger = TestLogger {
        messages: Arc::clone(&messages),
    };
    log::set_boxed_logger(Box::new(logger)).unwrap();
    log::set_max_level(log::LevelFilter::Debug);
    messages
}

#[tokio::test]
#[serial]
async fn logging_logs_message() -> Result<(), Error> {
    let config = BaseTestsBuildup::new().await;
    let mut context = SolrServerContextBuilder::new(config.host);
    if config.auth.is_some() {
        context = context.with_auth(config.auth.unwrap());
    }
    let context = context.build();
    let client = AsyncSolrCloudClient::new(context);

    LOGGER_MESSAGES
        .get_or_init(init_logger)
        .lock()
        .unwrap()
        .clear();

    let _ = client.get_configs().await.unwrap();
    let messages = LOGGER_MESSAGES.get().unwrap().lock().unwrap();
    for message in messages.iter() {
        if message.contains("Sending Solr request to") {
            return Ok(());
        }
    }
    Err(Error::Unknown("No log message found".to_string()))
}

#[tokio::test]
#[serial]
async fn logging_does_not_log_message_if_disabled() -> Result<(), Error> {
    let config = BaseTestsBuildup::new().await;
    let mut context =
        SolrServerContextBuilder::new(config.host).with_logging_policy(LoggingPolicy::Off);
    if config.auth.is_some() {
        context = context.with_auth(config.auth.unwrap());
    }
    let context = context.build();
    let client = AsyncSolrCloudClient::new(context);

    LOGGER_MESSAGES
        .get_or_init(init_logger)
        .lock()
        .unwrap()
        .clear();

    let _ = client.get_configs().await.unwrap();

    let messages = LOGGER_MESSAGES.get().unwrap().lock().unwrap();
    for message in messages.iter() {
        if message.contains("Sending Solr request to") {
            return Err(Error::Unknown(format!(
                "Did not expect log message, but got {}",
                message
            )));
        }
    }
    Ok(())
}

#[tokio::test]
#[serial]
async fn logging_works_if_request_fails() -> Result<(), Error> {
    let config = FunctionalityTestsBuildup::build_up("SyntaxErrorLogging")
        .await
        .unwrap();
    let client = AsyncSolrCloudClient::new(config.context);

    LOGGER_MESSAGES
        .get_or_init(init_logger)
        .lock()
        .unwrap()
        .clear();

    let query = SelectQuery::new().fq(["this_is_a_syntax_error::0"]);
    let _ = client.select(query, &config.collection_name).await;
    let messages = LOGGER_MESSAGES.get().unwrap().lock().unwrap();
    for message in messages.iter() {
        if message.contains("Sending Solr request to") {
            return Ok(());
        }
    }
    Err(Error::Unknown("No log message found".to_string()))
}

#[tokio::test]
#[serial]
async fn logging_works_if_request_never_reaches_solr() -> Result<(), Error> {
    let config = ErrrorTestsSetup::new().await;
    let client = AsyncSolrCloudClient::new(config.http_context);

    LOGGER_MESSAGES
        .get_or_init(init_logger)
        .lock()
        .unwrap()
        .clear();

    let _ = client.select(SelectQuery::new(), "error_collection").await;
    let messages = LOGGER_MESSAGES.get().unwrap().lock().unwrap();
    for message in messages.iter() {
        if message.contains("Sending Solr request to") {
            return Ok(());
        }
    }
    Err(Error::Unknown("No log message found".to_string()))
}