ashikawa-core 0.7.2 → 0.8.0

data/spec/fixtures/cursor/edges.json

@@ -0,0 +1,23 @@
+{
+  "hasMore": false,
+  "error": false,
+  "id": "26011191",
+  "result": [
+    {
+    "n": 0,
+    "_rev": 25880119,
+    "_id": "23914039/25880119",
+    "_from": "23914039/25880119",
+    "_to": "23914039/25880119"
+  },
+  {
+    "n": 1,
+    "_rev": 25880119,
+    "_id": "23914039/25880119",
+    "_from": "23914039/25880119",
+    "_to": "23914039/25880119"
+  }
+  ],
+  "code": 201,
+  "count": 2
+}

data/spec/setup/arangodb.sh

@@ -3,7 +3,7 @@
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 cd $DIR
 
-VERSION=1.2.0
+VERSION=1.3.0
 NAME=ArangoDB-$VERSION
 
 if [ ! -d "$DIR/$NAME" ]; then
@@ -11,7 +11,7 @@ if [ ! -d "$DIR/$NAME" ]; then
   echo "wget http://www.arangodb.org/travisCI/$NAME.tar.gz"
   wget http://www.arangodb.org/travisCI/$NAME.tar.gz
   echo "tar zxf $NAME.tar.gz"
-  tar zxf $NAME.tar.gz
+  tar zvxf $NAME.tar.gz
 fi
 
 ARCH=$(arch)
@@ -25,8 +25,7 @@ if [ "$ARCH" == "x86_64" ]; then
   ARANGOD="${ARANGOD}_x86_64"
 fi
 
-# (re-)create database directory
-rm -rf ${TMP_DIR}
+# create database directory
 mkdir ${TMP_DIR}
 
 echo "Starting arangodb '${ARANGOD}'"
@@ -36,8 +35,10 @@ ${ARANGOD} \
   --configuration none  \
   --server.endpoint tcp://127.0.0.1:8529 \
   --javascript.startup-directory ${ARANGODB_DIR}/js \
-  --javascript.modules-path ${ARANGODB_DIR}/js/server/modules:${ARANGODB_DIR}/js/common/modules \
-  --javascript.action-directory ${ARANGODB_DIR}/js/actions/system  \
+  --server.admin-directory ${ARANGODB_DIR}/html/admin \
+  --javascript.modules-path ${ARANGODB_DIR}/js/server/modules:${ARANGODB_DIR}/js/common/modules:${ARANGODB_DIR}/js/node \
+  --javascript.package-path ${ARANGODB_DIR}/js/npm:${ARANGODB_DIR}/js/common/test-data/modules \
+  --javascript.action-directory ${ARANGODB_DIR}/js/actions  \
   --database.maximal-journal-size 1048576  \
   --server.disable-admin-interface true \
   --server.disable-authentication true \

data/spec/unit/collection_spec.rb

@@ -5,7 +5,7 @@ describe Ashikawa::Core::Collection do
   subject { Ashikawa::Core::Collection }
 
   before :each do
-    @database = double()
+    @database = double
   end
 
   it "should have a name" do
@@ -21,7 +21,7 @@ describe Ashikawa::Core::Collection do
   it "should create a query" do
     collection = subject.new @database, server_response("collections/60768679")
 
-    mock Ashikawa::Core::Query
+    double Ashikawa::Core::Query
     Ashikawa::Core::Query.stub(:new)
     Ashikawa::Core::Query.should_receive(:new).exactly(1).times.with(collection)
 
@@ -75,7 +75,7 @@ describe Ashikawa::Core::Collection do
       @database.stub(:send_request).with("collection/60768679/figures", {}).and_return { server_response("collections/60768679-figures") }
       @database.should_receive(:send_request).with("collection/60768679/figures", {}).at_least(1).times
 
