rad_core 0.0.13

data/spec/http/micelaneous_spec.rb

@@ -0,0 +1,13 @@
+require 'http/spec_helper'
+
+describe "HTTP basics" do
+  it "response should accept string status messages" do
+    response = Rad::Response.new
+    
+    response.status = :error
+    response.status.should == 500
+    
+    response.status = :ok
+    response.status.should == 200
+  end
+end

data/spec/http/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'rspec_ext'
+
+require 'rad/http'
+
+require 'rad/spec/environment'

data/spec/integration/basic_spec/views/smoke_test_spec/action.erb

@@ -0,0 +1 @@
+some content

data/spec/integration/basic_spec.rb

@@ -0,0 +1,79 @@
+require 'integration/spec_helper'
+
+describe "Integration" do
+  with_environment
+  with_http
+  with_load_path spec_dir
+  
+  before :all do
+    HttpController = Rad::HttpController
+    load 'rad/profiles/web.rb'
+  end
+  
+  after :all do        
+    remove_constants %w(
+      HttpController
+      SmokeTestSpec
+      JsonFormatSpec
+      RequestAndSessionSpec
+    )
+  end
+  
+  it "smoke test" do
+    class ::SmokeTestSpec
+      inherit HttpController
+      
+      def action
+        respond_to do |format|
+          format.json{render json: {a: 'b'}}
+          format.html{render inline: "some content"}
+        end
+      end
+    end
+    
+    wcall("/smoke_test_spec/action")
+    response.body.should == %(some content)
+    
+    wcall("/smoke_test_spec/action", format: 'json')
+    response.body.should == %({"a":"b"})
+  end
+  
+  it "json" do
+    class ::JsonFormatSpec
+      inherit HttpController
+      
+      def action
+        render json: {a: 'b'}
+      end
+    end
+    
+    wcall("/json_format_spec/action.json")
+    response.body.should == %({"a":"b"})
+    # response.rson.should == {'result' => 'value'}
+  end
+  
+  it "should have workspace, request, env, and session" do
+    class ::RequestAndSessionSpec
+      inherit HttpController
+            
+      inject workspace: :workspace
+      def action
+        workspace.should_not == nil
+        workspace.env.should_not == nil
+        workspace.request.should_not == nil
+        workspace.request.session.should_not == nil        
+        
+        self.class.request_and_session_passed = true
+        
+        render json: {a: 'b'}
+      end
+      
+      class << self
+        attr_accessor :request_and_session_passed
+      end
+    end
+    
+    wcall('/request_and_session_spec/action.json')
+    RequestAndSessionSpec.request_and_session_passed.should be_true
+  end
+end

data/spec/integration/controller_routing_helper_spec.rb

@@ -0,0 +1,84 @@
+require 'html/spec_helper'
+require 'integration/spec_helper'
+
+describe "UrlHelper" do
+  before :all do
+    class ControllerStub
+      inherit Rad::ControllerRoutingHelper, Rad::ControllerMicelaneousHelper
+    
+      def url_for *args
+        args.first
+      end    
+    end
+  end
+  
+  after :all do
+    remove_constants :ControllerStub
+  end
+  
+  before :each do        
+    @c = ControllerStub.new
+  end
+  
+  def stub_workspace
+    @response = Rad::Response.new
+    @params = Rad::Params.new
+    
+    @workspace = Object.new    
+    @workspace.stub(:params).and_return(@params)
+    @workspace.stub(:response).and_return(@response)
+    
+    @c.stub(:workspace).and_return(@workspace)
+  end
+  
+  def within_request &block
+    @response.body = catch(:halt_render){block.call}
+  end
+  
+  describe "redirect_to" do
+    before :each do
+      stub_workspace
+    end
+    
+    it "html format" do      
+      @params.format = 'html'
+      
+      within_request{@c.redirect_to('/some_book')}
+      @response.status.should == 301
+      @response.headers['Location'].should == "/some_book"
+      @response.body.should =~ /You are being/
+    end
+    
+    it "full url, special case (from error)" do      
+      @params.format = 'html'
+      
+      within_request{@c.redirect_to('http://localhost/some_book')}
+      @response.status.should == 301
+      @response.headers['Location'].should == "http://localhost/some_book"
+      @response.body.should =~ /You are being/
+    end
+        
+    it "js format" do
+      @params.format = 'js'
+      
+      within_request{@c.redirect_to('/some_book')}
+      @response.status.should == 200
+      @response.headers['Location'].should be_blank
+      @response.body_as_string.should == "window.location = '/some_book';"
+    end
+  end 
+  
+  describe "reload_page" do
+    before :each do
+      stub_workspace
+    end
+    
+    it "basic" do            
+      @params.format = 'js'
+      
+      within_request{@c.reload_page}
+      @response.status.should == 200
+      @response.body_as_string.should =~ /reload/
+    end
+  end
+end

