papermill-agent 0.0.1 → 0.0.2

data/Gemfile

@@ -4,8 +4,7 @@ gem 'rest-client', '~>1.6.1'
 
 group :test do
   gem 'fakeweb',  '>=1.3.0'
-  gem 'autotest', '>=4.2.2'
+  gem 'autotest', '4.4.5'
   gem 'sinatra',  '1.1.0'
-  gem 'rails',    '~> 3.0.0'
   gem 'rspec',    '>=2.0.1'
 end

data/Rakefile

@@ -1,5 +1,4 @@
 require 'rspec/core/rake_task'
 task :default => :spec
 
-Rspec::Core::RakeTask.new do |t|
-end
+RSpec::Core::RakeTask.new

data/lib/papermill-agent/agent.rb

@@ -2,31 +2,34 @@ require 'singleton'
 require 'timeout'
 require 'json'
 require 'restclient'
-require 'yaml'
 
 module Papermill
 
   class Agent
     include Singleton
-
-    # papermill endpoint which will receive client requests
-    API_ENDPOINT = 'http://api.papermillapp.com'
     
     # send new request data every 10 seconds
     UPDATE_INTERVAL = 10
 
-    attr_reader :last_sent, :mutex, :config
+    attr_reader :last_sent, :mutex, :config, :logger
+
+    # request timeout threshold for sending data to papermill
+    @@request_timeout = 5
+    def self.request_timeout
+      @@request_timeout
+    end
 
     def start
       @last_sent = Time.now
       @mutex     = Mutex.new
-      @config    = YAML.load_file('config/papermill.yml')
+      @config    = Configurator.new
+      @logger    = Logger.new
+      logger.info "\n\n=============== Starting papermill-agent at #{Time.now} in process #{Process.pid}"
       Thread.abort_on_exception = true
 
       @worker_thread = Thread.new do
         loop do
           if time_since_last_sent > UPDATE_INTERVAL
-            p "sending #{Storage.store.count} requests to papermill..."
             send_data_to_papermill
             @last_sent = Time.now
           end
@@ -36,38 +39,45 @@ module Papermill
       end
     end
 
-    def time_since_last_sent
-      Time.now - last_sent
-    end
-
-    def seconds_until_next_run
-      UPDATE_INTERVAL - time_since_last_sent
-    end
-
     def send_data_to_papermill
       begin
-        Timeout.timeout(9) { do_request unless Storage.store.empty? }
-      rescue Timeout::Error
-        p 'timeout error'
+        Timeout.timeout(config.setting('request_timout') || self.class.request_timeout) do
+          do_request if !Storage.empty? && config.live_mode
+        end
+      rescue Timeout::Error => e
+        logger.log_exception(e)
       end
     end
 
     def do_request
       begin
-        RestClient.post API_ENDPOINT, { :api_key => config['token'], :payload => jsonify_payload }
-      rescue RestClient::Exception, Errno::ECONNREFUSED
-        p 'transmission error ocurred...'
+        logger.info("#{Time.now}: Sending #{Storage.size} requests to papermill")
+        RestClient.post config.endpoint, { :token => config.token, :payload => jsonify_payload }
+        Storage.clear
+      rescue RestClient::Exception, Errno::ECONNREFUSED, SocketError => e
+        logger.log_exception e
       end
     end
 
+    def time_since_last_sent
+      Time.now - last_sent
+    end
+
+    def seconds_until_next_run
+      UPDATE_INTERVAL - time_since_last_sent
+    end
+
     # Return a json version of the storage array.
     # Also, we'll clear out the storage here
     #
     # TODO: move this to the Storage class.
     def jsonify_payload
       mutex.synchronize do
-        json_data = JSON.generate(Storage.store.flatten)
-        Storage.clear
+        begin
+          json_data = Storage.store.flatten.to_json
+        rescue => e
+          logger.log_exception(e)
+        end
         return json_data
       end
     end

data/lib/papermill-agent/configurator.rb

