bacchus 0.0.9 → 0.1.0

data/lib/bacchus.rb

@@ -1,2 +1,4 @@
 require "bacchus/version"
+require "bacchus/access_pass"
+require "bacchus/backend"
 require "bacchus/rack/beta_site"

data/lib/bacchus/access_pass.rb

@@ -0,0 +1,24 @@
+module Bacchus
+  class AccessPass # TODO: AccessCode elsewhere (backend, see other places).
+    PARAM_KEY = "access_pass"
+    COOKIE_KEY = "access_pass"
+
+    def self.get(request)
+      AccessPass.new(request)
+    end
+
+    def initialize(request)
+      param = request.params[PARAM_KEY]
+      @pass = param || request.cookies[COOKIE_KEY] || ""
+      @updated = !param.nil? && !param.empty?
+    end
+    
+    def maybe_save(response)
+      response.set_cookie(COOKIE_KEY, @pass) if @updated
+    end
+    
+    def to_s
+      @pass
+    end
+  end
+end

data/lib/bacchus/backend.rb

@@ -0,0 +1,21 @@
+require 'rest_client'
+
+module Bacchus
+  class Backend    
+    def initialize(base_url)
+      @base_url = base_url
+    end
+    
+    def locked?(access_pass)
+      RestClient.get(path_to("/api/1/access/#{access_pass.to_s}")) do |response, _|
+        return response.code != 200
+      end
+    end
+    
+    def path_to(resource)
+      File.join(@base_url, resource)
+    end
+  end
+end
+
+      

data/lib/bacchus/rack/beta_site.rb

@@ -21,31 +21,48 @@ module Rack
       @excluded_routes = options[:except] || []
       @access_form_routes = options[:access_through] || []
       @access_template_route = options[:access_template] or raise "Specify the route to the template for the access form."
-      @server = options[:server] or raise "Specify the address of the server."
+      base_url = options[:backend] or raise "Specify the address of the backend server."
+      @backend = Bacchus::Backend.new(base_url)
     end
 
     def call(env)
       request = Request.new(env)
-      if access_form_route?(request)
-        request.path = @access_template_route
-        env["PATH_INFO"]        = request.path
-        env["REQUEST_URI"]      = request.fullpath
-        render_with_bacchus(env)
-      elsif access_denied?(request)
-        render_locked
-      else
-        @app.call(env)
-      end  
+      access_pass = Bacchus::AccessPass.get(request)
+      status, headers, body = respond_to(request, access_pass)
+      response = Response.new(body, status, headers)
+      access_pass.maybe_save(response)
+      response.finish
     end
   
     private
+
+    def respond_to(request, access_pass)
+      if @backend.locked?(access_pass)
+        if access_form_route?(request)
+          return render_with_bacchus(redirect(request, @access_template_route))
+        elsif access_denied?(request)
+          return render_locked
+        end
+      end
+      
+      @app.call(request.env)
+    end
+
+    def redirect(original_request, path)
+      request = original_request.dup
+      request.path = @access_template_route
+      env = request.env
+      env["PATH_INFO"]        = request.path
+      env["REQUEST_URI"]      = request.fullpath
+      Request.new(env)
+    end
   
     def access_form_route?(request) # TODO: Duplication -- access_denied? & excluded_route?
       @access_form_routes.index {|route| matching_path?(request, route)} 
     end
   
-    def render_with_bacchus(env)
-      status, headers, body = @app.call(env)
+    def render_with_bacchus(request)
+      status, headers, body = @app.call(request.env)
       script = <<-EOS
 <script src="#{path_to('bacchus.js')}" type="text/javascript"></script>
       EOS
@@ -57,7 +74,7 @@ module Rack
     ########################################################
   
     def path_to(file)
-      ::File.join(@server, file)
+      @backend.path_to(file)
     end
   
     ########################################################

data/lib/bacchus/version.rb

@@ -1,3 +1,3 @@
 module Bacchus
-  VERSION = "0.0.9"
+  VERSION = "0.1.0"
 end

data/spec/bacchus/access_pass_spec.rb

@@ -0,0 +1,54 @@
+require_relative '../../lib/bacchus/access_pass'
+
+module Bacchus
+  describe AccessPass do
+    let(:request) { mock("request") }
+    let(:access_pass) { "399tehu" }
+
+    before(:each) do
+      request.stub!(:params).and_return({})
+      request.stub!(:cookies).and_return({})
+    end
+
+    context "retrieving" do
+      it "should try to get it from request params" do
+        request.should_receive(:params).and_return({})
+        AccessPass.get(request)
+      end
+    
+      it "should get it from params if present" do
+        request.stub!(:params).and_return("access_pass" => access_pass)
+        AccessPass.get(request).to_s.should == access_pass
+      end
+    
+      it "should get it from cookies if not in params" do
+        request.stub!(:params).and_return({})
+        request.should_receive(:cookies).and_return("access_pass" => access_pass)
+        AccessPass.get(request).to_s.should == access_pass
+      end
+    
+      it "should be empty if neither in params nor in cookies" do
+        request.stub!(:params).and_return({})
+        request.stub!(:cookies).and_return({})
+        AccessPass.get(request).to_s.should == ""
+      end
+    end
+  
+    context "saving" do
+      let(:response) { mock("response") }
+    
+      it "should save if updated from params" do
+        request.stub!(:params).and_return("access_pass" => access_pass)
+        response.should_receive(:set_cookie).with("access_pass", access_pass)
+        AccessPass.get(request).maybe_save(response)
+      end
+    
+      it "should not save if not updated" do
+        request.stub!(:params).and_return({})
+        request.stub!(:cookies).and_return("access_pass" => access_pass)
+        response.should_not_receive(:set_cookie)
+        AccessPass.get(request).maybe_save(response)
+      end
+    end
+  end
+end

