vayacondios-client 0.2.11 → 0.3.0

data/spec/client/http_client_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+describe Vayacondios::Client::HttpClient do
+
+  let(:http_connection){ double :http }
+  let(:hash_event)     { { foo: 'bar' } }
+  subject(:http_client){ described_class.new(organization: 'organization') }
+  
+  def expect_query(verb, &assertions)
+    subject.http_connection.should_receive(verb) do |path, &blk|
+      request = double :request
+      assertions.call(path, request)
+      blk.call(request) unless blk.nil?
+    end
+  end
+
+  context '#initialize' do
+    it 'allows to customize the connection' do
+      http_client = described_class.new(host: 'foo.com')
+      http_client.http_connection.url_prefix.host.should eq('foo.com')
+    end
+  end
+
+  context '#announce', 'without an ID' do
+    it 'constructs a POST request to /v3/organization/event/topic with the Event as the body' do
+      expect_query(:post) do |path, req|
+        path.should eq('organization/event/topic')
+        req.should_receive(:body=).with(hash_event)
+      end
+      http_client.announce('topic', hash_event)
+    end
+  end
+  
+  context '#announce', 'with an ID' do
+    it 'constructs a POST request to /v3/organization/event/topic/id with the Event as the body' do
+      expect_query(:post) do |path, req|
+        path.should eq('organization/event/topic/id')
+        req.should_receive(:body=).with(hash_event)
+      end
+      http_client.announce('topic', hash_event, 'id')
+    end
+  end
+  
+  context '#events', 'without a query' do
+    it 'constructs a GET request to /v3/organization/events/topic' do
+      expect_query(:get) do |path, req|
+        path.should eq('organization/events/topic')
+        req.should_receive(:body=).with({})
+      end
+      http_client.events 'topic'
+    end
+  end
+    
+  context '#events', 'with a query' do
+    let(:query){ { foo: 'bar' } }
+
+    it 'constructs a GET request to /v3/organization/events/topic with the query as the body' do
+      expect_query(:get) do |path, req|
+        path.should eq('organization/events/topic')
+        req.should_receive(:body=).with(query)
+      end
+      subject.events('topic', query)
+    end
+  end
+  
+  context '#get', 'without an ID' do
+    it 'constructs a GET request to /v3/organization/stash/topic' do
+      expect_query(:get) do |path, req|
+        path.should eq('organization/stash/topic')
+      end
+      subject.get 'topic'
+    end
+  end
+  
+  context '#get', 'with an ID' do
+    it 'constructs a GET request to /v3/organization/stash/topic/id' do
+      expect_query(:get) do |path, req|
+        path.should eq('organization/stash/topic/id')
+      end
+      subject.get('topic', 'id')
+    end
+  end
+
+  context '#get_many', 'without a query' do
+    it 'sends a GET request to /v3/organization/stashes' do
+      expect_query(:get) do |path, req|
+        path.should eq('organization/stashes')
+        req.should_receive(:body=).with({})
+      end
+      subject.get_many
+    end
+  end
+    
+  context '#get_many', 'with a query' do
+    let(:query){ { foo: 'bar' } }
+
+    it 'constructs a GET request to /v3/organization/stashes with the query as the body' do
+      expect_query(:get) do |path, req|
+        path.should eq('organization/stashes')
+        req.should_receive(:body=).with(query)
+      end
+      subject.get_many query
+    end
+  end
+  
+  context '#set', 'without an ID' do
+    let(:stash){ { foo: 'bar' } }
+
+    it 'constructs a PUT request to /v3/organization/stash/topic with the Stash as the body' do
+      expect_query(:post) do |path, req|
+        path.should eq('organization/stash/topic')
+        req.should_receive(:body=).with(stash)
+      end
+      subject.set('topic', nil, stash)
+    end
+  end
+
+  context '#set', 'with an ID' do
+    let(:stash){ { foo: 'bar' } }
+
+    it 'constructs a PUT request to /v3/organization/stash/topic/id with the Stash as the body' do
+      expect_query(:post) do |path, req|
+        path.should eq('organization/stash/topic/id')
+        req.should_receive(:body=).with(stash)
+      end
+      subject.set('topic', 'id', stash)
+    end
+  end
+  
+  context '#unset', 'without an ID' do
+    it 'constructs a DELETE request to /v3/organization/stash/topic' do
+      expect_query(:delete) do |path, req|
+        path.should eq('organization/stash/topic')
+      end
+      subject.unset 'topic'
+    end
+  end
+  
+  context '#unset_many' do
+    let(:query){ { foo: 'bar' } }
+
+    it 'constructs a DELETE request to /v3/organization/stashes with the query' do
+      expect_query(:delete) do |path, req|
+        path.should eq('organization/stashes')
+        req.should_receive(:body=).with(query)
+      end
+      subject.unset_many query
+    end
+  end
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Vayacondios::Configuration do
+
+  def change_defaults new_defaults
+    subject.define_singleton_method(:defaults) do
+      new_defaults
+    end
+  end
+
+  context '#defaults' do
+    it 'defines defaults' do
+      subject.defaults.should eq(Hash.new)
+    end
+  end
+
+  context '#resolved_settings' do
+    it 'resolves settings automatically when accessed' do
+      subject.should_not be_resolved
+      subject.resolved_settings.should eq(Hash.new)
+      subject.should be_resolved
+    end
+  end
+
+  context '#overlay' do
+    before{ change_defaults(foo: 'bar', baz: 'qix') }
+
+    it 'allows a top-level override of settings' do
+      subject.overlay(foo: 'override')
+      subject.resolved_settings.should eq(foo: 'override', baz: 'qix')
+    end
+  end
+
+  context '#[]' do
+    before{ change_defaults(foo: 'bar') }
+
+    it 'allows access to the resolved_settings' do      
+      subject[:foo].should eq('bar')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+require 'bundler/setup' ; Bundler.require(:test)
+
+require 'goliath/test_helper'
+require 'mongo'
+
+if ENV['VAYACONDIOS_COV']
+  require 'simplecov'
+  SimpleCov.start do
+    add_group 'Library', 'lib/'
+    add_group 'Test',    '(spec|features)/'
+  end
+end
+
+WITH_MONGO = ENV['WITH_MONGO']
+
+require 'vayacondios-server'
+require 'vayacondios-client'
+
+Dir[File.expand_path('../support/**/*.rb', __FILE__)].each{ |f| require f }
+
+Goliath.env = :test
+
+require 'vayacondios/server/api'
+
+RSpec.configure do |c|
+  c.include Goliath::TestHelper
+end