data/spec/integration/flash_spec.rb

@@ -0,0 +1,206 @@
+require 'html/spec_helper'
+require 'integration/spec_helper'
+
+describe "Flash" do
+  with_environment environment: :development
+  
+  class MockFlashContext < Rad::MockTemplateContext
+    include Rad::FlashHelper , Rad::ControllerRoutingHelper
+    
+    def url_for *args;
+    end
+  end
+  
+  class FlashTestRenderCaller < Rad::Processor
+    def call
+      context = MockFlashContext.new
+      block = workspace.check_flash.request
+      catch :halt_render do
+        block.call context if block
+      end      
+      workspace.request_done = true
+      
+      next_processor.call
+    end
+  end
+  
+  class FlashTestHelper < Rad::Processor
+    def call
+      block = workspace.check_flash.before_request
+      block.call workspace if block
+      workspace.before_request_done = true
+    
+      next_processor.call
+      
+      block = workspace.check_flash.after_request
+      block.call workspace if block
+      workspace.after_request_done = true    
+    end
+  end
+    
+  before :all do    
+    rad.after :environment do      
+      rad.conveyors.web do |web|
+        web.use Rad::Processors::PrepareParams
+        web.use FlashTestHelper
+        web.use Rad::Processors::PrepareFlash
+        web.use FlashTestRenderCaller
+      end
+    end    
+  end
+  
+  def check_flash opt            
+    workspace = nil 
+    result = Rad::HTTPAdapter.call(Rad::HTTPAdapter.mock_environment, check_flash: opt.to_openobject) do |c|
+      c.call
+      workspace = rad[:workspace]
+    end
+    
+    workspace.before_request_done.should be_true
+    workspace.request_done.should be_true
+    workspace.after_request_done.should be_true    
+    workspace
+  end
+  
+  it "flash should be extracted from session if there's any" do
+    check_flash(
+      before_request: lambda{|workspace|        
+        workspace.params.format = 'html'
+        workspace.request.session['flash'] = {info: 'Ok'}.to_json
+      },
+      request: lambda{|context|
+        context.flash.info.should == "Ok"
+      },
+      after_request: lambda{|workspace|
+        workspace.request.session['flash'].should be_nil
+      }
+    )
+    
+    check_flash(
+      before_request: lambda{|workspace|
+        workspace.params.format = 'html'
+      },
+      request: lambda{|context|
+        context.flash.info.should be_nil
+      }
+    )
+  end
+  
+  it "flash should be seen in the same request" do
+    check_flash(
+      before_request: lambda{|workspace|
+        workspace.params.format = 'html'
+      },
+      request: lambda{|context|
+        context.flash.info = "Ok"
+        context.flash.info.should == "Ok"
+      },
+      after_request: lambda{|workspace|
+        workspace.request.session['flash'].should be_nil
+      }
+    )
+  end
+    
+  it "flash with :redirect should be saved for next request in session" do
+    check_flash(
+      before_request: lambda{|workspace|
+        workspace.params.format = 'html'
+      },
+      request: lambda{|context|
+        context.flash.info = "Ok"
+        context.flash.info.should == "Ok"
+        context.redirect_to '/'
+        context.flash.info.should be_nil
+      },
+      after_request: lambda{|workspace|
+        workspace.request.session['flash'].should == {info: 'Ok'}.to_json
+      }
+    )
+  end
+  
+  it "AJAX ('js' format) flash should be displayed in the same request" do
+    check_flash(
+      before_request: lambda{|workspace|
+        workspace.params.format = 'js'
+      },    
+      request: lambda{|context|
+        context.flash.info = "Ok"
+        context.flash.info.should == "Ok"
+      },
+      after_request: lambda{|workspace|
+        workspace.request.session['flash'].should be_nil
+      }
+    )
+  end
+  
+  it "flash with AJAX redirect ('js' format) should be saved for next request in session" do
+    check_flash(
+      before_request: lambda{|workspace|
+        workspace.params.format = 'js'
+      },      
+      request: lambda{|context|
+        context.flash.info = "Ok"
+        context.flash.info.should == "Ok"
+        context.redirect_to '/'
+        context.flash.info.should be_nil
+      },
+      after_request: lambda{|workspace|
+        workspace.request.session['flash'].should == {info: 'Ok'}.to_json
+      }
+    )
+  end
+  
+  it "multiple messages with non-AJAX request" do
+    check_flash(
+      before_request: lambda{|workspace|
+        workspace.request.session['flash'] = {info: 'Ok'}.to_json
+      },
+      request: lambda{|context|
+        context.flash.error = "Error"
+        context.flash.error.should == "Error"
+        
+        context.flash.info.should == 'Ok'
+      },
+      after_request: lambda{|workspace|
+        workspace.request.session['flash'].should be_nil
+      }
+    )
+    
+    check_flash(
+      before_request: lambda{|workspace|
+        workspace.params.format = 'js'
+        workspace.request.session['flash'] = {info: 'Ok'}.to_json
+      },
+      request: lambda{|context|
+        context.flash.error = "Error"
+        context.flash.error.should == "Error"
+        context.redirect_to '/'
+        context.flash.error.should be_nil
+        
+        context.flash.info.should == 'Ok'
+      },
+      after_request: lambda{|workspace|
+        workspace.request.session['flash'].should == {error: 'Error'}.to_json
+      }
+    )
+  end
+  
+  it "multiple messages with AJAX request" do
+    check_flash(
+      before_request: lambda{|workspace|
+        workspace.params.format = 'js'
+        workspace.request.session['flash'] = {info: 'Ok'}.to_json                
+      },
+      request: lambda{|context|
+        context.flash.error = "Error"
+        context.flash.error.should == "Error"
+        
+        context.flash.info.should == 'Ok'
+      },
+      after_request: lambda{|workspace|
+        workspace.request.session['flash'].should be_nil
+      }
+    )
+  end
+  
+end

