bradphelan-sinatras-hat 0.1.2

data/spec/model_spec.rb

@@ -0,0 +1,152 @@
+require 'spec/spec_helper'
+
+describe Sinatra::Hat::Model do
+  attr_reader :model, :maker, :fake_request
+  
+  before(:each) do
+    build_models!
+  end
+  
+  def new_model(maker=new_maker)
+    Sinatra::Hat::Model.new(maker)
+  end
+  
+  describe "initialization" do
+    it "takes an instance of Maker" do
+      proc {
+        maker = new_maker
+        new_model(maker)
+      }.should_not raise_error
+    end
+  end
+  
+  describe "find_last_modified" do
+    before(:each) do
+      @last_modified_article = Article.create!
+    end
+    
+    it "returns the last modified record" do
+      new_model.find_last_modified([@article, @last_modified_article]).should == @last_modified_article
+    end
+  end
+  
+  describe "all()" do
+    before(:each) do
+      @maker = new_maker
+      @model = new_model(maker)
+    end
+    
+    it "takes the params" do
+      proc {
+        model.all({ })
+      }.should_not raise_error
+    end
+    
+    it "calls the finder" do
+      mock.proxy(maker.options[:finder]).call(Article, { })
+      model.all({ }).should == Article.all
+    end
+  end
+  
+  describe "foreign_key" do
+    before(:each) do
+      @maker = new_maker
+      @model = new_model(maker)
+    end
+    
+    it "returns the singular name with _id" do
+      model.foreign_key.should == "#{model.singular}_id".to_sym
+    end
+  end
+  
+  describe "find_owner" do
+    before(:each) do
+      @maker = new_maker
+      @model = new_model(maker)
+    end
+    
+    it "uses the foreign key to search the params" do
+      model.find_owner(model.foreign_key => @article.to_param).should == @article
+    end
+  end
+  
+  describe "find()" do
+    attr_reader :article
+    
+    before(:each) do
+      @maker = new_maker
+      @model = new_model(maker)
+    end
+    
+    it "takes the params" do
+      proc {
+        model.find(:id => @article.to_param)
+      }.should_not raise_error
+    end
+    
+    it "calls for the :record" do
+      mock.proxy(maker.options[:record]).call(Article, { :id => @article.to_param })
+      model.find(:id => @article.to_param).should == @article
+    end
+  end
+  
+  describe "plural" do
+    it "returns snakecased, pluralized form of model name" do
+      new_model(new_maker(Article)).plural.should == "articles"
+    end
+  end
+  
+  describe "singular" do
+    it "returns snakecased, singular form of model name" do
+      new_model(new_maker(Article)).singular.should == "article"
+    end
+  end
+  
+  describe "update" do
+    it "finds the record" do
+      model = new_model
+      mock.proxy(model).find(anything) { @article }
+      mock.proxy(@article).attributes = { "name" => "Hooray!" }
+      model.update("id" => @article.to_param, "article[name]" => "Hooray!")
+    end
+  end
+  
+  describe "new" do
+    context "when there is no parent" do
+      it "instantiates a new model object" do
+        mock.proxy(Article).new(anything)
+        new_model.new
+      end
+      
+      it "railsifies params passed through" do
+        mock.proxy(Article).new("name" => "The article")
+        new_model.new("article[name]" => "The article")
+      end
+    end
+    
+    context "when there is a parent" do
+      attr_reader :article
+      
+      before(:each) do
+        @maker = new_maker(Article)
+        @maker.setup(mock_app)
+        child_maker = maker.mount(Comment)
+        child_maker.parent = maker
+        @child_model = new_model(child_maker)
+      end
+      
+      context "when there is an association proxy" do
+        it "uses the association proxy" do
+          @child_model.new(:article_id => @article.to_param)
+        end
+      end
+
+      context "when there isn't an association proxy" do
+        it "just returns the klass" do
+          mock.proxy(Comment).new(anything)
+          new_model(maker.mount(Comment)).new
+        end
+      end
+    end
+  end
+end

data/spec/resource_spec.rb

@@ -0,0 +1,74 @@
+require 'spec/spec_helper'
+
+describe Sinatra::Hat::Resource do
+  before(:each) do
+    build_models!
+  end
+  
+  describe "initialization" do
+    it "takes an instance of Maker" do
+      proc {
+        Sinatra::Hat::Resource.new(new_maker)
+      }.should_not raise_error
+    end
+  end
+  
+  describe "paths" do
+    context "when maker has no parent" do
+      before(:each) do
+        maker = new_maker(Article)
+        @resource = Sinatra::Hat::Resource.new(maker)
+      end
+      
+      it "returns normal resource path" do
+        @resource.path('/:id').should == "/articles/:id"
+      end
+      
+      it "can return :root path" do
+        @resource.path('/:id').should == "/articles/:id"
+      end
+      
+      it "can return path for model object" do
+        @resource.path('/:id', @article).should == "/articles/#{@article.to_param}"
+      end
+    end
+    
+    context "when maker has a parent" do
+      before(:each) do
+        @child = new_maker(Comment, :parent => new_maker(Article))
+        @resource = Sinatra::Hat::Resource.new(@child)
+      end
+      
+      it "returns nested resource path" do
+        @resource.path('/:id').should == "/articles/:article_id/comments/:id"
+      end
+      
+      it "doesn't mutate parents" do # regression test
+        @resource.path('/:id').should == "/articles/:article_id/comments/:id"
+        @resource.path('/:id').should == "/articles/:article_id/comments/:id"
+      end
+      
+      it "can return path for model object" do
+        @resource.path('/:id', @comment).should == "/articles/#{@article.to_param}/comments/#{@comment.to_param}"
+      end
+    end
+    
+    context "when maker has multiple parents" do
+      before(:each) do
+        build_model(:replies) { integer :comment_id; belongs_to :comment }
+        @reply = Reply.create! :comment => @comment
+        @child = new_maker(Comment, :parent => new_maker(Article))
+        @grand_child = new_maker(Reply, :parent => @child)
+        @resource = Sinatra::Hat::Resource.new(@grand_child)
+      end
+      
+      it "returns nested resource path" do
+        @resource.path('/:id').should == "/articles/:article_id/comments/:comment_id/replies/:id"
+      end
+      
+      it "can return path for model object" do
+        @resource.path('/:id', @reply).should == "/articles/#{@article.to_param}/comments/#{@comment.to_param}/replies/#{@reply.to_param}"
+      end
+    end
+  end
+end

data/spec/responder_spec.rb

@@ -0,0 +1,139 @@
+require 'spec/spec_helper'
+
+describe Sinatra::Hat::Responder do
+  attr_reader :maker, :responder
+  
+  def new_responder(maker=@maker)
+    Sinatra::Hat::Responder.new(maker)
+  end
+  
+  before(:each) do
+    build_models!
+    @maker = new_maker
+  end
+  
+  describe "initialization" do
+    it "takes an instance of Maker" do
+      proc {
+        Sinatra::Hat::Responder.new(@maker)
+      }.should_not raise_error
+    end
+  end
+  
+  describe "success" do
+    context "when there's a default format" do
+      before(:each) do
+        @maker.format :json
+      end
+      
+      it 'serializes the response with the default format' do
+        request = fake_request
+        responder = new_responder
+        responder.success(:show, request, :article).should == :article.to_json
+      end
+    end
+    
+    context "when there's a format" do
+      it "serializes the response" do
+        request = fake_request(:format => "yaml")
+        mock.proxy(responder = new_responder).serialize(:article, "yaml")
+        responder.success(:show, request, :article)
+      end
+    end
+    
+    context "when there's no format" do
+      it "calls that action's :success proc" do
+        request = fake_request
+        mock.proxy(Sinatra::Hat::Response).new(maker, request) do |response|
+          mock.proxy(response).render(anything)
+        end
+        new_responder.success(:show, request, :article)
+      end
+    end
+    
+    describe "assigning instance variables" do
+      context "when the result is a collection" do
+        it "assigns the plural instance variable in the request" do
+          request = fake_request
+          new_responder.success(:index, request, [:articles])
+          request.instance_eval { @articles }.should == [:articles]
+        end
+      end
+      
+      context "when the result is not a collection" do
+        it "assigns the singular instance variable in the request" do
+          request = fake_request
+          new_responder.success(:show, request, :article)
+          request.instance_eval { @article }.should == :article
+        end
+      end
+      
+      describe "assigning parent instance variables" do
+        before(:each) do
+          @parent_maker = new_maker(Article)
+          @child_maker = new_maker(Comment)
+          @responder = @child_maker.responder
+        end
+      end
+    end
+  end
+  
+  describe "failure" do
+    # context "when there's a format" do
+    #   it "serializes the response" do
+    #     request = fake_request(:format => "yaml")
+    #     mock.proxy(responder = new_responder).serialize("yaml", :article)
+    #     responder.success(:show, request, :article)
+    #   end
+    # end
+    
+    context "when there's no format" do
+      it "calls that action's :failure proc" do
+        request = fake_request
+        mock.proxy(Sinatra::Hat::Response).new(maker, request) do |response|
+          mock(response).redirect(anything)
+        end
+        new_responder.failure(:show, request, :article)
+      end
+    end
+  end
+  
+  describe "serialize()" do
+    before(:each) do
+      @responder = new_responder
+    end
+    
+    context "when there is no formatter" do
+      context "when the data responds to to_*" do
+        it "serializes data and gets mime type" do
+          response, mime = responder.serialize([:article], "yaml")
+          response.should == [:article].to_yaml
+          mime.should == 'text/yaml'
+        end
+      end
+
+      context "when the data doesn't respond to to_*" do
+        it "returns nil" do
+          responder.serialize([:article], "say_what").should be_nil
+        end
+      end
+    end
+    
+    context "when there is a formatter" do
+      before(:each) do
+        maker.formats[:yaml] = proc { |data| [data, :formatted].inspect }
+      end
+      
+      it "returns serialized data and the mime type" do
+        response = responder.serialize(:article, "yaml")
+        response.should == [[:article, :formatted].inspect, 'text/yaml']
+      end
+    end
+  end
+  
+  describe "custom responses using #on" do
+    before(:each) do
+      @responder = new_responder
+    end
+  end
+end

