ashikawa-core 0.1

data/spec/integration/spec_helper.rb

@@ -0,0 +1,34 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require "rest-client"
+require "json"
+require "ashikawa-core"
+
+RSpec.configure do |config|
+  raise "Could not find arangod. Please install it or check if it is in your path." if `which arangod` == ""
+  
+  database_directory = "/tmp/ashikawa-integration"
+  arango_process = false
+  
+  config.before(:suite) do
+    puts "Starting ArangoDB"
+    process_id = $$
+    
+    Dir.mkdir database_directory unless Dir.exists? database_directory
+    arango_process = IO.popen("arangod #{database_directory} --watch-process #{process_id}")
+    
+    sleep 2 # Wait for Arango to start up
+  end
+  
+  config.after(:suite) do
+    puts
+    puts "Shutting down ArangoDB"
+    
+    Process.kill "INT", arango_process.pid
+    sleep 2  # Wait for Arango to shut down
+    arango_process.close
+    
+    `rm -r #{database_directory}/*`
+  end
+end

data/spec/unit/collection_spec.rb

@@ -0,0 +1,228 @@
+require 'unit/spec_helper'
+require 'ashikawa-core/collection'
+
+describe Ashikawa::Core::Collection do
+  subject { Ashikawa::Core::Collection }
+  
+  before :each do
+    @database = double()
+  end
+  
+  it "should have a name" do
+    my_collection = subject.new @database, server_response("/collections/4588")
+    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
+  end
+  
+  describe "the status code" do
+    it "should know if the collection is new born" do
+      my_collection = subject.new @database, { "status" => "1" }
+      my_collection.new_born?.should == true
+    
+      my_collection = subject.new @database, { "status" => "200" }
+      my_collection.new_born?.should == false
+    end
+  
+    it "should know if the collection is unloaded" do
+      my_collection = subject.new @database, { "status" => "2" }
+      my_collection.unloaded?.should == true
+    
+      my_collection = subject.new @database, { "status" => "200" }
+      my_collection.unloaded?.should == false
+    end
+  
+    it "should know if the collection is loaded" do
+      my_collection = subject.new @database, { "status" => "3" }
+      my_collection.loaded?.should == true
+    
+      my_collection = subject.new @database, { "status" => "200" }
+      my_collection.loaded?.should == false
+    end
+  
+    it "should know if the collection is being unloaded" do
+      my_collection = subject.new @database, { "status" => "4" }
+      my_collection.being_unloaded?.should == true
+    
+      my_collection = subject.new @database, { "status" => "200" }
+      my_collection.being_unloaded?.should == false
+    end
+    
+    it "should know if the collection is corrupted" do
+      my_collection = subject.new @database, { "status" => "6" }
+      my_collection.corrupted?.should == true
+    end
+  end
+  
+  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")
+      
+      my_collection = subject.new @database, { "id" => "4590" }
+      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")
+      
+      my_collection = subject.new @database, { "id" => "4590" }
+      my_collection.length.should == 54
+    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")
+      
+      my_collection = subject.new @database, { "id" => "73482" }
+      my_collection.figure(:datafiles_count).should == 1
+      my_collection.figure(:alive_size).should == 0
+      my_collection.figure(:alive_count).should == 0
+      my_collection.figure(:dead_size).should == 2384
+      my_collection.figure(:dead_count).should == 149      
+    end
+  end
+  
+  describe "an initialized collection" do
+    subject { Ashikawa::Core::Collection.new @database, { "id" => "4590", "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: {})
+      
+      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: {})
+      
+      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: {})
+      
+      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: {})
+      
+      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})
+     
+      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"})
+      
+      subject.name = "my_new_name"
+    end
+    
+    describe "working with documents" do
+      
+      describe "list all" do
+        it "should list all documents" do
+          @database.stub(:send_request).with("/simple/all", put: {"collection" => "example_1"}).and_return { server_response('simple-queries/all') }
+          @database.should_receive(:send_request).with("/simple/all", put: {"collection" => "example_1"})
+      
+          # Documents need to get initialized:
+          Ashikawa::Core::Document.should_receive(:new).with("12345/57463", 57463)
+          Ashikawa::Core::Document.should_receive(:new).with("12346/3872", 3872)
+      
+          subject.all
+        end
+      
+        it "should limit to a certain amount" do
+          @database.stub(:send_request).with("/simple/all", put: {"collection" => "example_1", "limit" => 1}).and_return { server_response('simple-queries/all_skip') }
+          @database.should_receive(:send_request).with("/simple/all", put: {"collection" => "example_1", "limit" => 1})
+      
+          Ashikawa::Core::Document.should_receive(:new).with("12346/3872", 3872)
+      
+          subject.all :limit => 1
+        end
+      
+        it "should skip documents" do
+          @database.stub(:send_request).with("/simple/all", put: {"collection" => "example_1", "skip" => 1}).and_return { server_response('simple-queries/all_limit') }
+          @database.should_receive(:send_request).with("/simple/all", put: {"collection" => "example_1", "skip" => 1})
+      
+          Ashikawa::Core::Document.should_receive(:new).with("12345/57463", 57463)
+      
+          subject.all :skip => 1
+        end
+      end
+      
+      describe "by example" do
+        before(:each) do
+          @search_params = { :hello => "world" }
+        end
+        
+        it "should find documents by example" do
+          @database.stub(:send_request).with("/simple/by-example", put: {"collection" => "example_1", "example" => { :hello => "world"}}).and_return { server_response('simple-queries/example') }
+          @database.should_receive(:send_request).with("/simple/by-example", put: {"collection" => "example_1", "example" => { :hello => "world"}})
+        
+          Ashikawa::Core::Document.should_receive(:new).with("12345/57463", 57463)
+        
+          subject.by_example(@search_params)
+        end
+        
+        it "should skip documents" do
+          @database.stub(:send_request).with("/simple/by-example", put: {"collection" => "example_1", "skip" => 1, "example" => { :hello => "world"}}).and_return { server_response('simple-queries/example') }
+          @database.should_receive(:send_request).with("/simple/by-example", put: {"collection" => "example_1", "skip" => 1, "example" => { :hello => "world"}})
+        
+          Ashikawa::Core::Document.should_receive(:new).with("12345/57463", 57463)
+      
+          subject.by_example @search_params, :skip => 1
+        end
+        
+        it "should limit documents" do
+          @database.stub(:send_request).with("/simple/by-example", put: {"collection" => "example_1", "limit" => 2, "example" => { :hello => "world"}}).and_return { server_response('simple-queries/example') }
+          @database.should_receive(:send_request).with("/simple/by-example", put: {"collection" => "example_1", "limit" => 2, "example" => { :hello => "world"}})
+        
+          Ashikawa::Core::Document.should_receive(:new).with("12345/57463", 57463)
+      
+          subject.by_example @search_params, :limit => 2
+        end
+        
+      end
+
+      describe "near" do
+        it "should look for documents based on latitude/longitude" do
+          @database.stub(:send_request).with("/simple/near", put: { "collection" => "example_1", "latitude" => 0, "longitude" => 0 }).and_return { server_response('simple-queries/near') }
+          @database.should_receive(:send_request).with("/simple/near", put: { "collection" => "example_1", "latitude" => 0, "longitude" => 0 })
+
+          Ashikawa::Core::Document.should_receive(:new).with("12345/57463", 57463)
+          Ashikawa::Core::Document.should_receive(:new).with("12346/2938", 2938)
+          Ashikawa::Core::Document.should_receive(:new).with("12347/23737", 23737)
+
+          subject.near :latitude => 0, :longitude => 0
+        end
+      end
+
+      describe "within" do
+        it "should look for documents within a certain radius" do
+          @database.stub(:send_request).with("/simple/within", put: { "collection" => "example_1", "latitude" => 0, "longitude" => 0, "radius" => 2 }).and_return { server_response('simple-queries/within') }
+          @database.should_receive(:send_request).with("/simple/within" , put: { "collection" => "example_1", "latitude" => 0, "longitude" => 0, "radius" => 2 })
+
+          Ashikawa::Core::Document.should_receive(:new).with("12345/57463", 57463)
+
+          subject.within :latitude => 0, :longitude => 0, :radius => 2
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/connection_spec.rb

