mavenlink 0.0.1 → 0.2.0

data/lib/mavenlink/client.rb

@@ -1,116 +1,222 @@
 module Mavenlink
-  class Client
-    ENDPOINT = 'https://api.mavenlink.com/api/v1/'.freeze
-
-    # @param settings [ActiveSuppport::HashWithIndifferentAccess]
-    def initialize(settings = Mavenlink.default_settings)
-      @settings = settings
-      @oauth_token = settings[:oauth_token] or raise ArgumentError, 'OAuth token is not set'
-      @endpoint = settings[:endpoint] || ENDPOINT
-      @use_json = settings[:use_json]
-      if settings.key?(:user_agent_override)
-        @user_agent_override = settings[:user_agent_override]
-      end
+  class Base
+    base_uri ENV['TESTING'] ? 'https://mavenlink.local/api/v0' : 'https://www.mavenlink.com/api/v0'
+    debug ENV['DEBUG'] || false
+  end
 
-      # TODO: implement with method_missing?
-      # Declare API calls client.-->>workspaces<<---.create({})
-      Mavenlink.specification.keys.each do |collection_name|
-        singleton_class.instance_eval do
-          define_method collection_name do
-            ::Mavenlink::Request.new(collection_name, self)
-          end
-        end
-      end
+  # Wrapping objects that have no API endpoints yet
+
+  class User < Base
+    request_path "/not_available_yet"
+    class_name :user
+  end
+
+  class Asset < Base
+    request_path "/not_available_yet"
+    class_name :asset
+  end
+
+  # Normal API objects
+
+  class Client < Base
+    def initialize(user_id, token)
+      super({}, :basic_auth => {:username => user_id, :password => token})
     end
 
-    # @return [Faraday::Connection]
-    def connection
-      Faraday.new(connection_options) do |builder|
-        if @use_json
-          builder.headers['Content-Type'] = 'application/json'
-        else
-          builder.use Faraday::Request::UrlEncoded
-        end
-        builder.adapter(*Mavenlink.adapter)
-      end
+    def workspaces(options = {})
+      fetch('workspaces', Workspace, options)
     end
 
-    # Performs custom GET request
-    # @param [String] path
-    # @param [Hash] arguments
-    def get(path, arguments = {})
-      Mavenlink.logger.note "Started GET /#{path} with #{arguments.inspect}"
-      parse_request(connection.get(path, arguments).body)
+    def workspace(workspace_id)
+      fetch("workspaces/#{workspace_id}", Workspace, {})
     end
 
-    # Performs custom POST request
-    # @param [String] path
-    # @param [Hash] arguments
-    def post(path, arguments = {})
-      Mavenlink.logger.note "Started POST /#{path} with #{arguments.inspect}"
-      parse_request(connection.post(path, arguments).body)
+
+    def time_entries(options = {})
+      fetch('time_entries', TimeEntry, options, lambda { |time_entry| {:workspace_id => time_entry['workspace_id']} })
     end
 
-    # Performs custom PUT request
-    # @param [String] path
-    # @param [Hash] arguments
-    def put(path, arguments = {})
-      Mavenlink.logger.note "Started PUT /#{path} with #{arguments.inspect}"
-      parse_request(connection.put(path, arguments).body)
+    def time_entry(time_entry_id)
+      fetch("time_entries/#{time_entry_id}", TimeEntry, {}, lambda { |time_entry| {:workspace_id => time_entry['workspace_id']} })
     end
 
-    # Performs custom PUT request
-    # @param [String] path
-    # @param [Hash] arguments
-    def delete(path, arguments = {})
-      Mavenlink.logger.note "Started DELETE /#{path} with #{arguments.inspect}"
-      parse_request(connection.delete(path, arguments).body)
+
+    def expenses(options = {})
+      fetch('expenses', Expense, options, lambda { |expense| {:workspace_id => expense['workspace_id']} })
     end
 
-    private
+    def expense(expense_id)
+      fetch("expenses/#{expense_id}", Expense, {}, lambda { |expense| {:workspace_id => expense['workspace_id']} })
+    end
 