data/spec/bacchus/rack/beta_site_spec.rb

@@ -1,47 +1,95 @@
 require 'rack/mock'
 require_relative '../../../lib/bacchus/rack/beta_site'
+require_relative '../../../lib/bacchus/backend'
+require_relative '../../../lib/bacchus/access_pass'
 
 describe Rack::BetaSite do
   let(:app) { lambda { |env| app_response } }
   let(:app_response) { [200, { 'Content-Type' => 'text/plain' }, ['<body>hello</body>']] }
   let(:access_template_route) { "/access_template" }
-  let(:middleware) { Rack::BetaSite.new(app, except: ["/", %r{^/open/?$}], access_through: ["/form"], server: "localhost", access_template: access_template_route) }
+  let(:backend) { mock("backend").as_null_object }
+  let(:access_pass) { mock("access_pass").as_null_object }
+  let(:middleware) { Rack::BetaSite.new(app, except: ["/", %r{^/open/?$}], access_through: ["/form"], backend: "localhost", access_template: access_template_route) }
+  
+  before(:each) do
+    Bacchus::Backend.stub!(:new).and_return(backend)
+    Bacchus::AccessPass.stub!(:get).and_return(access_pass)
+  end
   
   def response_for(sample_app, path) 
     sample_app.call(Rack::MockRequest.env_for(path))
   end
   
+  it "should query the backend if the site is locked" do
+    request = mock("request").as_null_object
+    Rack::Request.stub!(:new).and_return(request)
+    Bacchus::AccessPass.should_receive(:get).with(request).and_return(access_pass)
+    backend.should_receive(:locked?).with(access_pass)
+    response_for(middleware, "/")
+  end
+  
   context "given a locked site" do
+    
+    before(:each) do
+      backend.stub!(:locked?).and_return(true)
+    end
+    
     it "should block access to all pages" do
-      sample_app = middleware
       status, * = response_for(middleware, "/page1")
       status.should == 500
     end
 
     it "should support string exceptions" do
-      sample_app = middleware
       status, * = response_for(middleware, "/")
       status.should == 200
     end
 
     it "should support regex exceptions" do
-      sample_app = middleware
       status, * = response_for(middleware, "/open")
       status.should == 200
     end
   
     it "should render access form script after the body closing tag" do
-      sample_app = middleware
-      status, _, body = response_for(middleware, "/form")
+      status, _, res = response_for(middleware, "/form")
       status.should == 200
-      body.first.should include("hello")
-      body.first.should include("</body>\n<script")
+      res.body.first.should include("hello")
+      res.body.first.should include("</body>\n<script")
     end
     
     it "should redirect to access template" do
-      sample_app = middleware
       app.should_receive(:call).with(hash_including("PATH_INFO" => "/access_template")).and_return(app_response)
       response_for(middleware, "/form")
     end
   end
+  
+  context "given an unlocked site" do
+    before(:each) do
+      backend.stub!(:locked?).and_return(false)
+    end
+    
+    it "should allow access to all pages" do
+      status, * = response_for(middleware, "/page1")
+      status.should == 200
+    end
+
+    it "should not render access form script" do
+      status, _, res = response_for(middleware, "/form")
+      status.should == 200
+      res.body.first.should_not include("</body>\n<script")
+    end
+  end
+  
+  context "should save access code" do
+    let(:response) { mock("response").as_null_object }
+    let(:access_pass) { mock("access_pass") }
+
+    before(:each) do
+      Rack::Response.stub!(:new).and_return(response)
+    end
+    
+    it "should not set if not present" do
+      access_pass.should_receive(:maybe_save).with(response)
+      response_for(middleware, "/")
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bacchus
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-03 00:00:00.000000000 Z
-dependencies: []
+date: 2012-11-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Adds support for private beta invites for Rack-based apps.
 email:
 - gyamtso@gmail.com
@@ -20,9 +36,12 @@ extra_rdoc_files: []
 files:
 - README.md
 - LICENSE.txt
+- lib/bacchus/access_pass.rb
+- lib/bacchus/backend.rb
 - lib/bacchus/rack/beta_site.rb
 - lib/bacchus/version.rb
 - lib/bacchus.rb
+- spec/bacchus/access_pass_spec.rb
 - spec/bacchus/rack/beta_site_spec.rb
 homepage: ''
 licenses: []
@@ -49,4 +68,5 @@ signing_key:
 specification_version: 3
 summary: Beta invites for Rack-based apps.
 test_files:
+- spec/bacchus/access_pass_spec.rb
 - spec/bacchus/rack/beta_site_spec.rb