[db] Add serialize derive macro #1433 (#1434)

* Update raft.rs

* Update lib.rs

* Update lib.rs

* Update db_user_value_test.rs

* test reorg for features

* Delete storage2

* Update lib.rs

* Update mod.rs

* Update lib.rs

* Update lib.rs

* Update memory_storage.rs

agdb/src/lib.rs

@@ -18,6 +18,8 @@
 //! // QueryResult { result: 1, elements: [ DbElement { id: DbId(1), values: [ DbKeyValue { key: String("key"), value: Int(123) } ] } ] }
 //! ```
 
+extern crate self as agdb;
+
 mod collections;
 mod command;
 mod db;
@@ -36,6 +38,9 @@ pub mod test_utilities;
 #[cfg(any(feature = "serde", feature = "openapi"))]
 pub use query::QueryType;
 
+#[cfg(feature = "derive")]
+pub use agdb_derive::AgdbDeSerialize;
+
 #[cfg(feature = "derive")]
 pub use agdb_derive::{UserValue, UserValueMarker};
 

agdb/src/storage/memory_storage.rs

@@ -92,12 +92,6 @@ mod tests {
     use crate::utilities::serialize::Serialize;
     use crate::utilities::serialize::SerializeStatic;
 
-    #[test]
-    fn backup_does_nothing() {
-        let storage = Storage::<MemoryStorage>::new("storage").unwrap();
-        assert!(storage.backup("storage2").is_ok())
-    }
-
     #[test]
     fn name() {
         let storage = Storage::<MemoryStorage>::new("storage").unwrap();

agdb/tests/db_test.rs

@@ -1,5 +1,11 @@
+#[cfg(feature = "derive")]
+mod derive_feature_test;
+#[cfg(feature = "derive")]
+mod efficient_agdb;
 #[cfg(feature = "openapi")]
 mod openapi_feature_test;
+#[cfg(feature = "derive")]
+mod quickstart;
 #[cfg(feature = "serde")]
 mod serde_feature_test;
 mod test_db;
@@ -78,7 +84,6 @@ fn public_types() {
     use agdb::StorageSlice;
     use agdb::Transaction;
     use agdb::TransactionMut;
-    use agdb::UserValue;
 }
 
 #[test]

agdb/tests/db_user_value_test.rs → agdb/tests/derive_feature_test/mod.rs

@@ -1,5 +1,7 @@
-mod test_db;
+use crate::test_db::TestDb;
 
+use agdb::AgdbDeSerialize;
+use agdb::AgdbSerialize;
 use agdb::DbElement;
 use agdb::DbError;
 use agdb::DbId;
@@ -10,8 +12,6 @@ use agdb::QueryId;
 use agdb::QueryResult;
 use agdb::UserValue;
 use agdb::UserValueMarker;
-#[allow(unused_imports)]
-use test_db::TestDb;
 
 #[derive(Default, Debug, Clone, PartialEq, UserValueMarker)]
 enum Status {
@@ -816,3 +816,111 @@ fn try_from_db_element_bad_conversion() {
         "Failed to convert value of 'password': Type mismatch. Cannot convert 'i64' to 'string'"
     );
 }
+
+#[test]
+fn derived_serialization_struct() {
+    #[derive(AgdbDeSerialize, Debug, PartialEq)]
+    struct S {
+        f1: u64,
+        f2: u64,
+    }
+
+    let s = S { f1: 1, f2: 2 };
+    let serialized = s.serialize();
+    let deserialized = S::deserialize(&serialized).unwrap();
+
+    assert_eq!(s, deserialized);
+}
+
+#[test]
+fn derived_serialization_tuple() {
+    #[derive(AgdbDeSerialize, Debug, PartialEq)]
+    struct S(u64, u64);
+
+    let s = S(1, 2);
+    let serialized = s.serialize();
+    let deserialized = S::deserialize(&serialized).unwrap();
+
+    assert_eq!(s, deserialized);
+}
+
+#[derive(AgdbDeSerialize, Debug, PartialEq)]
+struct S1 {
+    f1: u64,
+}
+
+#[derive(AgdbDeSerialize, Debug, PartialEq)]
+struct S2(S1);
+
+#[derive(AgdbDeSerialize, Debug, PartialEq)]
+struct S3(S2, S2);
+
+#[derive(AgdbDeSerialize, Debug, PartialEq)]
+enum MyOtherEnum {
+    A,
+    B,
+}
+
+#[derive(AgdbDeSerialize, Debug, PartialEq)]
+enum MyE {
+    A,
+    B(u64),
+    C(u64, u64),
+    D(S3),
+    E(MyOtherEnum),
+    F { f1: u64, f2: u64 },
+}
+
+#[test]
+fn derived_serialization_enum_unit() {
+    let s = MyE::A;
+    let serialized = s.serialize();
+    let deserialized = MyE::deserialize(&serialized).unwrap();
+
+    assert_eq!(s, deserialized);
+}
+
+#[test]
+fn derived_serialization_enum_tuple() {
+    let s = MyE::B(1);
+    let serialized = s.serialize();
+    let deserialized = MyE::deserialize(&serialized).unwrap();
+
+    assert_eq!(s, deserialized);
+}
+
+#[test]
+fn derived_serialization_enum_tuple_multiple() {
+    let s = MyE::C(1, 2);
+    let serialized = s.serialize();
+    let deserialized = MyE::deserialize(&serialized).unwrap();
+
+    assert_eq!(s, deserialized);
+}
+
+#[test]
+fn derived_serialization_enum_nested_struct() {
+    let s = MyE::D(S3(S2(S1 { f1: 1 }), S2(S1 { f1: 2 })));
+    let serialized = s.serialize();
+    let deserialized = MyE::deserialize(&serialized).unwrap();
+
+    assert_eq!(s, deserialized);
+}
+
+#[test]
+fn derived_serialization_enum_nested_enum() {
+    let s = MyE::E(MyOtherEnum::A);
+    let serialized = s.serialize();
+    let deserialized = MyE::deserialize(&serialized).unwrap();
+
+    assert_eq!(s, deserialized);
+}
+
+#[test]
+fn derived_serialization_enum_struct() {
+    let s = MyE::F { f1: 1, f2: 2 };
+    let serialized = s.serialize();
+    let deserialized = MyE::deserialize(&serialized).unwrap();
+
+    assert_eq!(s, deserialized);
+}

agdb/tests/efficient_agdb.rs → agdb/tests/efficient_agdb/mod.rs

@@ -1,5 +1,3 @@
-mod test_db;
-
 use crate::test_db::TestFile;
 use agdb::Comparison::Equal;
 use agdb::CountComparison;

agdb/tests/quickstart.rs → agdb/tests/quickstart/mod.rs

@@ -1,5 +1,3 @@
-mod test_db;
-
 use crate::test_db::TestFile;
 use agdb::QueryError;
 use agdb::{Comparison::Equal, Db, DbId, DbUserValue, QueryBuilder, UserValue};