confuddle 0.0.1

data/lib/unfuzzle/test/unit/unfuzzle/milestone_test.rb

@@ -0,0 +1,100 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+module Unfuzzle
+  class MilestoneTest < Test::Unit::TestCase
+
+    context "The Milestone class" do
+
+      should "be able to find all by project ID" do
+        project_id = 1
+
+        response = mock_request_cycle :for => "/projects/#{project_id}/milestones", :data => 'milestones'
+
+        Unfuzzle::Milestone.expects(:collection_from).with(response.body, 'milestones/milestone').returns(['milestone_1', 'milestone_2'])
+
+        Milestone.find_all_by_project_id(project_id).should == ['milestone_1', 'milestone_2']
+      end
+      
+      should "be able to find one by project ID an milestone ID" do
+        project_id    = 1
+        milestone_id  = 2
+        response = mock_request_cycle :for => "/projects/#{project_id}/milestones/#{milestone_id}", :data => 'milestone'
+        
+        Unfuzzle::Milestone.expects(:new).with(response.body).returns('milestone')
+        
+        Milestone.find_by_project_id_and_milestone_id(1, 2).should == 'milestone'
+      end
+
+    end
+
+    context "An instance of the Milestone class" do
+
+      when_populating Milestone, :from => 'milestone' do
+
+        value_for :id,          :is => 2
+        value_for :project_id,  :is => 1
+        value_for :archived,    :is => false
+        value_for :created_at,  :is => Time.parse('2009-04-02T19:43:16Z')
+        value_for :name,        :is => 'Milestone #1'
+        value_for :due_on,      :is => Date.parse('2009-04-03')
+        value_for :updated_at,  :is => Time.parse('2009-07-02T16:40:28Z')
+
+      end
+
+      context "with a new instance" do
+
+        setup { @milestone = Milestone.new }
+
+        should "know that it is archived" do
+          @milestone.stubs(:archived).with().returns(true)
+          @milestone.archived?.should be(true)
+        end
+
+        should "know that it isn't archived" do
+          @milestone.stubs(:archived).with().returns(false)
+          @milestone.archived?.should be(false)
+        end
+
+        should "have associated tickets" do
+          id         = 1
+          project_id = 1
+
+          Ticket.expects(:find_all_by_project_id_and_milestone_id).with(project_id, id).returns('tickets')
+
+          @milestone.stubs(:id).with().returns(id)
+          @milestone.stubs(:project_id).with().returns(project_id)
+
+          @milestone.tickets.should == 'tickets'
+        end
+        
+        should "know that it's in the past if the due date is in the past" do
+          due_date = Date.today
+          today    = due_date.next
+          
+          @milestone.stubs(:due_on).with().returns(due_date)
+          Date.expects(:today).with().returns(today)
+          
+          @milestone.past?.should be(true)
+        end
+        
+        should "know that it's not in the past if the date is today" do
+          due_date = Date.today
+          @milestone.stubs(:due_on).with().returns(due_date)
+          
+          @milestone.past?.should be(false)
+        end
+        
+        should "know that it's not in the past if the due date is in the future" do
+          due_date = Date.today.next
+          @milestone.stubs(:due_on).with().returns(due_date)
+          
+          @milestone.past?.should be(false)
+        end
+        
+
+      end
+
+    end
+
+  end
+end

data/lib/unfuzzle/test/unit/unfuzzle/priority_test.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+module Unfuzzle
+  class PriorityTest < Test::Unit::TestCase
+
+    def self.should_have_a_name_of(name, options)
+      should "have a name of '#{name}' when the priority is #{options[:when]}" do
+        p = Priority.new(options[:when])
+        p.name.should == name
+      end
+    end
+      
+    
+    context "An instance of the Priority class" do
+      
+      should_have_a_name_of 'Highest',  :when => 5
+      should_have_a_name_of 'High',     :when => 4
+      should_have_a_name_of 'Normal',   :when => 3
+      should_have_a_name_of 'Low',      :when => 2
+      should_have_a_name_of 'Lowest',   :when => 1
+      
+    end
+    
+  end
+end

data/lib/unfuzzle/test/unit/unfuzzle/project_test.rb