@@ -0,0 +1,63 @@
+require 'yaml'
+
+module Papermill
+
+  class Configurator
+    attr_writer :environment
+
+    def initialize(config_source = 'config/papermill.yml')
+      load_config(config_source)
+    end
+
+    def load_config(config_source)
+      @config = case
+      when config_source.class == String
+        YAML.load_file(config_source)
+      when config_source.class == Hash
+        config_source
+      end
+    end
+
+    def token
+      config['token']
+    end
+
+    def endpoint
+      if setting('endpoint') && environment != 'production'
+        config[environment]['endpoint']
+      else
+        API_ENDPOINT
+      end
+    end
+
+    # returns the value of a setting for the current environment or nil, 
+    # if it does not exist.
+    def setting(name)
+      config[environment] && config[environment][name]
+    end
+
+    def live_mode
+      if has_config_for_environment?('live_mode')
+        setting('live_mode')
+      else
+        # default to true for production environments, false otherwise
+        environment == 'production' ? true : false
+      end
+    end
+
+    def environment
+      @environment ||= (defined?(Rails) && Rails.env) || ENV['RACK_ENV'] || 'development'
+    end
+
+    private
+
+    # holds the internal config hash
+    def config
+      @config
+    end
+
+    def has_config_for_environment?(var)
+      config[environment] && config[environment].has_key?(var)
+    end
+  end
+end

data/lib/papermill-agent/logger.rb

@@ -0,0 +1,14 @@
+require 'logger'
+
+module Papermill
+  class Logger < ::Logger
+    def initialize(io_object = 'log/papermill.log')
+      FileUtils.mkdir('log') unless Dir.exists?('log')
+      super(io_object)
+    end
+
+    def log_exception(exception)
+      error(exception.message + exception.backtrace.join("\n"))
+    end
+  end
+end

data/lib/papermill-agent/response_adapters/base.rb

@@ -3,13 +3,20 @@ module Papermill
   module ResponseAdapters
 
     class Base
+      ENV_CAPTURE_FIELDS = [
+        'PATH_INFO', 'QUERY_STRING', 'REMOTE_ADDR', 'REMOTE_HOST', 'REQUEST_METHOD',
+        'REQUEST_URI', 'SCRIPT_NAME', 'SERVER_NAME', 'SERVER_SOFTWARE', 'HTTP_HOST',
+        'HTTP_ACCEPT', 'HTTP_USER_AGENT', 'REQUEST_PATH', 'rack.url_scheme',
+        'HTTP_REFERER'
+      ]
+
       attr_reader :status, :headers, :response, :env
-      def initialize(*args)
-        @status, @headers, @response, @env = args.flatten
+      def initialize(status, headers, response, env = {})
+        @status, @headers, @response, @env = status, headers, response, env
       end
 
       def parse
-        parsed_response = { :headers => headers.merge(env), :status => status }
+        parsed_response = { :headers => extract_env_info, :status => status }
         # if @status != 304 && @response #&& !@response.body.is_a?(Proc)
         #   parsed_response.merge!(prepare_extra_fields)
         # end
@@ -19,8 +26,21 @@ module Papermill
 
       private
       def additional_response_data
-        {:request_time => Time.now}
+        {'request_time' => Time.now}
       end
+
+      def extract_env_info
+        result_hash = env.select { |key, value| ENV_CAPTURE_FIELDS.include?(key) }
+
+        # rename rack.* keys b/c mongo does not allow key names containing a .
+        rack_keys = ENV_CAPTURE_FIELDS.select { |key| key =~ /^rack\./ }
+        rack_keys.each do |key|
+          new_key = key.gsub(/^rack\./, '').upcase
+          result_hash[new_key] = result_hash.delete(key)
+        end
+        result_hash
+      end
+
     end
 
   end

data/lib/papermill-agent/response_parser.rb

@@ -2,22 +2,18 @@
 module Papermill
 
   class ResponseParser
-    # ENV_CAPTURE_FIELDS = [
-    #   'PATH_INFO', 'QUERY_STRING', 'REMOTE_ADDR', 'REMOTE_HOST', 'REQUEST_METHOD', 
-    #   'REQUEST_URI', 'SCRIPT_NAME', 'SERVER_NAME', 'SERVER_SOFTWARE', 'HTTP_HOST', 
-    #   'HTTP_ACCEPT', 'HTTP_USER_AGENT', 'REQUEST_PATH'
-    # ]
-
-    def self.parse(status, headers, response, env = {})
-      klass = if defined?(Rails)
+    def self.parse_klass
+      @klass ||= if defined?(Rails)
         ResponseAdapters::Rails
       elsif defined?(Sinatra)
         ResponseAdapters::Sinatra
       else
         ResponseAdapters::Base
       end
