From d32aec22651f4e60e513ce1ed89bf357f36ff6b1 Mon Sep 17 00:00:00 2001
From: Chung Quan Tin <cqtin0903@gmail.com>
Date: Sat, 12 Nov 2022 11:24:44 +0700
Subject: [PATCH] Add relationship controller & refractor test dir

---
 db/src/controller/label.rs         | 35 +++++++--------
 db/src/controller/property.rs      | 45 ++++---------------
 db/src/controller/relationship.rs  | 67 +++++++++++++++++++++++-----
 db/src/controller/vertex.rs        | 65 ++++++++-------------------
 db/src/lib.rs                      |  2 +-
 db/src/model/graph/account.rs      |  5 ---
 db/src/model/graph/property.rs     | 10 ++---
 db/src/model/graph/relationship.rs | 20 ++++-----
 db/src/tests/label_test.rs         | 23 ++++++++++
 db/src/tests/mod.rs                | 10 ++++-
 db/src/tests/property_test.rs      | 25 +++++++++++
 db/src/tests/relationship_test.rs  | 70 ++++++++++++++++++++++++++++++
 db/src/tests/vertex_test.rs        | 39 +++++++++++++++++
 db/src/util/byte.rs                | 56 +++++++-----------------
 14 files changed, 295 insertions(+), 177 deletions(-)
 create mode 100644 db/src/tests/label_test.rs
 create mode 100644 db/src/tests/property_test.rs
 create mode 100644 db/src/tests/relationship_test.rs
 create mode 100644 db/src/tests/vertex_test.rs

diff --git a/db/src/controller/label.rs b/db/src/controller/label.rs
index 624bd0a..34f0a54 100644
--- a/db/src/controller/label.rs
+++ b/db/src/controller/label.rs
@@ -1,5 +1,7 @@
-use crate::util::{build_bytes, from_uuid_bytes, Component};
-use crate::{DatastoreAdapter, Error, Label, SimpleTransaction};
+use crate::util::{
+	build_bytes, build_meta, deserialize_data_with_meta, from_uuid_bytes, Component,
+};
+use crate::{AccountDiscriminator, DatastoreAdapter, Error, Label, SimpleTransaction};
 
 impl_controller!(LabelController("labels:v1"));
 
