ashikawa-core 0.6.0 → 0.7.0

data/spec/unit/cursor_spec.rb

@@ -10,31 +10,31 @@ describe Ashikawa::Core::Cursor do
   end
 
   it "should create a cursor for a non-complete batch" do
-    my_cursor = subject.new @database, server_response("/cursor/26011191")
-    my_cursor.id.should        == 26011191
+    my_cursor = subject.new @database, server_response("cursor/26011191")
+    my_cursor.id.should        == "26011191"
     my_cursor.length.should    == 5
   end
 
   it "should create a cursor for the last batch" do
-    my_cursor = subject.new @database, server_response("/cursor/26011191-3")
+    my_cursor = subject.new @database, server_response("cursor/26011191-3")
     my_cursor.id.should be_nil
     my_cursor.length.should == 5
   end
 
   describe "existing cursor" do
     subject { Ashikawa::Core::Cursor.new @database,
-      server_response("/cursor/26011191")
+      server_response("cursor/26011191")
     }
 
-    it "should iterate over all documents of a cursor" do
+    it "should iterate over all documents of a cursor when given a block" do
       first = true
 
-      @database.stub(:send_request).with("/cursor/26011191", :put => {}) do
+      @database.stub(:send_request).with("cursor/26011191", :put => {}) do
         if first
           first = false
-          server_response("/cursor/26011191-2")
+          server_response("cursor/26011191-2")
         else
-          server_response("/cursor/26011191-3")
+          server_response("cursor/26011191-3")
         end
       end
       @database.should_receive(:send_request).twice
@@ -45,9 +45,36 @@ describe Ashikawa::Core::Cursor do
       subject.each { |document| }
     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
+        if first
+          first = false
+          server_response("cursor/26011191-2")
+        else
+          server_response("cursor/26011191-3")
+        end
+      end
+      @database.should_receive(:send_request).twice
+
+      Ashikawa::Core::Document.stub(:new)
+      Ashikawa::Core::Document.should_receive(:new).exactly(5).times
+
+      enumerator = subject.each
+      enumerator.next
+      enumerator.next
+      enumerator.next
+      enumerator.next
+      enumerator.next
+      expect { enumerator.next }.to raise_exception(StopIteration)
+    end
+
     it "should be deletable" do
       @database.stub(:send_request)