+    end
 
-      klass.new(status, headers, response, env).parse
+    def self.parse(status, headers, response, env = {})
+      parse_klass.new(status, headers, response, env).parse
     end
   end
 

data/lib/papermill-agent/storage.rb

@@ -19,6 +19,14 @@ module Papermill
       def clear
         store.clear
       end
+
+      def size
+        store.size
+      end
+
+      def empty?
+        store.empty?
+      end
     end
   end
 

data/lib/papermill-agent.rb

@@ -2,8 +2,13 @@
 $:.unshift File.dirname(File.expand_path(__FILE__))
 
 module Papermill
+  # papermill endpoint which will receive client requests
+  API_ENDPOINT = 'http://api.papermillapp.com'
+
   autoload :Agent,          'papermill-agent/agent'
   autoload :Collector,      'papermill-agent/rack/collector'
+  autoload :Configurator,   'papermill-agent/configurator'
+  autoload :Logger,         'papermill-agent/logger'
   autoload :ResponseParser, 'papermill-agent/response_parser'
   autoload :Storage,        'papermill-agent/storage'
 

data/spec/agent_spec.rb

@@ -4,19 +4,19 @@ module Papermill
 
   describe 'the agent' do
     it 'has a mutex' do
-      Agent.instance.mutex.should be_instance_of Mutex
+      agent.mutex.should be_instance_of Mutex
     end
 
     context 'when a new process is started' do
       context 'when an agent process does not already exist' do
         it 'should create a new agent process' do
-          Papermill::Agent.instance.should be_instance_of Papermill::Agent
+          Agent.instance.should be_instance_of Papermill::Agent
         end
       end
 
       context 'when an agent process already exists' do
         it 'should only allow one agent instance to exist' do
-          Papermill::Agent.instance.should eql Papermill::Agent.instance
+          Agent.instance.should eql Papermill::Agent.instance
         end
       end
     end
@@ -29,62 +29,208 @@ module Papermill
       end
     end
 
+    context 'when in a production environment' do
+      before { agent.config.stub(:environment => 'production') }
+
+      context 'and the storage is empty' do
+        before { Storage.clear }
+
+        it 'does not send anything to papermill' do
+          agent.should_not_receive(:do_request)
+          agent.send_data_to_papermill
+        end
+      end
+
+      context 'and the storage is not empty' do
+        before { Storage.store << ['an item'] }
+
+        it 'sends data to papermill' do
+          agent.should_receive(:do_request)
+          agent.send_data_to_papermill
+        end
+      end
+    end
+
+    context 'when in a non-production environment' do
+      before { agent.config.environment = 'non-production' }
+
+      context 'and there is no config over-ride to log requests in that environment' do
+        context 'and the storage is not empty' do
+          before { Storage.store << [{:headers => {'Content-Type' => 'text/html'}, :status => 200}] }
+
+          it 'does not send data to papermill' do
+            agent.should_not_receive(:do_request)
+            agent.send_data_to_papermill
+          end
+        end
+
+        context 'and the storage is empty' do
+          before { Storage.clear }
+
+          it 'does not send data to papermill' do
+            agent.should_not_receive(:do_request)
+            agent.send_data_to_papermill
+          end
+        end
+      end
+
+      context 'and there is a config over-ride present for that environment' do
+        before { agent.config.stub!(:live_mode => true) }
+
+        context 'when the storage is empty' do
+          before { Storage.clear }
+
+          it 'sends data to papermill' do
+            agent.should_not_receive(:do_request)
+            agent.send_data_to_papermill
+          end
+        end
+
+        context 'when the storage is not empty' do
+          before { Storage.store << [{:headers => {'Content-Type' => 'text/html'}, :status => 200}] }
+
+          it 'sends data to papermill' do
+            agent.should_receive(:do_request)
+            agent.send_data_to_papermill
+          end
+        end
+      end
+    end
+
+    context 'when in a production environment' do
+      before { agent.config.environment = 'production' }
+
+      context 'by default' do
+        context 'when requests have been logged' do
+          before { Storage.store << [{:headers => {'Content-Type' => 'text/html'}, :status => 200}] }
+
+          it 'sends request data to the papermill api' do
+            agent.should_receive(:do_request)
+            agent.send_data_to_papermill
+          end
+        end
+
+        context 'when no requests have been logged' do
+          before { Storage.clear }
+
+          it 'does not send data to papermill' do
+            agent.should_not_receive(:do_request)
+            agent.send_data_to_papermill
+          end
+        end
+      end
+
+      context 'if a config over-ride is specified to not send data to papermill' do
+        before { agent.config.stub!(:live_mode => false) }
+
+        context 'when requests have been logged' do
+          before { Storage.store << [{:headers => {'Content-Type' => 'text/html'}, :status => 200}] }
+
+          it 'does not send data to papermill' do
+            agent.should_not_receive(:do_request)
+            agent.send_data_to_papermill
+          end
+        end
+
+        context 'when no requests have been logged' do
+          before { Storage.clear }
+
+          it 'does not send data to papermill' do
+            agent.should_not_receive(:do_request)
+            agent.send_data_to_papermill
+          end
+        end
+      end
+    end
+
   end
 
   describe 'the api endpoint' do