@@ -0,0 +1,87 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+module Unfuzzle
+  class ProjectTest < Test::Unit::TestCase
+
+    context "The Project class" do
+
+      should "be able to return a list of all projects" do
+        response = mock_request_cycle :for => '/projects', :data => 'projects'
+      
+        Unfuzzle::Project.expects(:collection_from).with(response.body, 'projects/project').returns(['project_1', 'project_2'])
+      
+        Project.all.should == ['project_1', 'project_2']
+      end
+
+      should "be able to find a project by its slug" do
+        slug = 'blip'
+
+        response = mock_request_cycle :for => "/projects/by_short_name/#{slug}", :data => 'project'
+
+        Unfuzzle::Project.expects(:new).with(response.body).returns('project')
+
+        Project.find_by_slug(slug).should == 'project'
+      end
+
+      should "be able to find a project by its ID" do
+        id = 1
+
+        response = mock_request_cycle :for => "/projects/#{id}", :data => 'project'
+
+        Unfuzzle::Project.expects(:new).with(response.body).returns('project')
+
+        Project.find_by_id(id).should == 'project'
+      end
+
+
+    end
+
+    context "An instance of the Project class" do
+
+      when_populating Project, :from => 'project' do
+      
+        value_for :id,          :is => 1
+        value_for :archived,    :is => false
+        value_for :slug,        :is => 'blip'
+        value_for :name,        :is => 'Blip Bleep Co.'
+        value_for :description, :is => 'This is the project for Blip Bleep Co.'
+        value_for :created_at,  :is => Time.parse('2008-07-28T16:57:10Z')
+        value_for :updated_at,  :is => Time.parse('2009-04-28T18:48:52Z')
+      
+      end
+
+      context "with a new instance" do
+
+        setup { @project = Project.new }
+
+        should "know that it's archived" do
+          @project.stubs(:archived).with().returns(true)
+          @project.archived?.should be(true)
+        end
+
+        should "know that it's not archived" do
+          @project.stubs(:archived).with().returns(false)
+          @project.archived?.should be(false)
+        end
+
+        should "have a list of associated milestones" do
+          id = 1
+          Milestone.expects(:find_all_by_project_id).with(id).returns('milestones')
+
+          @project.stubs(:id).with().returns(id)
+          @project.milestones.should == 'milestones'
+        end
+
+        should "have a list of associated tickets" do
+          id = 1
+          Ticket.expects(:find_all_by_project_id).with(id).returns('tickets')
+
+          @project.stubs(:id).with().returns(id)
+          @project.tickets.should == 'tickets'
+        end
+        
+      end
+    end
+
+  end
+end

data/lib/unfuzzle/test/unit/unfuzzle/request_test.rb

@@ -0,0 +1,104 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+module Unfuzzle
+  class RequestTest < Test::Unit::TestCase
+    
+    context "The Request class" do
+      
+      should "be able to perform a GET request" do
+        request = mock() {|r| r.expects(:get).with().returns('response') }
+        Unfuzzle::Request.expects(:new).with('/projects').returns(request)
+        
+        Unfuzzle::Request.get('/projects').should == 'response'
+      end
+      
+      should "be able to perform a PUT request" do
+        request = mock() {|r| r.expects(:put).with().returns('response') }
+        Unfuzzle::Request.expects(:new).with('/projects', '<payload>').returns(request)
+        
+        Unfuzzle::Request.put('/projects', '<payload>').should == 'response'
+      end
+      
+    end
+    
+    context "An instance of the Request class" do
+
+      should "have an endpoint URI" do
+        Unfuzzle.stubs(:subdomain).with().returns('viget')
+        
+        request = Unfuzzle::Request.new('/projects')
+        request.endpoint_uri.should == URI.parse('http://viget.unfuddle.com/api/v1/projects.xml')
+      end
+      
+      should "have an endpoint URI with the appropriate format when specified" do
+        Unfuzzle.stubs(:subdomain).with().returns('viget')
+        
+        request = Unfuzzle::Request.new('/projects', nil)
+        request.endpoint_uri.should == URI.parse('http://viget.unfuddle.com/api/v1/projects.xml')
+      end
+      
+      should "have a client" do
+        client = stub()
+        
+        request = Unfuzzle::Request.new('/projects')
+        request.stubs(:endpoint_uri).with().returns(URI.parse('http://example.com'))
+        
+        Net::HTTP.expects(:new).with('example.com').returns(client)
+        
+        request.client.should == client
+      end
+      
+      should "be able to perform a GET request" do
+        Unfuzzle.stubs(:username).with().returns('username')
+        Unfuzzle.stubs(:password).with().returns('password')
+        
+        request = Unfuzzle::Request.new('/projects')
+        request.stubs(:endpoint_uri).returns(URI.parse('http://example.com/projects'))
+        
+        get_request = mock() do |g|
+          g.expects(:basic_auth).with('username', 'password')
+        end
+        
+        client = mock() {|c| c.expects(:request).with(get_request).returns('response') }
+        
+        response = stub()
+        Unfuzzle::Response.expects(:new).with('response').returns(response)
+        
+        Net::HTTP::Get.expects(:new).with('/projects').returns(get_request)
+        
+        request.stubs(:client).with().returns(client)
+        
+        request.get.should == response
+      end
+      
+      should "be able to perform a PUT request" do
+        Unfuzzle.stubs(:username).with().returns('username')
+        Unfuzzle.stubs(:password).with().returns('password')
+        
+        request_body = '<payload>'
+        
+        request = Unfuzzle::Request.new('/projects', request_body)
+        
+        request.stubs(:endpoint_uri).returns(URI.parse('http://example.com/projects'))
+        
+        put_request = mock() do |p|
+          p.expects(:basic_auth).with('username', 'password')
+          p.expects(:content_type=).with('application/xml')
+        end
+        
+        client = mock() {|c| c.expects(:request).with(put_request, request_body).returns('response') }
+        
+        response = stub()
+        Unfuzzle::Response.expects(:new).with('response').returns(response)
+        
+        Net::HTTP::Put.expects(:new).with('/projects').returns(put_request)
+        
+        request.stubs(:client).with().returns(client)
+        
+        request.put.should == response
+      end
+      
+    end
+    
+  end
+end