-      mock Ashikawa::Core::Figure
+      double Ashikawa::Core::Figure
       Ashikawa::Core::Figure.stub(:new)
       Ashikawa::Core::Figure.should_receive(:new).exactly(1).times.with(server_response("collections/60768679-figures")["figures"])
 
@@ -122,6 +122,16 @@ describe Ashikawa::Core::Collection do
       subject.wait_for_sync = true
     end
 
+    it "should check for the key options" do
+      raw_key_options = double
+      @database.should_receive(:send_request).with("collection/60768679/properties", {}).and_return { { "keyOptions" => raw_key_options } }
+
+      key_options = double
+      Ashikawa::Core::KeyOptions.stub(:new).with(raw_key_options).and_return { key_options }
+
+      subject.key_options.should == key_options
+    end
+
     it "should change its name" do
       @database.stub(:send_request).with("collection/60768679/rename", :put => {"name" => "my_new_name"})
       @database.should_receive(:send_request).with("collection/60768679/rename", :put => {"name" => "my_new_name"})
@@ -130,7 +140,17 @@ describe Ashikawa::Core::Collection do
     end
 
     describe "add and get single documents" do
-      it "should receive a document by ID" do
+      it "should receive a document by ID via fetch" do
+        @database.stub(:send_request).with("document/60768679/333", {}).and_return { server_response('documents/example_1-137249191') }
+        @database.should_receive(:send_request).with("document/60768679/333", {})
+
+        # Documents need to get initialized:
+        Ashikawa::Core::Document.should_receive(:new)
+
+        subject.fetch(333)
+      end
+
+      it "should receive a document by ID via []" do
         @database.stub(:send_request).with("document/60768679/333", {}).and_return { server_response('documents/example_1-137249191') }
         @database.should_receive(:send_request).with("document/60768679/333", {})
 
@@ -140,35 +160,70 @@ describe Ashikawa::Core::Collection do
         subject[333]
       end
 
+      it "should throw an exception when the document was not found during a fetch" do
+        @database.stub(:send_request).and_return {
+          raise Ashikawa::Core::DocumentNotFoundException
+        }
+
+        expect {
+          subject.fetch(123)
+        }.to raise_exception Ashikawa::Core::DocumentNotFoundException
+      end
+
+      it "should return nil when the document was not found when using []" do
+        @database.stub(:send_request).and_return {
+          raise Ashikawa::Core::DocumentNotFoundException
+        }
+
+        subject[123].should == nil
+      end
+
       it "should replace a document by ID" do
         @database.stub(:send_request).with("document/60768679/333", :put => {"name" => "The Dude"})
         @database.should_receive(:send_request).with("document/60768679/333", :put => {"name" => "The Dude"})
 
-        subject[333] = {"name" => "The Dude"}
+        subject.replace(333, {"name" => "The Dude"})
       end
 
       it "should create a new document" do
         @database.stub(:send_request).with("document?collection=60768679", :post => { "name" => "The Dude" }).and_return do
           server_response('documents/new-example_1-137249191')
         end
-        @database.stub(:send_request).with("document/60768679/333", :post => { "name" => "The Dude" }).and_return { server_response('documents/example_1-137249191') }
+        @database.stub(:send_request).with("document/60768679/333", :post => {
+          "name" => "The Dude"
+        }).and_return {
+          {
+            "_id" => "example_1/137249191",
+            "_rev" => "137249191",
+            "_key" => "137249191"
+          }
+        }
+        @database.stub(:send_request).with("document/60768679/333", {}).and_return { server_response('documents/example_1-137249191') }
 
         # Documents need to get initialized:
-        Ashikawa::Core::Document.should_receive(:new)
+        Ashikawa::Core::Document.should_receive(:new).and_return {
+          document = double
+          document.should_receive(:refresh!)
+          document
+        }
 
         subject.create_document({"name" => "The Dude"})
       end
 
