mirror of https://gitee.com/bigwinds/arangodb
1110 lines
46 KiB
Ruby
1110 lines
46 KiB
Ruby
# coding: utf-8
|
|
|
|
require 'rspec'
|
|
require 'arangodb.rb'
|
|
|
|
describe ArangoDB do
|
|
api = "/_api/import"
|
|
prefix = "api-import"
|
|
|
|
context "importing documents:" do
|
|
|
|
################################################################################
|
|
## import a JSON array of documents
|
|
################################################################################
|
|
|
|
context "import, testing createCollection:" do
|
|
before do
|
|
@cn = "UnitTestsImport"
|
|
ArangoDB.drop_collection(@cn)
|
|
end
|
|
|
|
after do
|
|
ArangoDB.drop_collection(@cn)
|
|
end
|
|
|
|
it "createCollection=false" do
|
|
cmd = api + "?collection=#{@cn}&createCollection=false&type=array"
|
|
body = "[ { \"foo\" : true } ]";
|
|
doc = ArangoDB.log_post("#{prefix}-create", cmd, :body => body)
|
|
|
|
doc.code.should eq(404)
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['errorNum'].should eq(1203)
|
|
end
|
|
end
|
|
|
|
################################################################################
|
|
## import a JSON array of documents
|
|
################################################################################
|
|
|
|
context "import self-contained documents:" do
|
|
before do
|
|
@cn = "UnitTestsImport"
|
|
ArangoDB.drop_collection(@cn)
|
|
@cid = ArangoDB.create_collection(@cn, false)
|
|
end
|
|
|
|
after do
|
|
ArangoDB.drop_collection(@cn)
|
|
end
|
|
|
|
it "using different documents" do
|
|
cmd = api + "?collection=#{@cn}&createCollection=true&type=array"
|
|
body = "[ \n"
|
|
body += "{ \"name\" : \"John\", \"age\" : 29, \"gender\" : \"male\", \"likes\" : [ \"socket\", \"bind\", \"accept\" ] },\n"
|
|
body += "{ \"firstName\" : \"Jane\", \"lastName\" : \"Doe\", \"age\" : 35, \"gender\" : \"female\", \"livesIn\" : \"Manila\" },\n"
|
|
body += "{ \"sample\" : \"garbage\" },\n"
|
|
body += "{ }\n"
|
|
body += "]\n"
|
|
doc = ArangoDB.log_post("#{prefix}-array-different", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(4)
|
|
doc.parsed_response['errors'].should eq(0)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "using different documents, type=auto" do
|
|
cmd = api + "?collection=#{@cn}&createCollection=true&type=auto"
|
|
body = "[ \n"
|
|
body += "{ \"name\" : \"John\", \"age\" : 29, \"gender\" : \"male\", \"likes\" : [ \"socket\", \"bind\", \"accept\" ] },\n"
|
|
body += "{ \"firstName\" : \"Jane\", \"lastName\" : \"Doe\", \"age\" : 35, \"gender\" : \"female\", \"livesIn\" : \"Manila\" },\n"
|
|
body += "{ \"sample\" : \"garbage\" },\n"
|
|
body += "{ }\n"
|
|
body += "]\n"
|
|
doc = ArangoDB.log_post("#{prefix}-array-different", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(4)
|
|
doc.parsed_response['errors'].should eq(0)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "using whitespace" do
|
|
cmd = api + "?collection=#{@cn}&createCollection=true&type=array"
|
|
body = " [\n\n { \"name\" : \"John\", \"age\" : 29 }, \n \n \n \r\n \n { \"rubbish\" : \"data goes in here\" }\n\n ]"
|
|
doc = ArangoDB.log_post("#{prefix}-array-ws", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(2)
|
|
doc.parsed_response['errors'].should eq(0)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "invalid documents" do
|
|
cmd = api + "?collection=#{@cn}&createCollection=true&type=array"
|
|
body = "[ { \"this doc\" : \"isValid\" },\n{ \"this one\" : is not },\n{ \"again\" : \"this is ok\" },\n\n{ \"but this isn't\" }\n ]"
|
|
doc = ArangoDB.log_post("#{prefix}-array-invalid", cmd, :body => body)
|
|
|
|
doc.code.should eq(400)
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['errorNum'].should eq(400)
|
|
end
|
|
|
|
it "empty body" do
|
|
cmd = api + "?collection=#{@cn}&createCollection=true&type=array"
|
|
body = ""
|
|
doc = ArangoDB.log_post("#{prefix}-array-empty", 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(400)
|
|
end
|
|
|
|
it "no documents" do
|
|
cmd = api + "?collection=#{@cn}&createCollection=true&type=array"
|
|
body = "[\n\n]"
|
|
doc = ArangoDB.log_post("#{prefix}-array-none", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(0)
|
|
doc.parsed_response['errors'].should eq(0)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "no collection" do
|
|
cmd = api + "?type=array"
|
|
body = "[ \n\n ]"
|
|
doc = ArangoDB.log_post("#{prefix}-array-nocoll", cmd, :body => body)
|
|
|
|
doc.code.should eq(400)
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['errorNum'].should eq(1204)
|
|
end
|
|
|
|
it "non-existing collection" do
|
|
ArangoDB.drop_collection(@cn)
|
|
|
|
cmd = api + "?collection=#{@cn}&type=array"
|
|
body = "[ { \"sample\" : \"garbage\" } ]"
|
|
doc = ArangoDB.log_post("#{prefix}-array-nonexist", cmd, :body => body)
|
|
|
|
doc.code.should eq(404)
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['errorNum'].should eq(1203)
|
|
end
|
|
|
|
end
|
|
|
|
################################################################################
|
|
## import self-contained documents (one doc per line)
|
|
################################################################################
|
|
|
|
context "import self-contained documents:" do
|
|
before do
|
|
@cn = "UnitTestsImport"
|
|
ArangoDB.drop_collection(@cn)
|
|
@cid = ArangoDB.create_collection(@cn, false)
|
|
end
|
|
|
|
after do
|
|
ArangoDB.drop_collection(@cn)
|
|
end
|
|
|
|
it "using different documents" do
|
|
cmd = api + "?collection=#{@cn}&createCollection=true&type=documents"
|
|
body = "{ \"name\" : \"John\", \"age\" : 29, \"gender\" : \"male\", \"likes\" : [ \"socket\", \"bind\", \"accept\" ] }\n"
|
|
body += "{ \"firstName\" : \"Jane\", \"lastName\" : \"Doe\", \"age\" : 35, \"gender\" : \"female\", \"livesIn\" : \"Manila\" }\n"
|
|
body += "{ \"sample\" : \"garbage\" }\n"
|
|
body += "{ }"
|
|
doc = ArangoDB.log_post("#{prefix}-self-contained-different", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(4)
|
|
doc.parsed_response['errors'].should eq(0)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "using different documents, type=auto" do
|
|
cmd = api + "?collection=#{@cn}&createCollection=true&type=auto"
|
|
body = "{ \"name\" : \"John\", \"age\" : 29, \"gender\" : \"male\", \"likes\" : [ \"socket\", \"bind\", \"accept\" ] }\n"
|
|
body += "{ \"firstName\" : \"Jane\", \"lastName\" : \"Doe\", \"age\" : 35, \"gender\" : \"female\", \"livesIn\" : \"Manila\" }\n"
|
|
body += "{ \"sample\" : \"garbage\" }\n"
|
|
body += "{ }"
|
|
doc = ArangoDB.log_post("#{prefix}-self-contained-different", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(4)
|
|
doc.parsed_response['errors'].should eq(0)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "using whitespace" do
|
|
cmd = api + "?collection=#{@cn}&createCollection=true&type=documents"
|
|
body = "\n\n { \"name\" : \"John\", \"age\" : 29 } \n \n \n \r\n \n { \"rubbish\" : \"data goes in here\" }\n\n"
|
|
doc = ArangoDB.log_post("#{prefix}-self-contained-ws", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(2)
|
|
doc.parsed_response['errors'].should eq(0)
|
|
doc.parsed_response['empty'].should eq(7)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "invalid documents" do
|
|
cmd = api + "?collection=#{@cn}&createCollection=true&type=documents"
|
|
body = "{ \"this doc\" : \"isValid\" }\n{ \"this one\" : is not }\n{ \"again\" : \"this is ok\" }\n\n{ \"but this isn't\" }\n"
|
|
doc = ArangoDB.log_post("#{prefix}-self-contained-invalid", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(2)
|
|
doc.parsed_response['errors'].should eq(2)
|
|
doc.parsed_response['empty'].should eq(1)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "empty body" do
|
|
cmd = api + "?collection=#{@cn}&createCollection=true&type=documents"
|
|
body = ""
|
|
doc = ArangoDB.log_post("#{prefix}-self-contained-empty", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(0)
|
|
doc.parsed_response['errors'].should eq(0)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "no documents" do
|
|
cmd = api + "?collection=#{@cn}&createCollection=true&type=documents"
|
|
body = "\n\n"
|
|
doc = ArangoDB.log_post("#{prefix}-self-contained-none", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(0)
|
|
doc.parsed_response['errors'].should eq(0)
|
|
doc.parsed_response['empty'].should eq(2)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "no collection" do
|
|
cmd = api + "?type=documents"
|
|
body = "\n\n"
|
|
doc = ArangoDB.log_post("#{prefix}-self-contained-nocoll", cmd, :body => body)
|
|
|
|
doc.code.should eq(400)
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['errorNum'].should eq(1204)
|
|
end
|
|
|
|
it "non-existing collection" do
|
|
ArangoDB.drop_collection(@cn)
|
|
|
|
cmd = api + "?collection=#{@cn}&type=documents"
|
|
body = "{ \"sample\" : \"garbage\" }"
|
|
doc = ArangoDB.log_post("#{prefix}-self-contained-nonexist", cmd, :body => body)
|
|
|
|
doc.code.should eq(404)
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['errorNum'].should eq(1203)
|
|
end
|
|
|
|
end
|
|
|
|
################################################################################
|
|
## import attribute names and data
|
|
################################################################################
|
|
|
|
context "import attribute names and data:" do
|
|
before do
|
|
@cn = "UnitTestsImport"
|
|
ArangoDB.drop_collection(@cn)
|
|
@cid = ArangoDB.create_collection(@cn, false)
|
|
end
|
|
|
|
after do
|
|
ArangoDB.drop_collection(@cn)
|
|
end
|
|
|
|
it "regular" do
|
|
cmd = api + "?collection=#{@cn}&createCollection=true"
|
|
body = "[ \"name\", \"age\", \"gender\" ]\n"
|
|
body += "[ \"John\", 29, \"male\" ]\n"
|
|
body += "[ \"Jane\", 35, \"female\" ]"
|
|
doc = ArangoDB.log_post("#{prefix}-data-different", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(2)
|
|
doc.parsed_response['errors'].should eq(0)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "using whitespace" do
|
|
cmd = api + "?collection=#{@cn}&createCollection=true"
|
|
body = "[ \"name\", \"age\", \"gender\" ]\n\n"
|
|
body += " [ \"John\", 29, \"male\" ]\n\n\r\n"
|
|
body += "[ \"Jane\", 35, \"female\" ]\n\n"
|
|
doc = ArangoDB.log_post("#{prefix}-data-ws", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(2)
|
|
doc.parsed_response['errors'].should eq(0)
|
|
doc.parsed_response['empty'].should eq(4)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "invalid documents" do
|
|
cmd = api + "?collection=#{@cn}&createCollection=true"
|
|
body = "[ \"name\", \"age\", \"gender\" ]\n"
|
|
body += "[ \"John\", 29, \"male\" ]\n"
|
|
body += "[ \"Jane\" ]\n"
|
|
body += "[ ]\n"
|
|
body += "[ 1, 2, 3, 4 ]\n"
|
|
body += "[ \"John\", 29, \"male\" ]"
|
|
doc = ArangoDB.log_post("#{prefix}-data-invalid", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(2)
|
|
doc.parsed_response['errors'].should eq(3)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "missing header" do
|
|
cmd = api + "?collection=#{@cn}&createCollection=true"
|
|
body = "\n[ \"name\", \"age\", \"gender\" ]\n"
|
|
body += "[ \"John\", 29, \"male\" ]"
|
|
doc = ArangoDB.log_post("#{prefix}-data-missing-header", cmd, :body => body)
|
|
|
|
doc.code.should eq(400)
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['errorNum'].should eq(400)
|
|
end
|
|
|
|
it "wrong header" do
|
|
cmd = api + "?collection=#{@cn}&createCollection=true"
|
|
body = "{ \"name\" : \"John\", \"age\" : 29 }\n"
|
|
doc = ArangoDB.log_post("#{prefix}-data-wrong-header", cmd, :body => body)
|
|
|
|
doc.code.should eq(400)
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['errorNum'].should eq(400)
|
|
end
|
|
|
|
it "empty body" do
|
|
cmd = api + "?collection=#{@cn}&createCollection=true"
|
|
body = ""
|
|
doc = ArangoDB.log_post("#{prefix}-data-empty", cmd, :body => body)
|
|
|
|
doc.code.should eq(400)
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['errorNum'].should eq(400)
|
|
end
|
|
|
|
it "no documents" do
|
|
cmd = api + "?collection=#{@cn}&createCollection=true"
|
|
body = "[ \"name\" ]\n\n"
|
|
doc = ArangoDB.log_post("#{prefix}-data-none", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(0)
|
|
doc.parsed_response['errors'].should eq(0)
|
|
doc.parsed_response['empty'].should eq(1)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "no collection" do
|
|
cmd = api
|
|
body = "[ \"name\" ]\n"
|
|
body += "[ \"Jane\" ]"
|
|
doc = ArangoDB.log_post("#{prefix}-data-nocoll", cmd, :body => body)
|
|
|
|
doc.code.should eq(400)
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['errorNum'].should eq(1204)
|
|
end
|
|
|
|
it "non-existing collection" do
|
|
ArangoDB.drop_collection(@cn)
|
|
|
|
cmd = api + "?collection=#{@cn}"
|
|
body = "[ \"name\" ]\n"
|
|
doc = ArangoDB.log_post("#{prefix}-data-nonexist", cmd, :body => body)
|
|
|
|
doc.code.should eq(404)
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['errorNum'].should eq(1203)
|
|
end
|
|
|
|
end
|
|
|
|
################################################################################
|
|
## import documents into an edge collection, using a JSON array
|
|
################################################################################
|
|
|
|
context "import into an edge collection, using a JSON array:" do
|
|
before do
|
|
@vn = "UnitTestsImportVertex"
|
|
@en = "UnitTestsImportEdge"
|
|
ArangoDB.drop_collection(@vn)
|
|
ArangoDB.drop_collection(@en)
|
|
|
|
ArangoDB.create_collection(@vn, false, 2)
|
|
ArangoDB.create_collection(@en, false, 3)
|
|
|
|
body = ""
|
|
(0..50).each do |i|
|
|
body += "{ \"_key\" : \"vertex" + i.to_s + "\", \"value\" : " + i.to_s + " }\n"
|
|
end
|
|
|
|
ArangoDB.post("/_api/import?collection=" + @vn + "&type=documents", :body => body)
|
|
end
|
|
|
|
after do
|
|
ArangoDB.drop_collection(@vn)
|
|
ArangoDB.drop_collection(@en)
|
|
end
|
|
|
|
it "no _from" do
|
|
cmd = api + "?collection=#{@en}&createCollection=false&type=array"
|
|
body = "[ { \"_to\" : \"" + @vn + "/vertex1\" } ]";
|
|
doc = ArangoDB.log_post("#{prefix}-edge-json-nofrom", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(0)
|
|
doc.parsed_response['errors'].should eq(1)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "no _to" do
|
|
cmd = api + "?collection=#{@en}&createCollection=false&type=array"
|
|
body = "[ { \"_from\" : \"" + @vn + "/vertex1\" } ]";
|
|
doc = ArangoDB.log_post("#{prefix}-edge-json-noto", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(0)
|
|
doc.parsed_response['errors'].should eq(1)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "with _from and _to" do
|
|
cmd = api + "?collection=#{@en}&createCollection=false&type=array"
|
|
body = "[ { \"_from\" : \"" + @vn + "/vertex1\", \"_to\" : \"" + @vn + "/vertex2\" } ]"
|
|
doc = ArangoDB.log_post("#{prefix}-edge-json-fromto", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(1)
|
|
doc.parsed_response['errors'].should eq(0)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "multiple docs, with _from and _to" do
|
|
cmd = api + "?collection=#{@en}&createCollection=false&type=array"
|
|
body = "[\n"
|
|
body += "{ \"a\" : 1, \"_from\" : \"" + @vn + "/vertex1\", \"_to\" : \"" + @vn + "/vertex2\" },\n"
|
|
body += "{ \"foo\" : true, \"bar\": \"baz\", \"_from\" : \"" + @vn + "/vertex1\", \"_to\" : \"" + @vn + "/vertex2\" },\n"
|
|
body += "{ \"from\" : \"" + @vn + "/vertex1\", \"to\" : \"" + @vn + "/vertex2\" }\n"
|
|
body += "]";
|
|
doc = ArangoDB.log_post("#{prefix}-edge-json-fromto", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(2)
|
|
doc.parsed_response['errors'].should eq(1)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "multiple docs, with wrong fromPrefix" do
|
|
cmd = api + "?collection=#{@en}&createCollection=false&type=array&fromPrefix=a+b"
|
|
body = "[\n"
|
|
body += "{ \"a\" : 1, \"_from\" : \"vertex1\", \"_to\" : \"" + @vn + "/vertex2\" }\n"
|
|
body += "]";
|
|
doc = ArangoDB.log_post("#{prefix}-edge-json-fromto", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(0)
|
|
doc.parsed_response['errors'].should eq(1)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "multiple docs, with wrong toPrefix" do
|
|
cmd = api + "?collection=#{@en}&createCollection=false&type=array&toPrefix=a+b"
|
|
body = "[\n"
|
|
body += "{ \"a\" : 1, \"_to\" : \"vertex1\", \"_from\" : \"" + @vn + "/vertex2\" }\n"
|
|
body += "]";
|
|
doc = ArangoDB.log_post("#{prefix}-edge-json-fromto", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(0)
|
|
doc.parsed_response['errors'].should eq(1)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "multiple docs, with fromPrefix" do
|
|
cmd = api + "?collection=#{@en}&createCollection=false&type=array&fromPrefix=#{@vn}"
|
|
body = "[\n"
|
|
body += "{ \"a\" : 1, \"_from\" : \"vertex1\", \"_to\" : \"" + @vn + "/vertex2\" },\n"
|
|
body += "{ \"foo\" : true, \"bar\": \"baz\", \"_from\" : \"vertex1\", \"_to\" : \"" + @vn + "/vertex2\" },\n"
|
|
body += "{ \"from\" : \"vertex1\", \"to\" : \"" + @vn + "/vertex2\" }\n"
|
|
body += "]";
|
|
doc = ArangoDB.log_post("#{prefix}-edge-json-fromto", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(2)
|
|
doc.parsed_response['errors'].should eq(1)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "multiple docs, with toPrefix" do
|
|
cmd = api + "?collection=#{@en}&createCollection=false&type=array&toPrefix=#{@vn}"
|
|
body = "[\n"
|
|
body += "{ \"a\" : 1, \"_to\" : \"vertex1\", \"_from\" : \"" + @vn + "/vertex2\" },\n"
|
|
body += "{ \"foo\" : true, \"bar\": \"baz\", \"_to\" : \"vertex1\", \"_from\" : \"" + @vn + "/vertex2\" },\n"
|
|
body += "{ \"to\" : \"vertex1\", \"from\" : \"" + @vn + "/vertex2\" }\n"
|
|
body += "]";
|
|
doc = ArangoDB.log_post("#{prefix}-edge-json-fromto", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(2)
|
|
doc.parsed_response['errors'].should eq(1)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "multiple docs, with fromPrefix and toPrefix" do
|
|
cmd = api + "?collection=#{@en}&createCollection=false&type=array&fromPrefix=#{@vn}&toPrefix=#{@vn}"
|
|
body = "[\n"
|
|
body += "{ \"a\" : 1, \"_to\" : \"vertex1\", \"_from\" : \"vertex2\" },\n"
|
|
body += "{ \"foo\" : true, \"bar\": \"baz\", \"_to\" : \"vertex1\", \"_from\" : \"vertex2\" },\n"
|
|
body += "{ \"to\" : \"vertex1\", \"from\" : \"vertex2\" }\n"
|
|
body += "]";
|
|
doc = ArangoDB.log_post("#{prefix}-edge-json-fromto", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(2)
|
|
doc.parsed_response['errors'].should eq(1)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "multiple docs, with fromPrefix and toPrefix, double prefixing" do
|
|
cmd = api + "?collection=#{@en}&createCollection=false&type=array&fromPrefix=#{@vn}&toPrefix=#{@vn}"
|
|
body = "[\n"
|
|
body += "{ \"a\" : 1, \"_to\" : \"#{@vn}/vertex1\", \"_from\" : \"#{@vn}/vertex2\" },\n"
|
|
body += "{ \"foo\" : true, \"bar\": \"baz\", \"_to\" : \"#{@vn}/vertex1\", \"_from\" : \"#{@vn}vertex2\" },\n"
|
|
body += "{ \"to\" : \"#{@vn}/vertex1\", \"from\" : \"#{@vn}/vertex2\" }\n"
|
|
body += "]";
|
|
doc = ArangoDB.log_post("#{prefix}-edge-json-fromto", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(2)
|
|
doc.parsed_response['errors'].should eq(1)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
end
|
|
|
|
################################################################################
|
|
## import documents into an edge collection, using individual documents
|
|
################################################################################
|
|
|
|
context "import into an edge collection, using individual docs:" do
|
|
before do
|
|
@vn = "UnitTestsImportVertex"
|
|
@en = "UnitTestsImportEdge"
|
|
ArangoDB.drop_collection(@vn)
|
|
ArangoDB.drop_collection(@en)
|
|
|
|
ArangoDB.create_collection(@vn, false, 2)
|
|
ArangoDB.create_collection(@en, false, 3)
|
|
|
|
body = ""
|
|
(0..50).each do |i|
|
|
body += "{ \"_key\" : \"vertex" + i.to_s + "\", \"value\" : " + i.to_s + " }\n"
|
|
end
|
|
|
|
ArangoDB.post("/_api/import?collection=" + @vn + "&type=documents", :body => body)
|
|
end
|
|
|
|
after do
|
|
ArangoDB.drop_collection(@vn)
|
|
ArangoDB.drop_collection(@en)
|
|
end
|
|
|
|
it "no _from" do
|
|
cmd = api + "?collection=#{@en}&createCollection=false&type=documents"
|
|
body = "{ \"_to\" : \"" + @vn + "/vertex1\" }";
|
|
doc = ArangoDB.log_post("#{prefix}-edge-documents-nofrom", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(0)
|
|
doc.parsed_response['errors'].should eq(1)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "no _to" do
|
|
cmd = api + "?collection=#{@en}&createCollection=false&type=documents"
|
|
body = "{ \"_from\" : \"" + @vn + "/vertex1\" }"
|
|
doc = ArangoDB.log_post("#{prefix}-edge-documents-noto", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(0)
|
|
doc.parsed_response['errors'].should eq(1)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "with _from and _to" do
|
|
cmd = api + "?collection=#{@en}&createCollection=false&type=documents"
|
|
body = "{ \"_from\" : \"" + @vn + "/vertex1\", \"_to\" : \"" + @vn + "/vertex2\" }"
|
|
doc = ArangoDB.log_post("#{prefix}-edge-documents-fromto", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(1)
|
|
doc.parsed_response['errors'].should eq(0)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "multiple documents, with _from and _to" do
|
|
cmd = api + "?collection=#{@en}&createCollection=false&type=documents"
|
|
body = "{ \"a\" : 1, \"_from\" : \"" + @vn + "/vertex1\", \"_to\" : \"" + @vn + "/vertex2\" }\n";
|
|
body += "{ \"foo\" : true, \"bar\": \"baz\", \"_from\" : \"" + @vn + "/vertex1\", \"_to\" : \"" + @vn + "/vertex2\" }\n"
|
|
body += "{ \"from\" : \"" + @vn + "/vertex1\", \"to\" : \"" + @vn + "/vertex2\" }\n"
|
|
doc = ArangoDB.log_post("#{prefix}-edge-documents-fromto", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(2)
|
|
doc.parsed_response['errors'].should eq(1)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
end
|
|
|
|
################################################################################
|
|
## import documents into an edge collection, using CSV
|
|
################################################################################
|
|
|
|
context "import into an edge collection, using CSV:" do
|
|
before do
|
|
@vn = "UnitTestsImportVertex"
|
|
@en = "UnitTestsImportEdge"
|
|
ArangoDB.drop_collection(@vn)
|
|
ArangoDB.drop_collection(@en)
|
|
|
|
ArangoDB.create_collection(@vn, false, 2)
|
|
ArangoDB.create_collection(@en, false, 3)
|
|
|
|
body = ""
|
|
(0..50).each do |i|
|
|
body += "{ \"_key\" : \"vertex" + i.to_s + "\", \"value\" : " + i.to_s + " }\n"
|
|
end
|
|
|
|
ArangoDB.post("/_api/import?collection=" + @vn + "&type=documents", :body => body)
|
|
end
|
|
|
|
after do
|
|
ArangoDB.drop_collection(@vn)
|
|
ArangoDB.drop_collection(@en)
|
|
end
|
|
|
|
it "no _from" do
|
|
cmd = api + "?collection=#{@en}&createCollection=false"
|
|
body = "[ \"_to\" ]\n"
|
|
body += "[ \"" + @vn + "/vertex1\" ]";
|
|
doc = ArangoDB.log_post("#{prefix}-edge-list-nofrom", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(0)
|
|
doc.parsed_response['errors'].should eq(1)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "no _to" do
|
|
cmd = api + "?collection=#{@en}&createCollection=false"
|
|
body = "[ \"_from\" ]\n"
|
|
body += "[ \"" + @vn + "/vertex1\" ]"
|
|
doc = ArangoDB.log_post("#{prefix}-edge-list-noto", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(0)
|
|
doc.parsed_response['errors'].should eq(1)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "with _from and _to" do
|
|
cmd = api + "?collection=#{@en}&createCollection=false"
|
|
body = "[ \"_from\", \"_to\" ]\n"
|
|
body += "[ \"" + @vn + "/vertex1\", \"" + @vn + "/vertex2\" ]"
|
|
doc = ArangoDB.log_post("#{prefix}-edge-list-fromto", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(1)
|
|
doc.parsed_response['errors'].should eq(0)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
it "multiple documents, with _from and _to" do
|
|
cmd = api + "?collection=#{@en}&createCollection=false"
|
|
body = "[ \"a\", \"_from\", \"_to\", \"foo\" ]\n"
|
|
body += "[ 1, \"" + @vn + "/vertex1\", \"" + @vn + "/vertex2\", \"\" ]\n"
|
|
body += "\n"
|
|
body += "[ 2, \"" + @vn + "/vertex3\", \"" + @vn + "/vertex4\", \"\" ]\n"
|
|
body += "[ 2, 1, 2, 3 ]"
|
|
doc = ArangoDB.log_post("#{prefix}-edge-list-fromto", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(2)
|
|
doc.parsed_response['errors'].should eq(1)
|
|
doc.parsed_response['empty'].should eq(1)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
end
|
|
|
|
end
|
|
|
|
################################################################################
|
|
## import with update
|
|
################################################################################
|
|
|
|
context "import with update:" do
|
|
before do
|
|
@cn = "UnitTestsImport"
|
|
ArangoDB.drop_collection(@cn)
|
|
@cid = ArangoDB.create_collection(@cn, false)
|
|
|
|
cmd = api + "?collection=#{@cn}&type=documents"
|
|
body = "{ \"_key\" : \"test1\", \"value1\" : 1, \"value2\" : \"test\" }\n"
|
|
body += "{ \"_key\" : \"test2\", \"value1\" : \"abc\", \"value2\" : 3 }\n"
|
|
ArangoDB.post(cmd, :body => body)
|
|
end
|
|
|
|
after do
|
|
ArangoDB.drop_collection(@cn)
|
|
end
|
|
|
|
it "using onDuplicate=error" do
|
|
cmd = api + "?collection=#{@cn}&type=documents&onDuplicate=error"
|
|
body = "{ \"_key\" : \"test1\", \"value3\" : 3, \"value2\" : \"test-updated\" }\n"
|
|
body += "{ \"_key\" : \"test2\" }\n"
|
|
body += "{ \"_key\" : \"test3\", \"foo\" : \"bar\" }\n"
|
|
doc = ArangoDB.log_post("#{prefix}-update", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(1)
|
|
doc.parsed_response['errors'].should eq(2)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
|
|
doc = ArangoDB.get("/_api/document/#{@cn}/test1")
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['_key'].should eq('test1')
|
|
doc.parsed_response['value1'].should eq(1)
|
|
doc.parsed_response['value2'].should eq('test')
|
|
doc.parsed_response.should_not have_key('value3')
|
|
|
|
doc = ArangoDB.get("/_api/document/#{@cn}/test2")
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['_key'].should eq('test2')
|
|
doc.parsed_response['value1'].should eq('abc')
|
|
doc.parsed_response['value2'].should eq(3)
|
|
|
|
doc = ArangoDB.get("/_api/document/#{@cn}/test3")
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['_key'].should eq('test3')
|
|
doc.parsed_response['foo'].should eq('bar')
|
|
end
|
|
|
|
it "using onDuplicate=error, without _key" do
|
|
cmd = api + "?collection=#{@cn}&type=documents&onDuplicate=error"
|
|
body = "{ \"value3\" : 3, \"value2\" : \"test-updated\" }\n"
|
|
body += "{ }\n"
|
|
body += "{ \"foo\" : \"bar\" }\n"
|
|
doc = ArangoDB.log_post("#{prefix}-update", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(3)
|
|
doc.parsed_response['errors'].should eq(0)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
end
|
|
|
|
it "using onDuplicate=error, mixed _keys" do
|
|
cmd = api + "?collection=#{@cn}&type=documents&onDuplicate=error"
|
|
body = "{ \"_key\" : \"test1\", \"value3\" : 3, \"value2\" : \"test-updated\" }\n"
|
|
body += "{ \"foo\" : \"bar\" }\n"
|
|
doc = ArangoDB.log_post("#{prefix}-update", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(1)
|
|
doc.parsed_response['errors'].should eq(1)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
|
|
doc = ArangoDB.get("/_api/document/#{@cn}/test1")
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['_key'].should eq('test1')
|
|
doc.parsed_response['value1'].should eq(1)
|
|
doc.parsed_response['value2'].should eq('test')
|
|
doc.parsed_response.should_not have_key('value3')
|
|
end
|
|
|
|
it "using onDuplicate=update" do
|
|
cmd = api + "?collection=#{@cn}&type=documents&onDuplicate=update"
|
|
body = "{ \"_key\" : \"test1\", \"value3\" : 3, \"value2\" : \"test-updated\" }\n"
|
|
body += "{ \"_key\" : \"test2\" }\n"
|
|
body += "{ \"_key\" : \"test3\", \"foo\" : \"bar\" }\n"
|
|
doc = ArangoDB.log_post("#{prefix}-update", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(1)
|
|
doc.parsed_response['errors'].should eq(0)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(2)
|
|
|
|
doc = ArangoDB.get("/_api/document/#{@cn}/test1")
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['_key'].should eq('test1')
|
|
doc.parsed_response['value1'].should eq(1)
|
|
doc.parsed_response['value2'].should eq('test-updated')
|
|
doc.parsed_response['value3'].should eq(3)
|
|
|
|
doc = ArangoDB.get("/_api/document/#{@cn}/test2")
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['_key'].should eq('test2')
|
|
doc.parsed_response['value1'].should eq('abc')
|
|
doc.parsed_response['value2'].should eq(3)
|
|
|
|
doc = ArangoDB.get("/_api/document/#{@cn}/test3")
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['_key'].should eq('test3')
|
|
doc.parsed_response['foo'].should eq('bar')
|
|
end
|
|
|
|
it "using onDuplicate=update, without _key" do
|
|
cmd = api + "?collection=#{@cn}&type=documents&onDuplicate=update"
|
|
body = "{ \"value3\" : 3, \"value2\" : \"test-updated\" }\n"
|
|
body += "{ }\n"
|
|
body += "{ \"foo\" : \"bar\" }\n"
|
|
doc = ArangoDB.log_post("#{prefix}-update", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(3)
|
|
doc.parsed_response['errors'].should eq(0)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
end
|
|
|
|
it "using onDuplicate=update, mixed _keys" do
|
|
cmd = api + "?collection=#{@cn}&type=documents&onDuplicate=update"
|
|
body = "{ \"_key\" : \"test1\", \"value3\" : 3, \"value2\" : \"test-updated\" }\n"
|
|
body += "{ \"foo\" : \"bar\" }\n"
|
|
doc = ArangoDB.log_post("#{prefix}-update", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(1)
|
|
doc.parsed_response['errors'].should eq(0)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(1)
|
|
|
|
doc = ArangoDB.get("/_api/document/#{@cn}/test1")
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['_key'].should eq('test1')
|
|
doc.parsed_response['value1'].should eq(1)
|
|
doc.parsed_response['value2'].should eq('test-updated')
|
|
doc.parsed_response['value3'].should eq(3)
|
|
end
|
|
|
|
it "using onDuplicate=replace" do
|
|
cmd = api + "?collection=#{@cn}&type=documents&onDuplicate=replace"
|
|
body = "{ \"_key\" : \"test1\", \"value3\" : 3, \"value2\" : \"test-updated\" }\n"
|
|
body += "{ \"_key\" : \"test2\" }\n"
|
|
body += "{ \"_key\" : \"test3\", \"foo\" : \"bar\" }\n"
|
|
doc = ArangoDB.log_post("#{prefix}-update", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(1)
|
|
doc.parsed_response['errors'].should eq(0)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(2)
|
|
|
|
doc = ArangoDB.get("/_api/document/#{@cn}/test1")
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['_key'].should eq('test1')
|
|
doc.parsed_response.should_not have_key('value1')
|
|
doc.parsed_response['value2'].should eq('test-updated')
|
|
doc.parsed_response['value3'].should eq(3)
|
|
|
|
doc = ArangoDB.get("/_api/document/#{@cn}/test2")
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['_key'].should eq('test2')
|
|
doc.parsed_response.should_not have_key('value1')
|
|
doc.parsed_response.should_not have_key('value2')
|
|
|
|
doc = ArangoDB.get("/_api/document/#{@cn}/test3")
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['_key'].should eq('test3')
|
|
doc.parsed_response['foo'].should eq('bar')
|
|
end
|
|
|
|
it "using onDuplicate=replace, without _key" do
|
|
cmd = api + "?collection=#{@cn}&type=documents&onDuplicate=replace"
|
|
body = "{ \"value3\" : 3, \"value2\" : \"test-updated\" }\n"
|
|
body += "{ }\n"
|
|
body += "{ \"foo\" : \"bar\" }\n"
|
|
doc = ArangoDB.log_post("#{prefix}-update", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(3)
|
|
doc.parsed_response['errors'].should eq(0)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
end
|
|
|
|
it "using onDuplicate=replace, mixed _keys" do
|
|
cmd = api + "?collection=#{@cn}&type=documents&onDuplicate=replace"
|
|
body = "{ \"_key\" : \"test1\", \"value3\" : 3, \"value2\" : \"test-updated\" }\n"
|
|
body += "{ \"foo\" : \"bar\" }\n"
|
|
doc = ArangoDB.log_post("#{prefix}-update", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(1)
|
|
doc.parsed_response['errors'].should eq(0)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(1)
|
|
|
|
doc = ArangoDB.get("/_api/document/#{@cn}/test1")
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['_key'].should eq('test1')
|
|
doc.parsed_response.should_not have_key('value1')
|
|
doc.parsed_response['value2'].should eq('test-updated')
|
|
doc.parsed_response['value3'].should eq(3)
|
|
end
|
|
|
|
it "using onDuplicate=ignore" do
|
|
cmd = api + "?collection=#{@cn}&type=documents&onDuplicate=ignore"
|
|
body = "{ \"_key\" : \"test1\", \"value3\" : 3, \"value2\" : \"test\" }\n"
|
|
body += "{ \"_key\" : \"test2\" }\n"
|
|
body += "{ \"_key\" : \"test3\", \"foo\" : \"bar\" }\n"
|
|
doc = ArangoDB.log_post("#{prefix}-update", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(1)
|
|
doc.parsed_response['errors'].should eq(0)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(2)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
|
|
doc = ArangoDB.get("/_api/document/#{@cn}/test1")
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['_key'].should eq('test1')
|
|
doc.parsed_response['value1'].should eq(1)
|
|
doc.parsed_response['value2'].should eq('test')
|
|
doc.parsed_response.should_not have_key('value3')
|
|
|
|
doc = ArangoDB.get("/_api/document/#{@cn}/test2")
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['_key'].should eq('test2')
|
|
doc.parsed_response['value1'].should eq('abc')
|
|
doc.parsed_response['value2'].should eq(3)
|
|
|
|
doc = ArangoDB.get("/_api/document/#{@cn}/test3")
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['_key'].should eq('test3')
|
|
doc.parsed_response['foo'].should eq('bar')
|
|
end
|
|
|
|
it "using onDuplicate=ignore, without _key" do
|
|
cmd = api + "?collection=#{@cn}&type=documents&onDuplicate=ignore"
|
|
body = "{ \"value3\" : 3, \"value2\" : \"test\" }\n"
|
|
body += "{ }\n"
|
|
body += "{ \"foo\" : \"bar\" }\n"
|
|
doc = ArangoDB.log_post("#{prefix}-update", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(3)
|
|
doc.parsed_response['errors'].should eq(0)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(0)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
end
|
|
|
|
it "using onDuplicate=ignore, mixed _keys" do
|
|
cmd = api + "?collection=#{@cn}&type=documents&onDuplicate=ignore"
|
|
body = "{ \"_key\" : \"test1\", \"value3\" : 3, \"value2\" : \"test\" }\n"
|
|
body += "{ \"foo\" : \"bar\" }\n"
|
|
doc = ArangoDB.log_post("#{prefix}-update", cmd, :body => body)
|
|
|
|
doc.code.should eq(201)
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['created'].should eq(1)
|
|
doc.parsed_response['errors'].should eq(0)
|
|
doc.parsed_response['empty'].should eq(0)
|
|
doc.parsed_response['ignored'].should eq(1)
|
|
doc.parsed_response['updated'].should eq(0)
|
|
|
|
doc = ArangoDB.get("/_api/document/#{@cn}/test1")
|
|
doc.code.should eq(200)
|
|
doc.parsed_response['_key'].should eq('test1')
|
|
doc.parsed_response['value1'].should eq(1)
|
|
doc.parsed_response['value2'].should eq('test')
|
|
doc.parsed_response.should_not have_key('value3')
|
|
end
|
|
end
|
|
|
|
end
|
|
end
|