vayacondios-server 0.2.11 → 0.3.0

data/spec/server/handlers/events_handler_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Vayacondios::Server::EventsHandler, behaves_like: 'handler' do
+  
+  let(:params)     { { organization: 'organization', topic: 'topic' } }
+  let(:query)      { { foo: 'bar' } }
+  let(:model_class){ Vayacondios::Server::Event }
+
+  context '#create' do
+    it 'raises a validation error' do
+      expect{ handler.create(params, query) }.to raise_error(validation_error, /create/)
+    end
+  end
+
+  context '#search', 'when events are found' do
+    it 'returns an array of events' do
+      model_class.should_receive(:search).with(params, query).and_call_original
+      driver.should_receive(:search).and_return([{ _id: 'abc123', _t: '2013-01-01T08:12:23.328Z', _d: { foo: 'bar' } }])
+      handler.search(params, query).should eq([
+                                               {
+                                                 id:   'abc123',
+                                                 time: '2013-01-01T08:12:23.328Z',
+                                                 foo:  'bar'
+                                               }
+                                              ])
+    end
+  end
+
+  context '#search', 'when no events are found' do
+    it 'returns an empty array' do
+      model_class.should_receive(:search).with(params, query).and_call_original
+      driver.should_receive(:search).and_return([])
+      handler.search(params, query).should eq([])
+    end
+  end
+
+  context '#update' do
+    it 'raises a validation error' do
+      expect{ handler.update(params, query) }.to raise_error(validation_error, /update/)
+    end
+  end
+
+  context '#delete' do
+    it 'returns a success response' do
+      model_class.should_receive(:destroy).with(params, query).and_call_original
+      driver.should_receive(:remove).and_return(true)
+      handler.delete(params, query).should eq(success_response)
+    end
+  end
+  
+end

data/spec/server/handlers/stash_handler_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Vayacondios::Server::StashHandler, behaves_like: 'handler' do
+
+  let(:params)     { { organization: 'organization', topic: 'topic' } }
+  let(:document)   { { foo: 'bar' } }
+  let(:model_class){ Vayacondios::Server::Stash }
+
+  context '#create' do
+    it 'returns the created stash' do
+      model_class.should_receive(:create).with(params, document).and_call_original
+      driver.should_receive(:insert).and_return(_id: 'topic', foo: 'bar')
+      handler.create(params, document).should eq(foo: 'bar')
+    end
+  end
+
+  context '#retrieve', 'when not found' do
+    it 'raises a validation error' do
+      driver.should_receive(:retrieve).and_return(nil)
+      expect{ handler.retrieve(params, {}) }.to raise_error(validation_error, /not found/)
+    end
+  end
+
+  context '#retrieve', 'when params have no id' do
+    it 'returns the selected record' do
+      model_class.should_receive(:find).with(params).and_call_original
+      driver.should_receive(:retrieve).and_return(_id: 'topic', id: { foo: 'bar' })
+      handler.retrieve(params, {}).should eq(id: { foo: 'bar' })
+    end
+  end
+  
+  context '#retrieve', 'when params have an id' do
+    let(:params){ { organization: 'organization', topic: 'topic', id: 'id' } }
+    
+    it 'returns the selected record sliced by id' do
+      model_class.should_receive(:find).with(params).and_call_original
+      driver.should_receive(:retrieve).and_return(_id: 'topic', id: { foo: 'bar' })
+      handler.retrieve(params, {}).should eq(foo: 'bar')
+    end
+
+    it 'raises a validation error when retrieved record does not have id as a key' do
+      driver.should_receive(:retrieve).and_return(_id: 'topic', id2: { foo: 'bar' })
+      expect{ handler.retrieve(params, {}) }.to raise_error(validation_error, /contain id/i)
+    end
+  end
+  
+  context '#update' do
+    it 'raises a validation error' do
+      expect{ handler.update(params, document) }.to raise_error(validation_error, /update/)
+    end
+  end
+  
+  context '#delete', 'when params have an id' do
+    let(:params){ { organization: 'organization', topic: 'topic', id: 'id' } }
+
+    it 'raises a validation error' do
+      expect{ handler.delete(params, {}) }.to raise_error(validation_error, /not supported/)
+    end
+  end
+    
+  context '#delete', 'when params do not have an id' do
+    it 'returns a success response' do
+      model_class.should_receive(:destroy).with(params, {}).and_call_original
+      driver.should_receive(:remove).and_return(true)
+      handler.delete(params, {}).should eq(success_response)
+    end
+  end
+end

