circuit 0.2.0

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

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Circuit::Rack::Request do
+  context "Rack::Request should have module" do
+    it { ::Rack::Request.included_modules.should include(::Circuit::Rack::Request) }
+  end
+
+  describe "site" do
+    let(:site) { mock() }
+
+    context "get" do
+      subject { mock_request(Circuit::Rack::Request::ENV_SITE => site).site }
+      it { should == site }
+    end
+
+    context "set" do
+      subject { mock_request.tap { |r| r.site = site } }
+      it { subject.site.should == site }
+      it { subject.env[Circuit::Rack::Request::ENV_SITE].should == site }
+    end
+  end
+
+  describe "path segments" do
+    context "splits by slashes" do
+      subject { mock_request.path_segments }
+      it { should == [nil]+%w[foo bar baz] }
+    end
+
+    context "path_segments with blanks and double slashes" do
+      subject { mock_request(:path => "/foo//bar/baz///").path_segments }
+      it { should == [nil]+%w[foo bar baz] }
+    end
+
+    context "class method" do
+      it do
+        ::Rack::Request.expects(:path_segments).once.with("/foo/bar/baz")
+        mock_request.path_segments
+      end
+      after { ::Rack::Request.unstub(:path_segments) }
+    end
+  end
+
+  describe "route" do
+    let(:route) { mock() }
+
+    context "none" do
+      subject { mock_request.route }
+      it { should be_nil }
+    end
+
+    context "get" do
+      subject { mock_request(Circuit::Rack::Request::ENV_ROUTE => route).route }
+      it { should == route }
+    end
+
+    context "set" do
+      let(:path) { "/foo/bar/baz" }
+      let(:route) { mock(:last => mock(:path => path), :length => 4) }
+      subject { mock_request.tap { |r| r.route = route } }
+      it { subject.route.should == route }
+      it { subject.env["SCRIPT_NAME"].should == "/foo/bar/baz" }
+      it { subject.env["PATH_INFO"].should == "" }
+      it { subject.path.should == "/foo/bar/baz" }
+      it { subject.circuit_originals["SCRIPT_NAME"].should == "" }
+      it { subject.circuit_originals["PATH_INFO"].should == "/foo/bar/baz" }
+    end
+
+    context "set partial path" do
+      let(:path) { "/foo/bar" }
+      let(:route) { mock(:last => mock(:path => path), :length => 3) }
+      subject { mock_request.tap { |r| r.route = route } }
+      it { subject.route.should == route }
+      it { subject.env["SCRIPT_NAME"].should == "/foo/bar" }
+      it { subject.env["PATH_INFO"].should == "/baz" }
+      it { subject.path.should == "/foo/bar/baz" }
+      it { subject.circuit_originals["SCRIPT_NAME"].should == "" }
+      it { subject.circuit_originals["PATH_INFO"].should == "/foo/bar/baz" }
+    end
+  end
+end

data/spec/lib/circuit/railtie_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Circuit::Railtie do
+  context "middlewares" do
+    subject { Rails.application.config.middleware }
+    it { subject[0].klass.should == Circuit::Rack::MultiSite }
+    it { subject[1].klass.should == Circuit::Rack::Behavioral }
+  end
+
+  context "default cru_path" do
+    subject { Circuit.cru_path }
+    it { should == Rails.root.join("app", "behaviors") }
+  end
+
+  context "application paths" do
+    subject { Rails.application.config.paths.all_paths }
+    it { should include(["app/behaviors"]) }
+  end
+
+  context "eager load paths" do
+    subject { Rails.application.config.paths.eager_load }
+    it { should include(Circuit.cru_path.to_s) }
+    it do
+      Dir.glob(Circuit.cru_path.join("**", "*.rb")).each do |path|
+        subject.should include(path)
+      end
+    end
+  end
+
+  context "logger" do
+    subject { Circuit.logger }
+    it { should equal(Rails.logger) }
+  end
+end

data/spec/lib/circuit/storage/nodes_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Circuit::Storage::Nodes do
+  include SpecHelpers::StoresCleaner
+  include SpecHelpers::BaseModels
+
+  describe Circuit::Storage::Nodes::BaseStore do
+    context "unimplemented store" do
+      class Circuit::Storage::Nodes::UnimplementedStore < Circuit::Storage::Nodes::BaseStore
+      end
+
+      subject { Circuit::Storage::Nodes::UnimplementedStore.new }
+
+      it do
+        expect { subject.get("foo", "bar") }.
+          to raise_error(Circuit::Storage::Nodes::UnimplementedError, "Circuit::Storage::Nodes::UnimplementedStore#get not implemented.")
+      end
+
+      it do
+        expect { subject.get!("foo", "bar") }.
+          to raise_error(Circuit::Storage::Nodes::UnimplementedError, "Circuit::Storage::Nodes::UnimplementedStore#get not implemented.")
+      end
+    end
+
+    context "empty store" do
+      class Circuit::Storage::Nodes::EmptyStore < Circuit::Storage::Nodes::BaseStore
+        def get(site, path) nil; end
+      end
+
+      subject { Circuit::Storage::Nodes::EmptyStore.new }
+
+      it { subject.get("foo", "bar").should be_nil }
+
+      it do
+        expect { subject.get!("foo", "bar").
+          to raise_error(Circuit::Storage::Nodes::NotFoundError, "Host not found")
+        }
+      end
+    end
+  end
+
+  describe Circuit::Storage::Nodes::MemoryStore do
+    use_storage :memory_store
+    let!(:store) { :memory_store }
+    include_examples "node store"
+
+    describe Circuit::Storage::Nodes::MemoryStore::Node do
+      subject { child }
+      it { should have_attribute(:slug) }
+      it { should have_attribute(:behavior_klass) }
+      it { should have_attribute(:site) }
+      it { should have_attribute(:parent) }
+      it { should have_attribute(:children) }
+    end
+  end
+
+  describe "Circuit::Storage::Nodes::MongoidStore", :if => $mongo_tests do
+    use_storage :mongoid_store
+    let!(:store) { :mongoid_store }
+    include_examples "node store"
+  end
+end

data/spec/lib/circuit/storage/sites_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Circuit::Storage::Sites do
+  include SpecHelpers::StoresCleaner
+  include SpecHelpers::BaseModels
+
+  describe Circuit::Storage::Sites::BaseStore do
+    context "unimplemented store" do
+      class Circuit::Storage::Sites::UnimplementedStore < Circuit::Storage::Sites::BaseStore
+      end
+
+      subject { Circuit::Storage::Sites::UnimplementedStore.new }
+
+      it do
+        expect { subject.get("foo") }.
+          to raise_error(Circuit::Storage::Sites::UnimplementedError, "Circuit::Storage::Sites::UnimplementedStore#get not implemented.")
+      end
+
+      it do
+        expect { subject.get!("foo") }.
+          to raise_error(Circuit::Storage::Sites::UnimplementedError, "Circuit::Storage::Sites::UnimplementedStore#get not implemented.")
+      end
+    end
+
+    context "empty store" do
+      class Circuit::Storage::Sites::EmptyStore < Circuit::Storage::Sites::BaseStore
+        def get(host) nil; end
+      end
+
+      subject { Circuit::Storage::Sites::EmptyStore.new }
+
+      it { subject.get("foo").should be_nil }
+
+      it do
+        expect { subject.get!("foo").
+          to raise_error(Circuit::Storage::Sites::NotFoundError, "Host not found")
+        }
+      end
+    end
+  end
+
+  describe Circuit::Storage::Sites::MemoryStore do
+    use_storage :memory_store
+    let!(:store) { :memory_store }
+    include_examples "site store"
+
+    describe Circuit::Storage::Sites::MemoryStore::Site do
+      subject { site }
+      it { should have_attribute(:host) }
+      it { should have_attribute(:aliases) }
+      it { should have_attribute(:route) }
+    end
+  end
+
+  describe "Circuit::Storage::Sites::MongoidStore", :if => $mongo_tests do
+    use_storage :mongoid_store
+    let!(:store) { :mongoid_store }
+    include_examples "site store"
+  end
+end