data/spec/integration/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'rspec_ext'
+
+require 'rad/profiles/web_require'
+
+require 'rad/spec'

data/spec/integration/spec_helper_spec.rb

@@ -0,0 +1,63 @@
+require "controller/spec_helper"
+
+describe "spec helper" do
+  with_environment
+  with_http
+  with_router
+  
+  before :all do
+    load 'rad/profiles/web.rb'
+    
+    class ::Planes
+      inherit Rad::HttpController
+      
+      def fly
+        render inline: 'all right'
+      end
+    end
+  end
+  
+  after :all do
+    remove_constants :Planes
+  end
+    
+  describe 'wcall' do
+    it "basic usage" do
+      wcall(Planes, :fly).should =~ /all right/
+      wcall('/planes/fly').should =~ /all right/
+    end 
+    
+    it "with :cycle scope" do
+      wcall(Planes, :fly){|c|
+        c.call
+      }.should =~ /all right/
+    end
+    
+    describe "set_wcall" do
+      before :all do
+        set_wcall controller: Planes
+      end
+      
+      it "usage with handy shortcut" do
+        wcall(:fly).should =~ /all right/
+      end
+    end
+  end
+  
+  describe "routes" do
+    before :each do
+      router = rad[:router]
+      router.routes.unshift :restful_router, Rad::RestfulRouter.new
+      router.routes[:restful_router].add :planes, class: Planes
+    end
+    
+    it "url_for, url_for_path" do
+      url_for(Planes, :fly).should == "/planes/fly"
+      url_for_path("/path", key: 'value').should == "/path?key=value"            
+    end
+    
+    it "named routes" do
+      fly_planes_path.should == "/planes/fly"
+    end
+  end
+end

data/spec/integration/view_routing_helper_spec.rb

@@ -0,0 +1,134 @@
+require 'html/spec_helper'
+require 'integration/spec_helper'
+
+describe "UrlHelper" do
+  before :all do
+    class MockRouter < Rad::Router
+      def url_for_path path, params
+        path = if params.blank?
+          path
+        else
+          path + '?' + params.to_a.collect{|a, b| "#{a}=#{b}"}.join("&")
+        end
+        
+        "url_for: #{path}"
+      end
+
+      def url_for_class klass, method, params
+        path = "#{klass}.#{method}"
+        url_for_path path, params
+      end
+    end
+    
+    MOCK_ROUTER = MockRouter.new :class
+    
+    class MockUrlHelperContext < Rad::MockTemplateContext
+      inherit Rad::ViewRoutingHelper
+    
+      def url_for *args
+      
+        opt = args.extract_options!
+        format = opt[:format]
+        args << opt
+      
+        # url = args.inspect.gsub('"', "'")
+        url = MOCK_ROUTER.url_for *args
+    
+        # url = "url_for: #{args.to_s}"
+        url.marks.format = format
+        url
+      end    
+    end
+  end
+  
+  after :all do
+    remove_constants :MOCK_ROUTER, :MockRouter, :MockUrlHelperContext
+  end
+  
+  before :each do        
+    @t = MockUrlHelperContext.new
+  end
+  
+  describe "link_to" do
+    before :all do
+      rad[:config] = Rad::Config.new
+    end
+    
+    after :all do
+      rad.clear
+    end
+    
+    it "should works with url_for attributes" do
+      @t.link_to('Book', Object, :method, {format: 'json'}, class: 'highlight').to_xhtml('a').
+        should_be_fuzzy_equal_to(class: "highlight", href: "url_for: Object.method?format=json", content: "Book")
+        
+      @t.link_to(Object, :method, {format: 'json'}, class: 'highlight'){'Book'}.to_xhtml('a').
+        should_be_fuzzy_equal_to(class: "highlight", href: "url_for: Object.method?format=json", content: "Book")
+        
+      @t.link_to('Book', :method).to_xhtml('a').
+        should_be_fuzzy_equal_to(href: "url_for: .method", content: "Book")
+    end
+    
+    it "should works with url_for_path attributes" do
+      @t.link_to('Book', '/some_book', class: 'highlight').to_xhtml('a').
+        should_be_fuzzy_equal_to(class: "highlight", href: "/some_book", content: "Book")      
+      
+      @t.link_to('/some_book', class: 'highlight'){'Book'}.to_xhtml('a').
+        should_be_fuzzy_equal_to(class: "highlight", href: "/some_book", content: "Book")
+        
+      @t.link_to('/some_book'){'Book'}.to_xhtml('a').
+        should_be_fuzzy_equal_to(href: "/some_book", content: "Book")
+    end
+    
+    it "links for 'js', 'json' formats should be automatically became remote" do
+      @t.link_to('Book', @t.url_for('/some_book', format: 'json')).to_xhtml('a').should_be_fuzzy_equal_to(
+        href: "url_for: /some_book?format=json", content: "Book",
+        onclick: "$(this).link_to({method: 'get', ajax: true}); return false;"
+      )
+      
+      @t.link_to('Book', :method, {format: 'js'}, class: 'highlight').to_xhtml('a').should_be_fuzzy_equal_to(
+        href: "url_for: .method?format=js", content: "Book", class: 'highlight',
+        onclick: "$(this).link_to({method: 'get', ajax: true}); return false;"
+      )
+    end
+    
+    it "confirm" do
+      @t.link_to('Book', '/some_book', confirm: 'Are you shure?').to_xhtml('a').should_be_fuzzy_equal_to(
+        href: "/some_book", content: "Book",
+        onclick: "return confirm('Are you shure?');"
+      )
+    end
+    
+    it "POST method" do
+      @t.link_to('Book', '/some_book', method: :post).to_xhtml('a').should_be_fuzzy_equal_to(
+        href: "/some_book", content: "Book",
+        onclick: "$(this).link_to({method: 'post'}); return false;"
+      )
+    end
+    
+    it "remote" do
+      @t.link_to('Book', '/some_book', remote: true).to_xhtml('a').should_be_fuzzy_equal_to(
+        href: "/some_book", content: "Book",
+        onclick: "$(this).link_to({method: 'get', ajax: true}); return false;"
+      )
+    end
+    
+    it ":back" do
+      env = Object.new
+      env.stub(:[]).and_return('/go_back')
+      request = Object.new
+      request.stub(:env).and_return(env)
+      workspace = Object.new
+      workspace.stub(:request).and_return(request)
+      @t.stub(:workspace).and_return(workspace)
+      
+      @t.link_to('Book', :back).to_xhtml('a').should_be_fuzzy_equal_to(href: "/go_back", content: "Book")
+      @t.link_to('Book', :back, class: '_some_js_mark').to_xhtml('a').
+        should_be_fuzzy_equal_to(href: "/go_back", class: '_some_js_mark', content: "Book")
+    end
+    
+    it "#" do
+      @t.link_to('Book', '#').to_xhtml('a').should_be_fuzzy_equal_to(href: "#", content: "Book")
+    end
+  end
+end