data/spec/server/handlers/stashes_handler_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Vayacondios::Server::StashesHandler, behaves_like: 'handler' do
+
+  let(:params)     { { organization: 'organization', topic: 'topic' } }
+  let(:query)      { { foo: 'bar' } }
+  let(:model_class){ Vayacondios::Server::Stash }
+
+  context '#create' do
+    it 'raises a validation error' do
+      expect{ handler.create(params, query) }.to raise_error(validation_error, /create not allowed/)
+    end
+  end
+
+  context '#retrieve', 'when no stashes are found' do
+    it 'returns an empty array' do
+      model_class.should_receive(:search).with(params, query).and_call_original
+      driver.should_receive(:search).and_return([])
+      handler.retrieve(params, query).should eq([])
+    end
+  end
+
+  context '#retrieve', 'when stashes are found' do
+    it "returns the record found by the Stash model it delegates to" do
+      model_class.should_receive(:search).with(params, query).and_call_original
+      driver.should_receive(:search).and_return([{ _id: 'topic', foo: 'bar' }])
+      handler.retrieve(params, query).should eq([{ topic: 'topic', foo: 'bar' }])
+    end
+  end
+
+  context '#update' do
+    it 'raises a validation error' do
+      expect{ handler.update(params, query) }.to raise_error(validation_error, /update not allowed/)
+    end
+  end
+
+  context '#delete', 'with an empty query', focus: true do
+    it 'raises a validation error' do
+      expect{ handler.delete(params, {}) }.to  raise_error(validation_error, /empty/)
+    end
+  end
+
+  context '#delete', 'with a query', focus: true do
+    it 'returns a success response' do
+      model_class.should_receive(:destroy).with(params, query).and_call_original
+      driver.should_receive(:remove).and_return(true)
+      handler.delete(params, query).should eq(success_response)
+    end
+  end
+end

data/spec/server/handlers/stream_handler_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Vayacondios::Server::StreamHandler, behaves_like: 'handler' do
+  # FIX ME
+end

data/spec/server/models/document_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Vayacondios::Server::Document do
+  
+  let(:params){ { organization: 'organization', topic: 'topic' } }
+
+  subject(:document){ described_class.new(log, database, params) }
+
+end

data/spec/server/models/event_spec.rb