-    subject { Agent::API_ENDPOINT }
+    subject { Papermill::API_ENDPOINT }
     it { should == 'http://api.papermillapp.com' }
   end
 
+  describe 'request timeout interval' do
+    it 'defaults to 5 seconds' do
+      Agent.request_timeout.should == 5
+    end
+  end
+
   describe 'determining the time since the last time data was sent to papermill' do
     before do
-      Agent.instance.stub!(:last_sent => Time.mktime(2010, 11, 11, 0, 0, 0))
+      agent.stub!(:last_sent => Time.mktime(2010, 11, 11, 0, 0, 0))
       Time.stub!(:now => Time.mktime(2010, 11, 11, 0, 0, 9))
     end
 
     context 'time since the last run' do
       it 'subtracts the current time from @last_sent' do
-        Agent.instance.time_since_last_sent.should == 9
+        agent.time_since_last_sent.should == 9
       end
     end
 
     context 'the time until the next run' do
       it 'time until next = interval - time elapsed since last' do
-        Agent.instance.seconds_until_next_run.should == 1
+        agent.seconds_until_next_run.should == 1
       end
     end
-
   end
 
   describe 'configuration' do
     it 'provides access to the api token' do
-      Agent.instance.config['token'].should == 'api-key'
+      agent.config.token.should == 'api-key'
     end
   end
 
-  describe 'sending data to papermill' do
+  describe 'given a logged request' do
     before do
       Storage.store << [{:headers => {'Content-Type' => 'text/html'}, :status => 200}]
     end
 
-    it 'jsonifies the payload data' do
-      Agent.instance.jsonify_payload.should == '[{"headers":{"Content-Type":"text/html"},"status":200}]'
+    describe 'serializing the payload' do
+      it 'jsonifies the payload data' do
+        agent.jsonify_payload.should == '[{"headers":{"Content-Type":"text/html"},"status":200}]'
+      end
     end
 
-    it 'empties the store' do
-      Agent.instance.jsonify_payload
-      Storage.store.should be_empty
+    describe 'sending data to papermill' do
+      before { agent.config.stub!(:environment => 'production') }
+
+      it 'empties the store' do
+        agent.send_data_to_papermill
+        Storage.store.should be_empty
+      end
+
+      it 'sends a request to the papermill api endpoint' do
+        RestClient.should_receive(:post).with(Papermill::API_ENDPOINT, :token => 'api-key', :payload => '[{"headers":{"Content-Type":"text/html"},"status":200}]')
+        agent.send_data_to_papermill
+      end
+
+      it 'does not send anything if no requests have been stored' do
+        Storage.clear
+        Agent.should_not_receive(:do_request)
+        agent.send_data_to_papermill
+      end
+
+      it 'logs a message to the logger' do
+        agent.logger.should_receive(:info).with(/Sending 1 requests to papermill/)
+        agent.send_data_to_papermill
+      end
     end
 
-    it 'sends a request to the papermill api endpoint' do
-      RestClient.should_receive(:post).with(Agent::API_ENDPOINT, :api_key => 'api-key', :payload => '[{"headers":{"Content-Type":"text/html"},"status":200}]')
-      Agent.instance.send_data_to_papermill
+  end
+
+  describe 'the logger' do
+    before { agent.start }
+
+    it 'has a logger' do
+      agent.logger.should be_instance_of Papermill::Logger
     end
