mirror of https://gitee.com/bigwinds/arangodb
560 lines
24 KiB
Ruby
560 lines
24 KiB
Ruby
# coding: utf-8
|
|
|
|
require 'rspec'
|
|
require 'arangodb.rb'
|
|
|
|
describe ArangoDB do
|
|
api = "/_api/transaction"
|
|
prefix = "api-transaction"
|
|
|
|
context "running server-side transactions:" do
|
|
|
|
################################################################################
|
|
## error handling
|
|
################################################################################
|
|
|
|
context "error handling:" do
|
|
it "returns an error if a wrong method type is used" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { }, \"action\" : \" for \" }"
|
|
doc = ArangoDB.log_patch("#{prefix}-invalid-method", cmd, :body => body)
|
|
|
|
doc.code.should eq(405)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['code'].should eq(405)
|
|
doc.parsed_response['errorNum'].should eq(405)
|
|
end
|
|
|
|
it "returns an error if no body is posted" do
|
|
cmd = api
|
|
doc = ArangoDB.log_post("#{prefix}-missing-body", cmd)
|
|
|
|
doc.code.should eq(400)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['code'].should eq(400)
|
|
doc.parsed_response['errorNum'].should eq(10)
|
|
end
|
|
|
|
it "returns an error if no collections attribute is present" do
|
|
cmd = api
|
|
body = "{ \"foo\" : \"bar\" }"
|
|
doc = ArangoDB.log_post("#{prefix}-no-collection", cmd, :body => body)
|
|
|
|
doc.code.should eq(400)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['code'].should eq(400)
|
|
doc.parsed_response['errorNum'].should eq(10)
|
|
end
|
|
|
|
it "returns an error if the collections attribute has a wrong type" do
|
|
cmd = api
|
|
doc = ArangoDB.log_post("#{prefix}-collection-wrong-type", cmd)
|
|
|
|
doc.code.should eq(400)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['code'].should eq(400)
|
|
doc.parsed_response['errorNum'].should eq(10)
|
|
end
|
|
|
|
it "returns an error if collections sub-attribute is wrong" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { \"write\": false } }"
|
|
doc = ArangoDB.log_post("#{prefix}-invalid-collection-subattribute", cmd, :body => body)
|
|
|
|
doc.code.should eq(400)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['code'].should eq(400)
|
|
doc.parsed_response['errorNum'].should eq(10)
|
|
end
|
|
|
|
it "returns an error if no action is specified" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { } }"
|
|
doc = ArangoDB.log_post("#{prefix}-missing-action", cmd, :body => body)
|
|
|
|
doc.code.should eq(400)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['code'].should eq(400)
|
|
doc.parsed_response['errorNum'].should eq(10)
|
|
end
|
|
|
|
it "returns an error if action attribute has a wrong type" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { }, \"action\" : false }"
|
|
doc = ArangoDB.log_post("#{prefix}-invalid-action", cmd, :body => body)
|
|
|
|
doc.code.should eq(400)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['code'].should eq(400)
|
|
doc.parsed_response['errorNum'].should eq(10)
|
|
end
|
|
|
|
it "returns an error if action attribute contains broken code" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { }, \"action\" : \" for \" }"
|
|
doc = ArangoDB.log_post("#{prefix}-invalid-action1", cmd, :body => body)
|
|
|
|
doc.code.should eq(400)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['code'].should eq(400)
|
|
doc.parsed_response['errorNum'].should eq(10)
|
|
end
|
|
|
|
it "returns an error if action attribute contains broken code" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { }, \"action\" : \"return 1;\" }"
|
|
doc = ArangoDB.log_post("#{prefix}-invalid-action2", cmd, :body => body)
|
|
|
|
doc.code.should eq(400)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['code'].should eq(400)
|
|
doc.parsed_response['errorNum'].should eq(10)
|
|
end
|
|
|
|
it "returns an error if action attribute contains broken code" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { }, \"action\" : \"function() {\" }"
|
|
doc = ArangoDB.log_post("#{prefix}-invalid-action3", cmd, :body => body)
|
|
|
|
doc.code.should eq(400)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['code'].should eq(400)
|
|
doc.parsed_response['errorNum'].should eq(10)
|
|
end
|
|
|
|
it "returns an error if transactions are nested" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { }, \"action\" : \"function () { return TRANSACTION({ collections: { }, action: function() { return 1; } }); }\" }"
|
|
doc = ArangoDB.log_post("#{prefix}-nested1", cmd, :body => body)
|
|
|
|
doc.code.should eq(400)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['code'].should eq(400)
|
|
doc.parsed_response['errorNum'].should eq(1651)
|
|
end
|
|
|
|
it "returns an error if transactions are nested" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { }, \"action\" : \"function () { return TRANSACTION({ collections: { }, action: \\\"function () { return 1; }\\\" }); }\" }"
|
|
doc = ArangoDB.log_post("#{prefix}-nested2", cmd, :body => body)
|
|
|
|
doc.code.should eq(400)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['code'].should eq(400)
|
|
doc.parsed_response['errorNum'].should eq(1651)
|
|
end
|
|
|
|
end
|
|
|
|
################################################################################
|
|
## using "wrong" collections
|
|
################################################################################
|
|
|
|
context "using wrong collections:" do
|
|
before do
|
|
@cn1 = "UnitTestsTransactions1"
|
|
@cn2 = "UnitTestsTransactions2"
|
|
ArangoDB.create_collection(@cn1, false)
|
|
ArangoDB.create_collection(@cn2, false)
|
|
end
|
|
|
|
after do
|
|
ArangoDB.drop_collection(@cn1)
|
|
ArangoDB.drop_collection(@cn2)
|
|
end
|
|
|
|
it "returns an error if referring to a non-existing collection" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { \"write\": \"_meow\" }, \"action\" : \"function () { return 1; }\" }"
|
|
doc = ArangoDB.log_post("#{prefix}-non-existing-collection", cmd, :body => body)
|
|
doc.code.should eq(404)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['code'].should eq(404)
|
|
doc.parsed_response['errorNum'].should eq(1203)
|
|
end
|
|
|
|
it "returns an error when using a non-declared collection" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { \"write\": \"#{@cn1}\" }, \"action\" : \"function () { require(\\\"internal\\\").db.#{@cn2}.save({ }); }\" }"
|
|
doc = ArangoDB.log_post("#{prefix}-non-declared-collection", cmd, :body => body)
|
|
|
|
doc.code.should eq(400)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['code'].should eq(400)
|
|
doc.parsed_response['errorNum'].should eq(1652)
|
|
end
|
|
|
|
it "returns an error when using a collection in invalid mode" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { \"read\": \"#{@cn1}\" }, \"action\" : \"function () { require(\\\"internal\\\").db.#{@cn1}.save({ }); }\" }"
|
|
doc = ArangoDB.log_post("#{prefix}-invalid-mode1", cmd, :body => body)
|
|
|
|
doc.code.should eq(400)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['code'].should eq(400)
|
|
doc.parsed_response['errorNum'].should eq(1652)
|
|
end
|
|
|
|
it "returns an error when using a collection in invalid mode" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { \"read\": [ \"#{@cn1}\", \"#{@cn2}\" ] }, \"action\" : \"function () { require(\\\"internal\\\").db.#{@cn1}.save({ }); }\" }"
|
|
doc = ArangoDB.log_post("#{prefix}-invalid-mode2", cmd, :body => body)
|
|
|
|
doc.code.should eq(400)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['code'].should eq(400)
|
|
doc.parsed_response['errorNum'].should eq(1652)
|
|
end
|
|
|
|
it "returns an error when using a disallowed operation" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { }, \"action\" : \"function () { require(\\\"internal\\\").db._create(\\\"abc\\\"); }\" }"
|
|
doc = ArangoDB.log_post("#{prefix}-invalid-mode2", cmd, :body => body)
|
|
|
|
doc.code.should eq(400)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['code'].should eq(400)
|
|
doc.parsed_response['errorNum'].should eq(1653)
|
|
end
|
|
end
|
|
|
|
################################################################################
|
|
## params
|
|
################################################################################
|
|
|
|
context "using parameters:" do
|
|
it "checking return parameters" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { }, \"action\" : \"function (params) { return [ params[1], params[4] ]; }\", \"params\" : [ 1, 2, 3, 4, 5 ] }"
|
|
doc = ArangoDB.log_post("#{prefix}-params1", cmd, :body => body)
|
|
|
|
doc.code.should eq(200)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
doc.parsed_response['result'].should eq([ 2, 5 ])
|
|
end
|
|
|
|
it "checking return parameters, other argument name" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { }, \"action\" : \"function (args) { return [ args[1], args[4] ]; }\", \"params\" : [ 1, 2, 3, 4, 5 ] }"
|
|
doc = ArangoDB.log_post("#{prefix}-params2", cmd, :body => body)
|
|
|
|
doc.code.should eq(200)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
doc.parsed_response['result'].should eq([ 2, 5 ])
|
|
end
|
|
|
|
it "checking return parameters, object" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { }, \"action\" : \"function (params) { return params['foo']; }\", \"params\" : { \"foo\" : \"bar\" } }"
|
|
doc = ArangoDB.log_post("#{prefix}-params3", cmd, :body => body)
|
|
|
|
doc.code.should eq(200)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
doc.parsed_response['result'].should eq("bar")
|
|
end
|
|
|
|
it "checking return parameters, object" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { }, \"action\" : \"function (params) { return params['meow']; }\", \"params\" : { \"foo\" : \"bar\" } }"
|
|
doc = ArangoDB.log_post("#{prefix}-params4", cmd, :body => body)
|
|
doc.code.should eq(200)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
doc.parsed_response['result'].should eq(nil)
|
|
end
|
|
|
|
it "checking return parameters, undefined" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { }, \"action\" : \"function (params) { return params['meow']; }\", \"params\" : null }"
|
|
doc = ArangoDB.log_post("#{prefix}-params5", cmd, :body => body)
|
|
|
|
doc.code.should eq(400)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['code'].should eq(400)
|
|
doc.parsed_response['errorNum'].should eq(17) # TypeError
|
|
end
|
|
|
|
it "checking return parameters, undefined" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { }, \"action\" : \"function (params) { return params['meow']; }\", \"params\" : { } }"
|
|
doc = ArangoDB.log_post("#{prefix}-params5", cmd, :body => body)
|
|
|
|
doc.code.should eq(200)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
doc.parsed_response['result'].should eq(nil)
|
|
end
|
|
|
|
it "checking return parameters, undefined" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { }, \"action\" : \"function (params) { return params; }\" }"
|
|
doc = ArangoDB.log_post("#{prefix}-params7", cmd, :body => body)
|
|
|
|
doc.code.should eq(200)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
doc.parsed_response['result'].should eq(nil)
|
|
end
|
|
end
|
|
|
|
################################################################################
|
|
## non-collection transactions
|
|
################################################################################
|
|
|
|
context "non-collection transactions:" do
|
|
it "returning a simple type" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { }, \"action\" : \"function () { return 42; }\" }"
|
|
doc = ArangoDB.log_post("#{prefix}-empty-transaction1", cmd, :body => body)
|
|
|
|
doc.code.should eq(200)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
doc.parsed_response['result'].should eq(42)
|
|
end
|
|
|
|
it "returning a compound type" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { }, \"action\" : \"function () { return [ true, { a: 42, b: [ null, true ], c: \\\"foo\\\" } ]; }\" }"
|
|
doc = ArangoDB.log_post("#{prefix}-empty-transaction2", cmd, :body => body)
|
|
|
|
doc.code.should eq(200)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
doc.parsed_response['result'].should eq([ true, { "a" => 42, "b" => [ nil, true ], "c" => "foo" } ])
|
|
end
|
|
|
|
it "returning an exception" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { }, \"action\" : \"function () { throw \\\"doh!\\\"; }\" }"
|
|
doc = ArangoDB.log_post("#{prefix}-empty-exception", cmd, :body => body)
|
|
|
|
doc.code.should eq(500)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['code'].should eq(500)
|
|
doc.parsed_response['errorNum'].should eq(1650) #internal transaction error
|
|
end
|
|
end
|
|
|
|
################################################################################
|
|
## single-collection transactions
|
|
################################################################################
|
|
|
|
context "single collection transactions:" do
|
|
before do
|
|
@cn = "UnitTestsTransactions"
|
|
@cid = ArangoDB.create_collection(@cn, false)
|
|
end
|
|
|
|
after do
|
|
ArangoDB.drop_collection(@cn)
|
|
end
|
|
|
|
it "read-only, using write" do
|
|
body = "{ }"
|
|
doc = ArangoDB.post("/_api/document?collection=#{@cn}", :body => body)
|
|
doc = ArangoDB.post("/_api/document?collection=#{@cn}", :body => body)
|
|
doc = ArangoDB.post("/_api/document?collection=#{@cn}", :body => body)
|
|
|
|
ArangoDB.size_collection(@cn).should eq(3);
|
|
|
|
cmd = api
|
|
body = "{ \"collections\" : { \"write\": \"#{@cn}\" }, \"action\" : \"function () { var c = require(\\\"internal\\\").db.UnitTestsTransactions; return c.count(); }\" }"
|
|
doc = ArangoDB.log_post("#{prefix}-read-write", cmd, :body => body)
|
|
|
|
doc.code.should eq(200)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
doc.parsed_response['result'].should eq(3)
|
|
|
|
ArangoDB.size_collection(@cn).should eq(3);
|
|
end
|
|
|
|
it "read-only, using read" do
|
|
body = "{ }"
|
|
doc = ArangoDB.post("/_api/document?collection=#{@cn}", :body => body)
|
|
doc = ArangoDB.post("/_api/document?collection=#{@cn}", :body => body)
|
|
doc = ArangoDB.post("/_api/document?collection=#{@cn}", :body => body)
|
|
|
|
ArangoDB.size_collection(@cn).should eq(3);
|
|
|
|
cmd = api
|
|
body = "{ \"collections\" : { \"read\": \"#{@cn}\" }, \"action\" : \"function () { var c = require(\\\"internal\\\").db.UnitTestsTransactions; return c.count(); }\" }"
|
|
doc = ArangoDB.log_post("#{prefix}-read-only", cmd, :body => body)
|
|
|
|
doc.code.should eq(200)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
doc.parsed_response['result'].should eq(3)
|
|
|
|
ArangoDB.size_collection(@cn).should eq(3);
|
|
end
|
|
|
|
it "committing" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { \"write\": \"#{@cn}\" }, \"action\" : \"function () { var c = require(\\\"internal\\\").db.UnitTestsTransactions; c.save({ }); c.save({ }); return c.count(); }\" }"
|
|
doc = ArangoDB.log_post("#{prefix}-single-commit", cmd, :body => body)
|
|
|
|
doc.code.should eq(200)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
doc.parsed_response['result'].should eq(2)
|
|
|
|
ArangoDB.size_collection(@cn).should eq(2);
|
|
end
|
|
|
|
it "aborting" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { \"write\": \"#{@cn}\" }, \"action\" : \"function () { var c = require(\\\"internal\\\").db.UnitTestsTransactions; c.save({ }); c.save({ }); throw \\\"doh!\\\"; }\" }"
|
|
doc = ArangoDB.log_post("#{prefix}-single-abort", cmd, :body => body)
|
|
|
|
doc.code.should eq(500)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['code'].should eq(500)
|
|
doc.parsed_response['errorNum'].should eq(1650) #internal transaction error
|
|
|
|
ArangoDB.size_collection(@cn).should eq(0);
|
|
end
|
|
|
|
end
|
|
|
|
################################################################################
|
|
## multi-collection transactions
|
|
################################################################################
|
|
|
|
context "multi collection transactions:" do
|
|
before do
|
|
@cn1 = "UnitTestsTransactions1"
|
|
@cn2 = "UnitTestsTransactions2"
|
|
ArangoDB.create_collection(@cn1, false)
|
|
ArangoDB.create_collection(@cn2, false)
|
|
end
|
|
|
|
after do
|
|
ArangoDB.drop_collection(@cn1)
|
|
ArangoDB.drop_collection(@cn2)
|
|
end
|
|
|
|
it "read-only, using write" do
|
|
body = "{ }"
|
|
doc = ArangoDB.post("/_api/document?collection=#{@cn1}", :body => body)
|
|
doc = ArangoDB.post("/_api/document?collection=#{@cn1}", :body => body)
|
|
doc = ArangoDB.post("/_api/document?collection=#{@cn1}", :body => body)
|
|
doc = ArangoDB.post("/_api/document?collection=#{@cn2}", :body => body)
|
|
|
|
ArangoDB.size_collection(@cn1).should eq(3);
|
|
ArangoDB.size_collection(@cn2).should eq(1);
|
|
|
|
cmd = api
|
|
body = "{ \"collections\" : { \"write\": [ \"#{@cn1}\", \"#{@cn2}\" ] }, \"action\" : \"function () { var c1 = require(\\\"internal\\\").db.#{@cn1}; var c2 = require(\\\"internal\\\").db.#{@cn2}; return [ c1.count(), c2.count() ]; }\" }"
|
|
doc = ArangoDB.log_post("#{prefix}-multi-read-write", cmd, :body => body)
|
|
|
|
doc.code.should eq(200)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
doc.parsed_response['result'].should eq([ 3, 1 ])
|
|
|
|
ArangoDB.size_collection(@cn1).should eq(3);
|
|
ArangoDB.size_collection(@cn2).should eq(1);
|
|
end
|
|
|
|
it "read-only, using read" do
|
|
body = "{ }"
|
|
doc = ArangoDB.post("/_api/document?collection=#{@cn1}", :body => body)
|
|
doc = ArangoDB.post("/_api/document?collection=#{@cn1}", :body => body)
|
|
doc = ArangoDB.post("/_api/document?collection=#{@cn1}", :body => body)
|
|
doc = ArangoDB.post("/_api/document?collection=#{@cn2}", :body => body)
|
|
|
|
ArangoDB.size_collection(@cn1).should eq(3);
|
|
ArangoDB.size_collection(@cn2).should eq(1);
|
|
|
|
cmd = api
|
|
body = "{ \"collections\" : { \"read\": [ \"#{@cn1}\", \"#{@cn2}\" ] }, \"action\" : \"function () { var c1 = require(\\\"internal\\\").db.#{@cn1}; var c2 = require(\\\"internal\\\").db.#{@cn2}; return [ c1.count(), c2.count() ]; }\" }"
|
|
doc = ArangoDB.log_post("#{prefix}-multi-read-only", cmd, :body => body)
|
|
|
|
doc.code.should eq(200)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
doc.parsed_response['result'].should eq([ 3, 1 ])
|
|
|
|
ArangoDB.size_collection(@cn1).should eq(3);
|
|
ArangoDB.size_collection(@cn2).should eq(1);
|
|
end
|
|
|
|
it "committing" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { \"write\": [ \"#{@cn1}\", \"#{@cn2}\" ] }, \"action\" : \"function () { var c1 = require(\\\"internal\\\").db.#{@cn1}; var c2 = require(\\\"internal\\\").db.#{@cn2}; c1.save({ }); c1.save({ }); c2.save({ }); return [ c1.count(), c2.count() ]; }\" }"
|
|
doc = ArangoDB.log_post("#{prefix}-multi-commit", cmd, :body => body)
|
|
|
|
doc.code.should eq(200)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
|
|
doc.parsed_response['error'].should eq(false)
|
|
doc.parsed_response['code'].should eq(200)
|
|
doc.parsed_response['result'].should eq([ 2, 1 ])
|
|
|
|
ArangoDB.size_collection(@cn1).should eq(2);
|
|
ArangoDB.size_collection(@cn2).should eq(1);
|
|
end
|
|
|
|
it "aborting" do
|
|
cmd = api
|
|
body = "{ \"collections\" : { \"write\": [ \"#{@cn1}\", \"#{@cn2}\" ] }, \"action\" : \"function () { var c1 = require(\\\"internal\\\").db.#{@cn1}; var c2 = require(\\\"internal\\\").db.#{@cn2}; c1.save({ }); c1.save({ }); c2.save({ }); throw \\\"doh!\\\"; }\" }"
|
|
doc = ArangoDB.log_post("#{prefix}-multi-abort", cmd, :body => body)
|
|
|
|
doc.code.should eq(500)
|
|
doc.headers['content-type'].should eq("application/json; charset=utf-8")
|
|
doc.parsed_response['error'].should eq(true)
|
|
doc.parsed_response['code'].should eq(500)
|
|
doc.parsed_response['errorNum'].should eq(1650) #internal transaction error
|
|
|
|
ArangoDB.size_collection(@cn1).should eq(0);
|
|
ArangoDB.size_collection(@cn2).should eq(0);
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
end
|