data/spec/lib/circuit/storage_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Circuit::Storage do
+  include SpecHelpers::StoresCleaner
+
+  context "undefined site store" do
+    it do
+      expect { Circuit.site_store }.
+        to raise_error(Circuit::Storage::InstanceUndefinedError, "Storage instance is undefined.")
+    end
+  end
+
+  context "undefined node store" do
+    it do
+      expect { Circuit.node_store }.
+        to raise_error(Circuit::Storage::InstanceUndefinedError, "Storage instance is undefined.")
+    end
+  end
+
+end

data/spec/lib/circuit/validators_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+require 'circuit/validators'
+
+describe Circuit::Validators do
+  describe Circuit::Validators::DomainValidator do
+    subject { DomainValidator.new(:attributes => :domain) }
+    let(:record) { stub(:errors => ActiveModel::Errors.new(nil)) }
+
+    context "with a top level domain" do
+      before { subject.validate_each(record, :domain, "localhost") }
+      it { record.errors.should be_empty }
+    end
+
+    context "with a real domain name" do
+      before { subject.validate_each(record, :domain, "google.com") }
+      it { record.errors.should be_empty }
+    end
+
+    context "with a subdomain" do
+      before { subject.validate_each(record, :domain, "plus.google.com") }
+      it { record.errors.should be_empty }
+    end
+
+    context "with a invalid characters" do
+      before { subject.validate_each(record, :domain, "bad%domain.com") }
+      it { record.errors.to_hash.should == {:domain => ["is not a valid domain."]} }
+    end
+  end
+
+  describe Circuit::Validators::DomainArrayValidator do
+    subject { DomainArrayValidator.new(:attributes => :aliases) }
+    let(:record) { stub(:errors => ActiveModel::Errors.new(nil)) }
+
+    context "with a String" do
+      before { subject.validate_each(record, :domain, "localhost") }
+      it { record.errors.should be_empty }
+    end
+
+    context "with an empty array" do
+      before { subject.validate_each(record, :domain, []) }
+      it { record.errors.should be_empty }
+    end
+
+    context "with multiple bad domains" do
+      before { subject.validate_each(record, :domain, %w[bad%domain1.com bad%domain2.com]) }
+      it { record.errors.to_hash.should == {:domain => ["has an invalid domain."]} }
+    end
+
+    context "with all good domains" do
+      before { subject.validate_each(record, :domain, %w[google.com plus.google.com www.google.com]) }
+      it { record.errors.should be_empty }
+    end
+  end
+
+  describe Circuit::Validators::SlugValidator do
+    subject { SlugValidator.new(:attributes => :slug) }
+    let(:record) { stub(:errors => ActiveModel::Errors.new(nil)) }
+
+    context "with a valid slug" do
+      before { subject.validate_each(record, :slug, "a-path-segment") }
+      it { record.errors.should be_empty }
+    end
+
+    context "with an invalid slug" do
+      before { subject.validate_each(record, :slug, "%") }
+      it { record.errors.to_hash.should == {:slug => ["is not a valid path segment."]} }
+    end
+  end
+end

