vayacondios-server 0.2.11 → 0.3.0

data/pom.xml

@@ -4,17 +4,99 @@
   <groupId>com.infochimps</groupId>
   <artifactId>vayacondios</artifactId>
   <packaging>jar</packaging>
-<!-- ICSVERS --><version>1.7.0-SNAPSHOT</version>
-  <name>java-common</name>
+  <version>2.0.0-LESLIE</version>
+  <name>Vayacondios</name>
   <url>http://maven.apache.org</url>
 
   <parent>
     <groupId>com.infochimps</groupId>
     <artifactId>parent-pom</artifactId>
-<!-- ICSVERS --><version>1.7.0-SNAPSHOT</version>
-    <relativePath></relativePath>
+    <version>1.0.0-SNAPSHOT</version>
   </parent>
 
+  <reporting>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-javadoc-plugin</artifactId>
+        <version>2.9</version>
+        <configuration>
+	  <show>public</show>
+        </configuration>
+      </plugin>
+    </plugins>
+  </reporting>
+
+  <build>
+    <plugins>
+      <plugin>
+        <artifactId>maven-failsafe-plugin</artifactId>
+        <version>2.6</version>
+        <executions>
+          <execution>
+            <goals>
+              <goal>integration-test</goal>
+              <goal>verify</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+	<groupId>org.apache.maven.plugins</groupId>
+	<artifactId>maven-surefire-plugin</artifactId>
+	<version>2.11</version>
+	<dependencies>
+	  <dependency>
+	    <groupId>org.apache.maven.surefire</groupId>
+	    <artifactId>surefire-junit47</artifactId>
+	    <version>2.12</version>
+	  </dependency>
+	</dependencies>
+	<configuration>
+	  <includes>
+	    <include>**/*.class</include>
+	  </includes>
+	  <excludedGroups>com.infochimps.vayacondios.test.IntegrationTest</excludedGroups>
+	</configuration>
+      </plugin>
+      
+      <!-- <plugin> -->
+      <!--   <groupId>org.apache.maven.plugins</groupId> -->
+      <!--   <artifactId>maven-shade-plugin</artifactId> -->
+      <!--   <version>2.0</version> -->
+      <!--   <executions> -->
+      <!--     <execution> -->
+      <!--       <phase>package</phase> -->
+      <!--       <goals> -->
+      <!--         <goal>shade</goal> -->
+      <!--       </goals> -->
+      <!--       <configuration> -->
+      <!--         <transformers> -->
+      <!--           <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer"> -->
+      <!--             <mainClass>com.infochimps.vayacondios.VCDIntegrationTest</mainClass> -->
+      <!--           </transformer> -->
+      <!--         </transformers> -->
+      <!--       </configuration> -->
+      <!--     </execution> -->
+      <!--   </executions> -->
+      <!-- </plugin> -->
+      <plugin>
+	<groupId>org.codehaus.mojo</groupId>
+	<artifactId>exec-maven-plugin</artifactId>
+	<version>1.2.1</version>
+	<configuration>
+	  <executable>java</executable>
+	  <arguments>
+	    <argument>-cp</argument>
+	    <classpath/>
+	    <argument>-jar</argument>
+	    <argument>target/${project.artifactId}-${project.version}.jar</argument>
+	  </arguments>
+	</configuration>
+      </plugin>
+    </plugins>
+  </build>
+  
   <repositories>
     <!-- Infochimps Repositories -->
     <repository>
@@ -44,5 +126,43 @@
       <artifactId>commons-codec</artifactId>
       <version>1.2</version>
     </dependency>
+    <dependency>
+      <groupId>org.slf4j</groupId>
+      <artifactId>slf4j-api</artifactId>
+      <version>1.7.2</version>
+    </dependency>
+    <dependency>
+      <groupId>org.slf4j</groupId>
+      <artifactId>slf4j-simple</artifactId>
+      <version>1.7.2</version>
+    </dependency>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.8.1</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.ning</groupId>
+      <artifactId>async-http-client</artifactId>
+      <version>1.7.16</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.commons</groupId>
+      <artifactId>commons-lang3</artifactId>
+      <version>3.1</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.httpcomponents</groupId>
+      <artifactId>httpclient</artifactId>
+      <version>4.2.5</version>
+    </dependency>
+    <dependency>
+      <groupId>org.mongodb</groupId>
+      <artifactId>mongo-java-driver</artifactId>
+      <version>2.11.1</version>
+      <scope>verify</scope>
+    </dependency>
+            
   </dependencies>
 </project>

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/server/api_options_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Vayacondios::Server::ApiOptions do
+
+  let(:api) do
+    api_options = described_class
+    Class.new{ include api_options }.new
+  end
+  let(:settings){ Hash.new }
+  let(:parser)  { OptionParser.new }
+
+  it 'sets the default config file location' do
+    api.options_parser(parser, settings)
+    settings[:config].should eq(File.join(Vayacondios.library_dir, 'config/vcd-server.rb'))
+  end
+
+  it 'sets the default server port' do
+    api.options_parser(parser, settings)
+    settings[:port].should eq(3467)
+  end
+
+  it 'allows commandline overrides for database options' do
+    ARGV.replace %w[-d foo -h foo.com -D bar -o 1234 -n 10]
+    api.options_parser(parser, settings)
+    parser.parse!
+    settings[:database].should eq(driver:      'foo',
+                                  connections: 10,
+                                  host:        'foo.com',
+                                  name:        'bar',
+                                  port:        1234)
+  end
+end

data/spec/server/api_spec.rb

@@ -0,0 +1,279 @@
+require 'spec_helper'
+
+describe Vayacondios::Server::Api do
+  include Goliath::TestHelper
+
+  TestResponse = Struct.new(:status, :body, :headers) do
+    def parsed_body
+      MultiJson.load body
+    end
+  end
+
+  def build_request(verb, path, options = {})
+    options[:path] = path
+    proc{ |&callback| send("#{verb}_request", options, &callback) }
+  end
+
+  let(:captured_assertions){ Array.new }
+
+  def perform(request, &blk)
+    response = nil
+    with_api(described_class) do |server|
+      yield server.api if block_given?
+      request.call do |client| 
+        response = TestResponse.new(client.response_header.status.to_i, client.response, client.response_header)
+      end
+      captured_assertions.each{ |a| raise a if a.is_a?(Exception) }
+    end
+    response
+  end
+
+  def capture_assertions(&code)
+    code.call
+  rescue RSpec::Expectations::ExpectationNotMetError => e
+    captured_assertions << e    
+  end
+  
+  def stub_response(api, result = nil, &blk)
+    api.stub(:response) do |env|
+      capture_assertions do
+        blk.call(api, env)
+      end
+      result || success_response   
+    end
+  end
+
+  def success_response
+    [200, {}, {}]
+  end
+  
+  def stub_handler(api, result = {}, &blk)
+    handler = double(:handle, call: result)
+    handler_class = double(:handler_class, new: handler)
+    api.stub(:handler).and_return handler_class
+    if block_given?
+      handler.should_receive(:call) do |action, routes, document|
+        capture_assertions{ blk.call(action, routes, document) }
+        result
+      end
+    end
+  end
+  
+  context 'Rack', 'Heartbeat' do
+    subject(:response){ perform build_request(:get, '/status') }
+    
+    it 'returns a heartbeat message' do
+      response.body.should eq('OK')
+    end
+  end
+
+  context 'Rack', 'ApiVersion' do
+    subject(:response){ perform build_request(:get, '/version') }
+
+    it 'returns the server api version' do
+      response.parsed_body.should eq(Vayacondios::GEM_VERSION)
+    end
+
+    it 'attaches a version header to every response' do
+      response = perform build_request(:get, '/v3/org/event/topic')
+      response.headers['X_VAYACONDIOS_VERSION'].should eq(Vayacondios::GEM_VERSION)
+    end
+  end
+
+  context 'Rack', 'ForceContentType' do
+    let(:request) { build_request(:post, '/v3/org/event/topic', body: '{"foo":"bar"}') }
+    let(:response){ perform request }
+
+    it 'accepts a JSON body with no header' do
+      perform(request) do |server|
+        stub_handler(server, {}) do |action, routes, document|
+          document.should eq('foo' => 'bar')
+        end
+      end
+    end
+
+    it 'attaches a JSON content header to every response' do
+      response.headers['CONTENT_TYPE'].should match('application/json')
+    end
+  end
+
+  context 'Rack', 'Formatters::JSON' do
+    subject(:response) do
+      perform build_request(:get, '/v3/org/event/topic') do |server|
+        stub_handler(server, { foo: 'bar' })
+      end
+    end
+
+    it 'serializes all response bodies as JSON' do
+      response.parsed_body.should eq('foo' => 'bar')
+    end
+  end
+
+  context 'Rack', 'Params' do
+    it 'provides parsed params to the response method' do
+      request = build_request(:post, '/v3/org/event/topic', body: '{"foo":"bar"}')
+      perform(request) do |server|
+        stub_response(server, success_response) do |api|
+          api.should respond_to(:document)
+          api.document.should eq('foo' => 'bar')
+        end
+      end
+    end
+
+    it 'handles non-Hash JSON values' do
+      request = build_request(:post, '/v3/org/event/topic', body: '["foo","bar"]')
+      perform(request) do |server|
+        stub_response(server, success_response) do |api|
+          api.document.should eq(%w[ foo bar ])
+        end
+      end      
+    end
+  end
+
+  context 'Rack', 'Validation::RequestMethod' do
+    %w[ HEAD OPTIONS ].each do |method|
+      it "returns a validation error on #{method} requests" do
+        response = perform build_request(method.downcase.to_sym, '/v3/org/event/topic')
+        response.status.should eq(405)
+      end
+    end
+  end
+
+  context 'Rack', 'ControlMethods' do
+    {
+      post:   :create,
+      get:    :retrieve,
+      patch:  :update,
+      patch:  :update,
+      delete: :delete,
+    }.each_pair do |http_verb, handler_action|
+      it "maps #{http_verb.to_s.upcase} verbs to handler method #{handler_action}" do
+        perform build_request(http_verb, '/v3/org/event/topic') do |server|
+          stub_handler(server) do |action, routes, document|
+            action.should eq(handler_action)
+          end
+        end
+      end
+    end
+  end
+
+  context 'Rack', 'Validation::Routes' do
+    it 'returns a validation error when the route is not valid' do
+      response = perform build_request(:get, '/invalid/route/fool')
+      response.status.should eq(400)
+      response.parsed_body['error'].should match('/v3/<organization>/<type>/<topic>/<id>')
+    end
+
+    it 'parses the route pieces' do
+      perform build_request(:get, '/v3/twitter/event/hashtag/emoji') do |server|
+        stub_response(server) do |api|
+          api.should respond_to(:routes)
+          api.routes.should eq(organization: 'twitter', 
+                               type:         'event',
+                               topic:        'hashtag',
+                               id:           'emoji')
+        end
+      end
+    end
+  end
+
+  context 'Rack', 'Validation::RouteHandler' do
+    {
+      event:   Vayacondios::Server::EventHandler,
+      events:  Vayacondios::Server::EventsHandler,
+      stash:   Vayacondios::Server::StashHandler,
+      stashes: Vayacondios::Server::StashesHandler,
+      stream:  Vayacondios::Server::StreamHandler,
+    }.each_pair do |type, handler|
+      it "maps type #{type} to handler #{handler}" do
+        request = build_request(:get, "/v3/infochimps/#{type}/topic")
+        perform(request) do |server|
+          stub_response(server, success_response) do |api|
+            api.handler.should be(handler)
+          end
+        end
+      end
+    end
+
+    it 'returns a validation error when a handler cannot be found' do
+      response = perform build_request(:get, '/v3/infochimps/invalid/topic')
+      response.status.should eq(400)
+      response.parsed_body['error'].should match('No handler found')
+    end
+  end
+
+  context 'Rack', 'Validation::RequiredRoutes' do
+    it 'returns a validation error when a stash does not have a topic' do
+      response = perform build_request(:get, '/v3/infochimps/stash')
+      response.status.should eq(400)
+      response.parsed_body['error'].should match('A topic route is required')
+    end
+
+    it 'returns a validation error when an event does not have a topic' do
+      response = perform build_request(:get, '/v3/infochimps/event')
+      response.status.should eq(400)
+      response.parsed_body['error'].should match('A topic route is required')
+    end
+
+    it 'returns a validation error when events do not have a topic' do
+      response = perform build_request(:get, '/v3/infochimps/events')
+      response.status.should eq(400)
+      response.parsed_body['error'].should match('A topic route is required')
+    end
+
+    it 'returns a validation error when stream do not have a topic' do
+      response = perform build_request(:get, '/v3/infochimps/stream')
+      response.status.should eq(400)
+      response.parsed_body['error'].should match('A topic route is required')
+    end
+  end
+
+  context 'Rack', '#response' do
+    let(:request){ build_request(:get, '/v3/infochimps/event/topic') }
+
+    it 'returns a validation error when a handler raises one' do
+      response = perform(request) do |server|
+        stub_handler(server) do |action, routes, document|
+          raise Goliath::Validation::NotFoundError.new("Dude, where's my car?")
+        end
+      end
+      response.status.should eq(404)
+      response.parsed_body['error'].should eq("Dude, where's my car?")
+    end
+
+    it 'returns a document error when a handler raises one' do
+      response = perform(request) do |server|
+        stub_handler(server) do |action, routes, document|
+          raise Vayacondios::Server::Document::Error.new('Invalid')
+        end
+      end
+      response.status.should eq(400)
+      response.parsed_body['error'].should eq('Invalid')
+    end
+
+    it 'returns a server error when a handler raises one' do
+      response = perform(request) do |server|
+        stub_handler(server) do |action, routes, document|
+          raise ZeroDivisionError.new('infinity')
+        end
+      end
+      response.status.should eq(500)
+      response.parsed_body['error'].should match('ZeroDivisionError')
+    end
+
+    it 'returns a successful response on success' do
+      response = perform(request) do |server|
+        stub_handler(server, { foo: 'bar' })
+      end
+      response.status.should eq(200)
+      response.parsed_body.should eq('foo' => 'bar')
+    end
+
+    it 'returns a streaming response when requested', focus: true do
+      request = build_request(:get, '/v3/infochimps/stream/topic', connection_options: { inactivity_timeout: 0.5 })
+      response = perform(request)
+      response.status.should eq(200)
+      response.body.should eq('')
+    end
+  end
+end

data/spec/server/configuration_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Vayacondios::Server::Configuration do
+  its(:defaults) do
+    should eq(development: {
+                driver:      'mongo',
+                host:        'localhost',
+                port:        27017,
+                name:        'vayacondios_development',
+                connections: 20,                
+              })
+  end
+
+  it 'defines a db config constant' do
+    Vayacondios::Server::DbConfig.should be_a(described_class)
+  end
+
+  context '#env' do
+    it 'allows hash access scoped by environment' do
+      subject.env(:development).should eq(driver:      'mongo',
+                                          host:        'localhost',
+                                          port:        27017,
+                                          name:        'vayacondios_development',
+                                          connections: 20)
+    end
+  end
+end

data/spec/server/drivers/mongo_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe Vayacondios::Server::MongoDriver, if: WITH_MONGO do
+  include LogHelper
+
+  let!(:settings){ Vayacondios::Server::DbConfig.env :test }
+
+  subject{ described_class.connect settings.merge(log: log) }
+  
+  def mongo
+    Mongo::MongoClient.new(settings[:host], settings[:port])
+  end
+
+  def db
+    mongo.db settings[:name]
+  end
+
+  def collection name
+    db.collection name
+  end
+
+  def using(location, &blk)
+    EM.synchrony do
+      subject.set_location location
+      blk.call(subject)
+      EM::Synchrony.sleep(0.1) # ensure the operation completes
+      EM.stop
+    end
+  end
+
+  def clean name
+    collection(name).drop
+  end
+
+  context '#to_dotted_hash' do
+    let(:nested){ { foo: { bar: { baz: 'qix' } }, hey: { you: 'there' } } }
+    it 'flattens a nested hash into dotted keys' do
+      EM.synchrony do
+        subject.to_dotted_hash(nested).should eq('foo.bar.baz' => 'qix', 'hey.you' => 'there')
+        EM.stop
+      end
+    end
+  end
+
+  context '#insert' do
+    after do
+      clean 'organization.foo.events'
+    end
+
+    it 'returns the id' do
+      result = nil
+      using('organization.foo.events') do |driver| 
+        result = driver.insert(foo: 'bar')
+      end
+      collection('organization.foo.events').find(_id: BSON::ObjectId(result[:_id])).to_a.size.should eq(1)
+    end
+  end
+
+  context '#search' do
+    after{ clean 'organization.stash' }
+    
+    it 'returns an array of results' do
+      collection('organization.stash').insert(_id: 'topic', foo: 'bar')
+      result = nil
+      using('organization.stash') do |driver| 
+        result = driver.search({}, { foo: 'bar' }, {})
+      end
+      result.should eq([{ _id: 'topic', foo: 'bar' }])      
+    end
+  end
+
+  context '#retrieve' do
+    after{ clean 'organization.stash' }
+
+    it 'returns the record if found' do
+      collection('organization.stash').insert(_id: 'topic', foo: 'bar')
+      result = nil
+      using('organization.stash') do |driver| 
+        result = driver.retrieve(_id: 'topic')
+      end
+      result.should eq(_id: 'topic', foo: 'bar')
+    end
+
+    it 'returns nil if the record is not found' do
+      collection('organization.stash').insert(_id: 'topic', foo: 'bar')
+      result = nil
+      using('organization.stash') do |driver| 
+        result = driver.retrieve(_id: 'invalid')
+      end
+      result.should be_nil
+    end
+  end
+
+  context '#remove' do
+    after{ clean 'organization.stash' }
+
+    it 'returns nil after completion' do
+      collection('organization.stash').insert(_id: 'topic', foo: 'bar')
+      result = nil
+      using('organization.stash') do |driver| 
+        result = driver.remove({}, foo: 'bar')
+      end
+      result.should be_nil
+      collection('organization.stash').find(_id: 'topic').to_a.should be_empty
+    end    
+  end
+end

data/spec/server/handlers/event_handler_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Vayacondios::Server::EventHandler, behaves_like: 'handler' do
+
+  let(:params)     { { organization: 'organization', topic: 'topic' } }
+  let(:document)   { { foo: 'bar', time: '2013-01-01T10:23:10.432Z' } }
+  let(:model_class){ Vayacondios::Server::Event }
+
+  context '#create' do
+    it 'returns the created event' do
+      model_class.should_receive(:create).with(params, document).and_call_original      
+      driver.should_receive(:insert).and_return(_id: 'abc123')
+      handler.create(params, document).should eq(id: 'abc123',
+                                                   foo: 'bar',
+                                                   time: '2013-01-01T10:23:10.432Z')
+    end
+  end
+
+  context '#retrieve', 'when an event is found' do
+    let(:params){ { organization: 'organization', topic: 'topic', id: 'abc123' } }
+
+    it 'returns the selected event' do
+      model_class.should_receive(:find).with(params).and_call_original
+      driver.should_receive(:retrieve).and_return(_id: 'abc123', _t: '2013-01-01T10:23:10.432Z', _d: { foo: 'bar' })
+      handler.retrieve(params, {}).should eq(id:   'abc123',
+                                             foo:  'bar',
+                                             time: '2013-01-01T10:23:10.432Z')
+    end
+  end
+  
+  context '#retrieve', 'when an event is not found', focus: true do
+    let(:params){ { organization: 'organization', topic: 'topic', id: 'abc123' } }
+
+    it 'raises a validation error' do
+      model_class.should_receive(:find).with(params).and_call_original
+      driver.should_receive(:retrieve).and_return(nil)
+      expect{ handler.retrieve(params, {}) }.to raise_error(validation_error, /not found/)
+    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 no id' do
+    it 'raises a validation error' do
+      expect{ handler.delete(params, {}) }.to raise_error(validation_error, /id/i)
+    end
+  end
+
+  context '#delete', 'when successful' do
+    let(:params){ { organization: 'organization', topic: 'topic', id: 'abc123' } }
+
+    it 'returns 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