+  end
 
-    it 'should not send anything if no requests have been stored' do
-      Storage.clear
-      Agent.should_not_receive(:do_request)
-      Agent.instance.send_data_to_papermill
+  describe 'starting the agent' do
+    it 'loads the configurator' do
+      agent.start
+      agent.config.should be_instance_of Configurator
     end
   end
 

data/spec/configurator_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helper'
+
+module Papermill
+
+  describe 'loading the configurator' do
+    context 'when a string is passed in' do
+      it 'attempts to load the yaml file by that name' do
+        YAML.should_receive(:load_file).with('filename')
+        Configurator.new('filename')
+      end
+    end
+
+    context 'when a hash is passed in' do
+      it 'uses the hash as the config object' do
+        Configurator.new(mock_config_hash).token.should == mock_config_hash['token']
+      end
+    end
+
+    it 'loads the papermill yaml config file' do
+      Configurator.new
+    end
+  end
+
+  describe 'given a configurator instance' do
+    let(:configurator) do
+      YAML.stub!(:load_file).and_return({'token' => 'token'})
+      Configurator.new 
+    end
+
+    describe 'the token' do
+      it 'should return the token from the config' do
+        configurator.token.should == 'token'
+      end
+    end
+
+    describe 'configuring the api endpoint' do
+      let(:configurator) { Configurator.new(
+        mock_config_hash.merge(
+          'test' => {'endpoint' => 'another endpoint'}, 
+          'production' => {'endpoint' => 'fake production endpoint'})
+        ) 
+      }
+
+      context 'for non-production environments' do
+        it 'allows the user to over-ride the endpoint' do
+          configurator.stub!(:environment => 'test')
+          configurator.endpoint.should == 'another endpoint'
+        end
+
+        it 'defaults to the api endpoint if nothing else has been specified' do
+          configurator.stub!(:environment => 'an undefined env')
+          configurator.endpoint.should == Papermill::API_ENDPOINT
+        end
+      end
+
+      context 'for production environments' do
+        before { configurator.stub!(:environment => 'production') }
+
+        it "always sets the endpoint to papermillapp's servers" do
+          configurator.endpoint.should == Papermill::API_ENDPOINT
+        end
+
+        it 'should be the fake endpoint' do
+          configurator.endpoint.should_not == 'fake production endpoint'
+        end
+      end
+    end
+
+    describe 'determining the environment' do
+      let(:configurator) { Configurator.new(mock_config_hash) }
+
+      context 'when in a Rails app' do
+        before do
+          Papermill.class_eval do
+            # create a fake rails class
+            class Rails
+              def self.env; 'rails environment'; end
+            end
+          end
+        end
+        # remove the fake rails class
+        after { Papermill.class_eval { remove_const(:Rails) } }
+
+        it 'get the environment from rails' do
+          configurator.environment.should == 'rails environment'
+        end
+      end
+
+      context 'when in a rack app' do
+        before do
+          ENV.stub!(:[]).with('RACK_ENV').and_return('rack env')
+        end
+
+        it "gets the environment from ENV['RACK_ENV']" do
+          configurator.environment.should == 'rack env'
+        end
+      end
+
+      context 'not in rails or a rack app' do
+        before { ENV['RACK_ENV'] = nil }
+        after  { ENV['RACK_ENV'] = 'test' }
+
+        it 'defaults the environment to development' do
+          configurator.environment.should == 'development'
+        end
+      end
+    end
+  end
+
+  describe 'setting the environment' do
+    let(:configurator) { Configurator.new }
+    before { configurator.environment = 'some environment' }
+
+    it 'allows manual setting of the envionment' do
+      configurator.environment.should == 'some environment'
+    end
+  end
+
+  describe 'determining whether or not to send data to papermill' do
+    context 'for a production environment' do
+      let(:config) { Configurator.new }
+      before { config.environment = 'production' }
+
+      context 'by default' do
+        it 'is true' do
+          config.live_mode.should == true
+        end
+      end
+
+      context 'when a config override is specified with a value of false' do
+        let(:config) { Configurator.new({'production' => {'live_mode' => false}}) }
+
+        it 'does not send data to papermill' do
+          config.environment.should == 'production'
+          config.live_mode.should == false
+        end
+      end
+    end
+
+    context 'for a non-production environment' do
+      context 'by default' do
+        let(:config) { Configurator.new }
+        before { config.environment = 'non-production' }
+
+        it 'is false' do
+          config.live_mode.should == false
+        end
+      end
+
+      context 'when an environment override is specified' do
+        let(:config) { Configurator.new('non-production' => {'live_mode' => true}) }
+        before { config.environment = 'non-production' }
+
+        it 'uses that setting' do
+          config.live_mode.should == true
+        end
+      end
+    end
+  end
+
+  describe 'retrieving a setting for the current environment' do
+    context 'for a given environment' do
+      let(:config) { Configurator.new({'production' => {'my key' => 'my val'}}) }
+      before { config.environment = 'production' }
+
+      context 'for a setting that has a value' do
+        it 'returns the value of the setting identified by the name' do
+          config.setting('my key').should == 'my val'
+        end
+      end
+
+      context 'for a setting that does not have a value' do
+        it 'returns nil' do
+          config.setting('does not exist').should == nil
+        end
+      end
+    end
+
+  end
+end