@@ -0,0 +1,55 @@
+require 'unit/spec_helper'
+require 'ashikawa-core/connection'
+
+describe Ashikawa::Core::Connection do
+  subject { Ashikawa::Core::Connection }
+  
+  it "should have an IP and port" do
+    connection = subject.new "http://localhost:8529"
+    
+    connection.ip.should == "http://localhost"
+    connection.port.should == 8529
+  end
+  
+  describe "initialized connection" do
+    subject { Ashikawa::Core::Connection.new "http://localhost:8529" }
+    
+    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"
+      
+      WebMock.should have_requested(:get, "http://localhost:8529/_api/my/path")
+    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' }
+      
+      WebMock.should have_requested(:post, "http://localhost:8529/_api/my/path").with :body => '{"name":"new_collection"}'
+    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' }
+      
+      WebMock.should have_requested(:put, "http://localhost:8529/_api/my/path").with :body => '{"name":"new_collection"}'
+    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: { }
+      
+      WebMock.should have_requested(:delete, "http://localhost:8529/_api/my/path")
+    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").should == {"name" => "dude"}
+    end
+  end
+end

data/spec/unit/database_spec.rb

@@ -0,0 +1,73 @@
+require 'unit/spec_helper'
+require 'ashikawa-core/database'
+
+describe Ashikawa::Core::Database do
+  subject { Ashikawa::Core::Database }
+  
+  before :each do
+    mock(Ashikawa::Core::Connection)
+    mock(Ashikawa::Core::Collection)
+    @connection = double()
+  end
+  
+  it "should initialize with a connection" do
+    @connection.stub(:ip) { "http://localhost" }
+    @connection.stub(:port) { 8529 }
+    
+    database = subject.new @connection
+    database.ip.should == "http://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")
+    
+    database = subject.new "http://localhost:8529"
+  end
+  
+  describe "initialized database" do
+    subject { Ashikawa::Core::Database.new @connection }
+    
+    it "should fetch all available 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])
+      
+      subject.collections.length.should == 2
+    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")
+      
+      Ashikawa::Core::Collection.should_receive(:new).with(subject, server_response("/collections/4588"))
+      
+      subject[4588]
+    end
+    
+    it "should create a single collection if it doesn't exist" do
+      @connection.stub :send_request do |path, method = {}|
+        if method.has_key? :post
+          server_response("collections/4590")
+        else
+          raise RestClient::ResourceNotFound
+        end
+      end
+      @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"))
+      
+      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" })
+      
+      subject.send_request "/my/path", post: { data: "mydata" }
+    end
+  end
+end

