rory 0.9.1 → 0.9.2

data/spec/lib/rory/initializers_spec.rb

@@ -1,77 +0,0 @@
-RSpec.describe Rory::Initializers do
-
-  describe "#unshift" do
-    it "adds an item to the front" do
-      subject.unshift("test.1unshift") {}
-      subject.unshift("test.2unshift") {}
-      expect(subject.initializers.map(&:name)).to eq %w(test.2unshift test.1unshift)
-    end
-  end
-
-  describe "#insert" do
-    it "adds an item before another" do
-      subject.add("test.1insert") {}
-      subject.insert("test.1insert", "test.2insert") {}
-      expect(subject.initializers.map(&:name)).to eq %w(test.2insert test.1insert)
-    end
-  end
-
-  describe "#insert_before" do
-    it "adds an item before another" do
-      subject.add("test.1insert_before") {}
-      subject.insert_before("test.1insert_before", "test.2insert_before") {}
-      expect(subject.initializers.map(&:name)).to eq %w(test.2insert_before test.1insert_before)
-    end
-  end
-
-  describe "#insert_after" do
-    it "adds an item at certain point after a given initializer" do
-      subject.add("test.1insert_after") {}
-      subject.add("test.2insert_after") {}
-      subject.insert_after("test.1insert_after", "test.3insert_after") {}
-      expect(subject.initializers.map(&:name)).to eq %w(test.1insert_after test.3insert_after test.2insert_after)
-    end
-  end
-
-  describe "#delete" do
-    it "removes a given initializer from loading" do
-      subject.add("test.delete") {}
-      subject.delete("test.delete")
-      expect(subject.initializers.map(&:name)).to eq []
-    end
-  end
-
-  describe "#add" do
-    it "push an item on the list to be loaded" do
-      subject.add("test.1add") {}
-      subject.add("test.2add") {}
-      expect(subject.initializers.map(&:name)).to eq %w(test.1add test.2add)
-    end
-
-    context "when two initializers have the same name" do
-      it "raises an error" do
-        subject.add("same_name_test") {}
-        expect{subject.add("same_name_test") {}}.to raise_error(/Initializer name: 'same_name_test' is already used./)
-      end
-    end
-  end
-
-  describe "#run" do
-    it "runs the initializers when given an app" do
-      probe = :block_not_run
-      subject.add("test.1add") { |app| probe = app }
-      subject.run(:this_is_the_app)
-      expect(probe).to eq :this_is_the_app
-    end
-  end
-
-  context "delegated array methods" do
-    [:each, :clear, :size, :last, :first].each do |meth|
-      it "##{meth}" do
-        expect(subject.initializers).to receive(meth)
-        subject.public_send(meth)
-      end
-    end
-  end
-end
-

data/spec/lib/rory/logger_spec.rb