data/spec/mail/mail_controller_spec/views/body_template_spec/signup.erb

@@ -0,0 +1 @@
+Hello <%= @name %>, signup notification.

data/spec/mail/mail_controller_spec.rb

@@ -0,0 +1,61 @@
+require "mail/spec_helper"
+
+describe "MailController" do
+  with_environment
+  with_mail
+  with_view_path "#{spec_dir}/views"
+  
+  before :all do
+    MailController = Rad::MailController
+  end
+  
+  after :all do
+    remove_constants %w(
+      MailController
+      ExplicitBodySpec
+      BodyTemplateSpec
+    )
+  end
+  
+  def common_letter
+    {from: "john@mail.com", to: "ben@mail.com", subject: "hi there"}.to_openobject
+  end
+  
+  describe "building letter" do
+    it "shouldn't render view if body explicitly specified" do    
+      class ::ExplicitBodySpec
+        inherit MailController
+      
+        def signup model
+          @from, @to, @subject = model.from, model.to, model.subject
+          @body = "Hello Ben, signup notification."
+        end
+      end      
+      
+      letter = ExplicitBodySpec.signup(common_letter.merge(body: 'Hello Ben, signup notification.'))
+      letter.to_h.to_openobject.should == common_letter.merge(body: 'Hello Ben, signup notification.')
+    end
+    
+    it "should use template for body" do
+      class ::BodyTemplateSpec
+        inherit MailController
+      
+        def signup model, name
+          @name = name
+          @from, @to, @subject = model.from, model.to, model.subject
+        end
+      end
+  
+      letter = BodyTemplateSpec.signup(common_letter, "Ben")
+      letter.to_h.to_openobject.should == common_letter.merge(body: 'Hello Ben, signup notification.')
+    end
+  end
+  
+  it "delivering" do
+    letter = Rad::Letter.new common_letter.merge(body: "some text")
+    letter.deliver
+    letter.deliver
+    
+    sent_letters.should == [letter, letter]
+  end    
+end

data/spec/mail/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rspec_ext'
+
+require 'rad/profiles/mail'
+
+require 'rad/spec/environment'
+require 'rad/spec/template'
+require 'rad/spec/mail'