-      it "should create a new document with `<<`" do
+      it "should create a new document" do
         @database.stub(:send_request).with("document?collection=60768679", :post => { "name" => "The Dude" }).and_return do
           server_response('documents/example_1-137249191')
         end
         @database.stub(:send_request).with("document/60768679/333").and_return { server_response('documents/example_1-137249191') }
 
         # Documents need to get initialized:
-        Ashikawa::Core::Document.should_receive(:new)
+        Ashikawa::Core::Document.should_receive(:new).and_return {
+          document = double
+          document.should_receive(:refresh!)
+          document
+        }
 
-        subject << {"name" => "The Dude"}
+        subject.create_document("name" => "The Dude")
       end
 
       it "should not create a new document" do
@@ -227,14 +282,14 @@ describe Ashikawa::Core::Collection do
       # Documents need to get initialized:
       Ashikawa::Core::Edge.should_receive(:new)
 
-      subject[333]
+      subject.fetch(333)
     end
 
     it "should replace an edge by ID" do
       @database.stub(:send_request).with("edge/60768679/333", :put => {"name" => "The Dude"})
       @database.should_receive(:send_request).with("edge/60768679/333", :put => {"name" => "The Dude"})
 
-      subject[333] = {"name" => "The Dude"}
+      subject.replace(333, {"name" => "The Dude"})
     end
 
     it "should create a new edge" do
@@ -248,7 +303,11 @@ describe Ashikawa::Core::Collection do
       to_double.stub(:id => "2")
 
       # Documents need to get initialized:
-      Ashikawa::Core::Edge.should_receive(:new)
+      Ashikawa::Core::Edge.should_receive(:new).and_return {
+        document = double
+        document.should_receive(:refresh!)
+        document
+      }
 
       subject.create_edge(from_double, to_double, {"name" => "The Dude"})
     end
@@ -259,4 +318,21 @@ describe Ashikawa::Core::Collection do
       }.to raise_exception(RuntimeError, "Can't create a document in an edge collection")
     end
   end
+
+  describe "Deprecated methods" do
+    subject { Ashikawa::Core::Collection.new @database, { "id" => "60768679", "name" => "example_1" } }
+    let(:attributes) { { "test" => 123 } }
+
+    it "should mark `<<` as deprecated" do
+      subject.should_receive(:create_document).with(attributes).and_return nil
+      subject.should_receive(:warn).with("`<<` is deprecated, please use `create_document`")
+      subject << attributes
+    end
+
+    it "should mark `[]=` as deprecated" do
+      subject.should_receive(:replace).with(121, attributes).and_return nil
+      subject.should_receive(:warn).with("`[]=` is deprecated, please use `replace`")
+      subject[121] = attributes
+    end
+  end
 end

data/spec/unit/connection_spec.rb

@@ -14,7 +14,7 @@ describe Ashikawa::Core::Connection do
 
   it "should send a get request" do
     request_stub.get("/_api/my/path") do
-      [200, response_headers, MultiJson.dump({ "name" => "dude" })]
+      [200, response_headers, JSON.generate({ "name" => "dude" })]
     end
 
     subject.send_request "my/path"
@@ -25,7 +25,7 @@ describe Ashikawa::Core::Connection do
   it "should send a post request" do
     request_stub.post("/_api/my/path") do |request|
       request[:body].should == "{\"name\":\"new_collection\"}"
-      [200, response_headers, MultiJson.dump({ "name" => "dude" })]
+      [200, response_headers, JSON.generate({ "name" => "dude" })]
     end
 
     subject.send_request "my/path", :post => { :name => 'new_collection' }
@@ -36,7 +36,7 @@ describe Ashikawa::Core::Connection do
   it "should send a put request" do
     request_stub.put("/_api/my/path") do |request|
       request[:body].should == '{"name":"new_collection"}'
-      [200, response_headers, MultiJson.dump({ "name" => "dude" })]
+      [200, response_headers, JSON.generate({ "name" => "dude" })]
     end
 
     subject.send_request "my/path", :put => { :name => 'new_collection' }