@@ -1,90 +0,0 @@
-require "logger"
-require "thread/inheritable_attributes"
-require "rory/logger"
-
-describe Rory::Logger do
-  subject { described_class.new(string_io) }
-  let(:string_io) { StringIO.new }
-  let(:result) { string_io.tap(&:rewind).read }
-
-  let(:simple_format) {
-    subject.formatter = Proc.new do |severity, _, _, msg, tagged|
-      "#{severity} #{tagged} - #{msg}"
-    end
-  }
-
-  let(:rory_request_id) { "1111-2222" }
-
-  before { Thread.current[:inheritable_attributes] = {:rory_request_id => rory_request_id} }
-  after { Thread.current[:inheritable_attributes] = nil }
-
-  context "when tagged is empty" do
-    subject { described_class.new(string_io, tagged: []) }
-    it "does not tag anything" do
-      simple_format
-      subject.<< "Hello"
-      expect(result).to eq "Hello"
-    end
-  end
-
-  context "creating custom tags" do
-    subject { described_class.new(string_io, tagged: [:custom_tag, :request_id]) }
-    it "needs an instance method go along with new tag" do
-      def subject.custom_tag
-        "Words.."
-      end
-      simple_format
-      subject.<< "Hello"
-      expect(result).to eq "custom_tag=Words.. request_id=1111-2222 Hello"
-    end
-  end
-
-  describe "#<<" do
-    it "tags are present with this form" do
-      simple_format
-      subject.<< "Hello"
-      expect(result).to eq "request_id=1111-2222 Hello"
-    end
-  end
-
-  context "when a tagged values has spaces" do
-    let(:rory_request_id) { "1111 2222" }
-    it "is quoted" do
-      simple_format
-      subject.<< "Good Morning"
-      expect(result).to eq 'request_id="1111 2222" Good Morning'
-    end
-  end
-
-  describe "#info" do
-    it "severity level is set to INFO" do
-      simple_format
-      subject.info "Hello"
-      expect(result).to eq "INFO request_id=1111-2222 - Hello"
-    end
-  end
-
-  describe "#formatter" do
-    it "define a custom formatting" do
-      subject.formatter = Proc.new do |_, _, _, msg, tagged|
-        "This is formatted: #{tagged} - #{msg}"
-      end
-      subject.info "Hello"
-      expect(result).to eq "This is formatted: request_id=1111-2222 - Hello"
-    end
-
-    it "has default formatting" do
-      subject.info "Goodbye"
-      expect(result).to match /request_id=1111-2222.*INFO -- : Goodbye\n/
-    end
-  end
-
-  describe "integration with Rack::CommonLogger" do
-    it "only prepends tags" do
-      [200, { "REMOTE_ADDR" => "127.0.0.1", "HTTP_VERSION" => "1.1" }, ""]
-      Rack::CommonLogger.new(Proc.new { |a| a }, subject).send(:log, { "REMOTE_ADDR" => "127.0.0.1", "HTTP_VERSION" => "1.1", Rack::QUERY_STRING => "abc" }, 200, {}, 1)
-      "I, [1111-2222 - 2016-01-20T16:30:52.193516 #5341]  INFO -- : 127.0.0.1 - - [20/Jan/2016:16:30:52 -0800] \" ?abc 1.1\" 200 - 1453336251.1934\n\n"
-      expect(result).to match /request_id=1111-2222 127.0.0.1 - - /
-    end
-  end
-end

data/spec/lib/rory/middleware_stack_spec.rb

@@ -1,86 +0,0 @@
-RSpec.describe Rory::MiddlewareStack do
-
-  let(:middleware_order) { subject.middlewares.map(&:klass).map(&:name) }
-
-  describe "#unshift" do
-    it "adds an item to the front" do
-      subject.unshift(double(name: "unshift1")) {}
-      subject.unshift(double(name: "unshift2"), 1, 2)
-
-      expect(middleware_order).to eq %w(unshift2 unshift1)
-    end
-  end
-
-  describe "#insert" do
-    it "adds an item to the end" do
-      insert1 = (double(name: "insert1"))
-      subject.use(insert1) {}
-      subject.insert(insert1, double(name: "insert2"), 1, 2)
-
-      expect(middleware_order).to eq %w(insert2 insert1)
-    end
-  end
-
-  describe "#insert_before" do
-    it "adds an item to the end" do
-      insert1 = (double(name: "insert_before1"))
-      subject.use(insert1) {}
-      subject.insert(insert1, double(name: "insert_before2"), 1, 2)
-
-      expect(middleware_order).to eq %w(insert_before2 insert_before1)
-    end
-  end
-
-  describe "#insert_after" do
-    it "adds an item at certain point after a given middleware" do
-      insert_after1 = double(name: "test.1insert_after")
-      subject.use(insert_after1) {}
-      subject.use(double(name: "test.2insert_after")) {}
-      subject.insert_after(insert_after1, double(name: "test.3insert_after")) {}
-      expect(middleware_order).to eq %w(test.1insert_after test.3insert_after test.2insert_after)
-    end
-  end
-
-  describe "#delete" do
-    it "removes a given middleware from loading" do
-      test_delete = double(name: "delete")
-      subject.use(test_delete)
-      subject.delete(test_delete)
-      expect(middleware_order).to eq []
-    end
-  end
-
-  describe "#use" do
-    it "push an item on the list to be loaded" do
-      subject.use(double(name: "use1")) {}
-      subject.use(double(name: "use2"), 1, 2)
-
-      expect(middleware_order).to eq %w(use1 use2)
-    end
-
-    it "arguments will be saved" do
-      subject.use(double(name: "use1")) {}
-      subject.use(double(name: "use2"), 1, 2)
-
-      expect(subject.middlewares.map(&:args)).to eq [[], [1, 2]]
-    end
-
-    it "blocks will be saved" do
-      probe = :block_not_called
-      subject.use(double(name: "use1")) {probe = :block_called}
-      subject.use(double(name: "use2"), 1, 2)
-      subject.middlewares.map(&:block).compact.map(&:call)
-      expect(probe).to eq :block_called
-    end
-  end
-
-  context "delegated array methods" do
-    [:each, :clear, :size, :last, :first].each do |meth|
-      it "##{meth}" do
-        expect(subject.middlewares).to receive(meth)
-        subject.public_send(meth)
-      end
-    end
-  end
-end
-