data/spec/support/database_helper.rb

@@ -0,0 +1,42 @@
+module DatabaseHelper
+
+  def insert_record(index, document)
+    # mongo only
+    db_query(index){ |db| db.connection.insert(document) }
+  end
+
+  def database_count index
+    # mongo only
+    db_query(index){ |db| db.connection.count }
+  end
+
+  def retrieve_record(index, filter = {})
+    # mongo only
+    db_query(index){ |db| db.connection.find_one(filter) }
+  end
+
+  def db_connection
+    return @db_connection if @db_connection
+    settings = Vayacondios::Server::DbConfig.env :test
+    driver = Vayacondios::Server::Driver.retrieve settings[:driver]
+    @db_connection = driver.connect settings.merge(log: log)
+  end
+
+  def db_locations    
+    @locations ||= [ "organization.topic.events", "organization.stash" ]
+  end
+  
+  def db_query(location, &blk)
+    db_connection.set_location location
+    db_locations << location
+    result = blk.call db_connection
+    db_connection.unset_location
+    result
+  end
+
+  def db_reset!
+    db_locations.uniq.each do |location|
+      db_query(location){ |db| EM::Synchrony.sync db.reset! }
+    end
+  end
+end

data/spec/support/log_helper.rb

@@ -0,0 +1,19 @@
+require 'logger'
+
+module LogHelper
+
+  def log
+    @logdev = StringIO.new
+    Logger.new @logdev
+  end
+
+  def log_device
+    @logdev
+  end
+
+  def log_content
+    log_device.rewind
+    log_device.read
+  end
+  
+end

data/spec/support/shared_context_for_events.rb