-    attr_reader :oauth_token, :endpoint
 
-    # @return [Hash]
-    def connection_options
-      if @user_agent_override && @user_agent_override.length > 1
-        user_agent = "#{@user_agent_override}"
-      else
-        user_agent = "Mavenlink Ruby Gem"
-      end
-      {
-        headers: { 'Accept'        => "application/json",
-                   'User-Agent'    => "#{user_agent}",
-                   'Authorization' => "Bearer #{oauth_token}" },
-        ssl: { verify: false },
-        url: endpoint
-      }.freeze
-    end
-
-    def parse_request(response)
-      if response.present?
-        parsed_response = JSON.parse(response)
-      else
-        return
-      end
+    def invoices(options = {})
+      fetch('invoices', Invoice, options, lambda { |invoice| {:workspace_id => invoice['workspace_id']} })
+    end
 
-      parsed_response.tap do
-        Mavenlink.logger.whisper 'Received response:'
-        Mavenlink.logger.inspection response
-
-        case parsed_response
-        when Array
-          Mavenlink.logger.whisper 'Returned as a plain collection'
-        when Hash
-          if parsed_response['errors']
-            Mavenlink.logger.disappointment 'REQUEST FAILED:'
-            Mavenlink.logger.inspection parsed_response['errors']
-            raise InvalidRequestError.new(parsed_response)
-          end
-        end
-      end
-    rescue JSON::ParserError => e
-      raise Mavenlink::InvalidResponseError.new(e.message)
+    def invoice(invoice_id)
+      fetch("invoices/#{invoice_id}", Invoice, {}, lambda { |invoice| {:workspace_id => invoice['workspace_id']} })
+    end
+
+
+    def events(options = {})
+      fetch('events', Event, options)
+    end
+  end
+
+  class Workspace < Base
+    request_path "/workspaces/:id"
+    class_name :workspace
+
+    def posts(options = {})
+      fetch('posts', Post, options, :workspace_id => id)
+    end
+
+    def post(post_id, options = {})
+      fetch("posts/#{post_id}", Post, options, :workspace_id => id)
+    end
+
+    def create_post(options)
+      build("posts", Post, options, :workspace_id => id)
+    end
+
+
+    def time_entries(options = {})
+      fetch("time_entries", TimeEntry, options, :workspace_id => id)
+    end
+
+    def time_entry(time_entry_id, options = {})
+      fetch("time_entries/#{time_entry_id}", TimeEntry, options, :workspace_id => id)
+    end
+
+    def create_time_entry(options)
+      build("time_entries", TimeEntry, options, :workspace_id => id)
+    end
+
+
+    def expenses(options = {})
+      fetch("expenses", Expense, options, :workspace_id => id)
+    end
+
+    def expense(expense_id, options = {})
+      fetch("expenses/#{expense_id}", Expense, options, :workspace_id => id)
+    end
+
+    def create_expense(options)
+      build("expenses", Expense, options, :workspace_id => id)
+    end
+
+
+    def invoices(options = {})
+      fetch("invoices", Invoice, options, :workspace_id => id)
+    end
+
+    def invoice(invoice_id, options = {})
+      fetch("invoice/#{invoice_id}", Invoice, options, :workspace_id => id)
+    end
+
+
+    def stories(options = {})
+      fetch("stories", Story, options, :workspace_id => id)
     end