data/spec/lib/rory/parameter_filter_spec.rb

@@ -1,50 +0,0 @@
-describe Rory::ParameterFilter do
-
-  describe '#initialize' do
-    it 'sets the filters' do
-      expect(subject.instance_variable_get(:@filters)).to eq []
-    end
-  end
-
-  describe '#filter' do
-    it 'returns params unchanged' do
-      unfiltered_params = {"address"=>"11802 MCDONALD ST, Los Angeles, CA 90230",
-                "owners"=>[{"first_name"=>"GOLD", "last_name"=>"PATH", "ssn"=>"000-02-9999"}],
-                "overrides"=>{"ofac_7403"=>"clear"}}
-
-      expect(subject.filter(unfiltered_params)).to eq unfiltered_params
-    end
-
-    it 'returns params filtered by' do
-      subject = described_class.new([:ssn])
-      unfiltered_params = {"address"=>"11802 MCDONALD ST, Los Angeles, CA 90230",
-                "owners"=>[{"first_name"=>"GOLD", "last_name"=>"PATH", "ssn"=>"000-02-9999"}],
-                "overrides"=>{"ofac_7403"=>"clear"}}
-
-      filtered_params = {"address"=>"11802 MCDONALD ST, Los Angeles, CA 90230",
-                           "owners"=>[{"first_name"=>"GOLD", "last_name"=>"PATH", "ssn"=>"[FILTERED]"}],
-                           "overrides"=>{"ofac_7403"=>"clear"}}
-
-
-      expect(subject.filter(unfiltered_params)).to eq filtered_params
-    end
-
-    it 'filters based upon regex' do
-
-      filter_words = []
-      filter_words << /ofac*/
-
-      subject = described_class.new(filter_words)
-
-      unfiltered_params = {:address=>"11802 MCDONALD ST, Los Angeles, CA 90230",
-                           "owners"=>[{"first_name"=>"GOLD", "last_name"=>"PATH", "ssn"=>"000-02-9999"}],
-                           "overrides"=>{"ofac_7403"=>"clear"}}
-
-      filtered_params = {:address=>"11802 MCDONALD ST, Los Angeles, CA 90230",
-                           "owners"=>[{"first_name"=>"GOLD", "last_name"=>"PATH", "ssn"=>"000-02-9999"}],
-                           "overrides"=>{"ofac_7403"=>"[FILTERED]"}}
-
-      expect(subject.filter(unfiltered_params)).to eq filtered_params
-    end
-  end
-end

data/spec/lib/rory/renderer/context_spec.rb

@@ -1,41 +0,0 @@
-describe Rory::Renderer::Context do
-  it_has_behavior 'path_generation' do
-    let(:path_generator) {
-      Rory::Renderer::Context.new({
-        :app => Fixture::Application
-      })
-    }
-  end
-
-  describe "#render" do
-    it "returns sub-renderer output" do
-      renderer_context = Rory::Renderer::Context.new({
-        :app => :an_app,
-        :base_path => 'yoyo'
-      })
-      passed_renderer_options = {
-        :layout => false, :app => :an_app, :base_path => 'yoyo'
-      }
-      allow(Rory::Renderer).to receive(:new).
-        with('not/real', passed_renderer_options).
-        and_return(double('Renderer', :render => 'Here ya go'))
-      expect(renderer_context.render('not/real')).to eq('Here ya go')
-    end
-
-    it "does not pass locals or layout to sub-renderer" do
-      renderer_context = Rory::Renderer::Context.new({
-        :locals => { :thing => :great },
-        :app => :an_app,
-        :base_path => 'yoyo',
-        :layout => 'groooovy'
-      })
-      passed_renderer_options = {
-        :layout => false, :app => :an_app, :base_path => 'yoyo'
-      }
-      allow(Rory::Renderer).to receive(:new).
-        with('also/fake', passed_renderer_options).
-        and_return(double('Renderer', :render => 'Scamazing!'))
-      expect(renderer_context.render('also/fake')).to eq('Scamazing!')
-    end
-  end
-end