@@ -19,7 +21,9 @@ impl LabelController {
 
 		let cf = self.get_cf();
 		let key = build_bytes(&[Component::Uuid(label.id)]).unwrap();
-		let val = name.as_bytes();
+		let discriminator = AccountDiscriminator::Label.serialize();
+		let meta = &build_meta(1, name.len());
+		let val = [discriminator, meta.to_vec(), name.as_bytes().to_vec()].concat();
 
 		tx.set(cf, key, val).await.unwrap();
 		tx.commit().await.unwrap();
@@ -40,23 +44,16 @@ impl LabelController {
 		let tx = self.config.ds.transaction(false).unwrap();
 
 		let cf = self.get_cf();
-		let val = tx.get(cf, id.to_vec()).await.unwrap();
-		match val {
-			Some(v) => Ok(Label {
-				id: from_uuid_bytes(&id).unwrap(),
-				name: String::from_utf8(v).unwrap(),
-			}),
+		let raw = tx.get(cf, id.to_vec()).await.unwrap();
+		match raw {
+			Some(r) => {
+				let (data, _, _) = deserialize_data_with_meta(r, true).unwrap();
+				Ok(Label {
+					id: from_uuid_bytes(&id).unwrap(),
+					name: String::from_utf8(data[0].to_vec()).unwrap(),
+				})
+			}
 			None => panic!("No label value"),
 		}
 	}
 }
-
-// #[cfg(feature = "test-suite")]
-#[cfg(test)]
-#[tokio::test]
-async fn should_create_label() {
-	let lc = LabelController::default();
-	let res = lc.create_label("Person").await.unwrap();
-	let label = lc.get_label(res.id.as_bytes().to_vec()).await.unwrap();
-	assert_eq!(label, res);
-}
diff --git a/db/src/controller/property.rs b/db/src/controller/property.rs
index f4d1ca4..bf9391c 100644
--- a/db/src/controller/property.rs
+++ b/db/src/controller/property.rs
@@ -1,5 +1,5 @@
-use crate::util::{build_bytes, build_offset, deserialize_byte_data, from_uuid_bytes, Component};
-use crate::{DatastoreAdapter, Error, Property, PropertyVariant, SimpleTransaction};
+use crate::util::{build_bytes, build_meta, deserialize_byte_data, from_uuid_bytes, Component};
+use crate::{DatastoreAdapter, Error, PropType, Property, SimpleTransaction};
 
 impl_controller!(PropertyController("properties:v1"));
 
@@ -12,22 +12,18 @@ impl Default for PropertyController {
 }
 
 impl PropertyController {
-	pub async fn create_property(
-		&self,
-		name: &str,
-		variant: PropertyVariant,
-	) -> Result<Property, Error> {
+	pub async fn create_property(&self, name: &str, variant: PropType) -> Result<Property, Error> {
 		let mut tx = self.config.ds.transaction(true).unwrap();
 
 		let cf = self.get_cf();
 		// First four bytes are the property
-		let serialized_variant = bincode::serialize::<PropertyVariant>(&variant).unwrap();
+		let serialized_variant = bincode::serialize::<PropType>(&variant).unwrap();
 		let property = Property::new(name, variant).unwrap();
-		let property_offset = &build_offset(1, serialized_variant.len());
+		let property_meta = &build_meta(1, serialized_variant.len());
 		let name = name.as_bytes();
-		let name_offset = &build_offset(1, name.len());
+		let name_meta = &build_meta(1, name.len());
 		// Dynamic length string will be concatenated at the end
-		let val = [property_offset, &serialized_variant, name_offset, name].concat();
+		let val = [property_meta, &serialized_variant, name_meta, name].concat();
 
 		let key = build_bytes(&[Component::Uuid(property.id)]).unwrap();
 		tx.set(cf, key, val).await.unwrap();
@@ -37,7 +33,7 @@ impl PropertyController {
 
 	pub async fn create_properties(
 		&self,
-		properties: Vec<(&str, PropertyVariant)>,
+		properties: Vec<(&str, PropType)>,
 	) -> Result<Vec<Property>, Error> {
 		let mut result = vec![];
 		for (name, variant) in properties {
@@ -59,7 +55,7 @@ impl PropertyController {
 				let name = &deserialized[1].0.first().unwrap();
 
 				let name = String::from_utf8(name.to_vec()).unwrap();
-				let t = bincode::deserialize::<PropertyVariant>(property).unwrap();
+				let t = bincode::deserialize::<PropType>(property).unwrap();
 				Ok(Property {
 					id: from_uuid_bytes(&id).unwrap(),
 					name,
@@ -70,26 +66,3 @@ impl PropertyController {
 		}
 	}
 }
-
-#[cfg(test)]
-#[tokio::test]
-async fn should_create_property() {
-	let pc = PropertyController::default();
-	let res = pc.create_property("Name", PropertyVariant::String).await.unwrap();
-	let property = pc.get_property(res.id.as_bytes().to_vec()).await.unwrap();
-	assert_eq!(property, res);
-}
-
-#[cfg(test)]
-#[tokio::test]
-async fn should_create_properties() {
-	let pc = PropertyController::default();
-	let properties = pc
-		.create_properties(vec![
-			("name", PropertyVariant::String),
-			("age", PropertyVariant::UInt128),
-		])
-		.await
-		.unwrap();
-	assert_eq!(properties.len(), 2);
-}
diff --git a/db/src/controller/relationship.rs b/db/src/controller/relationship.rs
index 67d571d..753ab5a 100644
--- a/db/src/controller/relationship.rs
+++ b/db/src/controller/relationship.rs
@@ -1,9 +1,10 @@
 use std::collections::HashMap;
-
 use uuid::Uuid;
 
-use crate::util::{build_bytes, Component};
-use crate::{DatastoreAdapter, Error, Identifier, Relationship, SimpleTransaction};
+use crate::util::{build_bytes, deserialize_data_with_meta, from_uuid_bytes, Component};
+use crate::{
+	AccountDiscriminator, DatastoreAdapter, Error, Identifier, Relationship, SimpleTransaction,
+};
 
 impl_controller!(RelationshipController("relationships:v1"));
 
@@ -16,29 +17,73 @@ impl Default for RelationshipController {
 }
 
 impl RelationshipController {
-	pub async fn create_property(
+	pub async fn create_relationship(
 		&self,
-		s_node: Uuid,
-		t_node: Uuid,
+		source_vertex: Uuid,
+		target_vertex: Uuid,
 		t: &str,
 		props: HashMap<Uuid, Vec<u8>>,
 	) -> Result<Relationship, Error> {
 		let mut tx = self.config.ds.transaction(true).unwrap();
+		let prop_components =
+			props.iter().map(|(id, val)| Component::Property(id, val)).collect::<Vec<Component>>();
 
 		let cf = self.get_cf();
 		let t_id = Identifier::new(t.to_string()).unwrap();
 		let key = build_bytes(&[
-			Component::Uuid(s_node),
-			Component::Uuid(s_node),
+			Component::Uuid(source_vertex),
 			Component::Identifier(&t_id),
-			Component::Uuid(t_node),
+			Component::Uuid(target_vertex),
 		])
 		.unwrap();
-		let relationship = Relationship::new(s_node, t_node, t_id, props).unwrap();
-		let val = [];
+
+		// Handle byte concatenate for property components
+		let _prop_discriminator = AccountDiscriminator::Property.serialize();
+		let _props = &build_bytes(&prop_components).unwrap();
+		// (Property discriminator, Property byte array - meta for each property generated)
+		let (p_dis, p) = (_prop_discriminator.as_slice(), _props.as_slice());
+		let props_concat = [p_dis, p].concat();
+
+		let val = [props_concat].concat();
 
 		tx.set(cf, key, val).await.unwrap();
 		tx.commit().await.unwrap();
+
+		let relationship = Relationship::new(source_vertex, target_vertex, t_id, props).unwrap();
+		Ok(relationship)
+	}
+
+	pub async fn get_relationship(
+		&self,
+		source_vertex: Uuid,
+		target_vertex: Uuid,
+		t: &str,
+	) -> Result<Relationship, Error> {
+		let tx = self.config.ds.transaction(false).unwrap();
+		let cf = self.get_cf();
+		let t_id = Identifier::new(t.to_string()).unwrap();
+		let key = build_bytes(&[
+			Component::Uuid(source_vertex),
+			Component::Identifier(&t_id),
+			Component::Uuid(target_vertex),
+		])
+		.unwrap();
+
+		let mut props = HashMap::default();
+		let raw_relationship = tx.get(cf, key).await.unwrap();
+		match raw_relationship {
+			Some(r) => {
+				let (props_bytes, _, _) = deserialize_data_with_meta(r, true).unwrap();
+				let uuid_len = Component::Uuid(Uuid::nil()).len();
+				for slice in props_bytes {
+					let (uuid, value) = (&slice[..uuid_len], &slice[uuid_len..]);
+					props.insert(from_uuid_bytes(uuid).unwrap(), value.to_vec());
+				}
+			}
+			None => panic!("No relationship found"),
+		}
+
+		let relationship = Relationship::new(source_vertex, target_vertex, t_id, props).unwrap();
 		Ok(relationship)
 	}
 }
diff --git a/db/src/controller/vertex.rs b/db/src/controller/vertex.rs
index 5e06993..2d9e62d 100644
--- a/db/src/controller/vertex.rs
+++ b/db/src/controller/vertex.rs
@@ -2,8 +2,7 @@ use std::collections::HashMap;
 
 use crate::{
 	model::adapter::DatastoreAdapter,
-	serialize_discriminator,
-	util::{build_bytes, build_offset, deserialize_byte_data, from_uuid_bytes, Component},
+	util::{build_bytes, build_meta, deserialize_byte_data, from_uuid_bytes, Component},
 	AccountDiscriminator, Error, Label, SimpleTransaction, Vertex,
 };
 
@@ -21,6 +20,14 @@ impl Default for VertexController {
 
 impl VertexController {
 	/// # Create a new vertex from labels and properties
+	/// ## Description
+	/// Because Vertex has multiple dynamic sized attributes:
+	/// - labels: Vec<Label>
+	/// - props: HashMap<Uuid, Vec<u8>>
+	/// It will be a bit more complicated.
+	///
+	/// Data will be store in Vertex as
+	/// + label_discriminator | label_meta | label data
 	pub async fn create_vertex(
 		&self,
 		labels: Vec<Label>,
@@ -35,19 +42,21 @@ impl VertexController {
 		let label_components =
 			labels.iter().map(|l| Component::Uuid(l.id)).collect::<Vec<Component>>();
 		let prop_components =
-			props.iter().map(|p| Component::Property(p.0, p.1)).collect::<Vec<Component>>();
+			props.iter().map(|(id, val)| Component::Property(id, val)).collect::<Vec<Component>>();
 
 		// Handle byte concatenate for label components
-		let _label_discriminator = serialize_discriminator(AccountDiscriminator::Label).unwrap();
+		let label_discriminator = AccountDiscriminator::Label.serialize();
 		let _labels = build_bytes(&label_components).unwrap();
-		let _label_offset = &build_offset(ll, uuid_len);
-		let (l_dis, l, l_offset) =
-			(_label_discriminator.as_slice(), _label_offset.as_slice(), _labels.as_slice());
-		let labels_concat = [l_dis, l, l_offset].concat();
+		let label_meta = &build_meta(ll, uuid_len);
+		// (Label discriminator, Label byte array, Label metadata)
+		let (l_dis, l, l_meta) =
+			(label_discriminator.as_slice(), label_meta.as_slice(), _labels.as_slice());
+		let labels_concat = [l_dis, l, l_meta].concat();
 
 		// Handle byte concatenate for property components
+		let _prop_discriminator = AccountDiscriminator::Property.serialize();
 		let _props = &build_bytes(&prop_components).unwrap();
-		let _prop_discriminator = serialize_discriminator(AccountDiscriminator::Property).unwrap();
+		// (Property discriminator, Property byte array - meta for each property generated)
 		let (p_dis, p) = (_prop_discriminator.as_slice(), _props.as_slice());
 		let props_concat = [p_dis, p].concat();
 
@@ -105,41 +114,3 @@ impl VertexController {
 		}
 	}
 }
-
-// #[cfg(feature = "test-suite")]
-#[cfg(test)]
-#[tokio::test]
-async fn should_create_label() {
-	use crate::{LabelController, PropertyController, PropertyVariant};
-
-	let vc = VertexController::default();
-	let lc = LabelController::default();
-	let pc = PropertyController::default();
-
-	let raw_labels = ["Person", "Student", "Employee"];
-	let properties = pc
-		.create_properties(vec![
-			("name", PropertyVariant::String),
-			("age", PropertyVariant::UInt128),
-			("addresses", PropertyVariant::VecString),
-		])
-		.await
-		.unwrap();
-	let labels = lc.create_labels(raw_labels.to_vec()).await.unwrap();
-	let res = vc
-		.create_vertex(
-			labels,
-			HashMap::from([
-				(properties[0].id, "example name 1234".as_bytes().to_vec()),
-				(properties[1].id, Vec::from([15])),
-				(properties[2].id, ["address 1", "address 2"].concat().as_bytes().to_vec()),
-			]),
-		)
-		.await
-		.unwrap();
-	assert_eq!(res.labels.len(), raw_labels.len());
-
-	let vertex = vc.get_vertex(res.id.as_bytes().to_vec()).await.unwrap();
-	assert_eq!(vertex, res);
-	assert_eq!(vertex.labels.len(), raw_labels.len());
-}
diff --git a/db/src/lib.rs b/db/src/lib.rs
index 725c8f5..cdf7d9d 100644
--- a/db/src/lib.rs
+++ b/db/src/lib.rs
@@ -12,7 +12,7 @@ mod util;
 pub use crate::storage::kvs::CassandraDBAdapter;
 #[cfg(feature = "kv-rocksdb")]
 pub use crate::storage::kvs::RocksDBAdapter;
-#[cfg(feature = "test-suite")]
+// #[cfg(feature = "test-suite")]
 #[macro_use]
 pub mod tests;
 
diff --git a/db/src/model/graph/account.rs b/db/src/model/graph/account.rs
index 96e3d79..2a9581b 100644
--- a/db/src/model/graph/account.rs
+++ b/db/src/model/graph/account.rs
@@ -1,4 +1,3 @@
-use bincode::Error;
 use serde::{Deserialize, Serialize};
 
 #[derive(PartialEq, Serialize, Deserialize, Eq, Debug, Clone)]
@@ -15,7 +14,3 @@ impl AccountDiscriminator {
 		bincode::serialize(self).unwrap()
 	}
 }
-
-pub fn serialize_discriminator(ad: AccountDiscriminator) -> Result<Vec<u8>, Error> {
-	bincode::serialize(&ad)
-}
diff --git a/db/src/model/graph/property.rs b/db/src/model/graph/property.rs
index ab38aef..7d10469 100644
--- a/db/src/model/graph/property.rs
+++ b/db/src/model/graph/property.rs
@@ -4,7 +4,7 @@ use uuid::Uuid;
 use crate::Error;
 
 #[derive(PartialEq, Serialize, Deserialize, Eq, Debug, Clone)]
-pub enum PropertyVariant {
+pub enum PropType {
 	Unknown = 0,
 	String = 1,
 	UInt32 = 2,
@@ -17,9 +17,9 @@ pub enum PropertyVariant {
 	VecUint128 = 9,
 }
 
-impl Default for PropertyVariant {
+impl Default for PropType {
 	fn default() -> Self {
-		PropertyVariant::Unknown
+		PropType::Unknown
 	}
 }
 
@@ -29,12 +29,12 @@ impl Default for PropertyVariant {
 #[derive(PartialEq, Eq, Debug, Clone, Default)]
 pub struct Property {
 	pub id: Uuid,
-	pub t: PropertyVariant,
+	pub t: PropType,
 	pub name: String,
 }
 
 impl Property {
-	pub fn new(name: &str, t: PropertyVariant) -> Result<Self, Error> {
+	pub fn new(name: &str, t: PropType) -> Result<Self, Error> {
 		Ok(Property {
 			id: Uuid::new_v4(),
 			name: name.to_string(),
diff --git a/db/src/model/graph/relationship.rs b/db/src/model/graph/relationship.rs
index 3cd5dc4..cba0eae 100644
--- a/db/src/model/graph/relationship.rs
+++ b/db/src/model/graph/relationship.rs
@@ -9,13 +9,12 @@ use crate::{util::get_now, Error, Identifier};
 /// - Relationships describes a connection between a source node and a target node.
 /// - Relationships always has a direction (one direction).
 /// - Relationships must have a type (one type) to define (classify) what type of relationship they are.
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
 pub struct Relationship {
-	pub id: Uuid,
-	/// Source node (outgoing)
-	pub s_node: Uuid,
-	/// Target node (incoming)
-	pub t_node: Uuid,
+	/// Source vertex (inbound)
+	pub source: Uuid,
+	/// Target vertex (outbound)
+	pub target: Uuid,
 	/// Relationship type
 	pub t: Identifier,
 	/// Timestamp
@@ -26,15 +25,14 @@ pub struct Relationship {
 
 impl Relationship {
 	pub fn new(
-		s_node: Uuid,
-		t_node: Uuid,
+		source: Uuid,
+		target: Uuid,
 		t: Identifier,
 		props: HashMap<Uuid, Vec<u8>>,
 	) -> Result<Self, Error> {
 		Ok(Relationship {
-			id: Uuid::new_v4(),
-			s_node,
-			t_node,
+			source,
+			target,
 			t,
 			timestamp: get_now(),
 			props,
diff --git a/db/src/tests/label_test.rs b/db/src/tests/label_test.rs
new file mode 100644
index 0000000..712d480
--- /dev/null
+++ b/db/src/tests/label_test.rs
@@ -0,0 +1,23 @@
+#[cfg(feature = "test-suite")]
+#[cfg(test)]
+#[tokio::test]
+async fn should_create_label() {
+	use crate::LabelController;
+
+	let lc = LabelController::default();
+	let res = lc.create_label("Person").await.unwrap();
+	let label = lc.get_label(res.id.as_bytes().to_vec()).await.unwrap();
+	assert_eq!(label, res);
+}
+
+#[cfg(feature = "test-suite")]
+#[cfg(test)]
+#[tokio::test]
+async fn should_create_labels() {
+	use crate::LabelController;
+
+	let lc = LabelController::default();
+	let res = lc.create_labels(vec!["Person", "Human", "Coder"]).await.unwrap();
+	let label = lc.get_label(res[0].id.as_bytes().to_vec()).await.unwrap();
+	assert_eq!(label, res[0]);
+}
diff --git a/db/src/tests/mod.rs b/db/src/tests/mod.rs
index e14fcc0..bf5efe3 100644
--- a/db/src/tests/mod.rs
+++ b/db/src/tests/mod.rs
@@ -1,3 +1,11 @@
 mod adapter_test;
+mod label_test;
+mod property_test;
+mod relationship_test;
+mod vertex_test;
 
-pub use self::adapter_test::*;
+pub use adapter_test::*;
+pub use label_test::*;
+pub use property_test::*;
+pub use relationship_test::*;
+pub use vertex_test::*;
diff --git a/db/src/tests/property_test.rs b/db/src/tests/property_test.rs
new file mode 100644
index 0000000..180842e
--- /dev/null
+++ b/db/src/tests/property_test.rs
@@ -0,0 +1,25 @@
+#[cfg(feature = "test-suite")]
+#[cfg(test)]
+#[tokio::test]
+async fn should_create_property() {
+	use crate::{PropType, PropertyController};
+
+	let pc = PropertyController::default();
+	let res = pc.create_property("Name", PropType::String).await.unwrap();
+	let property = pc.get_property(res.id.as_bytes().to_vec()).await.unwrap();
+	assert_eq!(property, res);
+}
+
+#[cfg(feature = "test-suite")]
+#[cfg(test)]
+#[tokio::test]
+async fn should_create_properties() {
+	use crate::{PropType, PropertyController};
+
+	let pc = PropertyController::default();
+	let properties = pc
+		.create_properties(vec![("name", PropType::String), ("age", PropType::UInt128)])
+		.await
+		.unwrap();
+	assert_eq!(properties.len(), 2);
+}
diff --git a/db/src/tests/relationship_test.rs b/db/src/tests/relationship_test.rs
new file mode 100644
index 0000000..d285f61
--- /dev/null
+++ b/db/src/tests/relationship_test.rs
@@ -0,0 +1,70 @@
+#[cfg(feature = "test-suite")]
+#[cfg(test)]
+#[tokio::test]
+async fn should_create_relationship() {
+	use std::collections::HashMap;
+
+	use crate::{
+		LabelController, PropType, PropertyController, RelationshipController, VertexController,
+	};
+
+	let vc = VertexController::default();
+	let rc = RelationshipController::default();
+	let lc = LabelController::default();
+	let pc = PropertyController::default();
+
+	let raw_labels = ["Person", "Student", "Employee"];
+	let properties = pc
+		.create_properties(vec![
+			("name", PropType::String),
+			("age", PropType::UInt128),
+			("addresses", PropType::VecString),
+		])
+		.await
+		.unwrap();
+	let labels = lc.create_labels(raw_labels.to_vec()).await.unwrap();
+	let v1 = vc
+		.create_vertex(
+			labels.to_vec(),
+			HashMap::from([
+				(properties[0].id, "example name 1234".as_bytes().to_vec()),
+				(properties[1].id, Vec::from([15])),
+				(properties[2].id, ["address 1", "address 2"].concat().as_bytes().to_vec()),
+			]),
+		)
+		.await
+		.unwrap();
+	assert_eq!(v1.labels.len(), raw_labels.len());
+
+	let v2 = vc
+		.create_vertex(
+			labels.to_vec(),
+			HashMap::from([
+				(properties[0].id, "vertex number 2".as_bytes().to_vec()),
+				(properties[1].id, Vec::from([25])),
+				(properties[2].id, ["address 1"].concat().as_bytes().to_vec()),
+			]),
+		)
+		.await
+		.unwrap();
+
+	let relationship = rc
+		.create_relationship(
+			v1.id,
+			v2.id,
+			"LIKE",
+			HashMap::from([
+				(properties[0].id, "vertex number 2".as_bytes().to_vec()),
+				(properties[1].id, Vec::from([25])),
+				(properties[2].id, ["address 1"].concat().as_bytes().to_vec()),
+			]),
+		)
+		.await
+		.unwrap();
+
+	let res = rc.get_relationship(v1.id, v2.id, "LIKE").await.unwrap();
+
+	assert_eq!(relationship, res);
+	assert_eq!(relationship.source, v1.id);
+	assert_eq!(relationship.target, v2.id);
+}
diff --git a/db/src/tests/vertex_test.rs b/db/src/tests/vertex_test.rs
new file mode 100644
index 0000000..b6a27da
--- /dev/null
+++ b/db/src/tests/vertex_test.rs
@@ -0,0 +1,39 @@
+#[cfg(feature = "test-suite")]
+#[cfg(test)]
+#[tokio::test]
+async fn should_create_label() {
+	use std::collections::HashMap;
+
+	use crate::{LabelController, PropType, PropertyController, VertexController};
+
+	let vc = VertexController::default();
+	let lc = LabelController::default();
+	let pc = PropertyController::default();
+
+	let raw_labels = ["Person", "Student", "Employee"];
+	let properties = pc
+		.create_properties(vec![
+			("name", PropType::String),
+			("age", PropType::UInt128),
+			("addresses", PropType::VecString),
+		])
+		.await
+		.unwrap();
+	let labels = lc.create_labels(raw_labels.to_vec()).await.unwrap();
+	let res = vc
+		.create_vertex(
+			labels,
+			HashMap::from([
+				(properties[0].id, "example name 1234".as_bytes().to_vec()),
+				(properties[1].id, Vec::from([15])),
+				(properties[2].id, ["address 1", "address 2"].concat().as_bytes().to_vec()),
+			]),
+		)
+		.await
+		.unwrap();
+	assert_eq!(res.labels.len(), raw_labels.len());
+
+	let vertex = vc.get_vertex(res.id.as_bytes().to_vec()).await.unwrap();
+	assert_eq!(vertex, res);
+	assert_eq!(vertex.labels.len(), raw_labels.len());
+}
diff --git a/db/src/util/byte.rs b/db/src/util/byte.rs
index 457bd8b..7cd0832 100644
--- a/db/src/util/byte.rs
+++ b/db/src/util/byte.rs
@@ -105,55 +105,29 @@ pub fn from_uuid_bytes(bytes: &[u8]) -> Result<Uuid, IoError> {
 	Ok(component)
 }
 
-pub fn from_vec_uuid_bytes(bytes_vec: &Vec<u8>) -> Result<Vec<Uuid>, IoError> {
-	let mut i = 0;
-	let l = Component::Uuid(Uuid::nil()).len();
-	let mut ans = vec![];
-	if !bytes_vec.is_empty() {
-		loop {
-			let slice = &bytes_vec[i * l..(i + 1) * l];
-			if slice.is_empty() {
-				return Ok(ans);
-			}
-			let component = from_uuid_bytes(slice).unwrap();
-			ans.push(component);
-			i += 1;
-		}
-	}
-	Ok(ans)
-}
-
-pub fn from_vec_bytes(bytes_vec: &Vec<u8>) -> Result<Vec<Vec<u8>>, IoError> {
-	let mut i = 0;
-	let l = Component::Uuid(Uuid::nil()).len();
-	let mut ans = vec![];
-	if !bytes_vec.is_empty() {
-		loop {
-			let slice = &bytes_vec[i * l..(i + 1) * l];
-			if slice.is_empty() {
-				return Ok(ans);
-			}
-			ans.push(slice.to_vec());
-			i += 1;
-		}
-	}
-	Ok(ans)
-}
-
 pub fn generate_random_i32() -> i32 {
 	let mut rng = rand::thread_rng();
 	rng.gen::<i32>()
 }
 
-pub fn build_offset(size: u8, length: usize) -> Vec<u8> {
+pub fn build_meta(size: u8, length: usize) -> Vec<u8> {
 	vec![size, length as u8]
 }
 
-pub fn deserialize_data_with_offset(data: ByteData, has_discriminator: bool) -> DeserializeResult {
-	let mut offset = 2;
+/// # Deserialize data with metadata
+/// Metadata: [size, length]
+///
+/// Based on the information of metadata to slice the raw byte data
+pub fn deserialize_data_with_meta(data: ByteData, has_discriminator: bool) -> DeserializeResult {
+	let meta_length = 2;
+	let mut offset = meta_length;
 	let mut discriminator = AccountDiscriminator::None;
+	// If byte data includes discriminator, offset will be
+	// - meta length (2) + discriminator length (4) = offset (6)
 	if has_discriminator {
-		offset = 6;
+		let discriminator_length = 4;
+		offset = meta_length + discriminator_length;
+		// Binary deserialize byte data into AccountDiscriminator
 		discriminator = bincode::deserialize(&data[..offset - 2]).unwrap();
 	}
 
@@ -197,7 +171,7 @@ pub fn deserialize_data_with_offset(data: ByteData, has_discriminator: bool) ->
 }
 
 pub fn deserialize_byte_data(
-	data: Vec<u8>,
+	data: ByteData,
 	has_discriminator: bool,
 ) -> Result<Vec<(ByteDataArray, ByteData)>, IoError> {
 	let mut result = vec![];
@@ -206,7 +180,7 @@ pub fn deserialize_byte_data(
 	while total_length > 0 {
 		let slice = data[start..].to_vec();
 		let (data, length, discriminator) =
-			deserialize_data_with_offset(slice, has_discriminator).unwrap();
+			deserialize_data_with_meta(slice, has_discriminator).unwrap();
 
 		result.push((data, discriminator));
 		start += length;