taskrabbit 0.0.1

data/spec/taskrabbit/smash_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe Taskrabbit::Smash do
+
+  let(:api) { mock }
+  subject { Taskrabbit::Something.new({:name => 'Something'}, api) }
+  
+  module Taskrabbit
+    class Something < Smash
+      property :name
+    end
+  end
+
+  describe ".find" do
+    it "should raise error if there is no id passed" do
+      expect { 
+        Taskrabbit::Something.find(Taskrabbit::Api.new, nil) 
+      }.to raise_error(Taskrabbit::Error, "Couldn't find Taskrabbit::Something without an ID")
+    end
+  end
+
+  it "should be not loaded by default" do
+    subject.loaded.should be_false
+  end
+  
+  describe "#redirect_url" do
+    it "should return links['redirect']" do
+      subject.stub(:links => {'redirect' => 'something'})
+      subject.redirect_url.should == 'something'
+    end
+    
+    it "should not throw error if links is empty" do
+      expect { subject.redirect_url }.to_not raise_error
+    end
+  end
+  
+  describe "#redirect?" do
+    it "should return false if redirect_url is empty" do
+      subject.redirect?.should == false
+    end
+
+    it "should return true if redirect_url is not empty" do
+      subject.stub(:redirect_url => "something")
+      subject.redirect?.should == true
+    end
+  end
+  
+  describe "#valid?" do
+    it "should return true" do
+      subject.should be_valid
+    end
+    
+    it "should return false if errors is filled" do
+      subject.errors = ["something"]
+      subject.should_not be_valid
+    end
+    
+    it "should return false if error is filled" do
+      subject.error = "something"
+      subject.should_not be_valid
+    end
+  end
+  
+  describe "#reload" do
+    
+    context "the request is valid" do
+      before do
+        api.stub(:request => {"name" => 'Test', "other" => 'Other Test'})
+      end
+      
+      it "should return true" do
+        subject.reload(anything, anything).should be_true
+      end
+
+      it "should merge the object with the response" do
+        subject.reload(anything, anything)
+        subject.should == {"name" => 'Test', "other" => 'Other Test'}
+      end
+
+      it "should set loaded to true" do
+        subject.reload(anything, anything)
+        subject.loaded.should be_true
+      end
+    end
+
+    context "there is an error" do
+      before do
+        api.stub(:request).and_raise(Taskrabbit::Error.new("Something happened", {:something => "something"}))
+      end
+      
+      it "should raise an exception" do
+        expect { subject.reload(anything, anything) }.to raise_error(Taskrabbit::Error, 'Something happened')
+      end
+      
+    end
+
+    context "there is errors in attributes" do
+      let(:response) { 
+        {
+          "errors" => {
+            "messages" => ["Task title can't be blank", "Amount you are willing to pay is not a number"],
+            "fields" => [["name","can't be blank"], ["named_price","is not a number"]]
+            },
+            "error" => "Task title can't be blank, \nAmount you are willing to pay is not a number"
+          }
+      }
+      
+      before do
+        api.stub(:request).and_raise(Taskrabbit::Smash::Error.new("Error Message", response))
+      end
+      
+      it "should catch taskrabbit errors and return false" do
+        subject.reload(anything, anything)
+        subject.should == {"name" => 'Something'}.merge(response)
+      end
+      
+      it "should return false" do
+        subject.reload(anything, anything).should be_false
+      end
+    end
+
+    it "should empty errors if request does not raise exception" do
+      subject.error = "something"
+      api.stub(:request => {:name => 'Test', :other => 'Other Test'})
+      subject.reload(anything, anything).should be_true
+      subject.error.should be_nil
+    end
+  end
+end

data/spec/taskrabbit/task_spec.rb

