add tests for max_name_len and fix one bug.

Author: kafka1991

questdb-rs/src/ingress/http.rs

@@ -23,7 +23,6 @@
  ******************************************************************************/
 
 use super::conf::ConfigSetting;
-use super::MAX_NAME_LEN_DEFAULT;
 use crate::error::fmt;
 use crate::{error, Error};
 use base64ct::Base64;
@@ -441,6 +440,7 @@ pub(super) fn http_send_with_retries(
 pub(super) fn read_server_settings(
     state: &HttpHandlerState,
     settings_url: &str,
+    default_max_name_len: usize,
 ) -> Result<(Vec<ProtocolVersion>, usize), Error> {
     let default_protocol_version = ProtocolVersion::V1;
 
@@ -455,7 +455,7 @@ pub(super) fn read_server_settings(
                 let status = res.status();
                 _ = res.into_body().read_to_vec();
                 if status.as_u16() == 404 {
-                    return Ok((vec![default_protocol_version], MAX_NAME_LEN_DEFAULT));
+                    return Ok((vec![default_protocol_version], default_max_name_len));
                 }
                 return Err(fmt!(
                     ProtocolVersionError,
@@ -471,7 +471,7 @@ pub(super) fn read_server_settings(
             let e = match err {
                 ureq::Error::StatusCode(code) => {
                     if code == 404 {
-                        return Ok((vec![default_protocol_version], MAX_NAME_LEN_DEFAULT));
+                        return Ok((vec![default_protocol_version], default_max_name_len));
                     } else {
                         fmt!(
                             ProtocolVersionError,
@@ -528,7 +528,7 @@ pub(super) fn read_server_settings(
             .get("config")
             .and_then(|v| v.get("cairo.max.file.name.length"))
             .and_then(|v| v.as_u64())
-            .unwrap_or(MAX_NAME_LEN_DEFAULT as u64) as usize;
+            .unwrap_or(default_max_name_len as u64) as usize;
         Ok((support_versions, max_name_length))
     } else {
         Err(error::fmt!(

questdb-rs/src/ingress/mod.rs

@@ -57,7 +57,7 @@ use ring::{
     signature::{EcdsaKeyPair, ECDSA_P256_SHA256_FIXED_SIGNING},
 };
 
-pub(crate) const MAX_NAME_LEN_DEFAULT: usize = 127;
+const MAX_NAME_LEN_DEFAULT: usize = 127;
 
 /// The maximum allowed dimensions for arrays.
 pub const MAX_ARRAY_DIMS: usize = 32;
@@ -2618,7 +2618,7 @@ impl SenderBuilder {
                             self.port.deref()
                         );
                         let (protocol_versions, server_max_name_len) =
-                            read_server_settings(http_state, settings_url)?;
+                            read_server_settings(http_state, settings_url, max_name_len)?;
                         max_name_len = server_max_name_len;
                         if protocol_versions.contains(&ProtocolVersion::V2) {
                             ProtocolVersion::V2

questdb-rs/src/tests/http.rs

@@ -701,10 +701,12 @@ fn test_transactional(
 fn _test_sender_auto_detect_protocol_version(
     supported_versions: Option<Vec<u16>>,
     expect_version: ProtocolVersion,
+    max_name_len: usize,
+    expect_max_name_len: usize,
 ) -> TestResult {
     let supported_versions1 = supported_versions.clone();
     let mut server = MockServer::new()?
-        .configure_settings_response(supported_versions.as_deref().unwrap_or(&[]));
+        .configure_settings_response(supported_versions.as_deref().unwrap_or(&[]), max_name_len);
     let sender_builder = server.lsb_http();
 
     let server_thread = std::thread::spawn(move || -> io::Result<MockServer> {
@@ -735,6 +737,7 @@ fn _test_sender_auto_detect_protocol_version(
 
     let mut sender = sender_builder.build()?;
     assert_eq!(sender.protocol_version(), expect_version);
+    assert_eq!(sender.max_name_len(), expect_max_name_len);
     let mut buffer = sender.new_buffer();
     buffer
         .table("test")?
@@ -749,32 +752,32 @@ fn _test_sender_auto_detect_protocol_version(
 
 #[test]
 fn test_sender_auto_protocol_version_basic() -> TestResult {
-    _test_sender_auto_detect_protocol_version(Some(vec![1, 2]), ProtocolVersion::V2)
+    _test_sender_auto_detect_protocol_version(Some(vec![1, 2]), ProtocolVersion::V2, 130, 130)
 }
 
 #[test]
 fn test_sender_auto_protocol_version_old_server1() -> TestResult {
-    _test_sender_auto_detect_protocol_version(Some(vec![]), ProtocolVersion::V1)
+    _test_sender_auto_detect_protocol_version(Some(vec![]), ProtocolVersion::V1, 0, 127)
 }
 
 #[test]
 fn test_sender_auto_protocol_version_old_server2() -> TestResult {
-    _test_sender_auto_detect_protocol_version(None, ProtocolVersion::V1)
+    _test_sender_auto_detect_protocol_version(None, ProtocolVersion::V1, 0, 127)
 }
 
 #[test]
 fn test_sender_auto_protocol_version_only_v1() -> TestResult {
-    _test_sender_auto_detect_protocol_version(Some(vec![1]), ProtocolVersion::V1)
+    _test_sender_auto_detect_protocol_version(Some(vec![1]), ProtocolVersion::V1, 127, 127)
 }
 
 #[test]
 fn test_sender_auto_protocol_version_only_v2() -> TestResult {
-    _test_sender_auto_detect_protocol_version(Some(vec![2]), ProtocolVersion::V2)
+    _test_sender_auto_detect_protocol_version(Some(vec![2]), ProtocolVersion::V2, 127, 127)
 }
 
 #[test]
 fn test_sender_auto_protocol_version_unsupported_client() -> TestResult {
-    let mut server = MockServer::new()?.configure_settings_response(&[3, 4]);
+    let mut server = MockServer::new()?.configure_settings_response(&[3, 4], 127);
     let sender_builder = server.lsb_http();
     let server_thread = std::thread::spawn(move || -> io::Result<MockServer> {
         server.accept()?;
@@ -792,6 +795,76 @@ fn test_sender_auto_protocol_version_unsupported_client() -> TestResult {
     Ok(())
 }
 
+#[test]
+fn test_sender_short_max_name_len() -> TestResult {
+    _test_sender_max_name_len(4, 4, 0)
+}
+
+#[test]
+fn test_sender_specify_max_name_len_with_response() -> TestResult {
+    _test_sender_max_name_len(4, 4, 127)
+}
+
+#[test]
+fn test_sender_long_max_name_len() -> TestResult {
+    _test_sender_max_name_len(130, 130, 0)
+}
+
+#[test]
+fn test_sender_specify_max_name_len_without_response() -> TestResult {
+    _test_sender_max_name_len(0, 16, 16)
+}
+
+#[test]
+fn test_sender_default_max_name_len() -> TestResult {
+    _test_sender_max_name_len(0, 127, 0)
+}
+
+fn _test_sender_max_name_len(
+    response_max_name_len: usize,
+    expect_max_name_len: usize,
+    sender_specify_max_name_len: usize,
+) -> TestResult {
+    let mut server = MockServer::new()?;
+    if response_max_name_len != 0 {
+        server = server.configure_settings_response(&[1, 2], response_max_name_len);
+    }
+
+    let mut sender_builder = server.lsb_http();
+    if sender_specify_max_name_len != 0 {
+        sender_builder = sender_builder.max_name_len(sender_specify_max_name_len)?;
+    }
+    let server_thread = std::thread::spawn(move || -> io::Result<MockServer> {
+        server.accept()?;
+        match response_max_name_len {
+            0 => server.send_http_response_q(
+                HttpResponse::empty()
+                    .with_status(404, "Not Found")
+                    .with_header("content-type", "text/plain")
+                    .with_body_str("Not Found"),
+            )?,
+            _ => server.send_settings_response()?,
+        }
+        Ok(server)
+    });
+    let sender = sender_builder.build()?;
+    assert_eq!(sender.max_name_len(), expect_max_name_len);
+    let mut buffer = sender.new_buffer();
+    let name = "a name too long";
+    if expect_max_name_len < name.len() {
+        assert_err_contains(
+            buffer.table(name),
+            ErrorCode::InvalidName,
+            r#"Bad name: "a name too long": Too long (max 4 characters)"#,
+        );
+    } else {
+        assert!(buffer.table(name).is_ok());
+    }
+    // We keep the server around til the end of the test to ensure that the response is fully received.
+    _ = server_thread.join().unwrap()?;
+    Ok(())
+}
+
 #[test]
 fn test_buffer_protocol_version1_not_support_array() -> TestResult {
     let mut buffer = Buffer::new(ProtocolVersion::V1);

questdb-rs/src/tests/mock.rs

@@ -310,7 +310,11 @@ impl MockServer {
     }
 
     #[cfg(feature = "ilp-over-http")]
-    pub fn configure_settings_response(mut self, supported_versions: &[u16]) -> Self {
+    pub fn configure_settings_response(
+        mut self,
+        supported_versions: &[u16],
+        max_name_len: usize,
+    ) -> Self {
         if supported_versions.is_empty() {
             self.settings_response = serde_json::json!({"version": "8.1.2"});
         } else {
@@ -320,7 +324,7 @@ impl MockServer {
                     "ilp.proto.transports":["tcp", "http"],
                     "posthog.enabled":false,
                     "posthog.api.key":null,
-                    "cairo.max.file.name.length":127},
+                    "cairo.max.file.name.length": max_name_len},
                     "preferences.version":0,
                     "preferences":{}}
             );

system_test/test.py

@@ -54,7 +54,7 @@
 BUILD_MODE = None
 
 # The first QuestDB version that supports array types.
-FIRST_ARRAYS_RELEASE = (8, 3, 1)
+FIRST_ARRAYS_RELEASE = (8, 3, 3)
 
 
 def retry_check_table(*args, **kwargs):
@@ -137,6 +137,10 @@ def _expect_eventual_disconnect(self, sender):
                  .at_now())
                 sender.flush()
 
+    def test_default_max_name_len(self):
+        with self._mk_linesender() as sender:
+            self.assertEqual(sender.max_name_len, 127)
+
     def test_insert_three_rows(self):
         table_name = uuid.uuid4().hex
         pending = None