data/spec/logger_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+module Papermill
+  describe 'the papermill logger' do
+    it 'inherits from the ruby std lib logger' do
+      ::Papermill::Logger.superclass.should == ::Logger
+    end
+  end
+  
+  describe 'instantiating the log file' do
+    context 'when the log directory does not exist' do
+      it 'should not raise a file system error' do
+        lambda {
+          Logger.new
+        }.should_not raise_error(Errno::ENOENT)
+      end
+      
+      it 'creates the log file' do
+        Logger.new
+        File.exists?('log/papermill.log').should be_true
+      end
+    end
+  end
+
+  describe '#log_error' do
+    let(:logger) { Logger.new($stdout) }
+    let(:exception) { mock('Exception', :message => 'msg', :backtrace => ['...']) }
+
+    it 'records the message and the backtrace of the exception' do
+      logger.should_receive(:error)
+      exception.should_receive(:message)
+      exception.should_receive(:backtrace)
+
+      logger.log_exception(exception)
+    end
+  end
+end

data/spec/rack/collector_spec.rb

@@ -4,15 +4,18 @@ require 'sinatra'
 
 module Papermill
 
-  describe 'collecting statistics via the middleware layer' do
-    before do
-      @app = Sinatra.new Sinatra::Application do
+  describe 'collecting statistics with Collector' do
+    def app
+      @app ||= Sinatra.new Sinatra::Application do
         get '/' do
           '<html><body>Hello, world!</body></html>'
         end
+
+        use Papermill::Collector
       end
-      @app.use Papermill::Collector
+    end
 
+    before do
       request_headers = {'HTTP_USER_AGENT' => 'agent', 'REMOTE_ADDR' => '0.0.0.0', 
         'QUERY_STRING' => 'q=search',
         'SCRIPT_NAME'  => 'my-script',
@@ -20,11 +23,17 @@ module Papermill
         'HTTP_HOST'    => 'localhost',
         'REQUEST_URI'  => 'i-requested-this',
         'REMOTE_HOST'  => '123.345.34.2',
-        'SERVER_SOFTWARE' => 'apache'
+        'SERVER_SOFTWARE' => 'apache',
+        'HTTP_REFERER' => 'previous url'
       }
 
       Time.stub(:now => Time.utc(2010, 01, 01))
-      @status, @headers, @body = @app.call(Rack::MockRequest.env_for('/', request_headers))
+      @status, @headers, @body = app.call(Rack::MockRequest.env_for('/', request_headers))
+    end
+
+    context 'for a 304 response' do
+      it 'records the status code'
+      it 'doesnt attempt to save any headers'
     end
     
     def last_store
@@ -42,7 +51,7 @@ module Papermill
     it 'records request duration'
 
     it 'records the request time' do
-      last_store[:request_time].should == Time.utc(2010, 01, 01)
+      last_store['request_time'].should == Time.utc(2010, 01, 01)
     end
 
     it 'records the path info' do
@@ -93,8 +102,16 @@ module Papermill
       headers['REMOTE_HOST'].should == '123.345.34.2'
     end
 
