ashikawa-core 0.6.0 → 0.7.0

data/spec/fixtures/collections/60768679-properties.json

@@ -0,0 +1,12 @@
+{
+  "id": "60768679",
+  "name": "example_1",
+	"waitForSync": true,
+  "journalSize": 134217728,
+  "isVolatile": false,
+  "isSystem": false,
+	"status": 3,
+  "type": 2,
+	"error": false,
+	"code": 200
+}

data/spec/fixtures/collections/{4588.json → 60768679.json}

@@ -1,8 +1,8 @@
 {
+	"id": "60768679",
 	"name": "example_1",
-	"waitForSync": true,
-	"id": 4588,
 	"status": 3,
+  "type": 2,
 	"error": false,
 	"code": 200
 }

data/spec/fixtures/collections/all.json

@@ -3,13 +3,13 @@
 		{
 			"name": "example_1",
 			"waitForSync": true,
-			"id": 4588,
+			"id": "60768679",
 			"status": 3
 		},
 		{
 			"name": "example_2",
 			"waitForSync": true,
-			"id": 4589,
+			"id": "60768669",
 			"status": 3
 		}
 	],
@@ -19,14 +19,14 @@
 		"example_1": {
 			"name": "example_1",
 			"waitForSync": true,
-			"id": 4588,
+			"id": "60768679",
 			"status": 3
 		},
 		"example_2": {
 			"name": "example_2",
 			"waitForSync": true,
-			"id": 4589,
+			"id": "60768669",
 			"status": 3
 		}
 	}
-}
+}

data/spec/fixtures/cursor/26011191-2.json