+
+    def story(story_id, options = {})
+      fetch("stories/#{story_id}", Story, options, :workspace_id => id)
+    end
+
+    def create_story(options)
+      build("stories", Story, options, :workspace_id => id)
+    end
+
+
+    def participants(options = {})
+      fetch("participants", Participant, options, :workspace_id => id)
+    end
+  end
+
+  class Participant < Base
+    request_path "/workspaces/:workspace_id/participants/:id"
+    class_name :participant
+  end
+
+  class Post < Base
+    request_path "/workspaces/:workspace_id/posts/:id"
+    contains :user => User,
+             :google_documents => Asset,
+             :assets => Asset,
+             :replies => lambda {|parent, child| { :class => Post, :path_params => { :workspace_id => child['workspace_id'] } } }
+    class_name :post
+
+    def story(options = {})
+      fetch("../../stories/#{json['story_id']}", Story, options, :workspace_id => workspace_id) if json['story_id']
+    end
+
+    def workspace(options = {})
+      fetch("../..", Workspace, options)
+    end
+  end
+
+  class TimeEntry < Base
+    request_path "/workspaces/:workspace_id/time_entries/:id"
+    class_name :time_entry
+
+    def story(options = {})
+      fetch("../../stories/#{json['story_id']}", Story, options, :workspace_id => workspace_id) if json['story_id']
+    end
+
+    def workspace(options = {})
+      fetch("../..", Workspace, options)
+    end
+  end
+
+  class Expense < Base
+    request_path "/workspaces/:workspace_id/expenses/:id"
+    class_name :expense
+
+    def workspace(options = {})
+      fetch("../..", Workspace, options)
+    end
+  end
+
+  class AdditionalItem < Base
+    request_path "/not_available_yet"
+    class_name :additional_item
+  end
+
+  class Invoice < Base
+    request_path "/workspaces/:workspace_id/invoices/:id"
+    class_name :invoice
+    contains :time_entries => lambda { |time_entry, json| { :class => TimeEntry, :path_params => { :id => json['id'], :workspace_id => json['workspace_id'] } } },
+             :expenses => lambda { |expense, json| { :class => Expense, :path_params => { :id => json['id'], :workspace_id => json['workspace_id'] } } },
+             :additional_items => AdditionalItem
+
+    def workspace(options = {})
+      fetch("../..", Workspace, options)
+    end
+  end
+
+  class Story < Base
+    request_path "/workspaces/:workspace_id/stories/:id"
+    contains :creator => User, :assignee => User
+    class_name :story
+
+    def workspace(options = {})
+      fetch("../..", Workspace, options)
+    end
+  end
+
+  class Event < Base
+    request_path "/events/:id"
+    contains :subject => lambda { |event, json|
+      case event.subject_type
+        when "Post"
+          { :class => Post, :path_params => { :workspace_id => json['workspace_id'] } }
+        when "Story"
+          { :class => Story, :path_params => { :workspace_id => json['workspace_id'] } }
+        else
+          raise "Unknown event subject type: #{event.subject_type}"
+      end
+    }
+    class_name :event
   end
 end

data/mavenlink.gemspec

@@ -1,29 +1,95 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
   s.name = %q{mavenlink}