+    it 'records the http referrer' do
+      headers['HTTP_REFERER'].should == 'previous url'
+    end
+
+    it 'does not save any keys with a period in the name' do
+      headers.keys.detect { |k| k =~ /\./ }.should == nil
+    end
+
     it 'records the url scheme' do
-      headers['rack.url_scheme'].should == 'http'
+      headers['URL_SCHEME'].should == 'http'
     end
 
     context 'for a 304 response' do

data/spec/response_adapters/base_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+module Papermill
+  describe 'initializing the Base parser' do
+    context 'with no environment' do
+      let(:base) { ResponseAdapters::Base.new(200, {}, lambda {}) }
+
+      it 'sets it to an empty hash' do
+        base.env.should == {}
+      end
+    end
+  end
+end

data/spec/response_parser_spec.rb

@@ -14,12 +14,14 @@ module Papermill
     end
 
     context 'in a rails app' do
-      class Rails
+      before do
+        # self.class.module_eval { remove_const(:Sinatra) if defined?(Sinatra) }
       end
 
       it 'uses the rails adapter' do
-        ResponseAdapters::Rails.should_receive(:new).and_return(mock('object', :parse => nil))
-        ResponseParser.parse(200, {}, [], {})
+      class Rails
+      end
+        ResponseParser.parse_klass.should == ResponseAdapters::Rails
       end
     end
   end

data/spec/spec_helper.rb

@@ -12,8 +12,18 @@ require 'papermill-agent'
 require 'fakeweb'
 
 FakeWeb.allow_net_connect = false
+FakeWeb.register_uri(:post, Papermill::API_ENDPOINT, {})
 
 RSpec.configure do |config|
+  def mock_config_hash
+    {'token' => 'mock-token'}
+  end
+
+  def agent
+    Papermill::Agent.instance
+  end
+
+  config.mock_with :rspec
   config.before(:each) do
     # clear the storage before each example
     Papermill::Storage.clear

data/spec/storage_spec.rb

@@ -2,6 +2,22 @@ require 'spec_helper'
 
 module Papermill
 
+  describe 'determining if the storage has items in it' do
+    subject { Storage.empty? }
+
+    context 'when a request has been added to the storage' do
+      before { Storage.store << ['something worth saving'] }
+
+      it { should == false }
+    end
+
+    context 'when no requests have been added to the storage' do
+      before { Storage.clear }
+
+      it { should == true }
+    end
+  end
+
   describe 'adding an item to the local data storage' do
     it 'acts like an array' do
       Storage.store.should respond_to(:<<)
@@ -19,6 +35,17 @@ module Papermill
     end
   end
 
+  describe 'determine the number of records stored' do
+    before do
+      Storage.store << 'record 1'
+      Storage.store << 'record 2'
+    end
+
+    it 'should be 2' do
+      Storage.size.should == 2
+    end
+  end
+
   describe 'emptying the cache' do
     before { Storage.clear }
 

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Alex Sharp
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-19 00:00:00 -08:00
+date: 2011-01-02 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -44,6 +44,8 @@ extra_rdoc_files:
 - doc/ideas.md
 files: 
 - lib/papermill-agent/agent.rb
+- lib/papermill-agent/configurator.rb
+- lib/papermill-agent/logger.rb
 - lib/papermill-agent/rack/collector.rb
 - lib/papermill-agent/response_adapters/base.rb
 - lib/papermill-agent/response_adapters/rails.rb
@@ -58,9 +60,12 @@ files:
 - Rakefile
 - doc/ideas.md
 - spec/agent_spec.rb
+- spec/configurator_spec.rb
 - spec/integration/rails2_spec.rb
 - spec/integration/rails3_spec.rb
+- spec/logger_spec.rb
 - spec/rack/collector_spec.rb
+- spec/response_adapters/base_spec.rb
 - spec/response_parser_spec.rb
 - spec/spec_helper.rb
 - spec/storage_spec.rb
@@ -98,9 +103,12 @@ specification_version: 3
 summary: The client agent for papermillapp.com
 test_files: 
 - spec/agent_spec.rb
+- spec/configurator_spec.rb
 - spec/integration/rails2_spec.rb
 - spec/integration/rails3_spec.rb
+- spec/logger_spec.rb
 - spec/rack/collector_spec.rb
+- spec/response_adapters/base_spec.rb
 - spec/response_parser_spec.rb
 - spec/spec_helper.rb
 - spec/storage_spec.rb