@@ -46,7 +46,7 @@ describe Ashikawa::Core::Connection do
 
   it "should send a delete request" do
     request_stub.delete("/_api/my/path") do |request|
-      [200, response_headers, MultiJson.dump({ "name" => "dude" })]
+      [200, response_headers, JSON.generate({ "name" => "dude" })]
     end
 
     subject.send_request "my/path", :delete => { }
@@ -57,7 +57,7 @@ describe Ashikawa::Core::Connection do
   it "should write JSON request" do
     request_stub.post("/_api/my/path") do |req|
       req[:body].should == "{\"test\":1}"
-      [200, response_headers, MultiJson.dump({ "name" => "dude" })]
+      [200, response_headers, JSON.generate({ "name" => "dude" })]
     end
 
     subject.send_request("my/path", :post => { "test" => 1})
@@ -101,7 +101,7 @@ describe Ashikawa::Core::Connection do
       pending "Find out how to check for basic auth via Faraday Stubs"
 
       request_stub.get("/_api/my/path") do |request|
-        [200, response_headers, MultiJson.dump({ "name" => "dude" })]
+        [200, response_headers, JSON.generate({ "name" => "dude" })]
       end
 
       subject.authenticate_with :username => "user", :password => "pass"
@@ -112,14 +112,21 @@ describe Ashikawa::Core::Connection do
   end
 
   describe "exception handling" do
+    let(:error_message) { "cannot write file" }
+    let(:error_num) { 15 }
+
     it "should throw a general client error for I'm a teapot" do
       request_stub.get("/_api/bad/request") do
-        [418, response_headers, ""]
+        [
+          418,
+          response_headers,
+          JSON.generate({ "error" => true, "errorNum" => error_num, "errorMessage" => error_message })
+        ]
       end
 
       expect do
         subject.send_request("bad/request")
-      end.to raise_error(Ashikawa::Core::ClientError, /418/)
+      end.to raise_error(Ashikawa::Core::ClientError, "#{error_num}: #{error_message}")
 
       request_stub.verify_stubbed_calls
     end
@@ -138,12 +145,16 @@ describe Ashikawa::Core::Connection do
 
     it "should throw a general server error for the generic server error" do
       request_stub.get("/_api/bad/request") do
-        [500, response_headers, ""]
+        [
+          500,
+          response_headers,
+          JSON.generate({ "error" => true, "errorNum" => error_num, "errorMessage" => error_message })
+        ]
       end
 
       expect do
         subject.send_request("bad/request")
-      end.to raise_error(Ashikawa::Core::ServerError, /500/)
+      end.to raise_error(Ashikawa::Core::ServerError, "#{error_num}: #{error_message}")
 
       request_stub.verify_stubbed_calls
     end
@@ -218,7 +229,7 @@ describe Ashikawa::Core::Connection do
 
     it "should log a get request" do
       request_stub.get("/_api/test") do
-        [200, response_headers, MultiJson.dump({:a => 1})]
+        [200, response_headers, JSON.generate({:a => 1})]
       end
       logger.should_receive(:info).with("GET #{ARANGO_HOST}/_api/test ")
       logger.should_receive(:info).with("200 {\"a\":1}")
@@ -226,10 +237,8 @@ describe Ashikawa::Core::Connection do
     end
 
     it "should log a post request" do
-      pending "This fails on 1.8.7 for unknown reasons. Will investigate." if RUBY_VERSION == "1.8.7"
-
       request_stub.post("/_api/test") do
-        [201, response_headers, MultiJson.dump({:b => 2})]
+        [201, response_headers, JSON.generate({:b => 2})]
       end
       logger.should_receive(:info).with("POST #{ARANGO_HOST}/_api/test {:a=>2}")
       logger.should_receive(:info).with("201 {\"b\":2}")

