circuit 0.2.0

data/lib/circuit/version.rb

@@ -0,0 +1,3 @@
+module Circuit
+  VERSION = "0.2.0"
+end

data/spec/internal/app/behaviors/change_path.rb

@@ -0,0 +1,7 @@
+module ChangePath
+  include Circuit::Behavior
+
+  use Circuit::Middleware::Rewriter do |script_name, path_info|
+        ["/site/5#{script_name}", path_info]
+      end
+end

data/spec/internal/app/controllers/application_controller.rb

@@ -0,0 +1,5 @@
+class ApplicationController < ActionController::Base
+  respond_to :html
+
+  protect_from_forgery
+end

data/spec/internal/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/spec/internal/config/initializers/circuit.rb

@@ -0,0 +1,7 @@
+if defined?(::Mongoid)
+  Circuit.set_site_store :mongoid_store
+  Circuit.set_node_store :mongoid_store
+else
+  Circuit.set_site_store :memory_store
+  Circuit.set_node_store :memory_store
+end

data/spec/internal/config/routes.rb

@@ -0,0 +1,3 @@
+Rails.application.routes.draw do
+  #
+end

data/spec/internal/db/schema.rb

@@ -0,0 +1 @@
+# make it empty?

data/spec/lib/circuit/behavior_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe Circuit::Behavior do
+  class Middleware1
+    def initialize(app); end
+  end
+  class Middleware2
+    def initialize(app); end
+  end
+  class Middleware3
+    def initialize(app); end
+  end
+
+  class BaseClass
+    include Circuit::Behavior
+    use Middleware1
+    use Middleware2
+  end
+
+  class InheritedClass < BaseClass
+    use Middleware3
+  end
+
+  module NoBuilderBehavior
+    include Circuit::Behavior
+  end
+
+  let(:base_class) { BaseClass }
+  let(:inherited_class) { InheritedClass }
+  subject { BaseClass }
+
+  it { lambda{Circuit::Behavior}.should_not raise_error }
+  it { lambda{ subject }.should_not raise_error }
+  it { subject.builder.should be_true }
+
+  context 'is listed in ancestors' do
+    subject { base_class.ancestors }
+    it { should include Circuit::Behavior }
+  end
+
+  context 'is listed in inherited ancestors' do
+    subject { inherited_class.ancestors }
+    it { should include Circuit::Behavior }
+  end
+
+  context 'when mixed class is configured' do
+    subject { base_class.builder.instance_variable_get(:@use) }
+    it { subject.each { |u| u.should be_instance_of(Proc) } }
+    it { should have(2).procs}
+    it { subject[0].call(Object.new).class.should == Middleware1 }
+    it { subject[1].call(Object.new).class.should == Middleware2 }
+  end
+
+  context 'inherited stack is configured properly' do
+    subject { inherited_class.builder.instance_variable_get(:@use) }
+    it { subject.each { |u| u.should be_instance_of(Proc) } }
+    it { should have(3).procs}
+    it { subject[0].call(Object.new).class.should == Middleware1 }
+    it { subject[1].call(Object.new).class.should == Middleware2 }
+    it { subject[2].call(Object.new).class.should == Middleware3 }
+  end
+
+  context "without a builder" do
+    subject { NoBuilderBehavior }
+    it { subject.builder?.should be_false }
+  end
+
+  context "without a cru path" do
+    before do
+      @prev_cru_path = Circuit.cru_path
+      Circuit.cru_path = nil
+      NoBuilderBehavior.instance_variable_set(:@cru_path, nil)
+    end
+    subject { NoBuilderBehavior }
+    it { subject.builder?.should be_false }
+    it do
+      expect { subject.cru_path }.
+        to raise_error(Circuit::Behavior::RackupPathError, 
+                       "Rackup path cannot be determined for NoBuilderBehavior")
+    end
+    after { Circuit.cru_path = @prev_cru_path }
+  end
+
+  describe "get constants" do
+    context "already loaded" do
+      before { ChangePath }
+      subject { Circuit::Behavior.get("ChangePath") }
+      it { should == lambda{ChangePath}.call }
+      it { should have_module(Circuit::Behavior) }
+      it { subject.to_s.should == "ChangePath" }
+      it { subject.builder?.should be_true }
+      it "should not dynamically set a constant" do
+        Object.expects(:const_set).never
+        subject
+      end
+      after { Object.unstub(:const_set) }
+    end
+
+    context "load from .cru" do
+      before { Object.send(:remove_const, :RenderOk) if Object.const_defined?(:RenderOk) }
+      subject { Circuit::Behavior.get("RenderOk") }
+      it { should == lambda{RenderOk}.call }
+      it { should have_module(Circuit::Behavior) }
+      it { subject.to_s.should == "RenderOk" }
+      it { subject.builder?.should be_true }
+      it "should dynamically set a constant" do
+        Object.expects(:const_set).once
+        subject
+      end
+      after { Object.unstub(:const_set) }
+    end
+  end
+end