-      @database.should_receive(:send_request).with("/cursor/26011191",
+      @database.should_receive(:send_request).with("cursor/26011191",
         :delete => {})
 
       subject.delete
@@ -56,12 +83,12 @@ describe Ashikawa::Core::Cursor do
     it "should be enumerable" do
       first = true
 
-      @database.stub(:send_request).with("/cursor/26011191", :put => {}) do
+      @database.stub(:send_request).with("cursor/26011191", :put => {}) do
         if first
           first = false
-          server_response("/cursor/26011191-2")
+          server_response("cursor/26011191-2")
         else
-          server_response("/cursor/26011191-3")
+          server_response("cursor/26011191-3")
         end
       end
       @database.should_receive(:send_request).twice

data/spec/unit/database_spec.rb

@@ -15,20 +15,78 @@ describe Ashikawa::Core::Database do
     @connection.stub(:host) { "localhost" }
     @connection.stub(:port) { 8529 }
 
-    database = subject.new @connection
+    database = subject.new do |config|
+      config.connection = @connection
+    end
     database.host.should == "localhost"
     database.port.should == 8529
   end
 
   it "should initialize with a connection string" do
-    Ashikawa::Core::Connection.stub(:new).with("http://localhost:8529").and_return(double())
-    Ashikawa::Core::Connection.should_receive(:new).with("http://localhost:8529")
+    Ashikawa::Core::Connection.stub(:new).with("http://localhost:8529", {
+      :logger => nil,
+      :adapter => nil
+    }).and_return(double())
+    Ashikawa::Core::Connection.should_receive(:new).with("http://localhost:8529", {
+      :logger => nil,
+      :adapter => nil
+    })
+
+    database = subject.new do |config|
+      config.url = "http://localhost:8529"
+    end
+  end
+
+  it "should initialize with a connection string and logger" do
+    logger = double
+    Ashikawa::Core::Connection.stub(:new).with("http://localhost:8529", {
+      :logger => logger,
+      :adapter => nil
+    }).and_return(double())
+    Ashikawa::Core::Connection.should_receive(:new).with("http://localhost:8529", {
+      :logger => logger,
+      :adapter => nil
+    })
+
+    database = subject.new do |config|
+      config.url = "http://localhost:8529"
+      config.logger = logger
+    end
+  end
 
-    database = subject.new "http://localhost:8529"
+  it "should initialize with a connection string and adapter" do
+    adapter = double
+    Ashikawa::Core::Connection.stub(:new).with("http://localhost:8529", {
+      :logger => nil,
+      :adapter => adapter
+    }).and_return(double())
+    Ashikawa::Core::Connection.should_receive(:new).with("http://localhost:8529", {
+      :logger => nil,
+      :adapter => adapter
+    })
+
+    database = subject.new do |config|
+      config.url = "http://localhost:8529"
+      config.adapter = adapter
+    end
+  end
+
+  it "should throw an argument error when neither url nor connection was provided" do
+    adapter = double
+    logger = double
+
+    expect {
+      database = subject.new do |config|
+        config.adapter = adapter
+        config.logger = logger
+      end
+    }.to raise_error(ArgumentError, /either an url or a connection/)
   end
 
   it "should create a query" do
-    database = subject.new @connection
+    database = subject.new do |config|
+      config.connection = @connection
+    end
 
     mock Ashikawa::Core::Query
     Ashikawa::Core::Query.stub(:new)
@@ -38,7 +96,10 @@ describe Ashikawa::Core::Database do
   end
 
   describe "initialized database" do
-    subject { Ashikawa::Core::Database.new @connection }
+    subject { Ashikawa::Core::Database.new do |config|
+        config.connection = @connection
+      end
+    }
 
     it "should delegate authentication to the connection" do
       @connection.should_receive(:authenticate_with).with({ :username => "user", :password => "password" })
@@ -48,44 +109,83 @@ describe Ashikawa::Core::Database do
 
     it "should fetch all available collections" do
       @connection.stub(:send_request) {|path| server_response("collections/all") }
-      @connection.should_receive(:send_request).with("/collection")
+      @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])
+      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])
 
       subject.collections.length.should == 2
     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",
+        :post => { :name => "volatile_collection"})
+
+      Ashikawa::Core::Collection.should_receive(:new).with(subject, server_response("collections/60768679"))
+
+      subject.create_collection("volatile_collection")
+    end
+
+    it "should create a volatile collection when asked" do
+      @connection.stub(:send_request) { |path| server_response("collections/60768679") }
+      @connection.should_receive(:send_request).with("collection",
+        :post => { :name => "volatile_collection", :isVolatile => true})
+
+      Ashikawa::Core::Collection.should_receive(:new).with(subject, server_response("collections/60768679"))
+
+      subject.create_collection("volatile_collection", :is_volatile => true)
+    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",
+        :post => { :name => "volatile_collection", :type => 3})
+
+      Ashikawa::Core::Collection.should_receive(:new).with(subject, server_response("collections/60768679"))
+
+      subject.create_collection("volatile_collection", :content_type => :edge)
+    end
+
     it "should fetch a single collection if it exists" do
-      @connection.stub(:send_request) { |path| server_response("collections/4588") }
-      @connection.should_receive(:send_request).with("/collection/4588")
+      @connection.stub(:send_request) { |path| server_response("collections/60768679") }
+      @connection.should_receive(:send_request).with("collection/60768679")
+
+      Ashikawa::Core::Collection.should_receive(:new).with(subject, server_response("collections/60768679"))
+
+      subject.collection(60768679)
+    end
+
+    it "should fetch a single collection with the array syntax" do
+      @connection.stub(:send_request) { |path| server_response("collections/60768679") }
+      @connection.should_receive(:send_request).with("collection/60768679")
 