data/spec/unit/cursor_spec.rb

@@ -5,8 +5,8 @@ describe Ashikawa::Core::Cursor do
   subject { Ashikawa::Core::Cursor }
 
   before :each do
-    @database = double()
-    mock Ashikawa::Core::Document
+    @database = double
+    double Ashikawa::Core::Document
   end
 
   it "should create a cursor for a non-complete batch" do
@@ -46,8 +46,6 @@ describe Ashikawa::Core::Cursor do
     end
 
     it "should return an enumerator to go over all documents of a cursor when given no block" do
-      pending "This fails on 1.8.7 because of an old backports version" if RUBY_VERSION == "1.8.7"
-
       first = true
 
       @database.stub(:send_request).with("cursor/26011191", :put => {}) do
@@ -98,5 +96,18 @@ describe Ashikawa::Core::Cursor do
 
       subject.map{|i| i}[0].should == 1
     end
+
+    it "should return edge objects when recieving data from an edge collection" do
+      @database.stub(:send_request).with("cursor/26011191", :put => {}) do
+        server_response("cursor/edges")
+      end
+      @database.should_receive(:send_request).once
+
+      Ashikawa::Core::Edge.stub(:new).and_return { 1 }
+      Ashikawa::Core::Edge.should_receive(:new).exactly(2).times
+
+      subject.each { |document| }
+    end
+
   end
 end

data/spec/unit/database_spec.rb

@@ -5,10 +5,11 @@ describe Ashikawa::Core::Database do
   subject { Ashikawa::Core::Database }
 
   before :each do
-    mock(Ashikawa::Core::Connection)
-    mock(Ashikawa::Core::Collection)
-    mock(Ashikawa::Core::Cursor)
-    @connection = double()
+    double(Ashikawa::Core::Connection)
+    double(Ashikawa::Core::Collection)
+    double(Ashikawa::Core::Cursor)
+    double(Ashikawa::Core::Transaction)
+    @connection = double("connection", :host => "localhost", :port => 8529, :scheme => "http")
   end
 
   it "should initialize with a connection" do
@@ -26,13 +27,13 @@ describe Ashikawa::Core::Database do
     Ashikawa::Core::Connection.stub(:new).with("http://localhost:8529", {
       :logger => nil,
       :adapter => nil
-    }).and_return(double())
+    }).and_return(double)
     Ashikawa::Core::Connection.should_receive(:new).with("http://localhost:8529", {
       :logger => nil,
       :adapter => nil
     })
 
-    database = subject.new do |config|
+    subject.new do |config|
       config.url = "http://localhost:8529"
     end
   end
@@ -42,13 +43,13 @@ describe Ashikawa::Core::Database do
     Ashikawa::Core::Connection.stub(:new).with("http://localhost:8529", {
       :logger => logger,
       :adapter => nil
-    }).and_return(double())
+    }).and_return(double)
     Ashikawa::Core::Connection.should_receive(:new).with("http://localhost:8529", {
       :logger => logger,
       :adapter => nil
     })
 
-    database = subject.new do |config|
+    subject.new do |config|
       config.url = "http://localhost:8529"
       config.logger = logger
     end
@@ -59,13 +60,13 @@ describe Ashikawa::Core::Database do
     Ashikawa::Core::Connection.stub(:new).with("http://localhost:8529", {
       :logger => nil,
       :adapter => adapter
-    }).and_return(double())
+    }).and_return(double)
     Ashikawa::Core::Connection.should_receive(:new).with("http://localhost:8529", {
       :logger => nil,
       :adapter => adapter
     })
 
-    database = subject.new do |config|
+    subject.new do |config|
       config.url = "http://localhost:8529"
       config.adapter = adapter
     end
