#[macro_use] extern crate serde_derive;
extern crate tokio_core;
extern crate rincon_core;
extern crate rincon_connector;
extern crate rincon_client;
extern crate rincon_test_helper;
use rincon_core::api::connector::Execute;
use rincon_core::api::types::EMPTY;
use rincon_client::document::types::NewDocument;
use rincon_client::graph::methods::*;
use rincon_client::graph::types::*;
use rincon_test_helper::*;
#[test]
fn create_graph() {
arango_test_with_user_db("test_graph_user10", "test_graph_db10", |conn, ref mut core| {
let edge_defs = vec![
EdgeDefinition::new("UsersInGroups",
vec!["Users".to_owned()],
vec!["Groups".to_owned()]
),
];
#[cfg(not(feature = "enterprise"))]
let new_graph = NewGraph::new("test_graph1", edge_defs.clone());
#[cfg(feature = "enterprise")]
let new_graph = NewGraph::new("test_graph1", edge_defs.clone(), false);
let method = CreateGraph::new(new_graph);
let graph = core.run(conn.execute(method)).unwrap();
assert_eq!("_graphs", graph.id().collection_name());
assert_eq!("test_graph1", graph.id().document_key());
assert_eq!("test_graph1", graph.key().as_str());
assert!(!graph.revision().as_str().is_empty());
assert_eq!("test_graph1", graph.name());
assert_eq!(edge_defs, graph.edge_definitions());
assert_eq!(0, graph.orphan_collections().len());
#[cfg(feature = "enterprise")]
assert_eq!(false, graph.is_smart());
#[cfg(feature = "enterprise")]
assert_eq!("", graph.smart_graph_attribute());
});
}
#[cfg(feature = "enterprise")]
#[test]
fn create_smart_graph() {
arango_test_with_user_db("test_graph_user11", "test_graph_db11", |conn, ref mut core| {
let edge_defs = vec![
EdgeDefinition::new("UsersInGroups",
vec!["Users".to_owned()],
vec!["Groups".to_owned()]
),
];
let mut new_graph = NewGraph::new("test_graph1", edge_defs.clone(), true);
new_graph.options_mut().set_smart_graph_attribute("knows".to_owned());
let new_graph = new_graph;
let method = CreateGraph::new(new_graph);
let graph = core.run(conn.execute(method)).unwrap();
assert_eq!("_graphs", graph.id().collection_name());
assert_eq!("test_graph1", graph.id().document_key());
assert_eq!("test_graph1", graph.key().as_str());
assert!(!graph.revision().as_str().is_empty());
assert_eq!("test_graph1", graph.name());
assert_eq!(edge_defs, graph.edge_definitions());
assert_eq!(0, graph.orphan_collections().len());
assert_eq!(true, graph.is_smart());
assert_eq!("knows", graph.smart_graph_attribute());
});
}
#[test]
fn create_graph_with_2_edge_definitions() {
arango_test_with_user_db("test_graph_user12", "test_graph_db12", |conn, ref mut core| {
let edge_defs = vec![
EdgeDefinition::new("UsersInGroups",
vec!["Users".to_owned()],
vec!["Groups".to_owned()]
),
EdgeDefinition::new("UsersKnowsUsers",
vec!["Users".to_owned()],
vec!["Users".to_owned()]
),
];
#[cfg(not(feature = "enterprise"))]
let new_graph = NewGraph::new("test_graph1", edge_defs.clone());
#[cfg(feature = "enterprise")]
let new_graph = NewGraph::new("test_graph1", edge_defs.clone(), false);
let method = CreateGraph::new(new_graph);
let graph = core.run(conn.execute(method)).unwrap();
assert_eq!("_graphs", graph.id().collection_name());
assert_eq!("test_graph1", graph.id().document_key());
assert_eq!("test_graph1", graph.key().as_str());
assert!(!graph.revision().as_str().is_empty());
assert_eq!("test_graph1", graph.name());
assert_eq!(edge_defs, graph.edge_definitions());
assert_eq!(0, graph.orphan_collections().len());
#[cfg(feature = "enterprise")]
assert_eq!(false, graph.is_smart());
#[cfg(feature = "enterprise")]
assert_eq!("", graph.smart_graph_attribute());
});
}
#[test]
fn drop_graph() {
arango_test_with_user_db("test_graph_user20", "test_graph_db20", |conn, ref mut core| {
let edge_defs = vec![
EdgeDefinition::new("UsersInGroups",
vec!["Users".to_owned()],
vec!["Groups".to_owned()]
),
];
#[cfg(not(feature = "enterprise"))]
let new_graph = NewGraph::new("test_graph1", edge_defs);
#[cfg(feature = "enterprise")]
let new_graph = NewGraph::new("test_graph1", edge_defs, false);
let graph = core.run(conn.execute(CreateGraph::new(new_graph))).unwrap();
assert_eq!("_graphs/test_graph1".to_owned(), graph.id().to_string());
let method = DropGraph::with_name("test_graph1");
let deleted = core.run(conn.execute(method)).unwrap();
assert_eq!(true, deleted);
});
}
#[test]
fn get_graph() {
arango_test_with_user_db("test_graph_user30", "test_graph_db30", |conn, ref mut core| {
let edge_defs = vec![
EdgeDefinition::new("UsersInGroups",
vec!["Users".to_owned()],
vec!["Groups".to_owned()]
),
];
#[cfg(not(feature = "enterprise"))]
let new_graph = NewGraph::new("test_graph1", edge_defs);
#[cfg(feature = "enterprise")]
let new_graph = NewGraph::new("test_graph1", edge_defs, false);
let created = core.run(conn.execute(CreateGraph::new(new_graph))).unwrap();
assert_eq!("_graphs/test_graph1".to_owned(), created.id().to_string());
let method = GetGraph::with_name("test_graph1");
let graph = core.run(conn.execute(method)).unwrap();
assert_eq!(created, graph);
});
}
#[test]
fn list_graphs() {
arango_test_with_user_db("test_graph_user40", "test_graph_db40", |conn, ref mut core| {
let edge_defs1 = vec![
EdgeDefinition::new("UsersInGroups",
vec!["Users".to_owned()],
vec!["Groups".to_owned()]
),
];
#[cfg(not(feature = "enterprise"))]
let new_graph1 = NewGraph::new("test_graph1", edge_defs1);
#[cfg(feature = "enterprise")]
let new_graph1 = NewGraph::new("test_graph1", edge_defs1, false);
let created1 = core.run(conn.execute(CreateGraph::new(new_graph1))).unwrap();
assert_eq!("_graphs/test_graph1".to_owned(), created1.id().to_string());
let edge_defs2 = vec![
EdgeDefinition::new("UsersKnowsUsers",
vec!["Users".to_owned()],
vec!["Users".to_owned()]
),
];
#[cfg(not(feature = "enterprise"))]
let new_graph2 = NewGraph::new("test_graph2", edge_defs2);
#[cfg(feature = "enterprise")]
let new_graph2 = NewGraph::new("test_graph2", edge_defs2, false);
let created2 = core.run(conn.execute(CreateGraph::new(new_graph2))).unwrap();
assert_eq!("_graphs/test_graph2".to_owned(), created2.id().to_string());
let method = ListGraphs::new();
let graphs = core.run(conn.execute(method)).unwrap();
let graph1 = graphs.iter().find(|g| g.name() == "test_graph1").unwrap();
let graph2 = graphs.iter().find(|g| g.name() == "test_graph2").unwrap();
assert_eq!(&created1, graph1);
assert_eq!(&created2, graph2);
});
}
#[test]
fn add_vertex_collection() {
arango_test_with_user_db("test_graph_user50", "test_graph_db50", |conn, ref mut core| {
let edge_defs = vec![
EdgeDefinition::new("UsersInGroups",
vec!["Users".to_owned()],
vec!["Groups".to_owned()]
),
];
#[cfg(not(feature = "enterprise"))]
let new_graph = NewGraph::new("test_graph1", edge_defs);
#[cfg(feature = "enterprise")]
let new_graph = NewGraph::new("test_graph1", edge_defs, false);
let created = core.run(conn.execute(CreateGraph::new(new_graph))).unwrap();
assert_eq!("_graphs/test_graph1".to_owned(), created.id().to_string());
assert_eq!(0, created.orphan_collections().len());
let vertex_collection = VertexCollection::new("other_vertices");
let method = AddVertexCollection::new("test_graph1", vertex_collection);
let graph = core.run(conn.execute(method)).unwrap();
assert_eq!("_graphs", graph.id().collection_name());
assert_eq!("test_graph1", graph.id().document_key());
assert_eq!(1, graph.orphan_collections().len());
assert!(graph.orphan_collections().contains(&"other_vertices".to_owned()));
});
}
#[test]
fn remove_vertex_collection() {
arango_test_with_user_db("test_graph_user60", "test_graph_db60", |conn, ref mut core| {
let edge_defs = vec![
EdgeDefinition::new("UsersInGroups",
vec!["Users".to_owned()],
vec!["Groups".to_owned()]
),
];
#[cfg(not(feature = "enterprise"))]
let new_graph = NewGraph::new("test_graph1", edge_defs)
.with_orphan_collections(vec![
"add_ons".to_owned(),
"spare".to_owned()
]);
#[cfg(feature = "enterprise")]
let new_graph = NewGraph::new("test_graph1", edge_defs, false)
.with_orphan_collections(vec![
"add_ons".to_owned(),
"spare".to_owned()
]);
let created = core.run(conn.execute(CreateGraph::new(new_graph))).unwrap();
assert_eq!("_graphs/test_graph1".to_owned(), created.id().to_string());
assert_eq!(2, created.orphan_collections().len());
let method = RemoveVertexCollection::new("test_graph1", "add_ons");
let graph = core.run(conn.execute(method)).unwrap();
assert_eq!("_graphs", graph.id().collection_name());
assert_eq!("test_graph1", graph.id().document_key());
assert_eq!(1, graph.orphan_collections().len());
assert!(graph.orphan_collections().contains(&"spare".to_owned()));
});
}
#[test]
fn list_vertex_collections() {
arango_test_with_user_db("test_graph_user70", "test_graph_db70", |conn, ref mut core| {
let edge_defs = vec![
EdgeDefinition::new("UsersInGroups",
vec!["Users".to_owned()],
vec!["Groups".to_owned()]
),
];
#[cfg(not(feature = "enterprise"))]
let new_graph = NewGraph::new("test_graph1", edge_defs)
.with_orphan_collections(vec![
"add_ons".to_owned(),
"spare".to_owned()
]);
#[cfg(feature = "enterprise")]
let new_graph = NewGraph::new("test_graph1", edge_defs, false)
.with_orphan_collections(vec![
"add_ons".to_owned(),
"spare".to_owned()
]);
let created = core.run(conn.execute(CreateGraph::new(new_graph))).unwrap();
assert_eq!("_graphs/test_graph1".to_owned(), created.id().to_string());
let method = ListVertexCollections::new("test_graph1");
let vertices = core.run(conn.execute(method)).unwrap();
assert!(vertices.contains(&"Users".to_owned()));
assert!(vertices.contains(&"Groups".to_owned()));
assert!(vertices.contains(&"add_ons".to_owned()));
assert!(vertices.contains(&"spare".to_owned()));
assert_eq!(4, vertices.len());
});
}
#[test]
fn insert_vertex() {
arango_test_with_user_db("test_graph_user120", "test_graph_db120", |conn, ref mut core| {
let edge_defs = vec![
EdgeDefinition::new("works_in",
vec!["female".to_owned(), "male".to_owned()],
vec!["city".to_owned()],
),
];
#[cfg(not(feature = "enterprise"))]
let new_graph = NewGraph::new("social", edge_defs);
#[cfg(feature = "enterprise")]
let new_graph = NewGraph::new("social", edge_defs, false);
let created = core.run(conn.execute(CreateGraph::new(new_graph))).unwrap();
assert_eq!("_graphs/social".to_owned(), created.id().to_string());
#[derive(Debug, Serialize)]
struct City {
name: String,
}
let city_doc = NewDocument::from(City { name: "New Orleans".to_owned() });
let method = InsertVertex::new("social", "city", city_doc);
let doc_header = core.run(conn.execute(method)).unwrap();
assert_eq!("city".to_owned(), doc_header.id().collection_name());
assert!(!doc_header.key().as_str().is_empty());
assert!(!doc_header.revision().as_str().is_empty());
});
}
#[test]
fn add_edge_definition() {
arango_test_with_user_db("test_graph_user80", "test_graph_db80", |conn, ref mut core| {
let edge_defs = vec![
EdgeDefinition::new("relation",
vec!["female".to_owned(), "male".to_owned()],
vec!["male".to_owned(), "female".to_owned()],
),
];
#[cfg(not(feature = "enterprise"))]
let new_graph = NewGraph::new("social", edge_defs);
#[cfg(feature = "enterprise")]
let new_graph = NewGraph::new("social", edge_defs, false);
let created = core.run(conn.execute(CreateGraph::new(new_graph))).unwrap();
assert_eq!("_graphs/social".to_owned(), created.id().to_string());
let works_in = EdgeDefinition::new("works_in",
vec!["female".to_owned(), "male".to_owned()],
vec!["city".to_owned()],
);
let method = AddEdgeDefinition::new("social", works_in);
let graph = core.run(conn.execute(method)).unwrap();
assert_eq!("_graphs", graph.id().collection_name());
assert_eq!("social", graph.id().document_key());
assert_eq!("social", graph.name());
let expected_edge_defs = vec![
EdgeDefinition::new("relation",
vec!["female".to_owned(), "male".to_owned()],
vec!["female".to_owned(), "male".to_owned()],
),
EdgeDefinition::new("works_in",
vec!["female".to_owned(), "male".to_owned()],
vec!["city".to_owned()],
),
];
assert_eq!(&expected_edge_defs[..], graph.edge_definitions());
assert!(graph.orphan_collections().is_empty());
});
}
#[test]
fn remove_edge_definition() {
arango_test_with_user_db("test_graph_user90", "test_graph_db90", |conn, ref mut core| {
let edge_defs = vec![
EdgeDefinition::new("relation",
vec!["female".to_owned(), "male".to_owned()],
vec!["male".to_owned(), "female".to_owned()],
),
EdgeDefinition::new("works_in",
vec!["female".to_owned(), "male".to_owned()],
vec!["city".to_owned()],
),
];
#[cfg(not(feature = "enterprise"))]
let new_graph = NewGraph::new("social", edge_defs);
#[cfg(feature = "enterprise")]
let new_graph = NewGraph::new("social", edge_defs, false);
let created = core.run(conn.execute(CreateGraph::new(new_graph))).unwrap();
assert_eq!("_graphs/social".to_owned(), created.id().to_string());
let method = RemoveEdgeDefinition::new("social", "works_in");
let graph = core.run(conn.execute(method)).unwrap();
assert_eq!("_graphs", graph.id().collection_name());
assert_eq!("social", graph.id().document_key());
assert_eq!("social", graph.name());
let expected_edge_defs = vec![
EdgeDefinition::new("relation",
vec!["female".to_owned(), "male".to_owned()],
vec!["female".to_owned(), "male".to_owned()],
),
];
assert_eq!(&expected_edge_defs[..], graph.edge_definitions());
assert_eq!(&vec!["city".to_owned()][..], graph.orphan_collections());
});
}
#[test]
fn replace_edge_definition() {
arango_test_with_user_db("test_graph_user100", "test_graph_db100", |conn, ref mut core| {
let edge_defs = vec![
EdgeDefinition::new("relation",
vec!["female".to_owned(), "male".to_owned()],
vec!["male".to_owned(), "female".to_owned()],
),
];
#[cfg(not(feature = "enterprise"))]
let new_graph = NewGraph::new("social", edge_defs);
#[cfg(feature = "enterprise")]
let new_graph = NewGraph::new("social", edge_defs, false);
let created = core.run(conn.execute(CreateGraph::new(new_graph))).unwrap();
assert_eq!("_graphs/social".to_owned(), created.id().to_string());
let replacement_edge_def = EdgeDefinition::new("relation",
vec!["female".to_owned(), "male".to_owned(), "animal".to_owned()],
vec!["male".to_owned(), "female".to_owned(), "animal".to_owned()],
);
let method = ReplaceEdgeDefinition::new("social", "relation", replacement_edge_def);
let graph = core.run(conn.execute(method)).unwrap();
assert_eq!("_graphs", graph.id().collection_name());
assert_eq!("social", graph.id().document_key());
assert_eq!("social", graph.name());
let expected_edge_defs = vec![
EdgeDefinition::new("relation",
vec!["animal".to_owned(), "female".to_owned(), "male".to_owned()],
vec!["animal".to_owned(), "female".to_owned(), "male".to_owned()],
),
];
assert_eq!(&expected_edge_defs[..], graph.edge_definitions());
assert!(graph.orphan_collections().is_empty());
});
}
#[test]
fn list_edge_collections() {
arango_test_with_user_db("test_graph_user110", "test_graph_db110", |conn, ref mut core| {
let edge_defs = vec![
EdgeDefinition::new("relation",
vec!["female".to_owned(), "male".to_owned()],
vec!["male".to_owned(), "female".to_owned()],
),
EdgeDefinition::new("works_in",
vec!["female".to_owned(), "male".to_owned()],
vec!["city".to_owned()],
),
];
#[cfg(not(feature = "enterprise"))]
let new_graph = NewGraph::new("social", edge_defs);
#[cfg(feature = "enterprise")]
let new_graph = NewGraph::new("social", edge_defs, false);
let created = core.run(conn.execute(CreateGraph::new(new_graph))).unwrap();
assert_eq!("_graphs/social".to_owned(), created.id().to_string());
let method = ListEdgeCollections::new("social");
let edges = core.run(conn.execute(method)).unwrap();
assert!(edges.contains(&"relation".to_owned()));
assert!(edges.contains(&"works_in".to_owned()));
assert_eq!(2, edges.len());
});
}
#[test]
fn insert_edge() {
arango_test_with_user_db("test_graph_user130", "test_graph_db130", |conn, ref mut core| {
let edge_defs = vec![
EdgeDefinition::new("works_in",
vec!["female".to_owned(), "male".to_owned()],
vec!["city".to_owned()],
),
];
#[cfg(not(feature = "enterprise"))]
let new_graph = NewGraph::new("social", edge_defs);
#[cfg(feature = "enterprise")]
let new_graph = NewGraph::new("social", edge_defs, false);
let created = core.run(conn.execute(CreateGraph::new(new_graph))).unwrap();
assert_eq!("_graphs/social".to_owned(), created.id().to_string());
#[derive(Debug, Serialize)]
struct Person {
name: String,
}
let person_doc = NewDocument::from(Person { name: "Jane Doe".to_owned() });
let method = InsertVertex::new("social", "female", person_doc);
let (person_id, _, _) = core.run(conn.execute(method)).unwrap().deconstruct();
#[derive(Debug, Serialize)]
struct City {
name: String,
}
let city_doc = NewDocument::from(City { name: "New Orleans".to_owned() });
let method = InsertVertex::new("social", "city", city_doc);
let (city_id, _, _) = core.run(conn.execute(method)).unwrap().deconstruct();
let works_in = NewEdge::new(person_id, city_id, EMPTY);
let method = InsertEdge::new("social", "works_in", works_in);
let edge_header = core.run(conn.execute(method)).unwrap();
assert_eq!("works_in".to_owned(), edge_header.id().collection_name());
assert!(!edge_header.key().as_str().is_empty());
assert!(!edge_header.revision().as_str().is_empty());
});
}