data/spec/lib/rory/renderer_spec.rb

@@ -1,50 +0,0 @@
-describe Rory::Renderer do
-  describe "#render" do
-    let(:app) { Fixture::Application }
-
-    it "returns text of template" do
-      renderer = Rory::Renderer.new('test/static', :app => app)
-      expect(renderer.render).to eq('Static content')
-    end
-
-    it "returns text of template in given layout" do
-      controller = Rory::Renderer.new('test/static', :layout => 'surround', :app => app)
-      expect(controller.render).to eq('Surrounding Static content is fun')
-    end
-
-    it "handles symbolized layout name" do
-      controller = Rory::Renderer.new('test/static', :layout => :surround, :app => app)
-      expect(controller.render).to eq('Surrounding Static content is fun')
-    end
-
-    it "exposes locals to template" do
-      controller = Rory::Renderer.new('test/dynamic', :locals => { :word => 'hockey' }, :app => app)
-      expect(controller.render).to eq('Word: hockey')
-    end
-
-    it "can render nested templates" do
-      controller = Rory::Renderer.new('test/double_nested', :locals => { :word => 'hockey' }, :app => app)
-      expect(controller.render).to eq( 
-        "Don't Say A Bad Word: Poop!"
-      )
-    end
-
-    it "exposes base_path to template" do
-      controller = Rory::Renderer.new('test/a_link', :base_path => 'spoo', :app => app)
-      expect(controller.render).to eq('You came from spoo.')
-    end
-  end
-
-  describe '#view_path' do
-    it 'returns path to template from app root' do
-      fake_app = double('Application', :root => 'marbles')
-      renderer = Rory::Renderer.new('goose', :app => fake_app)
-      expect(renderer.view_path).to eq(File.expand_path(File.join('views', 'goose.html.erb'), 'marbles'))
-    end
-
-    it 'uses Rory.root if no app specified' do
-      renderer = Rory::Renderer.new('goose', :app => double(:root => "horse"))
-      expect(renderer.view_path).to eq(File.expand_path(File.join('views', 'goose.html.erb'), "horse"))
-    end
-  end
-end

data/spec/lib/rory/request_id_spec.rb

@@ -1,56 +0,0 @@
-RSpec.describe Rory::RequestId do
-  subject { described_class.new(Proc.new {|env|[200, headers, ""] },
-                                uuid_prefix:  uuid_prefix,
-                                uuid_creator: class_double(SecureRandom, uuid: "1234")) }
-  after { Thread.current[:inheritable_attributes] = nil }
-  let(:headers) { {} }
-  let(:env) { {} }
-  let(:uuid_prefix) { nil }
-
-  context "when no external_request_id is set" do
-    before { subject.call(env) }
-
-    it "sets env['rory.request_id']" do
-      expect(env["rory.request_id"]).to eq "1234"
-    end
-
-    it "sets header['X-Request-Id']" do
-      expect(headers["X-Request-Id"]).to eq "1234"
-    end
-
-    it "sets Thread.current[:rory_request_id]" do
-      expect(Thread.current.get_inheritable_attribute(:rory_request_id)).to eq "1234"
-    end
-
-    context "the uuid can be given a prefixed to know where it was created" do
-      let(:uuid_prefix) { "app_name" }
-      it { expect(Thread.current.get_inheritable_attribute(:rory_request_id)).to eq "app_name-1234" }
-    end
-  end
-
-  context "when external_request_id is set" do
-    before { subject.call(env) }
-    let(:env) { { "HTTP_X_REQUEST_ID" => "4321" } }
-
-    it "sets env['rory.request_id']" do
-      expect(env["rory.request_id"]).to eq "4321"
-    end
-
-    it "sets header['X-Request-Id']" do
-      expect(headers["X-Request-Id"]).to eq "4321"
-    end
-
-    it "sets Thread.current[:rory_request_id]" do
-      expect(Thread.current.get_inheritable_attribute(:rory_request_id)).to eq "4321"
-    end
-  end
-
-  context "use default SecureRandom" do
-    subject { described_class.new(Proc.new {|env|[200, headers, ""] },
-                                  uuid_prefix:  uuid_prefix).call({}) }
-    it "call uuid on SecureRandom" do
-      expect(SecureRandom).to receive(:uuid).once
-      subject
-    end
-  end
-end