-      Ashikawa::Core::Collection.should_receive(:new).with(subject, server_response("/collections/4588"))
+      Ashikawa::Core::Collection.should_receive(:new).with(subject, server_response("collections/60768679"))
 
-      subject[4588]
+      subject[60768679]
     end
 
     it "should create a single collection if it doesn't exist" do
       @connection.stub :send_request do |path, method|
         method ||= {}
         if method.has_key? :post
-          server_response("collections/4590")
+          server_response("collections/60768679")
         else
           raise Ashikawa::Core::CollectionNotFoundException
         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/new_collection")
+      @connection.should_receive(:send_request).with("collection", :post => { :name => "new_collection"} )
 
-      Ashikawa::Core::Collection.should_receive(:new).with(subject, server_response("collections/4590"))
+      Ashikawa::Core::Collection.should_receive(:new).with(subject, server_response("collections/60768679"))
 
       subject['new_collection']
     end
 
     it "should send a request via the connection object" do
-      @connection.should_receive(:send_request).with("/my/path", :post => { :data => "mydata" })
+      @connection.should_receive(:send_request).with("my/path", :post => { :data => "mydata" })
 
-      subject.send_request "/my/path", :post => { :data => "mydata" }
+      subject.send_request "my/path", :post => { :data => "mydata" }
     end
   end
 end

data/spec/unit/document_spec.rb