@@ -0,0 +1,235 @@
+require 'spec_helper'
+
+describe Taskrabbit::Task do
+  
+  describe "task properties" do
+
+    before :all do
+      tr = Taskrabbit::Api.new
+      VCR.use_cassette('tasks/properties', :record => :new_episodes) do
+        @tr_task = tr.tasks.find(22545)
+        @tr_task.fetch
+      end
+    end
+
+    subject { @tr_task }
+
+    its(:id) { should == 22545 }
+    its(:name) { should == "2 Hours of House Cleaning + 1 Hour of House Chores" }
+    its(:user) { should be_instance_of(Taskrabbit::User) }
+    its(:runner) { should be_instance_of(Taskrabbit::User) }
+    its(:runners) { should be_a(Taskrabbit::Collection) }
+    its(:cost_in_cents) { should == 0 }
+    its(:description) { should == '' }
+    its(:private_description) { should == '' }
+    its(:named_price) { should == nil }
+    its(:charge_price) { should == nil }
+    its(:cost_in_cents) { should == 0 }
+    its(:private_runner) { should == false }
+    its(:virtual) { should == false }
+    its(:state) { should == 'closed' }
+    its(:state_label) { should == 'closed' }
+    its(:location_visits) { should be_nil }
+    its(:city) { should be_instance_of(Taskrabbit::City) }
+    its(:assign_by_time) { should be_instance_of(Time) }
+    its(:complete_by_time) { should be_instance_of(Time) }
+    its(:state_changed_at) { should be_instance_of(Time) }
+    its(:links) { should be_instance_of(Hash) }
+  end
+
+  let(:valid_params) { 
+    {
+      "name" => "My First Task", 
+      "named_price" => 20, 
+      "city_id" => 4
+    } 
+  }
+  
+  describe "api endpoints" do
+    describe "#tasks" do
+      it "should fetch tasks only once" do
+        tr = Taskrabbit::Api.new
+        VCR.use_cassette('tasks/all', :record => :new_episodes) do
+          tr_tasks = nil
+          expect { tr_tasks = tr.tasks }.to_not raise_error
+          tr_tasks.first.should be_instance_of(Taskrabbit::Task)
+          Taskrabbit::Api.should_not_receive(:get).with("/api/v1/tasks", anything).never
+          tr_tasks.last.should be_instance_of(Taskrabbit::Task)
+        end
+      end
+
+      it "should refetch tasks if passed :reload => true" do
+        tr = Taskrabbit::Api.new
+        VCR.use_cassette('tasks/all', :record => :new_episodes) do
+          tr_tasks = nil
+          expect { tr_tasks = tr.tasks }.to_not raise_error
+          tr_tasks.first.should be_instance_of(Taskrabbit::Task)
+          Taskrabbit::Api.should_receive(:get).with("/api/v1/tasks", anything).once.and_return []
+          tr_tasks.last(:reload => true)
+          Taskrabbit::Api.should_not_receive(:get).with("/api/v1/tasks", anything)
+          tr_tasks.last
+        end
+      end
+    end
+    
+    describe "#find" do
+
+      it "should fetch tasks" do
+        tr = Taskrabbit::Api.new
+        VCR.use_cassette('tasks/find', :record => :new_episodes) do
+          tr_task = nil
+          expect { 
+            tr_task = tr.tasks.find(22545)
+            tr_task.name
+          }.to_not raise_error
+          tr_task.should be_instance_of(Taskrabbit::Task)
+        end
+      end
+      
+    end
+    
+    describe "#delete!" do
+      it "should request DELETE /tasks/#id" do
+        tr = Taskrabbit::Api.new(TR_USERS[:with_card][:secret])
+        VCR.use_cassette('tasks/delete', :record => :new_episodes) do
+          tr_task = nil
+          tr_task = tr.tasks.create(valid_params)
+          tr_task.should be_instance_of(Taskrabbit::Task)
+          expect { tr_task.delete! }.to_not raise_error
+          tr_task.should be_instance_of(Taskrabbit::Task)
+          tr_task.state.should == 'canceled'
+        end
+      end
+    end
+    
+    describe "#save" do
+
+      it "should not do an extra query to tasks if the id is nil" do
+        Taskrabbit::Api.should_not_receive(:get).with("http://localhost:3000/api/v1/tasks/?")
+        Taskrabbit::Api.should_receive(:post).with("/api/v1/tasks", anything).and_return({:id => 1})
+        tr = Taskrabbit::Api.new(TR_USERS[:with_card][:secret])
+        tr_task = tr.tasks.new(valid_params)
+        tr_task.save
+      end
+
+      it "should create a new task if new" do
+        tr = Taskrabbit::Api.new(TR_USERS[:with_card][:secret])
+        VCR.use_cassette('tasks/save', :record => :new_episodes) do
+          tr_task = nil
+          tr_task = tr.tasks.new(valid_params)
+          tr_task.should be_instance_of(Taskrabbit::Task)
+          tr_task.save.should == true
+          tr_task.id.should_not be_nil
+          tr_task.state.should == 'opened'
+          tr.tasks.find(tr_task.id).name.should == tr_task.name
+        end
+      end
+
+      it "should update the task if existing" do
+        tr = Taskrabbit::Api.new(TR_USERS[:with_card][:secret])
+        VCR.use_cassette('tasks/update', :record => :new_episodes) do
+          tr_task = tr.tasks.find(tr.tasks.create(valid_params).id)
+          tr_task.name = "New Name"
+          tr_task.save.should == true
+          tr_task.name.should == "New Name"
+        end
+      end
+    end
+    
+    describe "#update" do
+      context "with valid params" do
+        it "should return an error if the user is not logged in" do
+          tr = Taskrabbit::Api.new
+          VCR.use_cassette('tasks/create/without_user', :record => :new_episodes) do
+            tr_task = nil
+            expect { tr_task = tr.tasks.create(valid_params) }.to raise_error(Taskrabbit::Error, 'There must be an authenticated user for this action')
+            tr_task.should be_nil
+          end
+        end
+      end
+    end
+    
+    describe "#create" do
+      context "with valid params" do
+        it "should return an error if the user is not logged in" do
+          tr = Taskrabbit::Api.new
+          VCR.use_cassette('tasks/create/without_user', :record => :new_episodes) do
+            tr_task = nil
+            expect { tr_task = tr.tasks.create(valid_params) }.to raise_error(Taskrabbit::Error, 'There must be an authenticated user for this action')
+            tr_task.should be_nil
+          end
+        end
+
+        it "should create the task if the user is authenticated but does not have a credit card" do
+          tr = Taskrabbit::Api.new(TR_USERS[:without_card][:secret])
+          VCR.use_cassette('tasks/create/without_credit_card', :record => :new_episodes) do
+            tr_task = tr.tasks.new(valid_params)
+            tr_task.save.should == false
+            tr_task.should be_instance_of(Taskrabbit::Task)
+            tr_task.redirect?.should be_true
+            tr_task.redirect_url.should =~ %r{https://local\.taskrabbit\.com/tasks/my-first-task--\d+\?card=true}
+          end
+        end
+
+        it "should create the task if the user is authenticated and has a credit card" do
+          tr = Taskrabbit::Api.new(TR_USERS[:with_card][:secret])
+          VCR.use_cassette('tasks/create/default', :record => :new_episodes) do
+            tr_task = nil
+            expect { tr_task = tr.tasks.create(valid_params) }.to_not raise_error
+            tr_task.should be_instance_of(Taskrabbit::Task)
+          end
+        end
+
+        it "should create the task using the account" do
+          tr = Taskrabbit::Api.new(TR_USERS[:with_card][:secret])
+          VCR.use_cassette('tasks/create/using_account', :record => :new_episodes) do
+            tr_task = nil
+            expect { tr_task = tr.account.tasks.create(valid_params) }.to_not raise_error
+            tr_task.should be_instance_of(Taskrabbit::Task)
+          end
+        end
+      end
+      
+      context "with invalid params" do
+        let(:invalid_params) { {} }
+
+        it "should create the task if the user is authenticated and has a credit card" do
+          tr = Taskrabbit::Api.new(TR_USERS[:with_card][:secret])
+          VCR.use_cassette('tasks/create/with_invalid_params', :record => :new_episodes) do
+            tr_task = nil
+            expect { tr_task = tr.tasks.create(invalid_params) }.to
+            raise_error(Taskrabbit::Error, "Task title can't be blank,\n" +
+                                           "Amount you are willing to pay needs to be a whole dollar amount greater than zero")
+            tr_task.should be_nil
+          end
+        end
+      end
+      
+      it "should post locations" do
+        tr = Taskrabbit::Api.new(TR_USERS[:with_card][:secret])
+        VCR.use_cassette('tasks/create/with_location', :record => :new_episodes) do
+          tr_task = nil
+          params_with_locations = valid_params.merge({:other_locations_attributes => [
+            {
+              "name" => "Home",
+              "address" => "123 Main St",
+              "city" => "Boston",
+              "state" => "MA",
+              "zip" => "02154",
+              "lat" => "42.358432",
+              "lng" => "-71.059774"
+            }, 
+            {
+              "name" => "Middle of the park",
+              "lat" => "42.358430",
+              "lng" => "-71.059772"
+            }
+          ]})
+          expect { tr_task = tr.tasks.create(params_with_locations) }.to_not raise_error
+          tr_task.should be_instance_of(Taskrabbit::Task)
+          tr_task.location_visits.count.should == 2
+        end
+      end
+    end
+  end
+end

data/spec/taskrabbit/taskrabbit_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Taskrabbit do
+  after do
+    Taskrabbit.reset
+  end
+
+  describe ".options" do
+    it "should returns the options" do
+      Taskrabbit.options
+    end
+  end
+
+  describe ".configure" do
+    Taskrabbit::Config::VALID_OPTIONS_KEYS.each do |key|
+      it "should set the #{key}" do
+        Taskrabbit.configure do |config|
+          config.send("#{key}=", key)
+          Taskrabbit.send(key).should == key
+        end
+      end
+    end
+  end
+  
+  describe "api defaults" do
+    it "should be able to set the client_secret" do
+      Taskrabbit.client_secret = 'asecret'
+      Taskrabbit.client_secret.should == 'asecret'
+    end
+  end
+end

data/spec/taskrabbit/user_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Taskrabbit::User do
+
+  describe "user properties" do
+
+    before :all do
+      tr = Taskrabbit::Api.new(TR_USERS[:with_card][:secret])
+      VCR.use_cassette('users/properties', :record => :new_episodes) do
+        @user = tr.users.find(TR_USERS[:with_card][:id])
+        @user.fetch
+      end
+    end
+
+    subject { @user }
+
+    its(:id) { should == TR_USERS[:with_card][:id] }
+    its(:short_name) { should == "Bob" }
+    its(:first_name) { should == "Bob" }
+    its(:full_name) { should == "Bob Sponge" }
+    its(:display_name) { should == "Bob S." }
+    its(:runner) { should == false }
+    its(:email) { should == 'bobsponge@example.com' }
+    its(:mobile_phone) { should == nil }
+    its(:home_phone) { should == nil }
+    its(:tasks) { should == Taskrabbit::Task }
+    its(:city) { should be_instance_of(Taskrabbit::City) }
+    its(:zip_code) { should == "64321" }
+    its(:locations) { should == Taskrabbit::Location }
+    its(:links) { should be_instance_of(Hash) }
+  end
+
+  describe "api endpoints" do
+    describe "#find" do
+      it "should fetch users" do
+        tr = Taskrabbit::Api.new
+        VCR.use_cassette('users/find', :record => :new_episodes) do
+          tr_user = nil
+          expect { tr_user = tr.users.find(TR_USERS[:without_card][:id]) }.to_not raise_error
+          tr_user.id.should == TR_USERS[:without_card][:id]
+          tr_user.short_name.should == 'John'
+          tr_user.should be_instance_of(Taskrabbit::User)
+        end
+      end
+      
+      describe "tasks" do
+        let(:tr) { tr = Taskrabbit::Api.new(TR_USERS[:with_card][:secret]) }
+        
+        it "should not do an extra query to users/#{TR_USERS[:with_card][:id]} when fetching all tasks" do
+          Taskrabbit::Api.should_not_receive(:get).with("/api/v1/users/#{TR_USERS[:with_card][:id]}", anything).never
+          tr.users.find(TR_USERS[:with_card][:id]).tasks.all
+        end
+
+        it "should not do an extra query to users/#{TR_USERS[:with_card][:id]} when finding task" do
+          Taskrabbit::Api.should_not_receive(:get).with("/api/v1/users/#{TR_USERS[:with_card][:id]}", anything).never
+          tr.users.find(TR_USERS[:with_card][:id]).tasks.find('some-id')
+        end
+
+        it "should fetch tasks with users/#{TR_USERS[:with_card][:id]}/tasks" do
+          VCR.use_cassette('users/tasks/all', :record => :new_episodes) do
+            tr_tasks = nil
+            expect { tr_tasks = tr.users.find(TR_USERS[:with_card][:id]).tasks.all }.to_not raise_error
+            tr_tasks.should be_a(Taskrabbit::Collection)
+            tr_tasks.first.should be_instance_of(Taskrabbit::Task)
+          end
+        end
+      end
+    end
+  end
+end