@@ -0,0 +1,185 @@
+require 'spec_helper'
+
+describe Vayacondios::Server::Event do
+
+  let(:params)        { { topic: 'topic', organization: 'organization', id: 'id' } }
+  let(:now)           { event.format_time Time.now }
+  let(:document_error){ Vayacondios::Server::Document::Error }
+
+  subject(:event){ described_class.receive params }
+  
+  its(:location){ should eq('organization.topic.events') }
+
+  context '#receive_topic' do
+    it 'sanitizes the topic' do
+      event.receive_topic '.foo$bar'
+      event.topic.should eq('_foo_bar')
+    end
+  end
+
+  context '#receive_time' do
+    it 'formats the time' do
+      event.receive_time '2014-01-23T15:29:19.412412-06:00'
+      event.time.should be_a(Time)
+      event.time.should be_utc
+    end
+  end
+
+  context '#to_timestamp', 'when argument is a string' do
+    it 'returns a time' do
+      event.to_timestamp('Aug 31').should be_a(Time)
+    end
+
+    it 'returns the default when there is parse error' do
+      default = now
+      event.to_timestamp('foobar', default).should be(default)
+    end
+  end
+
+  context '#to_timestamp', 'when argument is a date' do
+    it 'returns a time' do
+      event.to_timestamp(Date.today).should be_a(Time)
+    end
+  end
+
+  context '#to_timestamp', 'when argument is a time' do
+    it 'returns the time argument' do
+      t = now
+      event.to_timestamp(t).should be(t)
+    end
+  end
+
+  context '#to_timestamp', 'when argument is numeric' do
+    it 'returns a time' do
+      event.to_timestamp(1390513812).should be_a(Time)
+    end
+  end
+
+  context '#to_timestamp', 'when argument is anything else' do
+    it 'returns the default' do
+      default = now
+      event.to_timestamp(Object.new, default).should be(default)
+    end
+  end
+
+  context '#format_time' do
+    it 'converts all time to UTC' do
+      tokyo_time = now.getlocal('+09:00')
+      event.format_time(tokyo_time).should be_utc
+    end
+
+    it 'rounds all time to milliseconds' do
+      precise_time = Time.at(1390514371.671_238_912)
+      event.format_time(precise_time).nsec.should eq(671_000_000)
+    end
+  end
+
+  context '#document' do
+    it 'returns the internal representation of this Event' do
+      event.receive!(time: now, body: { foo: 'bar' })
+      event.document.should eq(_id: 'id',
+                               _t:  now,
+                               _d:  { foo: 'bar' })
+    end
+  end
+
+  context '#from_document' do
+    it 'updates the Event with the document' do
+      updated = event.from_document(_t: now, _d: { foo: 'bar' })
+      updated.id.should   eq('id')
+      updated.time.should eq(now)
+      updated.body.should eq(foo: 'bar')
+    end
+  end
+
+  context '#external_document' do
+    it 'returns the external representation of this Event' do
+      event.receive!(time: now, body: { foo: 'bar' })
+      event.external_document.should eq(id:   'id', 
+                                        time: now.iso8601(3),
+                                        foo:  'bar')
+    end
+  end
+
+  context '#event_filter' do
+    it 'handles :after as greater than' do
+      event.event_filter(after: now).should eq(_t: { gt: now })
+    end
+
+    it 'handles :from as greater than or equal to' do
+      event.event_filter(from: now).should eq(_t: { gte: now })
+    end
+
+    it 'prioritizes :after over :from' do
+      event.event_filter(after: now, from: now).should eq(_t: { gt: now })
+    end
+
+    it 'handles :before as less than' do
+      event.event_filter(before: now).should eq(_t: { lt: now })
+    end
+
+    it 'handles :upto as less than or equal to' do
+      event.event_filter(upto: now).should eq(_t: { lte: now })
+    end
+
+    it 'prioritizes :before over :upto' do
+      event.event_filter(before: now, upto: now).should eq(_t: { lt: now })
+    end
+
+    it 'merges extra keys as data matchers' do
+      event.event_filter(foo: 'bar', before: now).should eq(_t: { lt: now }, _d: { foo: 'bar' })
+    end
+  end
+
+  context '#prepare_search', focus: true do
+    it 'returns self for chaining' do
+      event.prepare_search({}).should be(event)
+    end
+
+    it 'creates a filter based on the query' do
+      prepared = event.prepare_search(foo: 'bar', before: now)
+      prepared.filter.should eq(_t: { lt: now }, _d: { foo: 'bar' })
+    end
+  end
+
+  context '#prepare_find', focus: true do
+    it 'returns self for chaining' do
+      event.prepare_find.should be(event)
+    end
+
+    it 'raises an error if it was not created with an id' do
+      event.write_attribute(:id, nil)
+      expect{ event.prepare_find }.to raise_error(document_error, /id/i)
+    end
+
+    it 'returns itself' do
+      event.prepare_find.document.should eq(_id: 'id')
+    end
+  end
+
+  context '#prepare_create', focus: true do
+    it 'returns self for chaining' do
+      event.prepare_create({}).should be(event)
+    end
+
+    it 'raises an error when given a non-Hash' do
+      expect{ subject.prepare_create([]) }.to raise_error(document_error, /Hash/)
+    end
+
+    it 'sets the time and body of the event' do
+      prepared = event.prepare_create(time: now, foo: 'bar')
+      prepared.document.should eq(_id: 'id', _t: now, _d: { foo: 'bar' })
+    end
+  end
+
+  context '#prepare_destroy', focus: true do
+    it 'returns self for chaining' do
+      event.prepare_destroy({}).should be(event)
+    end
+
+    it 'creates a filter based on the query' do
+      prepared = event.prepare_destroy(foo: 'bar', before: now)
+      prepared.filter.should eq(_t: { lt: now }, _d: { foo: 'bar' })
+    end
+  end
+end

