evoke_client 0.2.0 → 0.2.1

data/README.markdown

@@ -4,8 +4,16 @@ evoke-client is a simple rest-client utility for allowing your application to co
 
 ### Usage
 
-    evoke = Evoke.new(:url => 'http://example.com/users/unsubscribe', :callback_at => (Time.now + 86400))
-    evoke.save
+    # evoke = Evoke.new(:url => 'http://example.com/users/unsubscribe', :callback_at => (Time.now + 86400))
+    # evoke.save
+
+    Evoke.configure(...)
+    callback = Evoke::Callback.new(:url => 'http://example.com/users/unsubscribe', :callback_at => (Time.now + 86400))
+    callback.save
+    
+    callback = Evoke::Callback.find(guid)
+    callback.destroy
+    callback.update
     
     # What happens if save fails
 
@@ -27,7 +35,7 @@ To modify host and port, just set the following:
 
 These should be automatically installed when you install evoke_client
 
-* [rest-client](http://github.com/adamwiggins/rest-client)
+* [httparty](http://github.com/jnunemaker/httparty/)
 
 ## License
 

data/Rakefile

@@ -1,17 +1,16 @@
 require 'rubygems'
 require 'rake'
-require 'rake/testtask'
 
 desc 'Default task: run all tests'
 task :default => [:test]
 
-task(:set_test_env) { ENV['APP_ENV'] ||= 'test' }
-
-task(:environment) { }
-
-task :test => [:set_test_env]
 desc 'Run all tests'
-Rake::TestTask.new do |t|
-  t.test_files = FileList['test/*_test.rb']
-  t.verbose = true
+task :test do
+  $:.concat ['./lib', './test']
+  Dir.glob("./test/*_test.rb").each { |test| require test }
+end
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  exec "irb -rubygems -I./lib -r evoke_client"
 end

data/evoke_client.gemspec

@@ -1,11 +1,11 @@
 Gem::Specification.new do |s|
   s.name     = "evoke_client"
-  s.version  = "0.2.0"
-  s.date     = "2009-06-07"
-  s.summary  = "Rest client interface for talking REST to the evoke service"
+  s.version  = "0.2.1"
+  s.date     = "2009-10-07"
+  s.summary  = "Tool for interfacing with the Evoke web service"
   s.email    = %w[gus@gusg.us]
   s.homepage = "http://github.com/thumblemonks/evoke_client"
-  s.description = "Rest client interface for talking REST to the evoke service"
+  s.description = "Tool for interfacing with the Evoke web service. See http://github.com/thumblemonks/evoke"
   s.authors  = %w[Justin\ Knowlden]
   s.post_install_message = %q{Choosy wizards choose Thumble Monks.}
 
@@ -13,23 +13,25 @@ Gem::Specification.new do |s|
   s.rdoc_options = ["--main", "README.markdown"]
   s.extra_rdoc_files = ["README.markdown"]
 
-  s.add_dependency("rest-client", [">= 0.9.2"])
+  s.add_dependency("httparty", [">= 0.4.4"])
 
-  # run git ls-files to get an updated list
   s.files = %w[
     MIT-LICENSE
     README.markdown
-    Rakefile
     evoke_client.gemspec
     lib/evoke_client.rb
     lib/evoke_client/base.rb
-    lib/evoke_client/stub.rb
-    lib/query_string.rb
-    shoulda_macros/rest_client.rb
+    lib/evoke_client/mock.rb
   ]
-  
+
   s.test_files = %w[
-    test/evoke_client_test.rb
-    test/test_helper.rb
+    Rakefile
+    test/configuration_test.rb
+    test/create_or_update_test.rb
+    test/create_test.rb
+    test/destroy_test.rb
+    test/find_test.rb
+    test/teststrap.rb
+    test/update_test.rb
   ]
 end

data/lib/evoke_client.rb

@@ -1,33 +1,8 @@
-require 'query_string'
 require 'evoke_client/base'
-require 'evoke_client/stub'
+require 'httparty'
 
-class Evoke
-  class ConnectionRefused < Exception; end
-
-  # Configuration
-
-  def self.test?; @test == true; end
-  def self.test=(setting) @test = setting; end
-
-  def self.host; @host || 'evoke.thumblemonks.com'; end
-  def self.host=(host) @host = host; end
-
-  def self.port; @port; end
-  def self.port=(port) @port = port; end
-
-  def self.host_and_port
-    [host, port].compact.join(':')
-  end
-
-  # Logic
-
-  def self.create_or_update!(*args)
-    prepare(*args).save
-  end
-
-  def self.prepare(*args)
-    (test? ? EvokeClient::Stub : EvokeClient::Base).new(*args)
-  end
-  
+Evoke::Callback.instance_eval do
+  include HTTParty
+  base_uri "http://localhost:3000"
+  format :json
 end

data/lib/evoke_client/base.rb

@@ -1,23 +1,60 @@
-require 'restclient'
+module Evoke
+  class RecordError < Exception; end
+  class RecordInvalid < RecordError; end
+  class RecordNotFound < RecordError; end
 
-module EvokeClient
-  class Base
-    attr_reader :params, :headers
+  def self.configure(base_uri)
+    Evoke::Callback.base_uri(base_uri)
+  end
 
-    def initialize(params={})
-      @evoke = ::RestClient::Resource.new("http://#{Evoke.host_and_port}/callbacks")
-      @params = params
-      @params[:callback_at] = @params[:callback_at].utc if @params[:callback_at]
-      @params[:data] = @params[:data].to_query_string if @params[:data]
+  class Callback
+    def self.find(guid)
+      callback = get("/callbacks/#{guid}")
+      callback.empty? ? nil : new(callback.merge(:new_record => false))
+    end
+
+    def self.create_or_update(data)
+      callback = (find(data["guid"]) || new(data)).update_attributes(data)
+      callback.save
+      callback
+    end
+
+    def initialize(data)
+      @new_record = determine_if_new_record(data.delete(:new_record))
+      @data = data
+    end
+
+    def new_record?; @new_record; end
+
+    def update_attributes(new_data)
+      @data = @data.merge(new_data)
+      self
     end
 
     def save
-      @evoke[params[:guid]].get
-      @evoke[params[:guid]].put(@params)
-    rescue ::RestClient::ResourceNotFound
-      @evoke.post(@params)
-    rescue Errno::ECONNREFUSED
-      raise Evoke::ConnectionRefused, "Connection refused while connecting to #{Evoke.host_and_port}"
-    end
-  end # Base
-end # EvokeClient
+      args = (new_record? ? [:post, "/callbacks"] : [:put, "/callbacks/#{guid}"]) + [{:query => @data}]
+      handle_response(self.class.send(*args)) { |response| @data = response }
+    end
+
+    def destroy
+      handle_response(self.class.delete("/callbacks/#{guid}")) { |response| nil }
+    end
+
+    def method_missing(method, *args, &block)
+      @data.include?(method.to_s) ? @data[method.to_s] : super
+    end
+  private
+    def handle_response(response, &block)
+      case response.code
+        when 404 then raise(Evoke::RecordNotFound)
+        when 422 then raise(Evoke::RecordInvalid, response["errors"])
+        when 200..201 then yield(response)
+        else raise(Evoke::RecordError, "#{response.code} - #{response.message}")
+      end
+    end
+    
+    def determine_if_new_record(condition)
+      condition.nil? || condition
+    end
+  end # Callback
+end # Evoke

data/lib/evoke_client/mock.rb

@@ -0,0 +1,76 @@
+require 'evoke_client/base'
+require 'httparty'
+
+module Evoke
+  module HTTMockParty
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def base_uri(uri=nil)
+        @base_uri = uri if uri
+        @base_uri
+      end
+
+      def format(fmt=nil)
+        @format = fmt if fmt
+        @format
+      end
+
+      #
+      # The mock part. Your code will call these methods and get a real HTTParty::Response
+
+      def get(path, query={}) HTTMockParty.router("get").dispatch(path, query); end
+      def post(path, query={}) HTTMockParty.router("post").dispatch(path, query); end
+      def put(path, query={}) HTTMockParty.router("put").dispatch(path, query); end
+      def delete(path, query={}) HTTMockParty.router("delete").dispatch(path, query); end
+    end # ClassMethods
+
+    #
+    # The shunt part. Setting up routers for responses
+
+    def self.get(path, query={}) router("get").maps(path, query); end
+    def self.post(path, query={}) router("post").maps(path, query); end
+    def self.put(path, query={}) router("put").maps(path, query); end
+    def self.delete(path, query={}) router("delete").maps(path, query); end
+
+    class Router
+      def initialize; @routes = {}; end
+      def maps(*args) @routes[args.inspect] = Responder.new; end
+      def dispatch(*args) @routes[args.inspect].process; end
+    end
+
+    class Responder
+      def process
+        HTTParty::Response.new(@delegate || "", @body, @code, @message, @headers)
+      end
+
+      def ok; status(200, "Ok"); end
+      def created; status(201, "Created"); end
+      def not_found; status(404, "Not Found"); end
+      def unprocessable_entity; status(422, "Unprocessable Entity"); end
+      def internal_server_error; status(500, "Internal Server Error"); end
+
+      def responds(delegate, body="", code=nil, message=nil, headers={})
+        @delegate, @body, @code, @message, @headers = delegate, body, code, message, headers
+        self
+      end
+    private
+      def status(code, message)
+        @code, @message = code, message
+        self
+      end
+    end
+
+  private
+    def self.routers; @routers ||= {}; end
+    def self.router(method) routers[method] ||= Router.new; end
+  end # HTTMockParty
+end # Evoke
+
+Evoke::Callback.instance_eval do
+  include Evoke::HTTMockParty
+  base_uri "http://test:3000"
+  format :json
+end

data/test/configuration_test.rb

@@ -0,0 +1,13 @@
+require 'teststrap'
+
+context "configuring evoke client" do
+  context "with defaults" do
+    asserts("base_uri") { Evoke::Callback.base_uri }.equals("http://test:3000")
+    asserts("format") { Evoke::Callback.format }.equals(:json)
+  end # with defaults
+
+  context "with custom base_uri" do
+    setup { Evoke.configure("http://yo.ma.ma:3000/") }
+    asserts("base_uri") { Evoke::Callback.base_uri }.equals("http://yo.ma.ma:3000/")
+  end
+end # configuring evoke client

data/test/create_or_update_test.rb

@@ -0,0 +1,33 @@
+require 'teststrap'
+
+context "create or update" do
+
+  context "when callback does not exist" do
+    setup do
+      Evoke::HTTMockParty.get('/callbacks/poster').not_found
+      Evoke::HTTMockParty.post('/callbacks', :query => {"guid" => "poster"}).
+        responds({"url" => "http://poster"}).created
+      Evoke::Callback.create_or_update({"guid" => "poster"})
+    end
+
+    should "post to callbacks and update itself accordingly" do
+      topic.url
+    end.equals("http://poster")
+  end # when callback does not exist
+
+  context "when callback does exist" do
+    setup do
+      Evoke::HTTMockParty.get('/callbacks/putter').
+        responds({"url" => "http://putter", "guid" => "putter"}).ok
+      Evoke::HTTMockParty.put('/callbacks/putter',
+          :query => {"guid" => "putter", "url" => "http://putter.back"}).
+        responds({"url" => "http://putter.new"}).ok
+      Evoke::Callback.create_or_update({"guid" => "putter", "url" => "http://putter.back"})
+    end
+  
+    should "put to callbacks and update itself accordingly" do
+      topic.url
+    end.equals("http://putter.new")
+  end # when callback does exist
+
+end # create or update

data/test/create_test.rb

@@ -0,0 +1,48 @@
+require 'teststrap'
+
+context "creating a callback" do
+
+  context "with valid data" do
+    setup do
+      good_response = {"url" => "http://foo.bar"}
+      Evoke::HTTMockParty.post('/callbacks', :query => {"url" => "http://good"}).
+        responds(good_response).created
+      callback = Evoke::Callback.new("url" => "http://good")
+      callback.save
+      callback
+    end
+
+    asserts("url is populated from returned values") do
+      topic.url
+    end.equals("http://foo.bar")
+
+  end # with valid data
+
+  context "with invalid data" do
+
+    setup do
+      bad_response = {"errors" => ["blah"]}
+      Evoke::HTTMockParty.post('/callbacks', :query => {"url" => "http://bad"}).
+        responds(bad_response).unprocessable_entity
+      Evoke::Callback.new("url" => "http://bad")
+    end
+
+    should "raise error and include save errors in exception message" do
+      topic.save
+    end.raises(Evoke::RecordInvalid, ["blah"])
+
+  end # with valid data
+
+  context "with some unknown error code" do
+
+    setup do
+      Evoke::HTTMockParty.post('/callbacks', :query => {"url" => "http://unknown"}).internal_server_error
+      Evoke::Callback.new("url" => "http://unknown")
+    end
+
+    should "raise and error with 500 response code message" do
+      topic.save
+    end.raises(Evoke::RecordError, "500 - Internal Server Error")
+
+  end # with valid data
+end # creating a callback

data/test/destroy_test.rb

@@ -0,0 +1,32 @@
+require 'teststrap'
+
+context "destroying a callback" do
+  context "that actually exists" do
+    setup do
+      Evoke::HTTMockParty.delete('/callbacks/good').ok
+      Evoke::Callback.new("guid" => "good")
+    end
+    
+    asserts("nil is returned from destroy") { topic.destroy }.nil
+  end # that actually exists
+
+  context "that causes some failure" do
+    setup do
+      Evoke::HTTMockParty.delete('/callbacks/bad').responds({"errors" => ["sucka"]}).unprocessable_entity
+      Evoke::Callback.new("guid" => "bad")
+    end
+    
+    asserts "error is raised with errors in exception message" do
+      topic.destroy
+    end.raises(Evoke::RecordInvalid, ["sucka"])
+  end # that causes some failure
+
+  context "that does not exist" do
+    setup do
+      Evoke::HTTMockParty.delete('/callbacks/what').not_found
+      Evoke::Callback.new("guid" => "what")
+    end
+    
+    should("raise an error") { topic.destroy }.raises(Evoke::RecordNotFound)
+  end # that does not exist
+end # destroying a callback

data/test/find_test.rb

@@ -0,0 +1,31 @@
+require 'teststrap'
+
+context "finding a callback" do
+  context "that exists" do
+    setup do
+      good_data = {"url" => "http://foo.bar", "http_method" => "get"}
+      Evoke::HTTMockParty.get('/callbacks/a1b2c3').responds(good_data).ok
+      Evoke::Callback.find('a1b2c3')
+    end
+
+    should("return a Callback object") { topic }.kind_of(Evoke::Callback)
+    should("not be a new record") { !topic.new_record? }
+
+    asserts("url attribute is accessible as method") do
+      topic.url
+    end.equals("http://foo.bar")
+
+    asserts("http_method attribute is accessible as method") do
+      topic.http_method
+    end.equals("get")
+  end
+
+  context "that does not exist" do
+    setup do
+      Evoke::HTTMockParty.get('/callbacks/blah').not_found
+      Evoke::Callback.find('blah')
+    end
+
+    asserts("result") { topic }.nil
+  end
+end # finding a callback

data/test/teststrap.rb

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'riot'
+require 'evoke_client/mock'

data/test/update_test.rb

@@ -0,0 +1,49 @@
+require 'teststrap'
+
+context "updating attributes of a callback" do
+  setup do
+    callback = Evoke::Callback.new("guid" => "meme", "url" => "http://foo.bar", "http_method" => "get")
+    callback.update_attributes("guid" => "mom", "url" => "http://a.b")
+    callback
+  end
+
+  asserts("guid updated") { topic.guid }.equals("mom")
+  asserts("url updated") { topic.url }.equals("http://a.b")
+  asserts("http_method is unchanged") { topic.http_method }.equals("get")
+end # updating attributes of a callback
+
+context "updating a callback" do
+
+  context "that actually exists" do
+    setup do
+      Evoke::HTTMockParty.put('/callbacks/good', :query => {"guid" => "good", "url" => "http://a.b"}).
+        responds({"url" => "http://foo.bar"}).ok
+      callback = Evoke::Callback.new("guid" => "good", "url" => "http://a.b", :new_record => false)
+      callback.save
+      callback
+    end
+    
+    asserts("url is updated from results") { topic.url }.equals("http://foo.bar")
+  end # that actually exists
+
+  context "that causes some failure" do
+    setup do
+      Evoke::HTTMockParty.put('/callbacks/bad', :query => {"guid" => "bad"}).
+        responds({"errors" => ["mutha"]}).unprocessable_entity
+      Evoke::Callback.new("guid" => "bad", :new_record => false)
+    end
+
+    should("raise an error") { topic.save }.raises(Evoke::RecordInvalid)
+    should("include errors in exception message") { topic.save }.raises(Evoke::RecordInvalid, "mutha")
+  end # that causes some failure
+
+  context "that does not exist" do
+    setup do
+      Evoke::HTTMockParty.put('/callbacks/what', :query => {"guid" => "what"}).not_found
+      Evoke::Callback.new("guid" => "what", :new_record => false)
+    end
+
+    should("raise an error") { topic.save }.raises(Evoke::RecordNotFound)
+  end # that does not exist
+
+end # updating a callback

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: evoke_client
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - Justin Knowlden
@@ -9,20 +9,20 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-07 00:00:00 -05:00
+date: 2009-10-07 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: rest-client
+  name: httparty
   type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.9.2
+        version: 0.4.4
     version: 
-description: Rest client interface for talking REST to the evoke service
+description: Tool for interfacing with the Evoke web service. See http://github.com/thumblemonks/evoke
 email: 
 - gus@gusg.us
 executables: []
@@ -34,13 +34,10 @@ extra_rdoc_files:
 files: 
 - MIT-LICENSE
 - README.markdown
-- Rakefile
 - evoke_client.gemspec
 - lib/evoke_client.rb
 - lib/evoke_client/base.rb
-- lib/evoke_client/stub.rb
-- lib/query_string.rb
-- shoulda_macros/rest_client.rb
+- lib/evoke_client/mock.rb
 has_rdoc: true
 homepage: http://github.com/thumblemonks/evoke_client
 licenses: []
@@ -69,7 +66,13 @@ rubyforge_project:
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: Rest client interface for talking REST to the evoke service
+summary: Tool for interfacing with the Evoke web service
 test_files: 
-- test/evoke_client_test.rb
-- test/test_helper.rb
+- Rakefile
+- test/configuration_test.rb
+- test/create_or_update_test.rb
+- test/create_test.rb
+- test/destroy_test.rb
+- test/find_test.rb
+- test/teststrap.rb
+- test/update_test.rb

data/lib/evoke_client/stub.rb

@@ -1,7 +0,0 @@
-module EvokeClient
-  class Stub
-    def initialize(params={}); end
-
-    def save; end
-  end # Stub
-end # EvokeClient

data/lib/query_string.rb

@@ -1,16 +0,0 @@
-module EvokeClient
-  module Hash
-    def to_query_string
-      map do |key, val|
-        "#{key}=#{val}"
-      end.join('&')
-    end
-  end # Hash
-
-  module String
-    alias_method :to_query_string, :to_s
-  end # String
-end # EvokeClient
-
-Hash.instance_eval { include EvokeClient::Hash }
-String.instance_eval { include EvokeClient::String }

data/shoulda_macros/rest_client.rb

@@ -1,16 +0,0 @@
-module EvokeClient
-  module RestClient
-    module Shoulda
-      def expect_restful_request(method, *args)
-        ::RestClient::Resource.any_instance.expects(method).with(*args)
-      end
-
-      def expect_restful_request_failure(method, *raises)
-        ::RestClient::Resource.any_instance.expects(method).raises(*raises)
-      end
-
-    end # Shoulda
-  end # RestClient
-end # EvokeClient
-
-Test::Unit::TestCase.instance_eval { include EvokeClient::RestClient::Shoulda }

data/test/evoke_client_test.rb

@@ -1,104 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-class EvokeTest < Test::Unit::TestCase
-  def setup
-    @params = {:url => 'foo', :callback_at => Time.now}
-  end
-
-  def teardown
-    Evoke.test = false
-  end
-
-  context "preparing an evokation" do
-    setup do
-      @data = {:foo => 'bar', 'goo' => 'car'}
-      @expected_data = "foo=bar&goo=car"
-      @evoke = Evoke.prepare(@params.merge(:data => @data))
-    end
-    
-    before_should("convert times to UTC") { Time.any_instance.expects(:utc) }
-
-    should "convert data to a single escaped parameter string" do
-      assert_match /foo=bar&?/, @evoke.params[:data]
-      assert_match /goo=car&?/, @evoke.params[:data]
-    end
-  end
-
-  context "saving" do
-    context "a new callback" do
-      setup do
-        expect_restful_request_failure(:get, ::RestClient::ResourceNotFound)
-        expect_restful_request(:post, @params)
-        @evoke = Evoke.prepare(@params)
-      end
-      should("try and post params after not finding a resource") { @evoke.save }
-    end
-
-    context "an existing callback" do
-      setup do
-        expect_restful_request(:get)
-        expect_restful_request(:put, @params)
-        @evoke = Evoke.prepare(@params)
-      end
-      should("try and put params after finding a resource") { @evoke.save }
-    end
-  end
-
-  context "create_or_update!" do
-    should "initialize instance and call save" do
-      fake_evoke = EvokeClient::Base.new
-      EvokeClient::Base.expects(:new).with(@params).returns(fake_evoke)
-      fake_evoke.expects(:save)
-      Evoke.create_or_update!(@params)
-    end
-  end
-
-  context "connection refused" do
-    setup do
-      expect_restful_request_failure(:get, Errno::ECONNREFUSED)
-    end
-
-    should "reraise Evoke::ConnectionRefused when saving" do
-      assert_raise(Evoke::ConnectionRefused) { Evoke.prepare({}).save }
-    end
-    
-    should "reraise Evoke::ConnectionRefused when storing" do
-      assert_raise(Evoke::ConnectionRefused) { Evoke.create_or_update!({}) }
-    end
-  end
-
-  context "host and port:" do
-    context "when unchanged" do
-      setup do
-        Evoke.host = nil
-        Evoke.port = nil
-      end
-      should("return default host") { assert_equal 'evoke.thumblemonks.com', Evoke.host }
-      should("return default port") { assert_nil Evoke.port }
-      should("return default host and port") { assert_equal 'evoke.thumblemonks.com', Evoke.host_and_port }
-    end
-
-    context "when changed" do
-      setup do
-        Evoke.host = 'example.com'
-        Evoke.port = 4567
-      end
-
-      should("return specified host") { assert_equal 'example.com', Evoke.host }
-      should("return specified port") { assert_equal 4567, Evoke.port }
-      should("return specified host and port") { assert_equal 'example.com:4567', Evoke.host_and_port }
-    end
-  end
-
-  context "when test mode is on" do
-    setup do
-      Evoke.test = true
-      @evoke = Evoke.prepare({})
-    end
-
-    should "expect an EvokeClient::Stub class" do
-      assert_kind_of EvokeClient::Stub, @evoke
-    end
-  end
-
-end

data/test/test_helper.rb

@@ -1,11 +0,0 @@
-require 'rubygems'
-require 'shoulda'
-require 'mocha'
-require 'redgreen'
-
-Shoulda.autoload_macros(File.join(File.dirname(__FILE__), '..'), ['.'])
-
-require 'evoke_client'
-
-Evoke.host = 'localhost'
-Evoke.port = 4567