data/spec/lib/circuit/middleware/rewriter_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Circuit::Middleware::Rewriter do
+  include SpecHelpers::LoggerHelpers
+  let(:request) { mock_request() } # http://www.example.com/foo/bar/baz
+
+  def self.run_app(&block)
+    before do
+      @response = ::Rack::Builder.new do
+        use Circuit::Middleware::Rewriter, &block
+        run lambda { |env| [ 200, {}, %w[SCRIPT_NAME PATH_INFO].collect {|k| env[k]} ] }
+      end.to_app.call(mock_request.env)
+    end
+    subject { @response }
+  end
+
+  context "should be able to not rewrite" do
+    run_app { |*args| args }
+    subject { @response }
+    it { should == [ 200, {}, ["", "/foo/bar/baz"] ] }
+
+    context "logger" do
+      subject { logger_output }
+      it { should be_blank }
+    end
+  end
+
+  context "rewrite script_name and path_info" do
+    run_app do |script_name, path_info|
+      ["/site/5#{script_name}", path_info+"/1"]
+    end
+    it { should == [ 200, {}, %w[/site/5 /foo/bar/baz/1] ] }
+
+    context "logger" do
+      subject { logger_output }
+      it { should == "[CIRCUIT] Rewriting: '/foo/bar/baz'->'/site/5/foo/bar/baz/1'\n" }
+    end
+  end
+
+  context "rewrite script_name and not path_info" do
+    run_app do |script_name, path_info|
+      ["/site/5#{script_name}", path_info]
+    end
+    it { should == [ 200, {}, %w[/site/5 /foo/bar/baz] ] }
+
+    context "logger" do
+      subject { logger_output }
+      it { should == "[CIRCUIT] Rewriting: '/foo/bar/baz'->'/site/5/foo/bar/baz'\n" }
+    end
+  end
+
+  context "rewrite path_info and not script_name" do
+    run_app do |script_name, path_info|
+      [script_name, path_info+"/1"]
+    end
+    it { should == [ 200, {}, ["", "/foo/bar/baz/1"] ] }
+
+    context "logger" do
+      subject { logger_output }
+      it { should == "[CIRCUIT] Rewriting: '/foo/bar/baz'->'/foo/bar/baz/1'\n" }
+    end
+  end
+
+  context "should catch and log rewriter errors" do
+    run_app do |*args|
+      raise Circuit::Middleware::RewriteError, "an error occurred"
+    end
+    it { should == [ 200, {}, ["", "/foo/bar/baz"] ] }
+
+    context "logger" do
+      subject { logger_output.split(/\n/) }
+      it { should have(2).lines }
+      it { subject.first.should == "[CIRCUIT] Rewrite Error: an error occurred" }
+      it "second line should have the backtrace" do
+        subject.last.should match(/\A\s+(.+)#{Regexp.quote("rewriter_spec.rb")}\:(\d+)(\:in|$)/)
+      end
+    end
+  end
+end

data/spec/lib/circuit/rack/behavioral_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Circuit::Rack::Behavioral do
+  include Rack::Test::Methods
+  include SpecHelpers::MultiSiteHelper
+
+  class RenderMyMiddlewareBehavior
+    include ::Circuit::Behavior
+
+    use(Class.new do
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        [200, {"Content-Type" => "test/html"}, ["RenderMyMiddlewareBehavior"]]
+      end
+    end)
+  end
+
+  def app
+    stub_app_with_circuit_site setup_site!(root.site, RenderMyMiddlewareBehavior)
+  end
+
+  context 'GET /' do
+    get "/"
+
+    context "status" do
+      subject { last_response.body }
+      it { should include("RenderMyMiddlewareBehavior") }
+    end
+  end
+
+  context 'GET / for site with no root' do
+    def app
+      stub_app_with_circuit_site dup_site_1
+    end
+
+    it "should raise a path not found error" do
+      expect { get '/' }.to raise_error(Circuit::Storage::Nodes::NotFoundError, "Path not found")
+    end
+  end
+
+  context "GET / without site" do
+    def no_site_middleware
+      (Class.new do
+        def initialize(app, site=nil) @app = app; end
+        def call(env) @app.call(env); end
+      end)
+    end
+
+    def app
+      stub_app_with_circuit_site nil, no_site_middleware
+    end
+
+    it "should raise a missing site error" do
+      expect { get "/" }.to raise_error(Circuit::Rack::MissingSiteError, "Rack variable rack.circuit.site is missing")
+    end
+  end
+end

data/spec/lib/circuit/rack/builder_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+describe Circuit::Rack::Builder do
+  context "without an app" do
+    subject { Circuit::Rack::Builder.new }
+    it { should respond_to(:app?) }
+    it { subject.app?.should be_false }
+  end
+
+  context "with an app" do
+    subject { Circuit::Rack::Builder.new(lambda { |env| [200, {}, %w[OK]]}) }
+    it { should respond_to(:app?) }
+    it { subject.app?.should be_true }
+  end
+
+  context "defers to ::Rack::Builder for .ru files" do
+    subject { Circuit::Rack::Builder.parse_file(Circuit.cru_path.join("render_not_found.ru")).first }
+    it { should be_instance_of(Circuit::Rack::Builder) }
+    it do
+      ::Rack::Builder.expects(:parse_file).once
+      subject
+    end
+    after { ::Rack::Builder.unstub(:parse_file) }
+  end
+
+  context "parses .cru files" do
+    subject { Circuit::Rack::Builder.parse_file(Circuit.cru_path.join("render_ok.cru")).first }
+    it { should be_instance_of(Circuit::Rack::Builder) }
+    it do
+      ::Rack::Builder.expects(:parse_file).never
+      subject
+    end
+    after { ::Rack::Builder.unstub(:parse_file) }
+  end
+
+  context "dup without map" do
+    let(:use) { [mock()] }
+    let(:run) { mock() }
+
+    subject do
+      ::Rack::Builder.new.tap do |b|
+        b.instance_variable_set(:@use, use)
+        b.instance_variable_set(:@run, run)
+      end.dup
+    end
+
+    it { subject.instance_variable_get(:@run).should equal(run) }
+    it { subject.instance_variable_get(:@use).should eql(use) }
+    it { subject.instance_variable_get(:@use).should_not equal(use) }
+    it { subject.instance_variable_get(:@map).should be_nil }
+    it { subject.dup.instance_variable_get(:@map).should be_nil }
+  end
+
+  context "dup with map" do
+    let(:use) { [mock()] }
+    let(:map) { {"/" => mock()} }
+    let(:run) { mock() }
+
+    subject do
+      ::Rack::Builder.new.tap do |b|
+        b.instance_variable_set(:@use, use)
+        b.instance_variable_set(:@map, map)
+        b.instance_variable_set(:@run, run)
+      end.dup
+    end
+
+    it { subject.instance_variable_get(:@run).should equal(run) }
+    it { subject.instance_variable_get(:@use).should eql(use) }
+    it { subject.instance_variable_get(:@use).should_not equal(use) }
+    it { subject.instance_variable_get(:@map).should eql(map) }
+    it { subject.instance_variable_get(:@map).should_not equal(map) }
+  end
+end
+
+describe ::Rack::Builder do
+  context "without an app" do
+    subject { ::Rack::Builder.new }
+    it { should respond_to(:app?) }
+    it { subject.app?.should be_false }
+  end
+
+  context "with an app" do
+    subject { ::Rack::Builder.new(lambda { |env| [200, {}, %w[OK]]}) }
+    it { should respond_to(:app?) }
+    it { subject.app?.should be_true }
+  end
+
+  context "dup without map" do
+    let(:use) { [mock()] }
+    let(:run) { mock() }
+
+    subject do
+      ::Rack::Builder.new.tap do |b|
+        b.instance_variable_set(:@use, use)
+        b.instance_variable_set(:@run, run)
+      end.dup
+    end
+
+    it { subject.instance_variable_get(:@run).should equal(run) }
+    it { subject.instance_variable_get(:@use).should eql(use) }
+    it { subject.instance_variable_get(:@use).should_not equal(use) }
+    it { subject.instance_variable_get(:@map).should be_nil }
+    it { subject.dup.instance_variable_get(:@map).should be_nil }
+  end
+
+  context "dup with map" do
+    let(:use) { [mock()] }
+    let(:map) { {"/" => mock()} }
+    let(:run) { mock() }
+
+    subject do
+      ::Rack::Builder.new.tap do |b|
+        b.instance_variable_set(:@use, use)
+        b.instance_variable_set(:@map, map)
+        b.instance_variable_set(:@run, run)
+      end.dup
+    end
+
+    it { subject.instance_variable_get(:@run).should equal(run) }
+    it { subject.instance_variable_get(:@use).should eql(use) }
+    it { subject.instance_variable_get(:@use).should_not equal(use) }
+    it { subject.instance_variable_get(:@map).should eql(map) }
+    it { subject.instance_variable_get(:@map).should_not equal(map) }
+  end
+end

data/spec/lib/circuit/rack/multi_site_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Circuit::Rack::MultiSite do
+  include Rack::Test::Methods
+  include SpecHelpers::MultiSiteHelper
+
+  def app
+    Rack::Builder.app do
+      use Circuit::Rack::MultiSite
+      run Proc.new {|env| [200, {}, ["ok"]] }
+    end
+  end
+
+  context 'GET example.com' do
+    before do
+      get "http://#{site.host}/"
+    end
+
+    context "status" do
+      subject { last_response.status }
+      it { should == 200 }
+    end
+  end
+
+  context "GET baddomain.com" do
+    before do
+      get "http://baddomain.com/"
+    end
+
+    subject { last_response }
+    it { subject.status.should == 404 }
+    it { subject.body.should == "Not Found"}
+  end
+end