data/lib/unfuzzle/test/unit/unfuzzle/response_test.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+module Unfuzzle
+  class ResponseTest < Test::Unit::TestCase
+    
+    context "An instance of the Response class" do
+      
+      should "delegate to the HTTP response to determine the body" do
+        http_response = mock() {|r| r.expects(:body).with().returns('check mah boday') }
+        
+        response = Unfuzzle::Response.new(http_response)
+        
+        response.body.should == 'check mah boday'
+      end
+      
+      should "know that there are no errors" do
+        http_response = mock() do |r|
+          r.expects(:is_a?).with(Net::HTTPSuccess).returns(true)
+        end
+        
+        response = Unfuzzle::Response.new(http_response)
+        response.error?.should be(false)
+      end
+      
+      should "know if there are errors" do
+        http_response = mock() do |r|
+          r.expects(:is_a?).with(Net::HTTPSuccess).returns(false)
+        end
+        
+        response = Unfuzzle::Response.new(http_response)
+        response.error?.should be(true)
+      end
+      
+    end
+    
+  end
+end

data/lib/unfuzzle/test/unit/unfuzzle/severity_test.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+module Unfuzzle
+  class SeverityTest < Test::Unit::TestCase
+    
+    context "The Severity class" do
+      
+      should "be able to return a severity for a project and severity id" do
+        project_id  = 1
+        severity_id = 1
+        
+        response = mock_request_cycle :for => "/projects/#{project_id}/severities/#{severity_id}", :data => 'severity'
+
+        Unfuzzle::Severity.expects(:new).with(response.body).returns('severity')
+        
+        Unfuzzle::Severity.find_by_project_id_and_severity_id(project_id, severity_id).should == 'severity'
+      end
+      
+    end
+    
+    context "An instance of the Severity class" do
+      
+      when_populating Severity, :from => 'severity' do
+
+        value_for :id,          :is => 1
+        value_for :name,        :is => 'Story'
+        value_for :project_id,  :is => 2
+        value_for :created_at,  :is => Time.parse('2009-04-02T19:44:49Z')
+        value_for :updated_at,  :is => Time.parse('2009-04-02T19:44:49Z')
+        
+      end
+      
+    end
+    
+  end
+end

data/lib/unfuzzle/test/unit/unfuzzle/ticket_test.rb

@@ -0,0 +1,181 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+module Unfuzzle
+  class TicketTest < Test::Unit::TestCase
+
+    context "The Ticket class" do
+
+      should "be able to return a list of tickets for a project" do
+        project_id = 1
+
+        response = mock_request_cycle :for => "/projects/#{project_id}/tickets", :data => 'tickets'
+
+        Unfuzzle::Ticket.expects(:collection_from).with(response.body, 'tickets/ticket').returns(['ticket_1', 'ticket_2'])
+
+        Ticket.find_all_by_project_id(project_id).should == ['ticket_1', 'ticket_2']
+      end
+
+      should "be able to return a list of tickets for a milestone" do
+        milestone_id = 1
+        project_id   = 1
+
+        response = mock_request_cycle :for => "/projects/#{project_id}/milestones/#{milestone_id}/tickets", :data => 'tickets'
+
+        Unfuzzle::Ticket.expects(:collection_from).with(response.body, 'tickets/ticket').returns(['ticket_1', 'ticket_2'])
+        
+        Ticket.find_all_by_project_id_and_milestone_id(project_id, milestone_id).should == ['ticket_1', 'ticket_2']
+      end
+
+    end
+
+    context "An instance of the Ticket class" do
+
+      when_populating Ticket, :from => 'ticket' do
+
+        value_for :id,                :is => 1
+        value_for :project_id,        :is => 1
+        value_for :milestone_id,      :is => 1
+        value_for :severity_id,       :is => 123
+        value_for :priority_id,       :is => 3
+        value_for :component_id,      :is => 1
+        value_for :created_at,        :is => Time.parse('2008-11-25T14:00:19Z')
+        value_for :updated_at,        :is => Time.parse('2008-12-31T15:51:41Z')
+        value_for :number,            :is => '1'
+        value_for :title,             :is => 'Ticket #1'
+        value_for :description,       :is => 'Do something important'
+        value_for :due_on,            :is => nil
+        value_for :status,            :is => 'closed'
+
+      end
+      
+      should_set_a_value_for :title
+      should_set_a_value_for :description
+      
+      context "with a new instance" do
+        setup { @ticket = Ticket.new }
+
+        should "have a due date" do
+          xml = '<ticket><due-on>2009-08-01</due-on></ticket>'
+          
+          ticket = Ticket.new(xml)
+          ticket.due_on.should == Date.parse('2009-08-01')
+        end
+        
+        should "have an associated milestone" do
+          Milestone.expects(:find_by_project_id_and_milestone_id).with(1, 2).returns('milestone')
+          
+          @ticket.stubs(:project_id).with().returns(1)
+          @ticket.stubs(:milestone_id).with().returns(2)
+          
+          @ticket.milestone.should == 'milestone'
+        end
+        
+        should "have an associated severity" do
+          project_id  = 1
+          severity_id = 1
+
+          Severity.expects(:find_by_project_id_and_severity_id).with(project_id, severity_id).returns('severity')
+          
+          @ticket.stubs(:project_id).with().returns(project_id)
+          @ticket.stubs(:severity_id).with().returns(severity_id)
+          
+          @ticket.severity.should == 'severity'
+        end
+        
+        should "have no associated severity if it is not set" do
+          @ticket.stubs(:severity_id).with().returns(nil)
+          @ticket.severity.should be(nil)
+        end
+        
+        should "have a severity_name" do
+          @ticket.stubs(:severity).with().returns(stub(:name => 'Story'))
+          @ticket.severity_name.should == 'Story'
+        end
+        
+        should "have no severity_name if there is no severity" do
+          @ticket.stubs(:severity).with().returns(nil)
+          @ticket.severity_name.should be(nil)
+        end
+        
+        should "have an associated priority" do
+          Priority.expects(:new).with(1).returns('priority')
+          
+          @ticket.stubs(:priority_id).with().returns(1)
+          @ticket.priority.should == 'priority'
+        end
+        
+        should "have a priority_name" do
+          @ticket.stubs(:priority).with().returns(stub(:name => 'High'))
+          @ticket.priority_name.should == 'High'
+        end
+        
+        should "have an associated component" do
+          project_id  = 1
+          component_id = 1
+
+          Component.expects(:find_by_project_id_and_component_id).with(project_id, component_id).returns('component')
+          
+          @ticket.stubs(:project_id).with().returns(project_id)
+          @ticket.stubs(:component_id).with().returns(component_id)
+          
+          @ticket.component.should == 'component'
+        end
+
+        should "have no associated component if it is not set" do
+          @ticket.stubs(:component_id).with().returns(nil)
+          @ticket.component.should be(nil)
+        end
+        
+        should "have a component_name" do
+          @ticket.stubs(:component).with().returns(stub(:name => 'Admin'))
+          @ticket.component_name.should == 'Admin'
+        end
+        
+        should "have no component_name if there is no component" do
+          @ticket.stubs(:component).with().returns(nil)
+          @ticket.component_name.should be(nil)
+        end
+        
+        should "be able to generate a hash representation of itself for updating" do
+          @ticket.id           = 1
+          @ticket.project_id   = 2
+          @ticket.milestone_id = 3
+          @ticket.number       = '12'
+          @ticket.title        = 'summary'
+          @ticket.description  = 'description'
+          @ticket.status       = 'closed'
+
+          
+          expected = {
+            'id'           => 1,
+            'project_id'   => 2,
+            'milestone_id' => 3,
+            'number'       => '12',
+            'summary'      => 'summary',
+            'description'  => 'description',
+            'status'       => 'closed'
+          }
+          
+          @ticket.to_hash.should == expected          
+        end
+        
+        should "be able to perform an update" do
+          @ticket.stubs(:project_id).with().returns(1)
+          @ticket.stubs(:id).with().returns(2)
+          
+          resource_path = '/projects/1/tickets/2'
+          ticket_xml    = '<ticket />'
+          
+          @ticket.stubs(:to_xml).with('ticket').returns(ticket_xml)
+          
+          Unfuzzle::Request.expects(:put).with(resource_path, ticket_xml).returns('response')
+          
+          @ticket.update.should == 'response'
+        end
+
+      end
+
+    end
+
+  end
+end