@@ -6,6 +6,7 @@ describe Ashikawa::Core::Document do
   let(:raw_data) {
     {
       "_id" => "1234567/2345678",
+      "_key" => "2345678",
       "_rev" => "3456789",
       "first_name" => "The",
       "last_name" => "Dude"
@@ -21,8 +22,9 @@ describe Ashikawa::Core::Document do
 
   it "should initialize data with ID" do
     document = subject.new database, raw_data
-    document.id.should == 2345678
-    document.revision.should == 3456789
+    document.id.should == "1234567/2345678"
+    document.key.should == "2345678"
+    document.revision.should == "3456789"
   end
 
   it "should initialize data without ID" do

data/spec/unit/edge_spec.rb

@@ -0,0 +1,54 @@
+require 'unit/spec_helper'
+require 'ashikawa-core/edge'
+
+describe Ashikawa::Core::Edge do
+  let(:database) { double() }
+  let(:raw_data) {
+    {
+      "_id" => "1234567/2345678",
+      "_key" => "2345678",
+      "_rev" => "3456789",
+      "_from" => "7848004/9289796",
+      "_to" => "7848004/9355332",
+      "first_name" => "The",
+      "last_name" => "Dude"
+    }
+  }
+  subject { Ashikawa::Core::Edge }
+
+  it "should initialize data" do
+    document = subject.new(database, raw_data)
+    document.id.should == "1234567/2345678"
+    document.key.should == "2345678"
+    document.revision.should == "3456789"
+  end
+
+  describe "initialized edge" do
+    subject { Ashikawa::Core::Edge.new(database, raw_data)}
+
+    it "should be deletable" do
+      database.should_receive(:send_request).with("edge/#{raw_data['_id']}",
+        { :delete => {} }
+      )
+
+      subject.delete
+    end
+
+    it "should store changes to the database" do
+      database.should_receive(:send_request).with("edge/#{raw_data['_id']}",
+        { :put => { "first_name" => "The", "last_name" => "Other" } }
+      )
+
+      subject["last_name"] = "Other"
+      subject.save
+    end
+
+    it "should know the ID of the 'from' document" do
+      subject.from_id.should == "7848004/9289796"
+    end
+
+    it "should know the ID of the 'to' document" do
+      subject.to_id.should == "7848004/9355332"
+    end
+  end
+end

data/spec/unit/exception_spec.rb

@@ -1,8 +1,36 @@
-require "ashikawa-core/exceptions/document_not_found"
-require "ashikawa-core/exceptions/collection_not_found"
-require "ashikawa-core/exceptions/index_not_found"
 require "ashikawa-core/exceptions/no_collection_provided"
-require "ashikawa-core/exceptions/unknown_path"
+require "ashikawa-core/exceptions/client_error"
+require "ashikawa-core/exceptions/client_error/bad_syntax"
+require "ashikawa-core/exceptions/client_error/resource_not_found"
+require "ashikawa-core/exceptions/client_error/resource_not_found/document_not_found"
+require "ashikawa-core/exceptions/client_error/resource_not_found/collection_not_found"
+require "ashikawa-core/exceptions/client_error/resource_not_found/index_not_found"
+require "ashikawa-core/exceptions/server_error"
+require "ashikawa-core/exceptions/server_error/json_error"
+
+describe Ashikawa::Core::NoCollectionProvidedException do
+  it "should have a good explanation" do
+    subject.to_s.should include "without a collection"
+  end
+end
+
+describe Ashikawa::Core::ClientError do
+  it "should have a good explanation" do
+    Ashikawa::Core::ClientError.new(411).to_s.should include "client"
+  end
+end
+
+describe Ashikawa::Core::BadSyntax do
+  it "should have a good explanation" do
+    subject.to_s.should include "syntax"
+  end
+end
+
+describe Ashikawa::Core::ResourceNotFound do
+  it "should have a good explanation" do
+    subject.to_s.should include "was not found"
+  end
+end
 
 describe Ashikawa::Core::DocumentNotFoundException do
   it "should have a good explanation" do
@@ -22,14 +50,14 @@ describe Ashikawa::Core::IndexNotFoundException do
   end
 end
 
-describe Ashikawa::Core::NoCollectionProvidedException do
+describe Ashikawa::Core::ServerError do
   it "should have a good explanation" do
-    subject.to_s.should include "without a collection"
+    Ashikawa::Core::ServerError.new(511).to_s.should include "server"
   end
 end
 
-describe Ashikawa::Core::UnknownPath do
+describe Ashikawa::Core::JsonError do
   it "should have a good explanation" do
-    subject.to_s.should include "path is unknown"
+    subject.to_s.should include "JSON from the server"
   end
 end

data/spec/unit/figure_spec.rb

@@ -3,26 +3,52 @@ require "ashikawa-core/figure"
 describe Ashikawa::Core::Figure do
   let(:raw_figures) {
     {
-      "datafiles" => {
-        "count" => 1
-      },
       "alive" => {
         "size" => 0,
         "count" => 0
       },
       "dead" => {
         "size" => 2384,
-        "count" => 149
+        "count" => 149,
+        "deletion" => 0
+      },
+      "datafiles" => {
+        "count" => 1,
+        "fileSize" => 124
+      },
+      "journals" => {
+        "count" => 1,
+        "fileSize" => 124
+      },
+      "shapes" => {
+        "count" => 2
       }
     }
   }
-  subject { Ashikawa::Core::Figure.new raw_figures }
+  subject { Ashikawa::Core::Figure.new(raw_figures) }
+
+  it "should check for the alive figures" do
+      subject.alive_size.should == 0
+      subject.alive_count.should == 0
+  end
+
+  it "should check for the dead figures" do
+      subject.dead_size.should == 2384
+      subject.dead_count.should == 149
+      subject.dead_deletion.should == 0
+  end
+
+  it "should check for the datafiles figures" do
+      subject.datafiles_count.should == 1
+      subject.datafiles_file_size.should == 124
+  end
+
+  it "should check for the journal figures" do
+      subject.journals_count.should == 1
+      subject.journals_file_size.should == 124
+  end
 
-  it "should check for the figures" do
-    subject.datafiles_count.should == 1
-    subject.alive_size.should == 0
-    subject.alive_count.should == 0
-    subject.dead_size.should == 2384
-    subject.dead_count.should == 149
+  it "should check for the shapes figure" do
+      subject.shapes_count.should == 2
   end
 end