data/spec/response_spec.rb

@@ -0,0 +1,120 @@
+require 'spec/spec_helper'
+
+class Article; end
+
+describe Sinatra::Hat::Response do
+  attr_reader :maker, :response, :request
+  
+  def new_response(maker=@maker)
+    Sinatra::Hat::Response.new(maker, request)
+  end
+  
+  before(:each) do
+    @maker = new_maker
+    @request = fake_request
+    stub(request.options).views { fixture('views') }
+  end
+
+  describe "render()" do
+    describe "rendering templates" do
+      it "renders the index template" do
+        mock.proxy(request).erb :"articles/index"
+        new_response.render(:index)
+      end
+      
+      it "renders the show template" do
+        mock.proxy(request).erb :"articles/show"
+        new_response.render(:show)
+      end
+    end
+    
+    context "when there are options passed" do
+      it "sends the options to the request" do
+        t = Time.now
+        mock(request).last_modified t
+        new_response.render(:show, :last_modified => t)
+      end
+    end
+        
+    context "when there is no views dir" do
+      before(:each) do
+        stub(request.options).views { nil }
+      end
+      
+      it "raises Sinatra::NoTemplateError" do
+        proc {
+          new_response.render(:show)
+        }.should raise_error(Sinatra::NoTemplateError)
+      end
+    end
+    
+    context "when the view does not exist" do
+      it "raises Sinatra::NoTemplateError" do
+        proc {
+          new_response.render(:nonsense)
+        }.should raise_error(Sinatra::NoTemplateError)
+      end
+    end
+  end
+  
+  describe "redirect()" do
+    context "when passed a path" do
+      it "redirects to the given path" do
+        mock(request).redirect("/articles")
+        new_response.redirect("/articles")
+      end
+    end
+    
+    context "when passed a record" do
+      before(:each) do
+        stub(@article = Article.new).id { 2 }
+      end
+      
+      context "when passed a record for the current maker" do
+        it "redirects to the resource path for that data" do
+          mock(request).redirect("/articles/2")
+          new_response.redirect(@article)
+        end
+      end
+
+      context "when passed a record for the current maker" do
+        before(:each) do
+          @article.save!
+          @comment = @article.comments.create!
+          @child_maker = new_maker(Comment, :parent => @maker)
+        end
+        
+        it "redirects to the resource path for that data" do
+          mock(request).redirect("/articles/#{@article.to_param}")
+          new_response(@child_maker).redirect(@article)
+        end
+      end      
+    end
+    
+    context "when passed a symbol" do
+      before(:each) do
+        stub(@article = Article.new).id { 2 }
+      end
+      
+      it "can redirect to the :index path" do
+        mock(request).redirect("/articles")
+        new_response.redirect(:index)
+      end
+      
+      it "can redirect to the :show path" do
+        mock(request).redirect("/articles/2")
+        new_response.redirect(:show, @article)
+      end
+      
+      it "can redirect to the :new path" do
+        mock(request).redirect("/articles/new")
+        new_response.redirect(:new)
+      end
+      
+      it "can redirect to the :edit path" do
+        mock(request).redirect("/articles/2/edit")
+        new_response.redirect(:edit, @article)
+      end
+    end
+  end
+end