data/spec/unit/document_spec.rb

@@ -0,0 +1,13 @@
+require 'unit/spec_helper'
+require 'ashikawa-core/document'
+
+describe Ashikawa::Core::Document do
+  subject { Ashikawa::Core::Document }
+    
+  it "should initialize with an id and revision" do 
+    document = subject.new "189990/1631782", 1631782
+    document.id.should == "189990/1631782"
+    document.revision.should == 1631782
+  end
+  
+end

data/spec/unit/spec_helper.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+# For HTTP Testing
+require 'webmock/rspec'
+require 'json'
+
+# Helper to simulate Server Responses. Parses the fixtures in the spec folder
+def server_response(path)
+  return JSON.parse(File.readlines("spec/fixtures/#{path}.json").join)
+end

metadata

@@ -0,0 +1,199 @@
+--- !ruby/object:Gem::Specification
+name: ashikawa-core
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- moonglum
+- EinLama
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.7
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.11.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.11.0
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.2.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.2.1
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.9
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.9
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.1
+description: Ashikawa Core is a Wrapper around the ArangoDB Rest API. It provides
+  low level access and will be used in different ArangoDB ODMs.
+email:
+- me@moonglum.net
+- tobias.eilert@me.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- ashikawa-core.gemspec
+- lib/ashikawa-core.rb
+- lib/ashikawa-core/collection.rb
+- lib/ashikawa-core/connection.rb
+- lib/ashikawa-core/database.rb
+- lib/ashikawa-core/document.rb
+- lib/ashikawa-core/version.rb
+- spec/fixtures/collections/4588.json
+- spec/fixtures/collections/4590-properties.json
+- spec/fixtures/collections/4590.json
+- spec/fixtures/collections/73482-figures.json
+- spec/fixtures/collections/all.json
+- spec/fixtures/collections/not_found.json
+- spec/fixtures/documents/4590-333.json
+- spec/fixtures/simple-queries/all.json
+- spec/fixtures/simple-queries/all_limit.json
+- spec/fixtures/simple-queries/all_skip.json
+- spec/fixtures/simple-queries/example.json
+- spec/fixtures/simple-queries/near.json
+- spec/fixtures/simple-queries/within.json
+- spec/integration/basic_spec.rb
+- spec/integration/spec_helper.rb
+- spec/unit/collection_spec.rb
+- spec/unit/connection_spec.rb
+- spec/unit/database_spec.rb
+- spec/unit/document_spec.rb
+- spec/unit/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- ArangoDB
+rubyforge_project: ashikawa-core
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Ashikawa Core is a Wrapper around the ArangoDB Rest API
+test_files:
+- spec/fixtures/collections/4588.json
+- spec/fixtures/collections/4590-properties.json
+- spec/fixtures/collections/4590.json
+- spec/fixtures/collections/73482-figures.json
+- spec/fixtures/collections/all.json
+- spec/fixtures/collections/not_found.json
+- spec/fixtures/documents/4590-333.json
+- spec/fixtures/simple-queries/all.json
+- spec/fixtures/simple-queries/all_limit.json
+- spec/fixtures/simple-queries/all_skip.json
+- spec/fixtures/simple-queries/example.json
+- spec/fixtures/simple-queries/near.json
+- spec/fixtures/simple-queries/within.json
+- spec/integration/basic_spec.rb
+- spec/integration/spec_helper.rb
+- spec/unit/collection_spec.rb
+- spec/unit/connection_spec.rb
+- spec/unit/database_spec.rb
+- spec/unit/document_spec.rb
+- spec/unit/spec_helper.rb
+has_rdoc: