rory 0.9.1 → 0.9.2

data/spec/lib/rory/request_parameter_logger_spec.rb

@@ -1,100 +0,0 @@
-describe Rory::RequestParameterLogger do
-
-  let(:logger) { double(:write) }
-  let(:app) { double(:call) }
-  subject { described_class.new(app, logger, :filters => :filters) }
-
-  describe '#initialize' do
-    it 'returns a new RequestParameterLogger' do
-      expect(subject).to be_an_instance_of(Rory::RequestParameterLogger)
-    end
-
-    it 'returns a new RequestParameterLogger with parameters' do
-      expect(subject.instance_variable_get(:@app)).to eq(app)
-      expect(subject.instance_variable_get(:@logger)).to eq(logger)
-      expect(subject.instance_variable_get(:@filters)).to eq(:filters)
-    end
-
-    it 'defaults filters to empty array' do
-      no_filter_logger = described_class.new(app, logger)
-      expect(no_filter_logger.instance_variable_get(:@filters)).to eq([])
-    end
-  end
-
-  describe '#log_request' do
-
-    context 'when logger responds to write' do
-      it 'writes the request to the logger' do
-        allow(subject).to receive(:request_signature).and_return('request_signature')
-        allow(subject).to receive(:filtered_params).and_return('filtered_params')
-        expect(logger).to receive(:write).exactly(2).times
-        subject.send(:log_request)
-      end
-    end
-
-    context 'when logger does not respond to write' do
-      let(:logger) { double(:info) }
-      it 'writes the request to the logger' do
-        allow(subject).to receive(:request_signature).and_return('request_signature')
-        allow(subject).to receive(:filtered_params).and_return('filtered_params')
-        expect(logger).to receive(:info).exactly(2).times
-        subject.send(:log_request)
-      end
-    end
-  end
-
-  describe '#logger' do
-    it 'returns @logger' do
-      expect(subject.send(:logger)).to eq(logger)
-    end
-
-    it 'returns rack.errors ' do
-      subject = described_class.new(:app)
-      subject.instance_variable_set(:@env, {'rack.errors' => 'cocoa'})
-      expect(subject.send(:logger)).to eq('cocoa')
-    end
-  end
-
-  describe '#filtered_params' do
-    it 'filters the params' do
-      expect(Rory::ParameterFilter).to receive(:new).and_return(double(:filter => nil))
-      expect(subject).to receive(:unfiltered_params)
-      subject.send(:filtered_params)
-    end
-  end
-
-  describe '#unfiltered_params' do
-    it 'returns unfiltered params' do
-      expect(Rack::Request).to receive(:new).and_return(double(:params => nil))
-      subject.send(:unfiltered_params)
-    end
-  end
-
-  describe '#request_signature' do
-    it 'returns a request signature formatted string' do
-      env = {
-        'REQUEST_METHOD' => "POST",
-        'PATH_INFO' => "/mushy_mushy",
-        'REMOTE_ADDR' => "127.0.0.1"
-      }
-
-      allow(Time).to receive(:now).and_return("2015-06-08 15:16:42 -0700")
-      subject.instance_variable_set(:@env, env)
-      expect(subject.send(:request_signature)).to eq('Started POST "/mushy_mushy" for 127.0.0.1 at 2015-06-08 15:16:42 -0700')
-    end
-  end
-
-
-  describe '#call' do
-    it 'writes the request and parameters to the log file' do
-      env = {
-        'rack.input' => double(:rewind => nil)
-      }
-      expect(app).to receive(:call).with(env)
-      expect(subject).to receive(:log_request)
-
-      subject.call(env)
-      expect(subject.instance_variable_get(:@env)).to eq(env)
-    end
-  end
-end

data/spec/lib/rory/request_spec.rb

@@ -1,14 +0,0 @@
-RSpec.describe Rory::Request do
-  describe "#uuid" do
-    it "returns the value set by env['rory.request_id']" do
-      env = { "rory.request_id" => "uuid-from_rory_request" }
-      expect(described_class.new(env).uuid).to eq "uuid-from_rory_request"
-    end
-
-    context "when no key exists" do
-      it "returns nil" do
-        expect(described_class.new({}).uuid).to eq nil
-      end
-    end
-  end
-end

data/spec/lib/rory/route_spec.rb

@@ -1,15 +0,0 @@
-describe Rory::Route do
-  describe '#name' do
-    it 'returns concatenated controller and action' do
-      route = described_class.new('/whatever', :to => 'pigeons#index')
-      expect(route.name).to eq 'pigeons_index'
-    end
-  end
-
-  describe "#path_params" do
-    it "extracts params from path into hash" do
-      route = described_class.new('/spoons/:spoon_id/forks/:fork_id', :to => 'cutlery#index')
-      expect(route.path_params('spoons/4/forks/yay')).to eq({ :spoon_id => "4", :fork_id => "yay" })
-    end
-  end
-end

data/spec/lib/rory/support_spec.rb

@@ -1,119 +0,0 @@
-describe Rory::Support do
-  describe ".camelize" do
-    it "camelizes given snake-case string" do
-      expect(Rory::Support.camelize('water_under_bridge')).to eq('WaterUnderBridge')
-    end
-
-    it "leaves already camel-cased string alone" do
-      expect(Rory::Support.camelize('OliverDrankGasoline')).to eq('OliverDrankGasoline')
-    end
-  end
-
-  describe '.require_all_files_in_directory' do
-    it 'requires all files from given path' do
-      allow(Dir).to receive(:[]).with(Pathname.new('spinach').join('**', '*.rb')).
-        and_return(["pumpkins", "some_guy_dressed_as_liberace"])
-      expect(Rory::Support).to receive(:require).with("pumpkins")
-      expect(Rory::Support).to receive(:require).with("some_guy_dressed_as_liberace")
-      Rory::Support.require_all_files_in_directory('spinach')
-    end
-  end
-
-  describe '.constantize' do
-    before(:all) do
-      Object.const_set('OrigamiDeliveryMan', Module.new)
-      OrigamiDeliveryMan.const_set('UnderWhere', Module.new)
-      OrigamiDeliveryMan::UnderWhere.const_set('Skippy', Module.new)
-    end
-
-    after(:all) do
-      Object.send(:remove_const, :OrigamiDeliveryMan)
-    end
-
-    it 'returns constant from camelized name' do
-      expect(Rory::Support.constantize('OrigamiDeliveryMan')).
-        to eq(OrigamiDeliveryMan)
-    end
-
-    it 'returns constant from snake-case string' do
-      expect(Rory::Support.constantize('origami_delivery_man')).
-        to eq(OrigamiDeliveryMan)
-    end
-
-    it 'returns namespaced constant' do
-      expect(Rory::Support.constantize(
-        'origami_delivery_man/under_where/skippy'
-      )).to eq(OrigamiDeliveryMan::UnderWhere::Skippy)
-    end
-  end
-
-  describe '.tokenize' do
-    it 'creates snake_case version of string' do
-      expect(described_class.tokenize('Albus Dumbledore & his_friend')).to eq('albus_dumbledore_and_his_friend')
-    end
-
-    it 'uncamelizes' do
-      expect(described_class.tokenize('thisStrangeJavalikeWord')).to eq('this_strange_javalike_word')
-    end
-
-    it 'returns nil if given nil' do
-      expect(described_class.tokenize(nil)).to be_nil
-    end
-
-    it 'also handles symbols' do
-      expect(described_class.tokenize(:yourFaceIsNice)).to eq('your_face_is_nice')
-    end
-  end
-
-  describe ".try_to_hash" do
-    it "returns given object if it does not respond to #to_hash" do
-      object = double
-      expect(described_class.try_to_hash(object)).to eq(object)
-    end
-
-    it "calls to_hash first if object responds to it" do
-      object = double(:to_hash => { 'april' => 'friday' })
-      expect(described_class.try_to_hash(object)).to eq({ 'april' => 'friday' })
-    end
-
-    it "converts each member of an array" do
-      object = [
-        double(:to_hash => :smurf),
-        double(:to_hash => :nerf)
-      ]
-      expect(described_class.try_to_hash(object)).to eq([:smurf, :nerf])
-    end
-
-    it "converts deeply" do
-      object = [
-        {
-          :perf => double(:to_hash => :smurf),
-          :kerf => [
-            double(:to_hash => :plurf),
-            'yurf'
-          ],
-          :erf => { :burf => double(:to_hash => :wurf) }
-        },
-        double(:to_hash => :nerf)
-      ]
-      expect(described_class.try_to_hash(object)).to eq(
-        [
-          {
-            :perf => :smurf,
-            :kerf => [ :plurf, 'yurf' ],
-            :erf => { :burf => :wurf }
-          },
-          :nerf
-        ]
-      )
-    end
-  end
-
-  describe ".encode_as_json" do
-    it "calls #try_to_hash on object then jsonifies" do
-      foo_hashed = double(:to_json => :jsonified)
-      allow(described_class).to receive(:try_to_hash).with(:foo).and_return(foo_hashed)
-      expect(described_class.encode_as_json(:foo)).to eq(:jsonified)
-    end
-  end
-end