-  s.version = "0.0.1"
-
-  s.date = %q{2014-04-01}
-  s.authors = ["Mavenlink"]
-  s.email = %q{opensource@mavenlink.com}
-  s.homepage = %q{http://github.com/mavenlink/mavenlink_gem}
+  s.version = "0.2.0"
 
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Roger Neel", "Andrew Cantino"]
+  s.date = %q{2011-06-30}
+  s.description = %q{This is a Ruby API client for Mavenlink.  Mavenlink's project collaboration suite allows you to manage your business relationships, share files, and track project activity online from anywhere in the world. Within a project workspace in Mavenlink, you can agree on budget & schedule, track time, send invoices, get paid via PayPal, and complete work.}
+  s.email = %q{support@mavenlink.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc",
+    "TODO"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "TODO",
+    "VERSION",
+    "lib/mavenlink.rb",
+    "lib/mavenlink/base.rb",
+    "lib/mavenlink/client.rb",
+    "mavenlink.gemspec",
+    "spec/mavenlink/base_spec.rb",
+    "spec/mavenlink/client_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/mavenlink/mavenlink_ruby_api}
   s.licenses = ["MIT"]
-
-  s.files = `git ls-files`.split("\n")
-  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
-  s.extra_rdoc_files = ["README.md"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Ruby client for Mavenlink's API}
+  s.test_files = [
+    "spec/mavenlink/base_spec.rb",
+    "spec/mavenlink/client_spec.rb",
+    "spec/spec_helper.rb"
+  ]
 
-  s.description = %q{Simple Ruby API for the Mavenlink API}
-  s.summary = %q{Mavenlink API Ruby Wrapper}
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
 
-  s.add_runtime_dependency 'activesupport', ">= 4.0.4"
-  s.add_runtime_dependency 'activemodel', ">= 4.0.4"
-  s.add_runtime_dependency 'brainstem-adaptor', ">= 0.0.3"
-  s.add_runtime_dependency 'faraday', ">= 0.9.0"
-  s.add_development_dependency 'rspec', "2.14.1"
-  s.add_development_dependency 'shoulda-matchers', "2.5.0"
-  s.add_development_dependency 'awesome_print'
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<httparty>, ["= 0.7.4"])
+      s.add_runtime_dependency(%q<webmock>, ["~> 1.6.2"])
+      s.add_runtime_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_runtime_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_runtime_dependency(%q<rr>, ["~> 1.0.2"])
+      s.add_runtime_dependency(%q<json>, ["~> 1.5.1"])
+      s.add_runtime_dependency(%q<httparty>, ["= 0.7.4"])
+      s.add_development_dependency(%q<webmock>, ["~> 1.6.2"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rr>, ["~> 1.0.2"])
+      s.add_development_dependency(%q<json>, ["~> 1.5.1"])
+    else
+      s.add_dependency(%q<httparty>, ["= 0.7.4"])
+      s.add_dependency(%q<webmock>, ["~> 1.6.2"])
+      s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rr>, ["~> 1.0.2"])
+      s.add_dependency(%q<json>, ["~> 1.5.1"])
+      s.add_dependency(%q<httparty>, ["= 0.7.4"])
+      s.add_dependency(%q<webmock>, ["~> 1.6.2"])
+      s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rr>, ["~> 1.0.2"])
+      s.add_dependency(%q<json>, ["~> 1.5.1"])
+    end
+  else
+    s.add_dependency(%q<httparty>, ["= 0.7.4"])
+    s.add_dependency(%q<webmock>, ["~> 1.6.2"])
+    s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rr>, ["~> 1.0.2"])
+    s.add_dependency(%q<json>, ["~> 1.5.1"])
+    s.add_dependency(%q<httparty>, ["= 0.7.4"])
+    s.add_dependency(%q<webmock>, ["~> 1.6.2"])
+    s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rr>, ["~> 1.0.2"])
+    s.add_dependency(%q<json>, ["~> 1.5.1"])
+  end
 end
+

data/spec/mavenlink/base_spec.rb

