Vendor dependencies

notes-service/vendor/sea-query-derive/tests/compile-fail/empty_list_iden.rs

@@ -0,0 +1,19 @@
+use sea_query::Iden;
+
+#[derive(Iden)]
+enum Asset {
+    Table,
+    Id,
+    AssetName,
+    #[iden()]
+    Creation(CreationInfo),
+}
+
+#[derive(Iden)]
+enum CreationInfo {
+    UserId,
+    #[iden = "creation_date"]
+    Date,
+}
+
+fn main() {}

notes-service/vendor/sea-query-derive/tests/compile-fail/empty_list_iden.stderr

@@ -0,0 +1,5 @@
+error: Must one of the following attributes: `flatten`, `rename` or `method`
+ --> $DIR/empty_list_iden.rs:8:7
+  |
+8 |     #[iden()]
+  |       ^^^^^^

notes-service/vendor/sea-query-derive/tests/compile-fail/enum_def/enum.rs

@@ -0,0 +1,8 @@
+use sea_query_derive::enum_def;
+
+#[enum_def]
+enum Hello {
+    Name,
+}
+
+fn main() {}

notes-service/vendor/sea-query-derive/tests/compile-fail/enum_def/enum.stderr

@@ -0,0 +1,5 @@
+error: #[enum_def] can only be used on non-tuple structs
+ --> tests/compile-fail/enum_def/enum.rs:4:1
+  |
+4 | enum Hello {
+  | ^^^^

notes-service/vendor/sea-query-derive/tests/compile-fail/enum_def/tuple_struct.rs

@@ -0,0 +1,6 @@
+use sea_query_derive::enum_def;
+
+#[enum_def]
+struct Hello(String);
+
+fn main() {}

notes-service/vendor/sea-query-derive/tests/compile-fail/enum_def/tuple_struct.stderr

@@ -0,0 +1,5 @@
+error: #[enum_def] can only be used on non-tuple structs
+ --> tests/compile-fail/enum_def/tuple_struct.rs:4:1
+  |
+4 | struct Hello(String);
+  | ^^^^^^

notes-service/vendor/sea-query-derive/tests/compile-fail/enum_def/unknown_field.rs

@@ -0,0 +1,8 @@
+use sea_query_derive::enum_def;
+
+#[enum_def(unknown_field)]
+pub struct Hello {
+    pub name: String,
+}
+
+fn main() {}

notes-service/vendor/sea-query-derive/tests/compile-fail/enum_def/unknown_field.stderr

@@ -0,0 +1,5 @@
+error: Unknown field: `unknown_field`
+ --> tests/compile-fail/enum_def/unknown_field.rs:3:12
+  |
+3 | #[enum_def(unknown_field)]
+  |            ^^^^^^^^^^^^^

notes-service/vendor/sea-query-derive/tests/compile-fail/mutli_field_flatten.rs

@@ -0,0 +1,19 @@
+use sea_query::Iden;
+
+#[derive(Iden)]
+enum Asset {
+    Table,
+    Id,
+    AssetName,
+    #[iden(flatten)]
+    Creation(CreationInfo, CreationInfo),
+}
+
+#[derive(Iden)]
+enum CreationInfo {
+    UserId,
+    #[iden = "creation_date"]
+    Date,
+}
+
+fn main() {}

notes-service/vendor/sea-query-derive/tests/compile-fail/mutli_field_flatten.stderr

@@ -0,0 +1,5 @@
+error: Must have a single field is supported for flattenning
+ --> $DIR/mutli_field_flatten.rs:9:13
+  |
+9 |     Creation(CreationInfo, CreationInfo),
+  |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

notes-service/vendor/sea-query-derive/tests/compile-fail/path_iden.rs

@@ -0,0 +1,12 @@
+use sea_query::Iden;
+
+#[derive(Iden)]
+enum Asset {
+    Table,
+    Id,
+    AssetName,
+    #[iden]
+    Creation,
+}
+
+fn main() {}

notes-service/vendor/sea-query-derive/tests/compile-fail/path_iden.stderr

@@ -0,0 +1,5 @@
+error: The iden attribute supports only the formats `#[iden = "name"]` or `#[iden(<ATTRIBUTE>)]` where ATTRIBUTE is either `flatten`, `rename` or `method`
+ --> $DIR/path_iden.rs:8:7
+  |
+8 |     #[iden]
+  |       ^^^^

notes-service/vendor/sea-query-derive/tests/compile-fail/path_method.rs

@@ -0,0 +1,12 @@
+use sea_query::Iden;
+
+#[derive(Iden)]
+enum Asset {
+    Table,
+    Id,
+    AssetName,
+    #[method]
+    Creation,
+}
+
+fn main() {}

notes-service/vendor/sea-query-derive/tests/compile-fail/path_method.stderr

@@ -0,0 +1,5 @@
+error: The method attribute only supports the `#[method = "name"]` or `#[iden(method = "name")]` formats
+ --> $DIR/path_method.rs:8:7
+  |
+8 |     #[method]
+  |       ^^^^^^

notes-service/vendor/sea-query-derive/tests/compile-fail/unsupported_container.rs

@@ -0,0 +1,8 @@
+use sea_query::Iden;
+
+#[derive(Iden)]
+struct User {
+    id: usize,
+}
+
+fn main() {}

notes-service/vendor/sea-query-derive/tests/compile-fail/unsupported_container.stderr

@@ -0,0 +1,5 @@
+error: you can only derive Iden on enums or unit structs
+ --> $DIR/unsupported_container.rs:4:8
+  |
+4 | struct User {
+  |        ^^^^

notes-service/vendor/sea-query-derive/tests/compile-fail/wrong_literal_type.rs

@@ -0,0 +1,13 @@
+use sea_query::Iden;
+
+#[derive(Iden)]
+enum User {
+    Table,
+    #[iden = 123]
+    Id,
+    FirstName,
+    LastName,
+    Email,
+}
+
+fn main() {}

notes-service/vendor/sea-query-derive/tests/compile-fail/wrong_literal_type.stderr

@@ -0,0 +1,5 @@
+error: Must be a string literal
+ --> $DIR/wrong_literal_type.rs:6:14
+  |
+6 |     #[iden = 123]
+  |              ^^^

notes-service/vendor/sea-query-derive/tests/pass-static/3_level_flatten.rs

@@ -0,0 +1,61 @@
+use sea_query::{Iden, IdenStatic};
+use strum::{EnumIter, IntoEnumIterator};
+
+#[derive(Copy, Clone, IdenStatic, EnumIter)]
+enum Asset {
+    Table,
+    Id,
+    AssetName,
+    #[iden(flatten)]
+    First {
+        first: FirstLevel,
+    },
+}
+
+#[derive(Copy, Clone, IdenStatic)]
+enum FirstLevel {
+    LevelOne,
+    #[iden(flatten)]
+    Second(SecondLevel),
+}
+
+#[derive(Copy, Clone, IdenStatic, EnumIter)]
+enum SecondLevel {
+    LevelTwo,
+    #[iden(flatten)]
+    Third(LevelThree),
+    UserId,
+}
+
+#[derive(Copy, Clone, IdenStatic, Default)]
+struct LevelThree;
+
+impl Default for FirstLevel {
+    fn default() -> Self {
+        Self::LevelOne
+    }
+}
+
+fn main() {
+    // custom ends up being default string which is an empty string
+    let expected = [
+        "asset",
+        "id",
+        "asset_name",
+        "level_one",
+        "level_two",
+        "level_three",
+        "user_id",
+    ];
+    Asset::iter()
+        .chain(
+            SecondLevel::iter()
+                .map(FirstLevel::Second)
+                .map(|s| Asset::First { first: s }),
+        )
+        .zip(expected)
+        .for_each(|(var, exp)| {
+            assert_eq!(var.to_string(), exp);
+            assert_eq!(var.as_str(), exp)
+        })
+}

notes-service/vendor/sea-query-derive/tests/pass-static/flattened_named.rs

@@ -0,0 +1,40 @@
+use sea_query::{Iden, IdenStatic};
+use strum::{EnumIter, IntoEnumIterator};
+
+#[derive(Copy, Clone, IdenStatic, EnumIter)]
+enum Asset {
+    Table,
+    Id,
+    AssetName,
+    #[iden(flatten)]
+    Creation {
+        info: CreationInfo,
+    },
+}
+
+#[derive(Copy, Clone, IdenStatic)]
+enum CreationInfo {
+    UserId,
+    #[iden = "creation_date"]
+    Date,
+}
+
+impl Default for CreationInfo {
+    fn default() -> Self {
+        Self::UserId
+    }
+}
+
+fn main() {
+    // custom ends up being default string which is an empty string
+    let expected = ["asset", "id", "asset_name", "user_id", "creation_date"];
+    Asset::iter()
+        .chain(std::iter::once(Asset::Creation {
+            info: CreationInfo::Date,
+        }))
+        .zip(expected)
+        .for_each(|(var, exp)| {
+            assert_eq!(var.to_string(), exp);
+            assert_eq!(var.as_str(), exp)
+        })
+}

notes-service/vendor/sea-query-derive/tests/pass-static/flattened_unnamed.rs

@@ -0,0 +1,31 @@
+use sea_query::{Iden, IdenStatic};
+use strum::{EnumIter, IntoEnumIterator};
+
+#[derive(Copy, Clone, IdenStatic, EnumIter)]
+enum Asset {
+    Table,
+    Id,
+    AssetName,
+    #[iden(flatten)]
+    Creation(CreationInfo),
+}
+
+#[derive(Default, Copy, Clone, IdenStatic)]
+enum CreationInfo {
+    #[default]
+    UserId,
+    #[iden = "creation_date"]
+    Date,
+}
+
+fn main() {
+    // custom ends up being default string which is an empty string
+    let expected = ["asset", "id", "asset_name", "user_id", "creation_date"];
+    Asset::iter()
+        .chain(std::iter::once(Asset::Creation(CreationInfo::Date)))
+        .zip(expected)
+        .for_each(|(var, exp)| {
+            assert_eq!(var.to_string(), exp);
+            assert_eq!(var.as_str(), exp)
+        })
+}

notes-service/vendor/sea-query-derive/tests/pass-static/meta_list_renaming_everything.rs

@@ -0,0 +1,48 @@
+use sea_query::{Iden, IntoIden, IdenStatic, MysqlQueryBuilder, PostgresQueryBuilder, QuotedBuilder};
+use strum::{EnumIter, IntoEnumIterator};
+
+#[derive(IdenStatic, EnumIter, Copy, Clone)]
+// Outer iden attributes overrides what's used for "Table"...
+#[iden(rename = "user")]
+enum Custom {
+    Table,
+    #[iden(rename = "my_id")]
+    Id,
+    #[iden(rename = "name")]
+    FirstName,
+    #[iden(rename = "surname")]
+    LastName,
+    // Custom casing if needed
+    #[iden(rename = "EM`ail")]
+    // the tuple value will be ignored
+    Email(i32),
+    // Custom method
+    #[iden(method = "custom_to_string")]
+    Custom,
+}
+
+impl Custom {
+    pub fn custom_to_string(&self) -> &'static str {
+        match self {
+            Self::Custom => "custom",
+            _ => panic!("not Custom::Custom"),
+        }
+    }
+}
+
+fn main() {
+    // custom ends up being default string which is an empty string
+    let expected = ["user", "my_id", "name", "surname", "EM`ail", "custom"];
+    Custom::iter()
+        .map(|var| var.to_string())
+        .zip(expected)
+        .for_each(|(iden, exp)| assert_eq!(iden, exp));
+    
+    let mut string = String::new();
+    PostgresQueryBuilder.prepare_iden(&Custom::Email(0).into_iden(), &mut string);
+    assert_eq!(string, "\"EM`ail\"");
+
+    let mut string = String::new();
+    MysqlQueryBuilder.prepare_iden(&Custom::Email(0).into_iden(), &mut string);
+    assert_eq!(string, "`EM``ail`");
+}

notes-service/vendor/sea-query-derive/tests/pass-static/renamed_unit_struct.rs

@@ -0,0 +1,10 @@
+use sea_query::{Iden, IdenStatic};
+
+#[derive(Copy, Clone, IdenStatic)]
+#[iden = "another_name"]
+pub struct CustomName;
+
+fn main() {
+    assert_eq!(CustomName.to_string(), "another_name");
+    assert_eq!(CustomName.as_str(), "another_name")
+}

notes-service/vendor/sea-query-derive/tests/pass-static/renaming_table.rs

@@ -0,0 +1,20 @@
+use sea_query::{Iden, IdenStatic};
+use strum::{EnumIter, IntoEnumIterator};
+
+#[derive(Copy, Clone, IdenStatic, EnumIter)]
+enum Something {
+    // ...the Table can also be overwritten like this
+    #[iden = "something_else"]
+    Table,
+    Id,
+    AssetName,
+    UserId,
+}
+
+fn main() {
+    let expected = ["something_else", "id", "asset_name", "user_id"];
+    Something::iter().zip(expected).for_each(|(var, exp)| {
+        assert_eq!(var.to_string(), exp);
+        assert_eq!(var.as_str(), exp)
+    })
+}

notes-service/vendor/sea-query-derive/tests/pass-static/simple_unit_struct.rs

@@ -0,0 +1,25 @@
+use sea_query::{Iden, IntoIden, IdenStatic, MysqlQueryBuilder, PostgresQueryBuilder, QuotedBuilder};
+
+#[derive(Copy, Clone, IdenStatic)]
+pub struct SomeType;
+
+#[derive(Copy, Clone, IdenStatic)]
+#[iden(rename = "Hel`lo")]
+pub struct SomeTypeWithRename;
+
+fn main() {
+    assert_eq!(SomeType.to_string(), "some_type");
+    assert_eq!(SomeTypeWithRename.to_string(), "Hel`lo");
+
+    let mut string = String::new();
+    PostgresQueryBuilder.prepare_iden(&SomeType.into_iden(), &mut string);
+    assert_eq!(string, "\"some_type\"");
+
+    let mut string = String::new();
+    PostgresQueryBuilder.prepare_iden(&SomeTypeWithRename.into_iden(), &mut string);
+    assert_eq!(string, "\"Hel`lo\"");
+
+    let mut string = String::new();
+    MysqlQueryBuilder.prepare_iden(&SomeTypeWithRename.into_iden(), &mut string);
+    assert_eq!(string, "`Hel``lo`");
+}

notes-service/vendor/sea-query-derive/tests/pass-static/without_attributes.rs

@@ -0,0 +1,28 @@
+use sea_query::{Iden, IdenStatic};
+use strum::{EnumIter, IntoEnumIterator};
+
+#[derive(Copy, Clone, IdenStatic, EnumIter)]
+enum User {
+    Table,
+    Id,
+    FirstName,
+    LastName,
+    Email,
+}
+
+#[derive(Copy, Clone, IdenStatic, EnumIter)]
+enum UserStatic {
+    Table,
+    Id,
+    FirstName,
+    LastName,
+    Email,
+}
+
+fn main() {
+    let expected = ["user", "id", "first_name", "last_name", "email"];
+    User::iter().zip(expected).for_each(|(var, exp)| {
+        assert_eq!(var.to_string(), exp);
+        assert_eq!(var.as_str(), exp)
+    });
+}

notes-service/vendor/sea-query-derive/tests/pass/3_level_flatten.rs

@@ -0,0 +1,60 @@
+use sea_query::Iden;
+use strum::{EnumIter, IntoEnumIterator};
+
+#[derive(Copy, Clone, Iden, EnumIter)]
+enum Asset {
+    Table,
+    Id,
+    AssetName,
+    #[iden(flatten)]
+    First {
+        first: FirstLevel,
+    },
+}
+
+#[derive(Copy, Clone, Iden)]
+enum FirstLevel {
+    LevelOne,
+    #[iden(flatten)]
+    Second(SecondLevel),
+}
+
+#[derive(Copy, Clone, Iden, EnumIter)]
+enum SecondLevel {
+    LevelTwo,
+    #[iden(flatten)]
+    Third(LevelThree),
+    UserId,
+}
+
+#[derive(Copy, Clone, Iden, Default)]
+struct LevelThree;
+
+impl Default for FirstLevel {
+    fn default() -> Self {
+        Self::LevelOne
+    }
+}
+
+fn main() {
+    // custom ends up being default string which is an empty string
+    let expected = [
+        "asset",
+        "id",
+        "asset_name",
+        "level_one",
+        "level_two",
+        "level_three",
+        "user_id",
+    ];
+    Asset::iter()
+        .chain(
+            SecondLevel::iter()
+                .map(FirstLevel::Second)
+                .map(|s| Asset::First { first: s }),
+        )
+        .zip(expected)
+        .for_each(|(var, exp)| {
+            assert_eq!(var.to_string(), exp);
+        })
+}

notes-service/vendor/sea-query-derive/tests/pass/enum_def/default.rs

@@ -0,0 +1,10 @@
+use sea_query_derive::enum_def;
+
+#[enum_def]
+pub struct Hello {
+    pub name: String
+}
+
+fn main() {
+    assert_eq!(format!("{:?}", HelloIden::Name), "Name");
+}

notes-service/vendor/sea-query-derive/tests/pass/enum_def/prefixed.rs

@@ -0,0 +1,10 @@
+use sea_query_derive::enum_def;
+
+#[enum_def(prefix = "Enum", suffix = "")]
+pub struct Hello {
+    pub name: String
+}
+
+fn main() {
+    assert_eq!(format!("{:?}", EnumHello::Name), "Name");
+}

notes-service/vendor/sea-query-derive/tests/pass/enum_def/suffixed.rs

@@ -0,0 +1,10 @@
+use sea_query_derive::enum_def;
+
+#[enum_def(prefix = "", suffix = "Def")]
+pub struct Hello {
+    pub name: String
+}
+
+fn main() {
+    assert_eq!(format!("{:?}", HelloDef::Name), "Name");
+}

notes-service/vendor/sea-query-derive/tests/pass/enum_def/table_iden.rs

@@ -0,0 +1,19 @@
+use sea_query::{Iden, IdenStatic};
+use sea_query_derive::enum_def;
+use std::convert::AsRef;
+
+#[enum_def(table_name = "HelloTable")]
+pub struct Hello {
+    pub name: String,
+}
+
+fn main() {
+    assert_eq!("HelloTable".to_string(), HelloIden::Table.to_string());
+    assert_eq!("name".to_string(), HelloIden::Name.to_string());
+
+    assert_eq!("HelloTable", HelloIden::Table.as_str());
+    assert_eq!("name", HelloIden::Name.as_str());
+
+    assert_eq!("HelloTable", AsRef::<str>::as_ref(&HelloIden::Table));
+    assert_eq!("name", AsRef::<str>::as_ref(&HelloIden::Name));
+}

notes-service/vendor/sea-query-derive/tests/pass/flattened_named.rs

@@ -0,0 +1,41 @@
+use sea_query::Iden;
+use strum::{EnumIter, IntoEnumIterator};
+use std::borrow::Cow;
+
+#[derive(Copy, Clone, Iden, EnumIter)]
+enum Asset {
+    Table,
+    Id,
+    AssetName,
+    #[iden(flatten)]
+    Creation {
+        info: CreationInfo,
+    },
+}
+
+#[derive(Copy, Clone, Iden)]
+enum CreationInfo {
+    UserId,
+    #[iden = "creation_date"]
+    Date,
+}
+
+impl Default for CreationInfo {
+    fn default() -> Self {
+        Self::UserId
+    }
+}
+
+fn main() {
+    // custom ends up being default string which is an empty string
+    let expected = ["asset", "id", "asset_name", "user_id", "creation_date"];
+    Asset::iter()
+        .chain(std::iter::once(Asset::Creation {
+            info: CreationInfo::Date,
+        }))
+        .zip(expected)
+        .for_each(|(var, exp)| {
+            assert_eq!(var.to_string(), exp);
+            assert_eq!(var.quoted(), Cow::Borrowed(exp));
+        })
+}

notes-service/vendor/sea-query-derive/tests/pass/flattened_unnamed.rs

@@ -0,0 +1,35 @@
+use sea_query::Iden;
+use strum::{EnumIter, IntoEnumIterator};
+
+#[derive(Copy, Clone, Iden, EnumIter)]
+enum Asset {
+    Table,
+    Id,
+    AssetName,
+    #[iden(flatten)]
+    Creation(CreationInfo),
+}
+
+#[derive(Copy, Clone, Iden)]
+enum CreationInfo {
+    UserId,
+    #[iden = "creation_date"]
+    Date,
+}
+
+impl Default for CreationInfo {
+    fn default() -> Self {
+        Self::UserId
+    }
+}
+
+fn main() {
+    // custom ends up being default string which is an empty string
+    let expected = ["asset", "id", "asset_name", "user_id", "creation_date"];
+    Asset::iter()
+        .chain(std::iter::once(Asset::Creation(CreationInfo::Date)))
+        .zip(expected)
+        .for_each(|(var, exp)| {
+            assert_eq!(var.to_string(), exp);
+        })
+}

notes-service/vendor/sea-query-derive/tests/pass/meta_list_renaming_everything.rs

@@ -0,0 +1,51 @@
+use sea_query::{Iden, IntoIden, MysqlQueryBuilder, PostgresQueryBuilder, QuotedBuilder};
+use strum::{EnumIter, IntoEnumIterator};
+use std::borrow::Cow;
+
+#[derive(Iden, EnumIter)]
+// Outer iden attributes overrides what's used for "Table"...
+#[iden(rename = "user")]
+enum Custom {
+    Table,
+    #[iden(rename = "my_id")]
+    Id,
+    #[iden(rename = "name")]
+    FirstName,
+    #[iden(rename = "surname")]
+    LastName,
+    // Custom casing if needed
+    #[iden(rename = "EM`ail")]
+    // the tuple value will be ignored
+    Email(String),
+    // Custom method
+    #[iden(method = "custom_to_string")]
+    Custom(String),
+}
+
+impl Custom {
+    pub fn custom_to_string(&self) -> &str {
+        match self {
+            Self::Custom(custom) => custom,
+            _ => panic!("not Custom::Custom"),
+        }
+    }
+}
+
+fn main() {
+    // custom ends up being default string which is an empty string
+    let expected = ["user", "my_id", "name", "surname", "EM`ail", ""];
+    Custom::iter()
+        .map(|var| var.to_string())
+        .zip(expected)
+        .for_each(|(iden, exp)| assert_eq!(iden, exp));
+    
+    let mut string = String::new();
+    PostgresQueryBuilder.prepare_iden(&Custom::Email("".to_owned()).into_iden(), &mut string);
+    assert_eq!(string, "\"EM`ail\"");
+
+    let mut string = String::new();
+    MysqlQueryBuilder.prepare_iden(&Custom::Email("".to_owned()).into_iden(), &mut string);
+    assert_eq!(string, "`EM``ail`");
+
+    assert!(matches!(Custom::FirstName.quoted(), Cow::Owned(_)));
+}

notes-service/vendor/sea-query-derive/tests/pass/renamed_unit_struct.rs

@@ -0,0 +1,9 @@
+use sea_query::Iden;
+
+#[derive(Copy, Clone, Iden)]
+#[iden = "another_name"]
+pub struct CustomName;
+
+fn main() {
+    assert_eq!(CustomName.to_string(), "another_name");
+}

notes-service/vendor/sea-query-derive/tests/pass/renaming_everything.rs

@@ -0,0 +1,39 @@
+use sea_query::Iden;
+use strum::{EnumIter, IntoEnumIterator};
+
+#[derive(Iden, EnumIter)]
+// Outer iden attributes overrides what's used for "Table"...
+#[iden = "user"]
+enum Custom {
+    Table,
+    #[iden = "my_id"]
+    Id,
+    #[iden = "name"]
+    FirstName,
+    #[iden = "surname"]
+    LastName,
+    // Custom casing if needed
+    #[iden = "EMail"]
+    // the tuple value will be ignored
+    Email(String),
+    // Custom method
+    #[method = "custom_to_string"]
+    Custom(String),
+}
+
+impl Custom {
+    pub fn custom_to_string(&self) -> &str {
+        match self {
+            Self::Custom(custom) => custom,
+            _ => panic!("not Custom::Custom"),
+        }
+    }
+}
+
+fn main() {
+    // custom ends up being default string which is an empty string
+    let expected = ["user", "my_id", "name", "surname", "EMail", ""];
+    Custom::iter().zip(expected).for_each(|(var, exp)| {
+        assert_eq!(var.to_string(), exp);
+    })
+}

notes-service/vendor/sea-query-derive/tests/pass/renaming_table.rs

@@ -0,0 +1,19 @@
+use sea_query::Iden;
+use strum::{EnumIter, IntoEnumIterator};
+
+#[derive(Copy, Clone, Iden, EnumIter)]
+enum Something {
+    // ...the Table can also be overwritten like this
+    #[iden = "something_else"]
+    Table,
+    Id,
+    AssetName,
+    UserId,
+}
+
+fn main() {
+    let expected = ["something_else", "id", "asset_name", "user_id"];
+    Something::iter().zip(expected).for_each(|(var, exp)| {
+        assert_eq!(var.to_string(), exp);
+    })
+}

notes-service/vendor/sea-query-derive/tests/pass/simple_unit_struct.rs

@@ -0,0 +1,25 @@
+use sea_query::{Iden, IntoIden, MysqlQueryBuilder, PostgresQueryBuilder, QuotedBuilder};
+
+#[derive(Copy, Clone, Iden)]
+pub struct SomeType;
+
+#[derive(Copy, Clone, Iden)]
+#[iden(rename = "Hel`lo")]
+pub struct SomeTypeWithRename;
+
+fn main() {
+    assert_eq!(SomeType.to_string(), "some_type");
+    assert_eq!(SomeTypeWithRename.to_string(), "Hel`lo");
+
+    let mut string = String::new();
+    PostgresQueryBuilder.prepare_iden(&SomeType.into_iden(), &mut string);
+    assert_eq!(string, "\"some_type\"");
+
+    let mut string = String::new();
+    PostgresQueryBuilder.prepare_iden(&SomeTypeWithRename.into_iden(), &mut string);
+    assert_eq!(string, "\"Hel`lo\"");
+
+    let mut string = String::new();
+    MysqlQueryBuilder.prepare_iden(&SomeTypeWithRename.into_iden(), &mut string);
+    assert_eq!(string, "`Hel``lo`");
+}

notes-service/vendor/sea-query-derive/tests/pass/without_attributes.rs

@@ -0,0 +1,18 @@
+use sea_query::Iden;
+use strum::{EnumIter, IntoEnumIterator};
+
+#[derive(Copy, Clone, Iden, EnumIter)]
+enum User {
+    Table,
+    Id,
+    FirstName,
+    LastName,
+    Email,
+}
+
+fn main() {
+    let expected = ["user", "id", "first_name", "last_name", "email"];
+    User::iter().zip(expected).for_each(|(var, exp)| {
+        assert_eq!(var.to_string(), exp);
+    });
+}

notes-service/vendor/sea-query-derive/tests/test_build.rs

@@ -0,0 +1,11 @@
+#[test]
+fn build_tests() {
+    let t = trybuild::TestCases::new();
+    t.compile_fail("./tests/compile-fail/*.rs");
+    t.compile_fail("./tests/compile-fail/enum_def/*.rs");
+
+    // all of these are exactly the same as the examples in `examples/derive.rs`
+    t.pass("./tests/pass/*.rs");
+    t.pass("./tests/pass/enum_def/*.rs");
+    t.pass("./tests/pass-static/*.rs");
+}