data/spec/lib/rory_spec.rb

@@ -1,15 +0,0 @@
-describe Rory do
-  let!(:new_app) { Class.new(Rory::Application) }
-
-  describe '.application' do
-    it 'is by default set to the Rory::Application instance' do
-      expect(Rory.application).to eq(new_app.instance)
-    end
-  end
-
-  describe '.root' do
-    it 'returns root of application' do
-      expect(Rory.root).to eq(new_app.root)
-    end
-  end
-end

data/spec/requests/controller_spec.rb

@@ -1,27 +0,0 @@
-describe "Controller" do
-  describe "presentation", :type => :feature do
-    it 'renders default action template' do
-      visit '/for_reals/pickles'
-
-      expect(page).to have_text("You've done it again, pickles!")
-      expect(page.status_code).to eq 200
-      expect(page.response_headers['Content-Type']).to eq('text/html')
-    end
-
-    it 'renders json' do
-      visit '/for_reals/switching.json'
-
-      expect(page).to have_text({ :a => 1 }.to_json)
-      expect(page.status_code).to eq 200
-      expect(page.response_headers['Content-Type']).to eq('application/json')
-    end
-
-    it 'renders custom template' do
-      visit '/for_reals/switching'
-
-      expect(page).to have_text("Oh, a secret!")
-      expect(page.status_code).to eq 404
-      expect(page.response_headers['Content-Type']).to eq('text/html')
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,25 +0,0 @@
-require 'simplecov'
-SimpleCov.start
-
-ENV['RORY_ENV'] = 'test'
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'rspec'
-require 'capybara/rspec'
-require 'rory'
-require 'rack'
-
-# Requires supporting files with custom matchers and macros, etc,
-# in ./support/ and its subdirectories.
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
-
-require_relative 'fixture_app/config/application'
-Fixture::Application.root = File.join(File.dirname(__FILE__), 'fixture_app')
-Fixture::Application.require_all_files
-
-Capybara.app = Fixture::Application
-
-RSpec.configure do |config|
-  config.order = "random"
-  config.include GenerationHelpers
-end

data/spec/support/generation_helpers.rb

@@ -1,19 +0,0 @@
-module GenerationHelpers
-  def sandbox_directory
-    Pathname.new(
-      File.join(File.dirname(__FILE__), "..", "sandbox")
-    )
-  end
-
-  def capture_output
-    begin
-      $stdout = StringIO.new
-      yield
-      result = $stdout.string
-    ensure
-      $stdout = STDOUT
-    end
-
-    result
-  end
-end

data/spec/support/shared_examples/path_generation.rb

@@ -1,27 +0,0 @@
-RSpec.configure do |c|
-  c.alias_it_should_behave_like_to :it_has_behavior, 'has behavior:'
-end
-
-shared_examples 'path_generation' do
-  describe '#path_to' do
-    it 'returns mask from route with given name prepended with root slash' do
-      allow(path_generator).to receive(:base_path).and_return(nil)
-      expect(path_generator.path_to('awesome_rad')).
-        to eq '/this/:path/is/:very_awesome'
-    end
-
-    it 'prepends base_path to returned mask' do
-      allow(path_generator).to receive(:base_path).and_return('/strawminos')
-      expect(path_generator.path_to('awesome_rad')).
-        to eq '/strawminos/this/:path/is/:very_awesome'
-    end
-
-    it 'substitutes tokens with given fields' do
-      allow(path_generator).to receive(:base_path).and_return('/strawminos')
-      expect(path_generator.path_to('awesome_rad', :path => 'house', :very_awesome => 352)).
-        to eq '/strawminos/this/house/is/352'
-    end
-  end
-end
-
-