From 0823e3be8fdaa559f48df48d6f3326d962d3e799 Mon Sep 17 00:00:00 2001
From: Scott Driggers <github@msd3.io>
Date: Sat, 24 Jul 2021 10:47:42 -0400
Subject: [PATCH] Adding single test

---
 diesel_derives/tests/as_expression.rs | 89 +++++++++++++++++++++++++++
 diesel_derives/tests/tests.rs         |  2 +
 2 files changed, 91 insertions(+)
 create mode 100644 diesel_derives/tests/as_expression.rs

diff --git a/diesel_derives/tests/as_expression.rs b/diesel_derives/tests/as_expression.rs
new file mode 100644
index 0000000000..82533c9fc5
--- /dev/null
+++ b/diesel_derives/tests/as_expression.rs
@@ -0,0 +1,89 @@
+use diesel::backend::Backend;
+use diesel::deserialize::FromSql;
+use diesel::expression::AsExpression;
+use diesel::serialize::{Output, ToSql};
+use diesel::*;
+use std::convert::TryInto;
+use std::io::Write;
+
+use helpers::connection;
+
+table! {
+    my_structs (foo) {
+        foo -> Integer,
+        bar -> Text,
+    }
+}
+use diesel::sql_types::Text;
+#[derive(Debug, AsExpression, FromSqlRow, Clone, Copy, PartialEq)]
+#[sql_type = "Text"]
+struct StringArray<const N: usize>(pub [u8; N]);
+
+impl<DB, const N: usize> FromSql<Text, DB> for StringArray<N>
+where
+    DB: Backend,
+    String: FromSql<Text, DB>,
+{
+    fn from_sql(bytes: backend::RawValue<DB>) -> deserialize::Result<Self> {
+        let string = <String as FromSql<Text, DB>>::from_sql(bytes)?;
+        let bytes_array: [u8; N] = string.into_bytes().try_into().unwrap();
+        Ok(StringArray(bytes_array))
+    }
+}
+
+impl<DB, const N: usize> ToSql<Text, DB> for StringArray<N>
+where
+    DB: Backend,
+    String: ToSql<Text, DB>,
+{
+    fn to_sql<W: Write>(&self, out: &mut Output<W, DB>) -> serialize::Result {
+        let string = std::str::from_utf8(&self.0).unwrap().to_owned();
+
+        string.to_sql(out)
+    }
+}
+
+#[test]
+fn struct_with_sql_type() {
+    #[derive(Debug, Clone, PartialEq, Queryable, Selectable)]
+    #[table_name = "my_structs"]
+    struct MyStruct {
+        foo: i32,
+        bar: StringArray<4>,
+    }
+
+    let conn = &mut connection();
+    let data = my_structs::table
+        .select(MyStruct::as_select())
+        .get_result(conn);
+    assert!(data.is_err());
+}
+
+// #[test]
+// #[cfg(all(feature = "postgres", not(feature = "sqlite"), not(feature = "mysql")))]
+// fn test_generic_array_type() {
+//     #[derive(Debug, Clone, PartialEq, Queryable)]
+//     struct MySqlItem {
+//         foo: StringArray<2>,
+//         bar: i32,
+//     }
+
+//     let new_generic_array_expression = GenericArray([4.4, 4.4]);
+
+//     let conn = &mut connection();
+//     let data = select(sql::<(Array<Float8>, Integer)>("[1, 2], 2")).get_result(conn);
+//     assert_eq!(
+//         Ok(MySqlItem {
+//             foo: StringArray([29, 1]),
+//             bar: 2
+//         }),
+//         data
+//     );
+// }
+
+// ::<dyn Expression<SqlType = Array<Float8>>>
+
+// use diesel::sql_types::{Array, Float8};
+// #[derive(Debug, AsExpression, Clone, Copy, PartialEq)]
+// #[sql_type = "Array<Float8>"]
+// struct GenericArray<T, const N: usize>(pub [T; N]);
diff --git a/diesel_derives/tests/tests.rs b/diesel_derives/tests/tests.rs
index 561d0375a2..f73075810b 100644
--- a/diesel_derives/tests/tests.rs
+++ b/diesel_derives/tests/tests.rs
@@ -15,3 +15,5 @@ mod insertable;
 mod queryable;
 mod queryable_by_name;
 mod selectable;
+
+mod as_expression;