tests

Author: comphead

datafusion/common/src/column.rs

@@ -428,7 +428,7 @@ mod tests {
             )
             .expect_err("should've failed to find field");
         let expected = r#"Schema error: No field named z. Valid fields are t1.a, t1.b, t2.c, t2.d, t3.a, t3.b, t3.c, t3.d, t3.e."#;
-        assert_eq!(err.to_string(), expected);
+        assert!(err.to_string().start_with(expected));
 
         // ambiguous column reference
         let col = Column::from_name("a");
@@ -439,7 +439,7 @@ mod tests {
             )
             .expect_err("should've found ambiguous field");
         let expected = "Schema error: Ambiguous reference to unqualified field a";
-        assert_eq!(err.to_string(), expected);
+        assert!(err.to_string().start_with(expected));
 
         Ok(())
     }

datafusion/common/src/dfschema.rs

@@ -811,10 +811,9 @@ mod tests {
         let schema = DFSchema::try_from_qualified_schema("t1", &test_schema_1())?;
         // lookup with unqualified name "t1.c0"
         let err = schema.index_of_column(&col).unwrap_err();
-        assert_eq!(
-            err.to_string(),
-            "Schema error: No field named \"t1.c0\". Valid fields are t1.c0, t1.c1.",
-        );
+        assert!(err.to_string().starts_with(
+            "Schema error: No field named \"t1.c0\". Valid fields are t1.c0, t1.c1."
+        ));
         Ok(())
     }
 
@@ -831,9 +830,9 @@ mod tests {
 
         // lookup with unqualified name "t1.c0"
         let err = schema.index_of_column(&col).unwrap_err();
-        assert_eq!(
-            err.to_string(),
-            "Schema error: No field named \"t1.c0\". Valid fields are t1.\"CapitalColumn\", t1.\"field.with.period\".",
+        assert!(
+            err.to_string().starts_with(
+            "Schema error: No field named \"t1.c0\". Valid fields are t1.\"CapitalColumn\", t1.\"field.with.period\".")
         );
         Ok(())
     }
@@ -915,9 +914,9 @@ mod tests {
         let left = DFSchema::try_from(test_schema_1())?;
         let right = DFSchema::try_from(test_schema_1())?;
         let join = left.join(&right);
-        assert_eq!(
-            join.unwrap_err().to_string(),
-            "Schema error: Schema contains duplicate unqualified field name c0",
+        assert!(
+            join.unwrap_err().to_string().starts_with(,
+            "Schema error: Schema contains duplicate unqualified field name c0")
         );
         Ok(())
     }
@@ -993,12 +992,16 @@ mod tests {
 
         let col = Column::from_qualified_name("t1.c0");
         let err = schema.index_of_column(&col).unwrap_err();
-        assert_eq!(err.to_string(), "Schema error: No field named t1.c0.");
+        assert!(err
+            .to_string()
+            .starts_with("Schema error: No field named t1.c0."));
 
         // the same check without qualifier
         let col = Column::from_name("c0");
         let err = schema.index_of_column(&col).err().unwrap();
-        assert_eq!("Schema error: No field named c0.", err.to_string());
+        assert!(err
+            .to_string()
+            .starts_with("Schema error: No field named c0."));
     }
 
     #[test]

datafusion/common/src/error.rs

@@ -507,16 +507,19 @@ mod test {
     #[test]
     fn arrow_error_to_datafusion() {
         let res = return_arrow_error().unwrap_err();
-        assert_eq!(
-            res.to_string(),
-            "External error: Error during planning: foo"
+        assert!(
+            res.to_string().starts_with(,
+            "External error: Error during planning: foo")
         );
     }
 
     #[test]
     fn datafusion_error_to_arrow() {
         let res = return_datafusion_error().unwrap_err();
-        assert_eq!(res.to_string(), "Arrow error: Schema error: bar");
+        assert_eq!(res
+            .to_string()
+            .to_string()
+            .starts_with("Arrow error: Schema error: bar"));
     }
 
     #[test]
@@ -579,33 +582,35 @@ mod test {
     fn test_make_error_parse_input() {
         let res: Result<(), DataFusionError> = plan_err!("Err");
         let res = res.unwrap_err();
-        assert_eq!(res.to_string(), "Error during planning: Err");
+        assert!(res.to_string().starts_with("Error during planning: Err"));
 
         let extra1 = "extra1";
         let extra2 = "extra2";
 
         let res: Result<(), DataFusionError> = plan_err!("Err {} {}", extra1, extra2);
         let res = res.unwrap_err();
-        assert_eq!(res.to_string(), "Error during planning: Err extra1 extra2");
+        assert!(res
+            .to_string()
+            .starts_with("Error during planning: Err extra1 extra2"));
 
         let res: Result<(), DataFusionError> =
             plan_err!("Err {:?} {:#?}", extra1, extra2);
         let res = res.unwrap_err();
-        assert_eq!(
-            res.to_string(),
-            "Error during planning: Err \"extra1\" \"extra2\""
-        );
+        assert!(res
+            .to_string()
+            .starts_with("Error during planning: Err \"extra1\" \"extra2\""));
 
         let res: Result<(), DataFusionError> = plan_err!("Err {extra1} {extra2}");
         let res = res.unwrap_err();
-        assert_eq!(res.to_string(), "Error during planning: Err extra1 extra2");
+        assert!(res
+            .to_string()
+            .starts_with("Error during planning: Err extra1 extra2"));
 
         let res: Result<(), DataFusionError> = plan_err!("Err {extra1:?} {extra2:#?}");
         let res = res.unwrap_err();
-        assert_eq!(
-            res.to_string(),
-            "Error during planning: Err \"extra1\" \"extra2\""
-        );
+        assert!(res
+            .to_string()
+            .starts_with("Error during planning: Err \"extra1\" \"extra2\""));
     }
 
     /// Model what happens when implementing SendableRecordBatchStream:
@@ -626,7 +631,7 @@ mod test {
         let e = e.find_root();
 
         // DataFusionError does not implement Eq, so we use a string comparison + some cheap "same variant" test instead
-        assert_eq!(e.to_string(), exp.to_string(),);
+        assert!(e.to_string().starts_with(exp.to_string()));
         assert_eq!(std::mem::discriminant(e), std::mem::discriminant(&exp),)
     }
 }

datafusion/common/src/scalar.rs

@@ -3239,9 +3239,9 @@ mod tests {
         let int_value = ScalarValue::Int32(Some(i32::MAX));
         let int_value_2 = ScalarValue::Int32(Some(i32::MIN));
         let err = int_value.sub_checked(&int_value_2).unwrap_err().to_string();
-        assert_eq!(
-            err,
-            "Arrow error: Compute error: Overflow happened on: 2147483647 - -2147483648"
+        assert!(
+            err.starts_with(,
+            "Arrow error: Compute error: Overflow happened on: 2147483647 - -2147483648")
         )
     }
 
@@ -3259,7 +3259,7 @@ mod tests {
         let int_value = ScalarValue::Int64(Some(i64::MAX));
         let int_value_2 = ScalarValue::Int64(Some(i64::MIN));
         let err = int_value.sub_checked(&int_value_2).unwrap_err().to_string();
-        assert_eq!(err, "Arrow error: Compute error: Overflow happened on: 9223372036854775807 - -9223372036854775808")
+        assert!(err.starts_with("Arrow error: Compute error: Overflow happened on: 9223372036854775807 - -9223372036854775808"))
     }
 
     #[test]