@@ -0,0 +1,22 @@
+shared_context 'events', events: true do
+  let(:nil_event)                    { nil }
+  let(:json_nil_event)               { 'null' }
+  let(:hash_event)                   { { 'foo' => 'bar'} }
+  let(:json_hash_event)              { '{"foo":"bar"}' }
+  let(:array_event)                  { [1, 2, 3] }
+  let(:json_array_event)             { '[1,2,3]' }
+  let(:string_event)                 { 'HELLO' }
+  let(:json_string_event)            { '"HELLO"' }
+  let(:numeric_event)                { 1 }
+  let(:json_numeric_event)           { '1' }
+  let(:nested_event)                 { { 'A' => 1, 'B' => { 'c' => 2, 'd' => 3 } } }
+  let(:json_nested_event)            { MultiJson.dump(nested_event) }  
+  let(:event_query)                  { { 'foo' => 'bar' } }
+  let(:json_event_query)             { MultiJson.dump(event_query) }  
+  let(:event_query_with_sort)        { { 'foo' => 'bar', 'sort' => %w[ bing descending ] } }
+  let(:event_query_with_limit)       { { 'foo' => 'bar', 'limit' => 10 } }
+  let(:event_query_with_fields)      { { 'foo' => 'bar', 'fields' => %w[ bing bam ] } }
+  let(:event_query_with_string_time) { { 'foo' => 'bar', 'from' => '2013-06-08 01:19:15 -0500' } }
+  let(:event_query_with_int_time)    { { 'foo' => 'bar', 'from' => 1370672418 } }
+  let(:event_query_with_id)          { { 'foo' => 'bar', 'id' => 'baz' } }
+end

data/spec/support/shared_context_for_stashes.rb

@@ -0,0 +1,24 @@
+shared_context 'stashes', stashes: true do
+  let(:nil_stash)               { nil }
+  let(:json_nil_stash)          { 'null' }
+  let(:hash_stash)              { { 'foo' => 'bar' } }
+  let(:json_hash_stash)         { '{"foo":"bar"}' }
+  let(:array_stash)             { [1, 2, 3] }
+  let(:json_array_stash)        { '[1,2,3]' }
+  let(:string_stash)            { 'HELLO' }
+  let(:json_string_stash)       { '"HELLO"' }
+  let(:numeric_stash)           { 1 }
+  let(:json_numeric_stash)      { '1' }
+  let(:nested_stash)            { { 'root' => { 'b' => 2, 'c' => { 'x' => 3 }, 'a' => 1 } } }
+  let(:stash_query)             { { 'foo' => 'bar' } }
+  let(:json_stash_query)        { MultiJson.dump(stash_query) }
+  let(:nested_stash_query)      { { 'root.b' => 2 } }
+  let(:json_nested_stash_query) { MultiJson.dump(nested_stash_query) }
+  let(:stash_query_with_limit)  { { 'foo' => 'bar', 'limit' => 10 } }
+  let(:stash_query_with_sort)   { { 'foo' => 'bar', 'sort'  => %w[ bar ascending ] } }
+  let(:stash_query_with_topic)  { { 'foo' => 'bar', 'topic' => 'baz' } }
+  let(:stash_replacement)       { { 'foo' => 'baz' } }
+  let(:json_stash_replacement)  { '{"foo":"baz"}' }
+  let(:stash_update)            { { 'counter' => 1 } }
+  let(:json_stash_update)       { '{"counter":1}' }
+end

data/spec/support/shared_examples_for_handlers.rb

@@ -0,0 +1,32 @@
+shared_examples 'handlers', behaves_like: 'handler' do
+  include LogHelper
+
+  let!(:driver) do
+    db = Class.new{ include Vayacondios::Server::Driver }.new
+    db.set_log log
+    db
+  end
+
+  def validation_error
+    Goliath::Validation::Error
+  end
+
+  def success_response
+    handler.action_successful
+  end
+
+  subject(:handler){ described_class.new(log, driver) }
+
+  it{ should respond_to(:log) }
+  it{ should respond_to(:database) }
+
+  its(:action_successful){ should eq(ok: true) }
+  
+  context '#call' do
+    it 'calls base methods for logging before delegating' do
+      handler.log.should_receive(:debug).at_least(1).times
+      handler.should_receive(:create).with({}, {})
+      handler.call(:create, {}, {})
+    end
+  end
+end