mirror of https://gitee.com/bigwinds/arangodb
710 lines
30 KiB
Ruby
710 lines
30 KiB
Ruby
# coding: utf-8
|
|
|
|
require 'rspec'
|
|
require './arangodb.rb'
|
|
|
|
|
|
describe ArangoDB do
|
|
prefix = "api-blueprints"
|
|
|
|
vertex_collection = "v"
|
|
edge_collection = "e"
|
|
graph_name = "graph1"
|
|
|
|
context "testing blueprints methods:" do
|
|
|
|
def truncate_collection (prefix, name)
|
|
cmd = "/_api/collection/#{name}/truncate"
|
|
ArangoDB.log_put("#{prefix}", cmd)
|
|
end
|
|
|
|
################################################################################
|
|
## checking graph responses
|
|
################################################################################
|
|
|
|
context "checks blueprints graph requests" do
|
|
before do
|
|
#ArangoDB.create_collection( edge_collection , 0, 3)
|
|
#ArangoDB.create_collection( vertex_collection , 0, 2)
|
|
truncate_collection(prefix, "_graphs")
|
|
end
|
|
|
|
after do
|
|
truncate_collection(prefix, "_graphs")
|
|
ArangoDB.drop_collection( vertex_collection )
|
|
ArangoDB.drop_collection( edge_collection )
|
|
end
|
|
|
|
it "checks create graph" do
|
|
cmd = "/_api/blueprints/graph"
|
|
body = "{\"name\" : \"#{graph_name}\", \"verticesName\" : \"#{vertex_collection}\", \"edgesName\" : \"#{edge_collection}\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
doc.parsed_response['graph']['name'].should eq("#{graph_name}")
|
|
end
|
|
|
|
it "checks create graph with wrong edges collection" do
|
|
ArangoDB.create_collection( edge_collection , 0, 2)
|
|
|
|
cmd = "/_api/blueprints/graph"
|
|
body = "{\"name\" : \"#{graph_name}\", \"verticesName\" : \"#{vertex_collection}\", \"edgesName\" : \"#{edge_collection}\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
|
|
doc.code.should eq(400)
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['code'].should eq(400)
|
|
doc.parsed_response['errorNum'].should eq(1902)
|
|
end
|
|
|
|
it "checks (re)create graph" do
|
|
cmd = "/_api/blueprints/graph"
|
|
body = "{\"name\" : \"#{graph_name}\", \"verticesName\" : \"#{vertex_collection}\", \"edgesName\" : \"#{edge_collection}\"}"
|
|
doc1 = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
|
|
doc1.code.should eq(200)
|
|
|
|
doc2 = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
|
|
doc2.code.should eq(200)
|
|
|
|
doc1.parsed_response['graph']['_id'].should eq(doc2.parsed_response['graph']['_id'])
|
|
end
|
|
|
|
it "checks create and get graph" do
|
|
cmd = "/_api/blueprints/graph"
|
|
body = "{\"name\" : \"#{graph_name}\", \"verticesName\" : \"#{vertex_collection}\", \"edgesName\" : \"#{edge_collection}\"}"
|
|
doc1 = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
g_id = doc1.parsed_response['graph']['_id']
|
|
|
|
doc1.code.should eq(200)
|
|
|
|
cmd = "/_api/blueprints/graph/#{graph_name}"
|
|
doc2 = ArangoDB.log_get("#{prefix}", cmd)
|
|
|
|
doc2.code.should eq(200)
|
|
doc2.parsed_response['graph']['_id'].should eq(g_id)
|
|
|
|
cmd = "/_api/blueprints/graph/#{g_id}"
|
|
doc3 = ArangoDB.log_get("#{prefix}", cmd)
|
|
|
|
doc3.code.should eq(200)
|
|
doc3.parsed_response['graph']['_id'].should eq(g_id)
|
|
end
|
|
|
|
it "checks create and delete graph" do
|
|
# create
|
|
cmd = "/_api/blueprints/graph"
|
|
body = "{\"name\" : \"#{graph_name}\", \"verticesName\" : \"#{vertex_collection}\", \"edgesName\" : \"#{edge_collection}\"}"
|
|
doc1 = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
doc1.code.should eq(200)
|
|
|
|
# delete
|
|
cmd = "/_api/blueprints/graph/#{graph_name}"
|
|
doc2 = ArangoDB.log_delete("#{prefix}", cmd)
|
|
doc2.code.should eq(200)
|
|
doc2.parsed_response['deleted'].should eq(true)
|
|
|
|
# check
|
|
doc3 = ArangoDB.log_get("#{prefix}", cmd)
|
|
doc3.code.should eq(400)
|
|
end
|
|
|
|
end
|
|
|
|
################################################################################
|
|
## checking vertex responses
|
|
################################################################################
|
|
|
|
context "checks blueprints vertex requests" do
|
|
before do
|
|
truncate_collection(prefix, "_graphs")
|
|
cmd = "/_api/blueprints/graph"
|
|
body = "{\"name\" : \"#{graph_name}\", \"verticesName\" : \"#{vertex_collection}\", \"edgesName\" : \"#{edge_collection}\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
end
|
|
|
|
after do
|
|
truncate_collection(prefix, "_graphs")
|
|
ArangoDB.drop_collection( vertex_collection )
|
|
ArangoDB.drop_collection( edge_collection )
|
|
end
|
|
|
|
it "checks create vertex with \$id" do
|
|
cmd = "/_api/blueprints/vertex?graph=#{graph_name}"
|
|
body = "{\"\$id\" : \"v1\", \"optional1\" : \"val1\", \"optional2\" : \"val2\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
doc.parsed_response['vertex']['$id'].should eq("v1")
|
|
doc.parsed_response['vertex']['optional1'].should eq("val1")
|
|
end
|
|
|
|
it "checks create second vertex with \$id" do
|
|
cmd = "/_api/blueprints/vertex?graph=#{graph_name}"
|
|
body = "{\"\$id\" : \"double_id\", \"optional1\" : \"val1\", \"optional2\" : \"val2\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
|
|
doc2 = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
doc2.code.should eq(400)
|
|
doc2.parsed_response['error'].should eq(true)
|
|
doc2.parsed_response['code'].should eq(400)
|
|
end
|
|
|
|
it "checks get vertex by \$id" do
|
|
cmd = "/_api/blueprints/vertex?graph=#{graph_name}"
|
|
body = "{\"\$id\" : \"v1\", \"optional1\" : \"val1\", \"optional2\" : \"val2\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
doc.parsed_response['vertex']['$id'].should eq("v1")
|
|
doc.parsed_response['vertex']['optional1'].should eq("val1")
|
|
|
|
cmd = "/_api/blueprints/vertex/v1?graph=#{graph_name}"
|
|
doc2 = ArangoDB.log_get("#{prefix}", cmd)
|
|
doc2.code.should eq(200)
|
|
doc2.parsed_response['error'].should eq(false)
|
|
doc2.parsed_response['code'].should eq(200)
|
|
doc2.parsed_response['vertex']['optional1'].should eq(doc.parsed_response['vertex']['optional1'])
|
|
|
|
_id = doc2.parsed_response['vertex']['_id'];
|
|
cmd = "/_api/blueprints/vertex/#{_id}?graph=#{graph_name}"
|
|
doc3 = ArangoDB.log_get("#{prefix}", cmd)
|
|
doc3.code.should eq(200)
|
|
doc3.parsed_response['error'].should eq(false)
|
|
doc3.parsed_response['code'].should eq(200)
|
|
doc3.parsed_response['vertex']['optional1'].should eq(doc.parsed_response['vertex']['optional1'])
|
|
end
|
|
|
|
it "checks get vertex by wrong \$id" do
|
|
cmd = "/_api/blueprints/vertex/vv11?graph=#{graph_name}"
|
|
doc = ArangoDB.log_get("#{prefix}", cmd)
|
|
doc.code.should eq(400)
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['code'].should eq(400)
|
|
end
|
|
|
|
it "checks update vertex by \$id" do
|
|
cmd = "/_api/blueprints/vertex?graph=#{graph_name}"
|
|
body = "{\"\$id\" : \"v1\", \"optional1\" : \"val1\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
doc.parsed_response['vertex']['$id'].should eq("v1")
|
|
doc.parsed_response['vertex']['optional1'].should eq("val1")
|
|
|
|
cmd = "/_api/blueprints/vertex/v1?graph=#{graph_name}"
|
|
doc2 = ArangoDB.log_get("#{prefix}", cmd)
|
|
doc2.code.should eq(200)
|
|
doc2.parsed_response['error'].should eq(false)
|
|
doc2.parsed_response['code'].should eq(200)
|
|
doc2.parsed_response['vertex']['optional1'].should eq(doc.parsed_response['vertex']['optional1'])
|
|
|
|
_id = doc2.parsed_response['vertex']['_id'];
|
|
cmd = "/_api/blueprints/vertex/#{_id}?graph=#{graph_name}"
|
|
body = "{\"\$id\" : \"v1\", \"optional1\" : \"val2\"}"
|
|
doc3 = ArangoDB.log_put("#{prefix}", cmd, :body => body)
|
|
doc3.code.should eq(200)
|
|
doc3.parsed_response['error'].should eq(false)
|
|
doc3.parsed_response['code'].should eq(200)
|
|
doc3.parsed_response['vertex']['optional1'].should eq("val2")
|
|
|
|
cmd = "/_api/blueprints/vertex/v1?graph=#{graph_name}"
|
|
doc2 = ArangoDB.log_get("#{prefix}", cmd)
|
|
doc2.code.should eq(200)
|
|
doc2.parsed_response['error'].should eq(false)
|
|
doc2.parsed_response['code'].should eq(200)
|
|
doc2.parsed_response['vertex']['optional1'].should eq("val2")
|
|
end
|
|
|
|
it "checks update vertex" do
|
|
cmd = "/_api/blueprints/vertex?graph=#{graph_name}"
|
|
body = "{\"optional1\" : \"val1\", \"optional2\" : \"val2\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
doc.parsed_response['vertex']['$id'].should eq(nil)
|
|
doc.parsed_response['vertex']['optional1'].should eq("val1")
|
|
doc.parsed_response['vertex']['optional2'].should eq("val2")
|
|
_id = doc.parsed_response['vertex']['_id'];
|
|
|
|
cmd = "/_api/blueprints/vertex/#{_id}?graph=#{graph_name}"
|
|
doc2 = ArangoDB.log_get("#{prefix}", cmd)
|
|
doc2.code.should eq(200)
|
|
doc2.parsed_response['error'].should eq(false)
|
|
doc2.parsed_response['code'].should eq(200)
|
|
doc2.parsed_response['vertex']['optional1'].should eq(doc.parsed_response['vertex']['optional1'])
|
|
|
|
cmd = "/_api/blueprints/vertex/#{_id}?graph=#{graph_name}"
|
|
body = "{\"optional1\" : \"val2\"}"
|
|
doc3 = ArangoDB.log_put("#{prefix}", cmd, :body => body)
|
|
doc3.code.should eq(200)
|
|
doc3.parsed_response['error'].should eq(false)
|
|
doc3.parsed_response['code'].should eq(200)
|
|
doc3.parsed_response['vertex']['optional1'].should eq("val2")
|
|
doc3.parsed_response['vertex']['optional2'].should eq(nil)
|
|
|
|
cmd = "/_api/blueprints/vertex/#{_id}?graph=#{graph_name}"
|
|
doc4 = ArangoDB.log_get("#{prefix}", cmd)
|
|
doc4.code.should eq(200)
|
|
doc4.parsed_response['error'].should eq(false)
|
|
doc4.parsed_response['code'].should eq(200)
|
|
doc4.parsed_response['vertex']['optional1'].should eq("val2")
|
|
doc4.parsed_response['vertex']['optional2'].should eq(nil)
|
|
end
|
|
|
|
it "checks delete vertex" do
|
|
cmd = "/_api/blueprints/vertex?graph=#{graph_name}"
|
|
body = "{\"optional1\" : \"val1\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
doc.parsed_response['vertex']['$id'].should eq(nil)
|
|
doc.parsed_response['vertex']['optional1'].should eq("val1")
|
|
_id = doc.parsed_response['vertex']['_id'];
|
|
|
|
cmd = "/_api/blueprints/vertex/#{_id}?graph=#{graph_name}"
|
|
doc2 = ArangoDB.log_delete("#{prefix}", cmd)
|
|
doc2.code.should eq(200)
|
|
doc2.parsed_response['error'].should eq(false)
|
|
doc2.parsed_response['code'].should eq(200)
|
|
doc2.parsed_response['deleted'].should eq(true)
|
|
|
|
cmd = "/_api/blueprints/vertex/#{_id}?graph=#{graph_name}"
|
|
doc3 = ArangoDB.log_get("#{prefix}", cmd)
|
|
doc3.code.should eq(400)
|
|
doc3.parsed_response['error'].should eq(true)
|
|
doc3.parsed_response['code'].should eq(400)
|
|
end
|
|
|
|
end
|
|
|
|
################################################################################
|
|
## checking vertices responses
|
|
################################################################################
|
|
|
|
context "checks blueprints vertices requests" do
|
|
before do
|
|
truncate_collection(prefix, "_graphs")
|
|
cmd = "/_api/blueprints/graph"
|
|
body = "{\"name\" : \"#{graph_name}\", \"verticesName\" : \"#{vertex_collection}\", \"edgesName\" : \"#{edge_collection}\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
end
|
|
|
|
after do
|
|
truncate_collection(prefix, "_graphs")
|
|
ArangoDB.drop_collection( vertex_collection )
|
|
ArangoDB.drop_collection( edge_collection )
|
|
end
|
|
|
|
it "checks list of vertices" do
|
|
cmd = "/_api/blueprints/vertex?graph=#{graph_name}"
|
|
body = "{\"$id\" : \"id1\", \"optional1\" : \"val1\", \"optional2\" : 1}"
|
|
ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
body = "{\"$id\" : \"id2\", \"optional1\" : \"val1\", \"optional2\" : 2}"
|
|
ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
body = "{\"$id\" : \"id3\", \"optional1\" : \"val1\", \"optional2\" : 2}"
|
|
ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
body = "{\"$id\" : \"id4\", \"optional1\" : \"val1\", \"optional2\" : 3}"
|
|
ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
body = "{\"$id\" : \"id5\", \"optional2\" : \"val2\"}"
|
|
ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
|
|
cmd = "/_api/blueprints/edge?graph=#{graph_name}"
|
|
body = "{\"$id\" : \"edge1\", \"_from\" : \"id1\", \"_to\" : \"id2\", \"$label\" : \"l1\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
body = "{\"$id\" : \"edge2\", \"_from\" : \"id2\", \"_to\" : \"id3\", \"$label\" : \"l2\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
|
|
cmd = "/_api/blueprints/vertices?graph=#{graph_name}"
|
|
body = "{\"batchSize\" : 100 }"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(201)
|
|
doc.parsed_response['result'].count.should eq(5)
|
|
|
|
cmd = "/_api/blueprints/vertices?graph=#{graph_name}"
|
|
body = "{\"batchSize\" : 100, \"key\" : \"optional2\", \"value\" : 3 }"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(201)
|
|
doc.parsed_response['result'].count.should eq(1)
|
|
|
|
cmd = "/_api/blueprints/vertices?graph=#{graph_name}"
|
|
body = "{\"batchSize\" : 100, \"key\" : \"optional2\", \"value\" : 2 }"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(201)
|
|
doc.parsed_response['result'].count.should eq(2)
|
|
|
|
cmd = "/_api/blueprints/vertices?graph=#{graph_name}"
|
|
body = "{\"batchSize\" : 100, \"vertex\" : \"id2\" }"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(201)
|
|
doc.parsed_response['result'].count.should eq(2)
|
|
|
|
cmd = "/_api/blueprints/vertices?graph=#{graph_name}"
|
|
body = "{\"batchSize\" : 100, \"vertex\" : \"id2\", \"direction\" : \"in\" }"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(201)
|
|
doc.parsed_response['result'].count.should eq(1)
|
|
doc.parsed_response['result'][0]['$id'].should eq("id1")
|
|
|
|
cmd = "/_api/blueprints/vertices?graph=#{graph_name}"
|
|
body = "{\"batchSize\" : 100, \"vertex\" : \"id2\", \"direction\" : \"out\" }"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(201)
|
|
doc.parsed_response['result'].count.should eq(1)
|
|
doc.parsed_response['result'][0]['$id'].should eq("id3")
|
|
|
|
cmd = "/_api/blueprints/vertices?graph=#{graph_name}"
|
|
body = "{\"batchSize\" : 100, \"vertex\" : \"id2\", \"labels\" : [\"l2\"] }"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(201)
|
|
doc.parsed_response['result'].count.should eq(1)
|
|
doc.parsed_response['result'][0]['$id'].should eq("id3")
|
|
|
|
end
|
|
|
|
end
|
|
|
|
################################################################################
|
|
## checking edge responses
|
|
################################################################################
|
|
|
|
context "checks blueprints edge requests" do
|
|
before do
|
|
truncate_collection(prefix, "_graphs")
|
|
cmd = "/_api/blueprints/graph"
|
|
body = "{\"name\" : \"#{graph_name}\", \"verticesName\" : \"#{vertex_collection}\", \"edgesName\" : \"#{edge_collection}\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
|
|
cmd = "/_api/blueprints/vertex?graph=#{graph_name}"
|
|
body = "{\"$id\" : \"vert1\"}"
|
|
ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
body = "{\"$id\" : \"vert2\"}"
|
|
ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
body = "{\"$id\" : \"vert3\"}"
|
|
ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
|
|
end
|
|
|
|
after do
|
|
truncate_collection(prefix, "_graphs")
|
|
ArangoDB.drop_collection( vertex_collection )
|
|
ArangoDB.drop_collection( edge_collection )
|
|
end
|
|
|
|
it "checks create edge" do
|
|
cmd = "/_api/blueprints/edge?graph=#{graph_name}"
|
|
body = "{\"$id\" : \"edge1\", \"_from\" : \"vert2\", \"_to\" : \"vert1\", \"optional1\" : \"val1\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
doc.parsed_response['edge']['$id'].should eq("edge1")
|
|
doc.parsed_response['edge']['optional1'].should eq("val1")
|
|
doc.parsed_response['edge']['$label'].should eq(nil)
|
|
end
|
|
|
|
it "checks create second edge with same \$id" do
|
|
cmd = "/_api/blueprints/edge?graph=#{graph_name}"
|
|
body = "{\"$id\" : \"edge1\", \"_from\" : \"vert2\", \"_to\" : \"vert1\", \"optional1\" : \"val1\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
doc.parsed_response['edge']['$id'].should eq("edge1")
|
|
doc.parsed_response['edge']['optional1'].should eq("val1")
|
|
doc.parsed_response['edge']['$label'].should eq(nil)
|
|
|
|
cmd = "/_api/blueprints/edge?graph=#{graph_name}"
|
|
body = "{\"$id\" : \"edge1\", \"_from\" : \"vert2\", \"_to\" : \"vert1\", \"optional1\" : \"val1\"}"
|
|
doc1 = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
|
|
doc1.code.should eq(400)
|
|
doc1.parsed_response['error'].should eq(true)
|
|
doc1.parsed_response['code'].should eq(400)
|
|
end
|
|
|
|
it "checks create edge with unknown vertex" do
|
|
cmd = "/_api/blueprints/edge?graph=#{graph_name}"
|
|
body = "{\"$id\" : \"edge1\", \"_from\" : \"unknown\", \"_to\" : \"vert1\", \"optional1\" : \"val1\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
|
|
doc.code.should eq(400)
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['code'].should eq(400)
|
|
end
|
|
|
|
it "checks create edge with \$label" do
|
|
cmd = "/_api/blueprints/edge?graph=#{graph_name}"
|
|
body = "{\"$id\" : \"edge1\", \"_from\" : \"vert2\", \"_to\" : \"vert1\", \"$label\" : \"label1\", \"optional1\" : \"val1\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
doc.parsed_response['edge']['$id'].should eq("edge1")
|
|
doc.parsed_response['edge']['optional1'].should eq("val1")
|
|
doc.parsed_response['edge']['$label'].should eq("label1")
|
|
end
|
|
|
|
it "checks create edge with _id of vertex" do
|
|
cmd = "/_api/blueprints/vertex?graph=#{graph_name}"
|
|
body = "{}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
v_id1 = doc.parsed_response['vertex']['_id']
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
v_id2 = doc.parsed_response['vertex']['_id']
|
|
|
|
cmd = "/_api/blueprints/edge?graph=#{graph_name}"
|
|
body = "{\"$id\" : \"edge1\", \"_from\" : \"#{v_id1}\", \"_to\" : \"#{v_id2}\", \"$label\" : \"label1\", \"optional1\" : \"val1\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
doc.parsed_response['edge']['$id'].should eq("edge1")
|
|
doc.parsed_response['edge']['optional1'].should eq("val1")
|
|
doc.parsed_response['edge']['_from'].should eq(v_id1)
|
|
doc.parsed_response['edge']['_to'].should eq(v_id2)
|
|
end
|
|
|
|
it "checks get edge by $id" do
|
|
cmd = "/_api/blueprints/edge?graph=#{graph_name}"
|
|
body = "{\"$id\" : \"edge1\", \"_from\" : \"vert2\", \"_to\" : \"vert1\", \"optional1\" : \"val1\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
eid = doc.parsed_response['edge']['$id']
|
|
e_id = doc.parsed_response['edge']['_id']
|
|
|
|
|
|
cmd = "/_api/blueprints/edge/#{eid}?graph=#{graph_name}"
|
|
doc1 = ArangoDB.log_get("#{prefix}", cmd)
|
|
|
|
doc1.code.should eq(200)
|
|
doc1.parsed_response['error'].should eq(false)
|
|
doc1.parsed_response['code'].should eq(200)
|
|
doc1.parsed_response['edge']['$id'].should eq(eid)
|
|
doc1.parsed_response['edge']['_id'].should eq(e_id)
|
|
doc1.parsed_response['edge']['optional1'].should eq("val1")
|
|
doc1.parsed_response['edge']['$label'].should eq(nil)
|
|
end
|
|
|
|
it "checks get edge by _id" do
|
|
cmd = "/_api/blueprints/edge?graph=#{graph_name}"
|
|
body = "{\"$id\" : \"edge1\", \"_from\" : \"vert2\", \"_to\" : \"vert1\", \"optional1\" : \"val1\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
eid = doc.parsed_response['edge']['$id']
|
|
e_id = doc.parsed_response['edge']['_id']
|
|
|
|
|
|
cmd = "/_api/blueprints/edge/#{e_id}?graph=#{graph_name}"
|
|
doc1 = ArangoDB.log_get("#{prefix}", cmd)
|
|
|
|
doc1.code.should eq(200)
|
|
doc1.parsed_response['error'].should eq(false)
|
|
doc1.parsed_response['code'].should eq(200)
|
|
doc1.parsed_response['edge']['$id'].should eq(eid)
|
|
doc1.parsed_response['edge']['_id'].should eq(e_id)
|
|
doc1.parsed_response['edge']['optional1'].should eq("val1")
|
|
doc1.parsed_response['edge']['$label'].should eq(nil)
|
|
end
|
|
|
|
it "checks replace edge properties by _id" do
|
|
cmd = "/_api/blueprints/edge?graph=#{graph_name}"
|
|
body = "{\"$id\" : \"edge1\", \"_from\" : \"vert2\", \"_to\" : \"vert1\", \"optional1\" : \"val1\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
doc.parsed_response['edge']['optional1'].should eq("val1")
|
|
doc.parsed_response['edge']['optional2'].should eq(nil)
|
|
doc.parsed_response['edge']['$label'].should eq(nil)
|
|
eid = doc.parsed_response['edge']['$id']
|
|
e_id = doc.parsed_response['edge']['_id']
|
|
e_to = doc.parsed_response['edge']['_to']
|
|
|
|
|
|
cmd = "/_api/blueprints/edge/#{e_id}?graph=#{graph_name}"
|
|
body = "{\"$id\" : \"edge4711\", \"optional2\" : \"val2\", \"label\" : \"label1\", \"_to\" : \"to\"}"
|
|
doc1 = ArangoDB.log_put("#{prefix}", cmd, :body => body)
|
|
doc1.code.should eq(200)
|
|
doc1.parsed_response['error'].should eq(false)
|
|
doc1.parsed_response['code'].should eq(200)
|
|
doc1.parsed_response['edge']['$id'].should eq(eid)
|
|
doc1.parsed_response['edge']['_id'].should eq(e_id)
|
|
doc1.parsed_response['edge']['_to'].should eq(e_to)
|
|
doc1.parsed_response['edge']['nameEdges'].should eq(nil)
|
|
doc1.parsed_response['edge']['optional1'].should eq(nil)
|
|
doc1.parsed_response['edge']['optional2'].should eq("val2")
|
|
doc1.parsed_response['edge']['$label'].should eq(nil)
|
|
end
|
|
|
|
it "checks delete edge by $id" do
|
|
cmd = "/_api/blueprints/edge?graph=#{graph_name}"
|
|
body = "{\"$id\" : \"edge1\", \"_from\" : \"vert2\", \"_to\" : \"vert1\", \"optional1\" : \"val1\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
eid = doc.parsed_response['edge']['$id']
|
|
e_id = doc.parsed_response['edge']['_id']
|
|
|
|
|
|
cmd = "/_api/blueprints/edge/#{eid}?graph=#{graph_name}"
|
|
doc1 = ArangoDB.log_delete("#{prefix}", cmd)
|
|
doc1.code.should eq(200)
|
|
doc1.parsed_response['error'].should eq(false)
|
|
doc1.parsed_response['code'].should eq(200)
|
|
|
|
cmd = "/_api/blueprints/edge/#{eid}?graph=#{graph_name}"
|
|
doc2 = ArangoDB.log_get("#{prefix}", cmd)
|
|
doc2.code.should eq(400)
|
|
doc2.parsed_response['error'].should eq(true)
|
|
doc2.parsed_response['code'].should eq(400)
|
|
end
|
|
|
|
it "checks delete edge by _id" do
|
|
cmd = "/_api/blueprints/edge?graph=#{graph_name}"
|
|
body = "{\"$id\" : \"edge1\", \"_from\" : \"vert2\", \"_to\" : \"vert1\", \"optional1\" : \"val1\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
eid = doc.parsed_response['edge']['$id']
|
|
e_id = doc.parsed_response['edge']['_id']
|
|
|
|
cmd = "/_api/blueprints/edge/#{e_id}?graph=#{graph_name}"
|
|
doc1 = ArangoDB.log_delete("#{prefix}", cmd)
|
|
doc1.code.should eq(200)
|
|
doc1.parsed_response['error'].should eq(false)
|
|
doc1.parsed_response['code'].should eq(200)
|
|
|
|
cmd = "/_api/blueprints/edge/#{eid}?graph=#{graph_name}"
|
|
doc2 = ArangoDB.log_get("#{prefix}", cmd)
|
|
doc2.code.should eq(400)
|
|
doc2.parsed_response['error'].should eq(true)
|
|
doc2.parsed_response['code'].should eq(400)
|
|
end
|
|
|
|
end
|
|
|
|
################################################################################
|
|
## checking edges responses
|
|
################################################################################
|
|
|
|
context "checks blueprints edges requests" do
|
|
before do
|
|
truncate_collection(prefix, "_graphs")
|
|
cmd = "/_api/blueprints/graph"
|
|
body = "{\"name\" : \"#{graph_name}\", \"verticesName\" : \"#{vertex_collection}\", \"edgesName\" : \"#{edge_collection}\"}"
|
|
ArangoDB.post(cmd, :body => body)
|
|
|
|
cmd = "/_api/blueprints/vertex?graph=#{graph_name}"
|
|
body = "{\"$id\" : \"id1\", \"optional1\" : \"val1a\", \"optional2\" : \"val2a\"}"
|
|
ArangoDB.post(cmd, :body => body)
|
|
body = "{\"$id\" : \"id2\", \"optional1\" : \"val1b\", \"optional2\" : \"val2b\"}"
|
|
ArangoDB.post(cmd, :body => body)
|
|
body = "{\"$id\" : \"id3\", \"optional1\" : \"val1c\", \"optional2\" : \"val2c\"}"
|
|
ArangoDB.post(cmd, :body => body)
|
|
|
|
cmd = "/_api/blueprints/edge?graph=#{graph_name}"
|
|
body1 = "{\"$id\" : \"edge1\", \"_from\" : \"id1\", \"_to\" : \"id2\", \"optional1\" : \"val1a\"}"
|
|
ArangoDB.post(cmd, :body => body1)
|
|
|
|
body2 = "{\"$id\" : \"edge2\", \"_from\" : \"id2\", \"_to\" : \"id3\", \"optional1\" : \"val1b\"}"
|
|
ArangoDB.post(cmd, :body => body2)
|
|
end
|
|
|
|
after do
|
|
truncate_collection(prefix, "_graphs")
|
|
ArangoDB.drop_collection( vertex_collection )
|
|
ArangoDB.drop_collection( edge_collection )
|
|
end
|
|
|
|
it "checks list of all edges" do
|
|
cmd = "/_api/blueprints/edges?graph=#{graph_name}"
|
|
body = "{\"batchSize\" : 100}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(201)
|
|
doc.parsed_response['result'].count.should eq(2)
|
|
end
|
|
|
|
it "checks list of all edges of one vertex" do
|
|
cmd = "/_api/blueprints/edges?graph=#{graph_name}"
|
|
body = "{\"batchSize\" : 100, \"vertex\" : \"id1\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(201)
|
|
doc.parsed_response['result'].count.should eq(1)
|
|
doc.parsed_response['result'][0]['$id'].should eq("edge1")
|
|
|
|
cmd = "/_api/blueprints/edges?graph=#{graph_name}"
|
|
body = "{\"batchSize\" : 100, \"vertex\" : \"id2\"}"
|
|
doc2 = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
|
|
doc2.code.should eq(201)
|
|
doc2.parsed_response['error'].should eq(false)
|
|
doc2.parsed_response['code'].should eq(201)
|
|
doc2.parsed_response['result'].count.should eq(2)
|
|
end
|
|
|
|
it "checks list of all in edges of one vertex" do
|
|
cmd = "/_api/blueprints/edges?graph=#{graph_name}"
|
|
body = "{\"batchSize\" : 100, \"vertex\" : \"id2\", \"direction\" : \"in\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(201)
|
|
doc.parsed_response['result'].count.should eq(1)
|
|
doc.parsed_response['result'][0]['$id'].should eq("edge1")
|
|
end
|
|
|
|
it "checks list of all out edges of one vertex" do
|
|
cmd = "/_api/blueprints/edges?graph=#{graph_name}"
|
|
body = "{\"batchSize\" : 100, \"vertex\" : \"id2\", \"direction\" : \"out\"}"
|
|
doc = ArangoDB.log_post("#{prefix}", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(201)
|
|
doc.parsed_response['result'].count.should eq(1)
|
|
doc.parsed_response['result'][0]['$id'].should eq("edge2")
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|