@@ -0,0 +1,223 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe Mavenlink::Base do
+  describe "request_path and join_paths" do
+    class Example < Mavenlink::Base
+      request_path "/:something/blah/foo/:id"
+    end
+
+    describe "request_path" do
+      it "should interpolate id and any path_params into the request_path string" do
+        Example.new({ 'id' => 2 }, :path_params => { :something => "hello" }).request_path.should == "/hello/blah/foo/2"
+      end
+    end
+
+    describe "join_paths" do
+      it "should combine paths, respecting leading ..'s" do
+        Example.new({}).join_paths("/hello/world", "").should == "/hello/world"
+        Example.new({}).join_paths("", "hi").should == "/hi"
+        Example.new({}).join_paths("", "/hi").should == "/hi"
+        Example.new({}).join_paths("/hello/world", "../there").should == "/hello/there"
+        Example.new({}).join_paths("/", "there").should == "/there"
+        Example.new({}).join_paths("/hello/world", "/again").should == "/hello/world/again"
+        Example.new({}).join_paths("/hello/world/", "/again").should == "/hello/world/again"
+        Example.new({}).join_paths("/hello/world/", "again").should == "/hello/world/again"
+        Example.new({}).join_paths("/hello/world", "../../../there").should == "/there"
+        Example.new({}).join_paths("hi", "there").should == "/hi/there"
+      end
+    end
+  end
+
+  describe "example usage with a test client and some widgets with many prongs" do
+    class TestBase < Mavenlink::Base
+      base_uri 'http://www.example.com/api/v0'
+      debug false
+    end
+
+    class TestClient < TestBase
+      def initialize(username, password)
+        super({}, :basic_auth => { :username => username, :password => password })
+      end
+
+      def widgets(options = {})
+        fetch('widgets', Widget, options)
+      end
+    end
+
+    class User < TestBase; end
+
+    class Prong < TestBase
+      request_path "/widgets/:widget_id/prongs/:id"
+      class_name "prong"
+    end
+
+    class Widget < TestBase
+      request_path "/widgets/:id"
+      contains :owners => User
+      class_name "widget"
+
+      def prongs(options = {})
+        fetch("prongs", Prong, options, :widget_id => id)
+      end
+
+      def prong(prong_id)
+        fetch("prongs/#{prong_id}", Prong, {}, :widget_id => id)
+      end
+
+      def create_prong(options)
+        build("prongs", Prong, options, :widget_id => id)
+      end
+    end
+
+    before do
+      stub_request(:get, "http://user:password@www.example.com/api/v0/widgets?limit=5").
+        with(:headers => {'Accept'=>'application/json'}).
+        to_return(:status => 200, :body => [{ :kind => "sprocket", :id => 1, :owners => [{ :name => "Bob" }, { :name => "Sam" }] }, { :kind => "gizmo", :id => 2 }].to_json, :headers => {})
+    end
+
+    describe "the test client" do
+      it "should do basic auth" do
+        client = TestClient.new("user", "password")
+        client.widgets(:limit => 5)
+        WebMock.should have_requested(:get, "http://user:password@www.example.com/api/v0/widgets?limit=5")
+      end
+
+      it "should have many widgets" do
+        client = TestClient.new("user", "password")
+        widgets = client.widgets(:limit => 5)
+        widgets.length.should == 2
+        widgets.first.kind.should == "sprocket"
+        widgets.first.owners.length.should == 2
+        widgets.first.owners.first.should be_a(User)
+        widgets.first.owners.first.name.should == "Bob"
+        widgets.last.owners.should be_nil
+      end
+    end
+
+    describe "widgets" do
+      before do
+        @client = TestClient.new("user", "password")
+        @widget = @client.widgets(:limit => 5).first
+        @widget.should be_a(Widget)
+      end
+
+      it "should be reloadable" do
+        stub_request(:get, "http://user:password@www.example.com/api/v0/widgets/1?some=option").
+          with(:headers => {'Accept'=>'application/json'}).
+          to_return(:status => 200, :body => { :kind => "sprocket_updated", :id => 1, :owners => [{ :name => "Bob_updated" }, { :name => "Sam" }] }.to_json, :headers => {})
+
+        @widget.reload(:some => :option)
+        @widget.kind.should == "sprocket_updated"
+        @widget.owners.first.name.should == "Bob_updated"
+      end
+
+      describe "#prongs" do
+        before do
+          stub_request(:get, "http://user:password@www.example.com/api/v0/widgets/1/prongs?exclude=gears").
+            with(:headers => {'Accept'=>'application/json'}).
+            to_return(:status => 200, :body => [{ :price => "$5", :id => 100 }, { :price => "$10", :id => 101 }].to_json, :headers => {})
+
+          @prongs = @widget.prongs(:exclude => "gears")
+        end
+
+        it "should return prongs" do
+          @prongs.length.should == 2
+          @prongs.first.should be_a(Prong)
+          @prongs.first.price.should == "$5"
+          @prongs.first.id.should == 100
+          @prongs.first.request_path.should == "/widgets/1/prongs/100"
+          @prongs.first.path_params.should == { :widget_id => 1 }
+        end
+
+        describe "#update" do
+          it "updates the local model when successful" do
+            stub_request(:put, "http://user:password@www.example.com/api/v0/widgets/1/prongs/100").
+              with(:headers => {'Accept'=>'application/json'}, :body => "prong[price]=%248.50").
+              to_return(:status => 200, :body => { :price => "$8.50", :id => 100 }.to_json, :headers => {})
+
+            prong = @prongs.first
+            prong.update(:price => "$8.50")
+            prong.price.should == "$8.50"
+            prong.errors.should be_empty
+          end
+
+          it "doesn't update the local model but adds errors when unsuccessful" do
+            stub_request(:put, "http://user:password@www.example.com/api/v0/widgets/1/prongs/100").
+              with(:headers => {'Accept'=>'application/json'}, :body => "prong[price]=%248.50").
+              to_return(:status => 422, :body => { :errors => ["error 1", "error 2"] }.to_json, :headers => {})
+
+            prong = @prongs.first
+            prong.update(:price => "$8.50")
+            prong.price.should == "$5"
+            prong.errors.should == ["error 1", "error 2"]
+          end
+        end
+
+        describe "#destroy" do
+          it "returns true when successful" do
+            stub_request(:delete, "http://user:password@www.example.com/api/v0/widgets/1/prongs/100?").
+              with(:headers => {'Accept'=>'application/json'}).
+              to_return(:status => 200, :body => '', :headers => {})
+
+            prong = @prongs.first
+            prong.destroy.should be_true
+          end
+
+          it "returns false and sets errors on failure" do
+            stub_request(:delete, "http://user:password@www.example.com/api/v0/widgets/1/prongs/100?").
+              with(:headers => {'Accept'=>'application/json'}).
+              to_return(:status => 422, :body => { :errors => ["error 1", "error 2"] }.to_json, :headers => {})
+
+            prong = @prongs.first
+            prong.destroy.should be_false
+            prong.errors.should == ["error 1", "error 2"]
+          end
+        end
+      end
+
+      describe "#prong" do
+        it "should return a single prong by id" do
+          stub_request(:get, "http://user:password@www.example.com/api/v0/widgets/1/prongs/100?").
+            with(:headers => {'Accept'=>'application/json'}).
+            to_return(:status => 200, :body => { :price => "$5", :id => 100 }.to_json, :headers => {})
+          prong = @widget.prong(100)
+          prong.should be_a(Prong)
+          prong.price.should == "$5"
+        end
+      end
+
+      describe "#create_prong" do
+        it "should return the new prong object when successful" do
+          stub_request(:post, "http://user:password@www.example.com/api/v0/widgets/1/prongs").
+            with(:headers => {'Accept'=>'application/json'}, :body => "prong[price]=%24100").
+            to_return(:status => 200, :body => { :price => "$100", :id => 102 }.to_json, :headers => {})
+
+          prong = @widget.create_prong(:price => "$100")
+          prong.request_path.should == "/widgets/1/prongs/102"
+          prong.should be_a(Prong)
+          prong.price.should == "$100"
+          prong.id.should == 102
+          prong.errors.should be_empty
+
+          stub_request(:put, "http://user:password@www.example.com/api/v0/widgets/1/prongs/102").
+            with(:headers => {'Accept'=>'application/json'}, :body => "prong[price]=%2490").
+            to_return(:status => 200, :body => { :price => "$90", :id => 102 }.to_json, :headers => {})
+          prong.update(:price => "$90")
+          prong.price.should == "$90"
+          prong.errors.should be_empty
+          prong.request_path.should == "/widgets/1/prongs/102"
+        end
+
+        it "should return the new prong object with errors when unsuccessful" do
+          stub_request(:post, "http://user:password@www.example.com/api/v0/widgets/1/prongs").
+            with(:headers => {'Accept'=>'application/json'}, :body => "prong[price]=%24100").
+            to_return(:status => 422, :body => { :errors => ["error 1", "error 2"] }.to_json, :headers => {})
+
+          prong = @widget.create_prong(:price => "$100")
+          prong.should be_a(Prong)
+          prong.errors.should == ["error 1", "error 2"]
+        end
+      end
+    end
+  end
+end