@@ -76,7 +77,7 @@ describe Ashikawa::Core::Database do
     logger = double
 
     expect {
-      database = subject.new do |config|
+      subject.new do |config|
         config.adapter = adapter
         config.logger = logger
       end
@@ -88,7 +89,7 @@ describe Ashikawa::Core::Database do
       config.connection = @connection
     end
 
-    mock Ashikawa::Core::Query
+    double Ashikawa::Core::Query
     Ashikawa::Core::Query.stub(:new)
     Ashikawa::Core::Query.should_receive(:new).exactly(1).times.with(database)
 
@@ -96,7 +97,8 @@ describe Ashikawa::Core::Database do
   end
 
   describe "initialized database" do
-    subject { Ashikawa::Core::Database.new do |config|
+    subject {
+      Ashikawa::Core::Database.new do |config|
         config.connection = @connection
       end
     }
@@ -107,16 +109,26 @@ describe Ashikawa::Core::Database do
       subject.authenticate_with :username => "user", :password => "password"
     end
 
-    it "should fetch all available collections" do
+    it "should fetch all available non-system collections" do
       @connection.stub(:send_request) {|path| server_response("collections/all") }
       @connection.should_receive(:send_request).with("collection")
 
-      Ashikawa::Core::Collection.should_receive(:new).with(subject, server_response("collections/all")["collections"][0])
-      Ashikawa::Core::Collection.should_receive(:new).with(subject, server_response("collections/all")["collections"][1])
+      (0..1).each do |k|
+        Ashikawa::Core::Collection.should_receive(:new).with(subject, server_response("collections/all")["collections"][k])
+      end
 
       subject.collections.length.should == 2
     end
 
+    it "should fetch all available non-system collections" do
+      @connection.stub(:send_request) {|path| server_response("collections/all") }
+      @connection.should_receive(:send_request).with("collection")
+
+      Ashikawa::Core::Collection.should_receive(:new).exactly(5).times
+
+      subject.system_collections.length.should == 5
+    end
+
     it "should create a non volatile collection by default" do
       @connection.stub(:send_request) { |path| server_response("collections/60768679") }
       @connection.should_receive(:send_request).with("collection",
@@ -137,6 +149,26 @@ describe Ashikawa::Core::Database do
       subject.create_collection("volatile_collection", :is_volatile => true)
     end
 
+    it "should create an autoincrement collection when asked" do
+      @connection.should_receive(:send_request).with("collection",
+        :post => { :name => "autoincrement_collection", :keyOptions => {
+          :type => "autoincrement",
+          :offset => 0,
+          :increment => 10,
+          :allowUserKeys => false
+        }
+      })
+
+      Ashikawa::Core::Collection.should_receive(:new)
+
+      subject.create_collection("autoincrement_collection", :key_options => {
+        :type => :autoincrement,
+        :offset => 0,
+        :increment => 10,
+        :allow_user_keys => false
+      })
+    end
+
     it "should create an edge collection when asked" do
       @connection.stub(:send_request) { |path| server_response("collections/60768679") }
       @connection.should_receive(:send_request).with("collection",
@@ -175,7 +207,7 @@ describe Ashikawa::Core::Database do
         end
       end
       @connection.should_receive(:send_request).with("collection/new_collection")
-      @connection.should_receive(:send_request).with("collection", :post => { :name => "new_collection"} )
+      @connection.should_receive(:send_request).with("collection", :post => { :name => "new_collection"})
 
       Ashikawa::Core::Collection.should_receive(:new).with(subject, server_response("collections/60768679"))
 
@@ -187,5 +219,14 @@ describe Ashikawa::Core::Database do
 
       subject.send_request "my/path", :post => { :data => "mydata" }
     end
+
+    let(:js_function) { double }
+    let(:collections) { double }
+    let(:transaction) { double }
+
+    it "should create a transaction" do
+      Ashikawa::Core::Transaction.should_receive(:new).with(subject, js_function, collections).and_return { transaction }
+      subject.create_transaction(js_function, collections).should == transaction
+    end
   end
 end