data/spec/lib/circuit_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+require 'stringio'
+
+describe Circuit do
+  include SpecHelpers::LoggerHelpers
+  include SpecHelpers::StoresCleaner
+
+  context 'object' do
+    subject { lambda { Circuit } }
+    it { should_not raise_error }
+  end
+
+  context "logger" do
+    context "default" do
+      subject { Circuit.logger }
+      it { should be_instance_of(::Logger) }
+    end
+
+    context "set" do
+      before &:clean_logger!
+      let(:new_logger) { ::Logger.new(StringIO.new) }
+      before { Circuit.logger = new_logger }
+      subject { Circuit.logger }
+      it { should == new_logger }
+    end
+
+    context "change" do
+      let(:new_logger) { ::Logger.new(StringIO.new) }
+      before { Circuit.logger = new_logger }
+      subject { Circuit.logger }
+      it { should == new_logger }
+      it { should_not == default_logger }
+    end
+  end
+
+  context "site store" do
+    let(:klass) { $mongo_tests ? Circuit::Storage::Sites::MongoidStore : Circuit::Storage::Sites::MemoryStore }
+
+    context "get" do
+      let(:mock_instance) { mock() }
+      before { Circuit::Storage::Sites.expects(:instance).returns(mock_instance) }
+      after { Circuit::Storage::Sites.unstub(:instance) }
+      it { Circuit.site_store.should == mock_instance}
+    end
+
+    context "not set" do
+      it do
+        expect { Circuit.site_store }.
+          to raise_error(Circuit::Storage::InstanceUndefinedError, "Storage instance is undefined.")
+      end
+      it { expect { Circuit::Site }.to raise_error(NameError) }
+    end
+
+    context "set by class" do
+      before { Circuit.set_site_store klass }
+      it { Circuit.site_store.should be_instance_of klass }
+      it { Circuit::Site.should == klass.const_get(:Site) }
+    end
+
+    context "set by instance" do
+      let(:instance) { klass.new }
+      before { Circuit.set_site_store instance }
+      it { Circuit.site_store.should == instance }
+      it { Circuit::Site.should == klass.const_get(:Site) }
+    end
+
+    context "set by symbol" do
+      before { Circuit.set_site_store($mongo_tests ? :mongoid_store : :memory_store) }
+      it { Circuit.site_store.should be_instance_of(klass) }
+      it { Circuit::Site.should == klass.const_get(:Site) }
+    end
+
+    context "set wrong type" do
+      it do
+        expect { Circuit.set_site_store Object.new }.
+          to raise_error(ArgumentError, "Unexpected type for storage instance: Object")
+      end
+    end
+
+    context "set with no Site class" do
+      it do
+        expect { Circuit.set_site_store Object }.
+          to raise_error(ArgumentError, "Cannot determine a Site or Node class for storage type: Object")
+      end
+    end
+  end
+
+  context "node store" do
+    let(:klass) { $mongo_tests ? Circuit::Storage::Nodes::MongoidStore : Circuit::Storage::Nodes::MemoryStore }
+
+    context "get" do
+      let(:mock_instance) { mock() }
+      before { Circuit::Storage::Nodes.expects(:instance).returns(mock_instance) }
+      after { Circuit::Storage::Nodes.unstub(:instance) }
+      it { Circuit.node_store.should == mock_instance}
+    end
+
+    context "not set" do
+      it do
+        expect { Circuit.node_store }.
+          to raise_error(Circuit::Storage::InstanceUndefinedError, "Storage instance is undefined.")
+      end
+      it { expect { Circuit::Node }.to raise_error(NameError) }
+    end
+
+    context "set by class" do
+      before { Circuit.set_node_store klass }
+      it { Circuit.node_store.should be_instance_of klass }
+      it { Circuit::Node.should == klass.const_get(:Node) }
+    end
+
+    context "set by instance" do
+      let(:instance) { klass.new }
+      before { Circuit.set_node_store instance }
+      it { Circuit.node_store.should == instance }
+      it { Circuit::Node.should == klass.const_get(:Node) }
+    end
+
+    context "set by symbol" do
+      before { Circuit.set_node_store($mongo_tests ? :mongoid_store : :memory_store) }
+      it { Circuit.node_store.should be_instance_of klass }
+      it { Circuit::Node.should == klass.const_get(:Node) }
+    end
+
+    context "set wrong type" do
+      it do
+        expect { Circuit.set_node_store Object.new }.
+          to raise_error(ArgumentError, "Unexpected type for storage instance: Object")
+      end
+    end
+
+    context "set with no Node class" do
+      it do
+        expect { Circuit.set_node_store Object }.
+          to raise_error(ArgumentError, "Cannot determine a Site or Node class for storage type: Object")
+      end
+    end
+  end
+end