data/spec/server/models/stash_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Vayacondios::Server::Stash, stashes: true do
+
+  let(:params)        { { topic: 'topic', organization: 'organization', id: 'id' } }
+  let(:document_error){ Vayacondios::Server::Document::Error }
+
+  subject(:stash){ described_class.receive params }
+
+  its(:location){ should eq('organization.stash') }
+
+  context '#document' do
+    it 'returns the internal representation of this stash' do
+      stash.receive!(body: { foo: 'bar' })
+      stash.document.should eq(_id: 'topic', foo: 'bar')
+    end
+  end
+
+  context '#from_document' do
+    it 'updates the stash with the document' do
+      updated = stash.from_document(_id: 'qix', foo: 'bar')
+      updated.document.should eq(_id: 'qix', foo: 'bar')
+    end
+  end
+
+  context '#external_document' do
+    it 'returns the external representation of this stash' do
+      stash.receive!(body: { foo: 'bar' })
+      stash.external_document.should eq(topic: 'topic', foo: 'bar')
+    end
+  end
+  
+  context '#prepare_search' do
+    it 'returns itself for chaining' do
+      stash.prepare_search({}).should be(stash)
+    end
+
+    it 'prepares a search filter' do
+      prepared = stash.prepare_search(foo: 'bar')
+      prepared.filter.should eq(_id: 'topic', foo: 'bar')
+    end
+  end
+
+  context '#prepare_create' do
+    it 'returns itself for chaining' do
+      stash.prepare_create({}).should be(stash)
+    end
+  end
+
+  context '#prepare_create', 'without an id' do
+    before(:each){ stash.write_attribute(:id, nil) }
+
+    it 'raises an error if document is not a Hash' do
+      expect{ stash.prepare_create([]) }.to raise_error(document_error, /hash/i)
+    end
+
+    it 'sets :body to be the document' do
+      prepared = stash.prepare_create(foo: 'bar')
+      prepared.body.should eq(foo: 'bar')
+    end
+  end
+
+  context '#prepare_create', 'with an id' do
+    it 'sets :body to be the document' do
+      prepared = stash.prepare_create(foo: 'bar')
+      prepared.body.should eq('id' => { foo: 'bar' })
+    end
+  end
+
+  context '#prepare_find' do
+    it 'returns itself for chaining' do
+      stash.prepare_find.should be(stash)
+    end
+
+    it 'raises an error if there is no topic' do
+      stash.write_attribute(:topic, nil)
+      expect{ stash.prepare_find }.to raise_error(document_error, /topic/)
+    end
+
+    it 'returns itself' do
+      stash.prepare_find.document.should eq(_id: 'topic')
+    end
+  end
+
+  context '#prepare_destroy' do
+    it 'returns itself for chaining' do
+      stash.prepare_destroy({}).should be(stash)
+    end
+
+    it 'prepares a delete filter' do
+      prepared = stash.prepare_destroy(foo: 'bar')
+      prepared.filter.should eq(_id: 'topic', foo: 'bar')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,7 +1,27 @@
-require 'bundler/setup' ; Bundler.require
-
-Dir["spec/support/**/*.rb"].each {|f| require File.join(File.dirname(__FILE__), '..', f) }
+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