@@ -1,7 +1,7 @@
 {
   "hasMore": true,
   "error": false,
-  "id": 26011191,
+  "id": "26011191",
   "result": [
     {
       "n": 2,

data/spec/fixtures/cursor/26011191.json

@@ -1,7 +1,7 @@
 {
   "hasMore": true,
   "error": false,
-  "id": 26011191,
+  "id": "26011191",
   "result": [
     {
     "n": 0,

data/spec/fixtures/documents/example_1-137249191.json

@@ -0,0 +1,6 @@
+{
+  "hello": "world",
+  "_id": "example_1/137249191",
+  "_rev": "137249191",
+  "_key": "137249191"
+}

data/spec/fixtures/documents/new-example_1-137249191.json

@@ -0,0 +1,6 @@
+{
+  "error": false,
+  "_id": "example_1/137183655",
+  "_rev": "137183655",
+  "_key": "137183655"
+}

data/spec/setup/arangodb.sh

@@ -3,7 +3,7 @@
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 cd $DIR
 
-VERSION=1.1.2
+VERSION=1.2.0
 NAME=ArangoDB-$VERSION
 
 if [ ! -d "$DIR/$NAME" ]; then

data/spec/unit/collection_spec.rb

@@ -9,17 +9,17 @@ describe Ashikawa::Core::Collection do
   end
 
   it "should have a name" do
-    my_collection = subject.new @database, server_response("/collections/4588")
+    my_collection = subject.new @database, server_response("collections/60768679")
     my_collection.name.should == "example_1"
   end
 
   it "should accept an ID" do
-    my_collection = subject.new @database, server_response("/collections/4588")
-    my_collection.id.should == 4588
+    my_collection = subject.new @database, server_response("collections/60768679")
+    my_collection.id.should == "60768679"
   end
 
   it "should create a query" do
-    collection = subject.new @database, server_response("/collections/4588")
+    collection = subject.new @database, server_response("collections/60768679")
 
     mock Ashikawa::Core::Query
     Ashikawa::Core::Query.stub(:new)
@@ -30,83 +30,109 @@ describe Ashikawa::Core::Collection do
 
   describe "attributes of a collection" do
     it "should check if the collection waits for sync" do
-      @database.stub(:send_request).with("/collection/4590/properties", {}).and_return { server_response("/collections/4590") }
-      @database.should_receive(:send_request).with("/collection/4590/properties", {})
+      @database.stub(:send_request).with("collection/60768679/properties", {}).and_return { server_response("collections/60768679-properties") }
+      @database.should_receive(:send_request).with("collection/60768679/properties", {})
 
-      my_collection = subject.new @database, { "id" => "4590" }
+      my_collection = subject.new @database, { "id" => "60768679" }
       my_collection.wait_for_sync?.should be_true
     end
 
     it "should know how many documents the collection has" do
-      @database.stub(:send_request).with("/collection/4590/count", {}).and_return { server_response("/collections/4590-properties") }
-      @database.should_receive(:send_request).with("/collection/4590/count", {})
+      @database.stub(:send_request).with("collection/60768679/count", {}).and_return { server_response("collections/60768679-count") }
+      @database.should_receive(:send_request).with("collection/60768679/count", {})
 
-      my_collection = subject.new @database, { "id" => "4590" }
+      my_collection = subject.new @database, { "id" => "60768679" }
       my_collection.length.should == 54
     end
 
+    it "should know if the collection is volatile" do
+      @database.stub(:send_request).with("collection/60768679/properties", {}).and_return { server_response("collections/60768679-properties-volatile") }
+      @database.should_receive(:send_request).with("collection/60768679/properties", {})
+
+      my_collection = subject.new(@database, { "id" => "60768679" })
+      my_collection.volatile?.should == true
+    end
+
+    it "should know if the collection is not volatile" do
+      @database.stub(:send_request).with("collection/60768679/properties", {}).and_return { server_response("collections/60768679-properties") }
+      @database.should_receive(:send_request).with("collection/60768679/properties", {})
+
+      my_collection = subject.new(@database, { "id" => "60768679" })
+      my_collection.volatile?.should == false
+    end
+
+    it "should know that a collection is from type 'document'" do
+      my_collection = subject.new(@database, { "id" => "60768679", "type" => 2 })
+      my_collection.content_type.should == :document
+    end
+
+    it "should know that a collection is from type 'edge'" do
+      my_collection = subject.new(@database, { "id" => "60768679", "type" => 3 })
+      my_collection.content_type.should == :edge
+    end
+
     it "should check for the figures" do
-      @database.stub(:send_request).with("/collection/73482/figures", {}).and_return { server_response("/collections/73482-figures") }
-      @database.should_receive(:send_request).with("/collection/73482/figures", {}).at_least(1).times
+      @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
       Ashikawa::Core::Figure.stub(:new)
-      Ashikawa::Core::Figure.should_receive(:new).exactly(1).times.with(server_response("/collections/73482-figures")["figures"])
+      Ashikawa::Core::Figure.should_receive(:new).exactly(1).times.with(server_response("collections/60768679-figures")["figures"])
 
-      my_collection = subject.new @database, { "id" => "73482" }
+      my_collection = subject.new @database, { "id" => "60768679" }
       my_collection.figure
     end
   end
 
   describe "an initialized collection" do
-    subject { Ashikawa::Core::Collection.new @database, { "id" => "4590", "name" => "example_1" } }
+    subject { Ashikawa::Core::Collection.new @database, { "id" => "60768679", "name" => "example_1" } }
 
     it "should get deleted" do
-      @database.stub(:send_request).with("/collection/4590", :delete => {})
-      @database.should_receive(:send_request).with("/collection/4590", :delete => {})
+      @database.stub(:send_request).with("collection/60768679/", :delete => {})
+      @database.should_receive(:send_request).with("collection/60768679/", :delete => {})
 
       subject.delete
     end
 
     it "should get loaded" do
-      @database.stub(:send_request).with("/collection/4590/load", :put => {})
-      @database.should_receive(:send_request).with("/collection/4590/load", :put => {})
+      @database.stub(:send_request).with("collection/60768679/load", :put => {})
+      @database.should_receive(:send_request).with("collection/60768679/load", :put => {})
 
       subject.load
     end
 
     it "should get unloaded" do
-      @database.stub(:send_request).with("/collection/4590/unload", :put => {})
-      @database.should_receive(:send_request).with("/collection/4590/unload", :put => {})
+      @database.stub(:send_request).with("collection/60768679/unload", :put => {})
+      @database.should_receive(:send_request).with("collection/60768679/unload", :put => {})
 
       subject.unload
     end
 
     it "should get truncated" do
-      @database.stub(:send_request).with("/collection/4590/truncate", :put => {})
-      @database.should_receive(:send_request).with("/collection/4590/truncate", :put => {})
+      @database.stub(:send_request).with("collection/60768679/truncate", :put => {})
+      @database.should_receive(:send_request).with("collection/60768679/truncate", :put => {})
 
       subject.truncate!
     end
 
     it "should change if it waits for sync" do
-      @database.stub(:send_request).with("/collection/4590/properties", :put => {"waitForSync" => true})
-      @database.should_receive(:send_request).with("/collection/4590/properties", :put => {"waitForSync" => true})
+      @database.stub(:send_request).with("collection/60768679/properties", :put => {"waitForSync" => true})
+      @database.should_receive(:send_request).with("collection/60768679/properties", :put => {"waitForSync" => true})
 
       subject.wait_for_sync = true
     end
 
     it "should change its name" do
-      @database.stub(:send_request).with("/collection/4590/rename", :put => {"name" => "my_new_name"})
-      @database.should_receive(:send_request).with("/collection/4590/rename", :put => {"name" => "my_new_name"})
+      @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"})
 
       subject.name = "my_new_name"
     end
 
     describe "add and get single documents" do
       it "should receive a document by ID" do
-        @database.stub(:send_request).with("/document/4590/333").and_return { server_response('documents/4590-333') }
-        @database.should_receive(:send_request).with("/document/4590/333")
+        @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)
@@ -115,29 +141,29 @@ describe Ashikawa::Core::Collection do
       end
 
       it "should replace a document by ID" do
-        @database.stub(:send_request).with("/document/4590/333", :put => {"name" => "The Dude"})
-        @database.should_receive(:send_request).with("/document/4590/333", :put => {"name" => "The Dude"})
+        @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"}
       end
 
       it "should create a new document" do
-        @database.stub(:send_request).with("/document?collection=4590", :post => { "name" => "The Dude" }).and_return do
-          server_response('documents/new-4590-333')
+        @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/4590/333", :post => { "name" => "The Dude" }).and_return { server_response('documents/4590-333') }
+        @database.stub(:send_request).with("document/60768679/333", :post => { "name" => "The Dude" }).and_return { server_response('documents/example_1-137249191') }
 
         # Documents need to get initialized:
         Ashikawa::Core::Document.should_receive(:new)
 
-        subject.create({"name" => "The Dude"})
+        subject.create_document({"name" => "The Dude"})
       end
 
       it "should create a new document with `<<`" do
-        @database.stub(:send_request).with("/document?collection=4590", :post => { "name" => "The Dude" }).and_return do
-          server_response('documents/new-4590-333')
+        @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/4590/333").and_return { server_response('documents/4590-333') }
+        @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)
@@ -145,12 +171,18 @@ describe Ashikawa::Core::Collection do
         subject << {"name" => "The Dude"}
       end
 
+      it "should not create a new document" do
+        expect {
+          subject.create_edge(nil, nil, {"quote" => "D'ya have to use s'many cuss words?"})
+        }.to raise_exception(RuntimeError, "Can't create an edge in a document collection")
+      end
+
       describe "indices" do
         it "should add a new index" do
-          @database.stub(:send_request).with("/index?collection=4590", :post => {
+          @database.stub(:send_request).with("index?collection=60768679", :post => {
             "type" => "hash", "fields" => [ "a", "b" ]
           }).and_return { server_response('indices/new-hash-index') }
-          @database.should_receive(:send_request).with("/index?collection=4590", :post => {
+          @database.should_receive(:send_request).with("index?collection=60768679", :post => {
             "type" => "hash", "fields" => [ "a", "b" ]
           })
 
@@ -162,7 +194,7 @@ describe Ashikawa::Core::Collection do
 
         it "should get an index by ID" do
           @database.stub(:send_request).with(
-            "/index/4590/168054969"
+            "index/example_1/168054969"
           ).and_return { server_response('indices/hash-index') }
 
           Ashikawa::Core::Index.should_receive(:new).with(subject,
@@ -173,7 +205,7 @@ describe Ashikawa::Core::Collection do
 
         it "should get all indices" do
           @database.stub(:send_request).with(
-            "/index?collection=4590"
+            "index?collection=60768679"
           ).and_return { server_response('indices/all') }
 
           Ashikawa::Core::Index.should_receive(:new).exactly(1).times
@@ -184,4 +216,47 @@ describe Ashikawa::Core::Collection do
       end
     end
   end
+
+  describe "an initialized edge collection" do
+    subject { Ashikawa::Core::Collection.new @database, { "id" => "60768679", "name" => "example_1", "type" => 3 } }
+
+    it "should receive an edge by ID" do
+      @database.stub(:send_request).with("edge/60768679/333", {}).and_return { server_response('documents/example_1-137249191') }
+      @database.should_receive(:send_request).with("edge/60768679/333", {})
+
+      # Documents need to get initialized:
+      Ashikawa::Core::Edge.should_receive(:new)
+
+      subject[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"}
+    end
+
+    it "should create a new edge" do
+      @database.stub(:send_request).with("edge?collection=60768679&from=1&to=2", :post => { "name" => "The Dude" }).and_return do
+        server_response('documents/new-example_1-137249191')
+      end
+      @database.stub(:send_request).with("edge?collection=60768679&from=1&to=2", :post => { "name" => "The Dude" }).and_return { server_response('documents/example_1-137249191') }
+      from_double = double
+      from_double.stub(:id => "1")
+      to_double = double
+      to_double.stub(:id => "2")
+
+      # Documents need to get initialized:
+      Ashikawa::Core::Edge.should_receive(:new)
+
+      subject.create_edge(from_double, to_double, {"name" => "The Dude"})
+    end
+
+    it "should not create a new document" do
+      expect {
+        subject.create_document({"quote" => "D'ya have to use s'many cuss words?"})
+      }.to raise_exception(RuntimeError, "Can't create a document in an edge collection")
+    end
+  end
 end

data/spec/unit/connection_spec.rb

@@ -2,76 +2,78 @@ require 'unit/spec_helper'
 require 'ashikawa-core/connection'
 
 describe Ashikawa::Core::Connection do
-  subject { Ashikawa::Core::Connection }
+  let(:request_stub) { Faraday::Adapter::Test::Stubs.new }
+  let(:response_headers) { {"content-type" => "application/json; charset=utf-8" } }
+  subject { Ashikawa::Core::Connection.new(ARANGO_HOST, :adapter => [:test, request_stub]) }
 
   it "should have a scheme, hostname and port" do
-    connection = subject.new "http://localhost:8529"
-
-    connection.scheme.should == "http"
-    connection.host.should == "localhost"
-    connection.port.should == 8529
-  end
-
-  it "should default to HTTP, localhost and ArangoDB port" do
-    connection = subject.new
-
-    connection.scheme.should == "http"
-    connection.host.should == "localhost"
-    connection.port.should == 8529
+    subject.scheme.should == "http"
+    subject.host.should == "localhost"
+    subject.port.should == 8529
   end
 
-  describe "initialized connection" do
-    subject { Ashikawa::Core::Connection.new "http://localhost:8529" }
+  it "should send a get request" do
+    request_stub.get("/_api/my/path") do
+      [200, response_headers, MultiJson.dump({ "name" => "dude" })]
+    end
 
-    it "should send a get request" do
-      stub_request(:get, "http://localhost:8529/_api/my/path").to_return :body => '{ "name": "dude" }'
+    subject.send_request "my/path"
 
-      subject.send_request "/my/path"
+    request_stub.verify_stubbed_calls
+  end
 
-      WebMock.should have_requested(:get, "http://localhost:8529/_api/my/path")
+  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" })]
     end
 
-    it "should send a post request" do
-      stub_request(:post, "http://localhost:8529/_api/my/path").with(:body => '{"name":"new_collection"}').to_return :body => '{ "name": "dude" }'
+    subject.send_request "my/path", :post => { :name => 'new_collection' }
 
-      subject.send_request "/my/path", :post => { :name => 'new_collection' }
+    request_stub.verify_stubbed_calls
+  end
 
-      WebMock.should have_requested(:post, "http://localhost:8529/_api/my/path").with :body => '{"name":"new_collection"}'
+  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" })]
     end
 
-    it "should send a put request" do
-      stub_request(:put, "http://localhost:8529/_api/my/path").with(:body => '{"name":"new_collection"}').to_return :body => '{ "name": "dude" }'
+    subject.send_request "my/path", :put => { :name => 'new_collection' }
 
-      subject.send_request "/my/path", :put => { :name => 'new_collection' }
+    request_stub.verify_stubbed_calls
+  end
 
-      WebMock.should have_requested(:put, "http://localhost:8529/_api/my/path").with :body => '{"name":"new_collection"}'
+  it "should send a delete request" do
+    request_stub.delete("/_api/my/path") do |request|
+      [200, response_headers, MultiJson.dump({ "name" => "dude" })]
     end
 
-    it "should send a delete request" do
-      stub_request(:delete, "http://localhost:8529/_api/my/path").to_return :body => '{ "name": "dude" }'
+    subject.send_request "my/path", :delete => { }
 
-      subject.send_request "/my/path", :delete => { }
+    request_stub.verify_stubbed_calls
+  end
 
-      WebMock.should have_requested(:delete, "http://localhost:8529/_api/my/path")
+  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" })]
     end
 
-    it "should parse JSON" do
-      stub_request(:get, "http://localhost:8529/_api/my/path").to_return :body => '{ "name": "dude" }'
+    subject.send_request("my/path", :post => { "test" => 1})
+    request_stub.verify_stubbed_calls
+  end
 
-      subject.send_request("/my/path").should == {"name" => "dude"}
+  it "should parse JSON response" do
+    request_stub.get("/_api/my/path") do
+      [200, response_headers, "{\"name\":\"dude\"}"]
     end
+
+    subject.send_request("my/path").should == {"name" => "dude"}
+    request_stub.verify_stubbed_calls
   end
 
   describe "authentication" do
-    subject { Ashikawa::Core::Connection.new }
-
-    it "should authenticate with username and password" do
-      subject.authenticate_with :username => "testuser", :password => "testpassword"
-
-      subject.username.should == "testuser"
-      subject.password.should == "testpassword"
-    end
-
     it "should have authentication turned off by default" do
       subject.authentication?.should be_false
     end
@@ -81,7 +83,7 @@ describe Ashikawa::Core::Connection do
       subject.authentication?.should be_true
     end
 
-    it "should only accept a username & password pairs" do
+    it "should only accept username & password pairs" do
       expect {
         subject.authenticate_with :username => "kitty"
       }.to raise_error(ArgumentError)
@@ -96,44 +98,142 @@ describe Ashikawa::Core::Connection do
     end
 
     it "should send the authentication data with every GET request" do
-      stub_request(:get, "http://user:pass@localhost:8529/_api/my/path").to_return :body => '{ "name": "dude" }'
+      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" })]
+      end
 
       subject.authenticate_with :username => "user", :password => "pass"
-      subject.send_request "/my/path"
+      subject.send_request "my/path"
 
-      WebMock.should have_requested(:get, "http://user:pass@localhost:8529/_api/my/path")
+      request_stub.verify_stubbed_calls
     end
   end
 
   describe "exception handling" do
-    subject { Ashikawa::Core::Connection.new }
+    it "should throw a general client error for I'm a teapot" do
+      request_stub.get("/_api/bad/request") do
+        [418, response_headers, ""]
+      end
+
+      expect do
+        subject.send_request("bad/request")
+      end.to raise_error(Ashikawa::Core::ClientError, /418/)
+
+      request_stub.verify_stubbed_calls
+    end
+
+    it "should throw its own exception when doing a bad request" do
+      request_stub.get("/_api/bad/request") do
+        [400, response_headers, ""]
+      end
+
+      expect do
+        subject.send_request("bad/request")
+      end.to raise_error(Ashikawa::Core::BadSyntax)
+
+      request_stub.verify_stubbed_calls
+    end
+
+    it "should throw a general server error for the generic server error" do
+      request_stub.get("/_api/bad/request") do
+        [500, response_headers, ""]
+      end
+
+      expect do
+        subject.send_request("bad/request")
+      end.to raise_error(Ashikawa::Core::ServerError, /500/)
+
+      request_stub.verify_stubbed_calls
+    end
 
     it "should raise an exception if a document is not found" do
-      stub_request(:get, "http://localhost:8529/_api/document/4590/333").to_return do
-        raise RestClient::ResourceNotFound
+      request_stub.get("/_api/document/4590/333") do
+        [404, response_headers, ""]
       end
-      expect { subject.send_request "/document/4590/333" }.to raise_error(Ashikawa::Core::DocumentNotFoundException)
+
+      expect { subject.send_request "document/4590/333" }.to raise_error(Ashikawa::Core::DocumentNotFoundException)
+
+      request_stub.verify_stubbed_calls
     end
 
     it "should raise an exception if a collection is not found" do
-      stub_request(:get, "http://localhost:8529/_api/collection/4590").to_return do
-        raise RestClient::ResourceNotFound
+      request_stub.get("/_api/collection/4590") do
+        [404, response_headers, ""]
       end
-      expect { subject.send_request "/collection/4590" }.to raise_error(Ashikawa::Core::CollectionNotFoundException)
+
+      expect { subject.send_request "collection/4590" }.to raise_error(Ashikawa::Core::CollectionNotFoundException)
+
+      request_stub.verify_stubbed_calls
     end
 
     it "should raise an exception if an index is not found" do
-      stub_request(:get, "http://localhost:8529/_api/index/4590/333").to_return do
-        raise RestClient::ResourceNotFound
+      request_stub.get("/_api/index/4590/333") do
+        [404, response_headers, ""]
       end
-      expect { subject.send_request "/index/4590/333" }.to raise_error(Ashikawa::Core::IndexNotFoundException)
+
+      expect { subject.send_request "index/4590/333" }.to raise_error(Ashikawa::Core::IndexNotFoundException)
+
+      request_stub.verify_stubbed_calls
     end
 
     it "should raise an exception for unknown pathes" do
-      stub_request(:get, "http://localhost:8529/_api/unknown_path/4590/333").to_return do
-        raise RestClient::ResourceNotFound
+      request_stub.get("/_api/unknown_path/4590/333") do
+        [404, response_headers, ""]
+      end
+
+      expect { subject.send_request "unknown_path/4590/333" }.to raise_error(Ashikawa::Core::ResourceNotFound)
+
+      request_stub.verify_stubbed_calls
+    end
+
+    it "should raise an error if a malformed JSON was returned from the server" do
+      request_stub.get("/_api/document/4590/333") do
+        [200, response_headers, "{\"a\":1"]
+      end
+
+      expect { subject.send_request "document/4590/333" }.to raise_error(Ashikawa::Core::JsonError)
+
+      request_stub.verify_stubbed_calls
+    end
+
+    it "should raise an error if the content type of the response is not JSON" do
+      request_stub.get("/_api/document/4590/333") do
+        [200, {"content-type" => "text/html; charset=utf-8"}, ""]
+      end
+
+      expect { subject.send_request "document/4590/333" }.to raise_error(Ashikawa::Core::JsonError)
+
+      request_stub.verify_stubbed_calls
+    end
+  end
+
+  describe "logging" do
+    let(:request_stub) { Faraday::Adapter::Test::Stubs.new }
+    let(:logger) { double }
+    subject {
+      Ashikawa::Core::Connection.new(ARANGO_HOST, :adapter => [:test, request_stub], :logger => logger)
+    }
+
+    it "should log a get request" do
+      request_stub.get("/_api/test") do
+        [200, response_headers, MultiJson.dump({:a => 1})]
+      end
+      logger.should_receive(:info).with("GET #{ARANGO_HOST}/_api/test ")
+      logger.should_receive(:info).with("200 {\"a\":1}")
+      subject.send_request("test")
+    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})]
       end
-      expect { subject.send_request "/unknown_path/4590/333" }.to raise_error(Ashikawa::Core::UnknownPath)
+      logger.should_receive(:info).with("POST #{ARANGO_HOST}/_api/test {:a=>2}")
+      logger.should_receive(:info).with("201 {\"b\":2}")
+      subject.send_request("test", :post => { :a => 2})
     end
   end
 end