ticketevolution-ruby 0.5.0

data/spec/lib/ticket_evolution_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe TicketEvolution do
+  subject{ TicketEvolution }
+
+  it "should specify a version" do
+    subject::VERSION.should be
+  end
+
+  describe ".root" do
+    subject { TicketEvolution.root }
+
+    it { should be_a Pathname }
+
+    it "should end in 'ticket_evolution'" do
+      subject.to_s.should =~ /ticket_evolution$/
+    end
+  end
+end
+

data/spec/shared_examples/endpoints/class.rb

@@ -0,0 +1,241 @@
+require 'spec_helper'
+
+shared_examples_for "a ticket_evolution endpoint class" do
+  let(:connection) { TicketEvolution::Connection.new({:token => Fake.token, :secret => Fake.secret}) }
+  let(:sample_parent) { TicketEvolution::Samples.new }
+  let(:curl) { double(:curl, :http => nil) }
+  let(:instance) { klass.new({:parent => connection}) }
+  let(:path) { '/search' }
+  let(:full_path) { "#{instance.base_path}#{path}" }
+
+  describe "#initialize" do
+    context "with an options hash for it's first parameter" do
+      it "should create accessors for each key value pair" do
+        instance = klass.new({
+          :parent => connection,
+          :test => :one,
+          :testing => "two",
+          :number => 3,
+          :hash => {}
+        })
+        instance.parent.should == connection
+        instance.test.should == :one
+        instance.testing.should == "two"
+        instance.number.should == 3
+        instance.hash.should == {}
+      end
+
+      context "with a parent k/v pair" do
+        context "that does not inherit from TicketEvolution::Base" do
+          it "should raise an EndpointConfigurationError" do
+            message = "#{klass} instances require a parent which inherits from TicketEvolution::Base"
+            expect {
+              klass.new({:parent => Object.new})
+            }.to raise_error TicketEvolution::EndpointConfigurationError, message
+          end
+        end
+
+        context "that does inherit from TicketEvolution::Base" do
+          context "and is a TicketEvolution::Connection object" do
+            it "should not raise" do
+              expect { klass.new({:parent => connection}) }.to_not raise_error
+            end
+          end
+
+          context "and has a TicketEvolution::Connection object in it's parent chain" do
+            let(:sample_chain) do
+              TicketEvolution::Endpoint.new({
+                :parent => TicketEvolution::Endpoint.new({
+                  :parent => connection
+                })
+              })
+            end
+
+            it "should not raise" do
+              expect { klass.new({:parent => klass.new({:parent => sample_chain})}) }.to_not raise_error
+            end
+          end
+
+          context "and does not have a TicketEvolution::Connection object in it's parent chain" do
+            it "should raise an EndpointConfigurationError" do
+              message = "The parent passed in the options hash must be a TicketEvolution::Connection object or have one in it's parent chain"
+              expect {
+                klass.new({:parent => sample_parent})
+              }.to raise_error TicketEvolution::EndpointConfigurationError, message
+            end
+          end
+        end
+      end
+
+      context "without a parent k/v pair" do
+        it "should raise an EndpointConfigurationError" do
+          message = "The options hash must include a parent key / value pair"
+          expect {
+            klass.new({})
+          }.to raise_error TicketEvolution::EndpointConfigurationError, message
+        end
+      end
+    end
+
+    context "with no first parameter or a non hash object" do
+      it "should raise an EndpointConfigurationError" do
+        message = "#{klass} instances require a hash as their first parameter"
+        expect { klass.new }.to raise_error TicketEvolution::EndpointConfigurationError, message
+      end
+    end
+  end
+
+  describe "#base_path" do
+    let(:endpoint_name) { klass.name.demodulize.underscore }
+
+    context "when #parent is a TicketEvolution::Connection object" do
+      let(:path) { "/#{endpoint_name}" }
+
+      it "should be generated based on its class name" do
+        klass.new({:parent => connection}).base_path.should == path
+      end
+    end
+
+    context "when #parent is not a TicketEvolution::Connection object" do
+      let(:instance) { klass.new({:parent => connection, :id => 1}) }
+      let(:path) { "/#{instance.endpoint_name}/#{instance.id}/#{endpoint_name}" }
+      it "should be generated based on its class name and the class names of its parents" do
+        klass.new({:parent => instance}).base_path.should == path
+      end
+    end
+  end
+
+  describe "#connection" do
+    context "the connection object is the parent" do
+      subject { klass.new({:parent => connection}) }
+
+      its(:connection) { should == connection }
+    end
+
+    context "the connection object is not the parent" do
+      subject { klass.new({:parent => TicketEvolution::Endpoint.new({:parent => connection})}) }
+
+      its(:connection) { should == connection }
+    end
+  end
+
+  describe "#build_request" do
+
+    context "which is valid" do
+      context "with params" do
+        let(:params) do
+          {
+            :page => 1,
+            :per_page => 10,
+            :name => "test"
+          }
+        end
+
+        [:GET, :POST, :PUT, :DELETE].each do |method|
+          it "should accept an http '#{method}' method, a url path for the call and a list of parameters as a hash and pass them to connection" do
+            connection.should_receive(:build_request).with(method, full_path, params).and_return(curl)
+
+            instance.build_request(method, path, params)
+          end
+        end
+      end
+
+      context "without params" do
+        [:GET, :POST, :PUT, :DELETE].each do |method|
+          it "should accept an http '#{method}' method and a url path for the call and pass them to connection" do
+            connection.should_receive(:build_request).with(method, full_path, nil).and_return(curl)
+
+            instance.build_request(method, path)
+          end
+        end
+      end
+    end
+
+    context "given an invalid http method" do
+      it "should raise a EndpointConfigurationError" do
+        message = "#{klass.to_s}#request requires it's first parameter to be a valid HTTP method"
+
+        expect { instance.request('BAD', path) }.to raise_error TicketEvolution::EndpointConfigurationError, message
+      end
+    end
+  end
+
+  describe "#request" do
+    subject { instance.request method, full_path }
+    let(:method) { :GET }
+    let(:response) { Fake.response }
+    let(:handler) { Fake.send(:method, :response_handler) }
+
+    before do
+      connection.should_receive(:build_request).and_return(curl)
+      instance.should_receive(:naturalize_response).and_return(response)
+    end
+
+    it "calls http on the return Curl object with the method for the request" do
+      curl.should_receive(:http).with(method)
+
+      instance.request(method, path, nil, &handler).should == Fake.response_handler(true)
+    end
+
+    context "when there is an error from the api" do
+      let(:response) { Fake.error_response }
+
+      before { curl.should_receive(:http) }
+
+      it "should return an instance of TicketEvolution::ApiError" do
+        subject.should be_a TicketEvolution::ApiError
+      end
+    end
+
+    context "when successful" do
+      let(:response) { Fake.response }
+
+      before { curl.should_receive(:http) }
+
+      it "should pass the response object to #build_object" do
+        instance.request(method, path, nil, &handler).should == Fake.response_handler(true)
+      end
+    end
+  end
+
+  describe "#naturalize_response" do
+    let(:path) { '/list' }
+    let(:instance) { klass.new({:parent => connection}) }
+    let(:full_path) { "#{instance.base_path}#{path}" }
+    let(:response_code) { 200 }
+    let(:response) { mock(:response, {
+      :header_str => "header",
+      :response_code => response_code,
+      :body_str => body_str
+    }) }
+
+    context "with a valid body" do
+      subject { instance.naturalize_response response }
+      let(:body_str) { "{\"test\": \"hello\"}" }
+
+      its(:header) { should == response.header_str }
+      its(:body) { should == MultiJson.decode(response.body_str).merge({:connection => connection}) }
+
+      TicketEvolution::Endpoint::RequestHandler::CODES.each do |code, value|
+        context "with response code #{code}" do
+          let(:response_code) { code }
+
+          its(:response_code) { should == code }
+          its(:server_message) { should == value.last }
+        end
+      end
+    end
+  end
+
+  context "#endpoint_name" do
+    it "returns the demodulized version of the endpoint name" do
+      instance.endpoint_name.should == klass.name.demodulize.underscore
+    end
+  end
+
+  context "#singular_class" do
+    it "returns the singular version of an Endpoint class" do
+      instance.singular_class.should == single_klass
+    end
+  end
+end

data/spec/shared_examples/endpoints/create.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+shared_examples_for "a create endpoint" do
+  let(:connection) { TicketEvolution::Connection.new({:token => Fake.token, :secret => Fake.secret}) }
+  let(:builder_klass) { "TicketEvolution::#{klass.to_s.split('::').last.singularize.camelize}".constantize }
+  let(:instance) { klass.new({:parent => connection}) }
+
+  describe "#create" do
+    context "with params" do
+      let(:params) { {:name => "Bob"} }
+
+      it "should pass call request as a POST, passing params" do
+        instance.should_receive(:request).with(:POST, nil, instance.endpoint_name.to_sym => [params])
+
+        instance.create(params)
+      end
+    end
+
+    context "without params" do
+      it "should pass call request as a POST, without params" do
+        instance.should_receive(:request).with(:POST, nil, nil)
+
+        instance.create
+      end
+    end
+  end
+
+  describe "#build_for_create" do
+    let(:response) { Fake.create_response instance.endpoint_name, connection }
+
+    it "should invoke an instance of its builder class" do
+      builder_klass.should_receive(:new).with(response.body[instance.endpoint_name].first.merge({
+        :status_code => response.response_code,
+        :server_message => response.server_message,
+        :connection => connection
+      }))
+
+      instance.build_for_create(response)
+    end
+  end
+end

data/spec/shared_examples/endpoints/deleted.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+shared_examples_for "a deleted endpoint" do
+  let(:connection) { TicketEvolution::Connection.new({:token => Fake.token, :secret => Fake.secret}) }
+  let(:instance) { klass.new({:parent => connection}) }
+
+  describe "#deleted" do
+    context "with params" do
+      let(:params) { {:page => 2, :per_page => 2} }
+
+      it "should pass call request as a GET, passing params" do
+        instance.should_receive(:request).with(:GET, '/deleted', params)
+
+        instance.deleted(params)
+      end
+    end
+
+    context "without params" do
+      it "should pass call request as a GET, passing params" do
+        instance.should_receive(:request).with(:GET, '/deleted', nil)
+
+        instance.deleted
+      end
+    end
+  end
+
+  context "#build_for_deleted" do
+    let(:response) { Fake.list_response }
+
+    it "invokes Collection#build_from_response" do
+      TicketEvolution::Collection.
+        should_receive(:build_from_response).
+        with(response, klass.name.demodulize.underscore, instance.singular_class)
+      instance.build_for_deleted(response)
+    end
+
+    it "returns a collection" do
+      instance.build_for_deleted(response).should be_a TicketEvolution::Collection
+    end
+  end
+end

data/spec/shared_examples/endpoints/list.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+shared_examples_for "a list endpoint" do
+  let(:connection) { TicketEvolution::Connection.new({:token => Fake.token, :secret => Fake.secret}) }
+  let(:instance) { klass.new({:parent => connection}) }
+
+  describe "#list" do
+    context "with params" do
+      let(:params) { {:page => 2, :per_page => 2} }
+
+      it "should pass call request as a GET, passing params" do
+        instance.should_receive(:request).with(:GET, nil, params)
+
+        instance.list(params)
+      end
+    end
+
+    context "without params" do
+      it "should pass call request as a GET, passing params" do
+        instance.should_receive(:request).with(:GET, nil, nil)
+
+        instance.list
+      end
+    end
+  end
+
+  context "#build_for_list" do
+    let(:response) { Fake.list_response }
+
+    it "invokes Collection#build_from_response" do
+      TicketEvolution::Collection.
+        should_receive(:build_from_response).
+        with(response, klass.name.demodulize.underscore, instance.singular_class)
+      instance.build_for_list(response)
+    end
+
+    it "returns a collection" do
+      instance.build_for_list(response).should be_a TicketEvolution::Collection
+    end
+  end
+end

data/spec/shared_examples/endpoints/search.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+shared_examples_for "a search endpoint" do
+  let(:connection) { TicketEvolution::Connection.new({:token => Fake.token, :secret => Fake.secret}) }
+  let(:instance) { klass.new({:parent => connection}) }
+
+  describe "#search" do
+    context "with params" do
+      let(:params) { {:page => 2, :per_page => 2, :q => "test"} }
+
+      it "should pass call request as a GET, passing params" do
+        instance.should_receive(:request).with(:GET, '/search', params)
+
+        instance.search(params)
+      end
+    end
+
+    context "without params" do
+      it "should pass call request as a GET, passing params" do
+        instance.should_receive(:request).with(:GET, '/search', nil)
+
+        instance.search
+      end
+    end
+  end
+
+  context "#build_for_search" do
+    let(:response) { Fake.list_response }
+
+    it "invokes Collection#build_from_response" do
+      TicketEvolution::Collection.
+        should_receive(:build_from_response).
+        with(response, klass.name.demodulize.underscore, instance.singular_class)
+      instance.build_for_search(response)
+    end
+
+    it "returns a collection" do
+      instance.build_for_search(response).should be_a TicketEvolution::Collection
+    end
+  end
+
+end

data/spec/shared_examples/endpoints/show.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+shared_examples_for "a show endpoint" do
+  let(:connection) { TicketEvolution::Connection.new({:token => Fake.token, :secret => Fake.secret}) }
+  let(:builder_klass) { "TicketEvolution::#{klass.to_s.split('::').last.singularize.camelize}".constantize }
+  let(:instance) { klass.new({:parent => connection}) }
+
+  describe "#show" do
+    context "with id" do
+      let(:id) { 1 }
+
+      it "should pass call request as a GET, passing the id as a piece of the path" do
+        instance.should_receive(:request).with(:GET, "/#{id}")
+
+        instance.show(id)
+      end
+    end
+
+    context "without id" do
+      it "should raise an ArgumentError" do
+        expect { instance.show }.to raise_error ArgumentError
+      end
+    end
+  end
+
+  describe "#build_for_show" do
+    let(:response) { Fake.show_response }
+
+    it "should invoke an instance of its builder class" do
+      builder_klass.should_receive(:new).with(response.body.merge({
+        :status_code => response.response_code,
+        :server_message => response.server_message})
+      )
+
+      instance.build_for_show(response)
+    end
+  end
+end

data/spec/shared_examples/endpoints/update.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+shared_examples_for "an update endpoint" do
+  let(:connection) { TicketEvolution::Connection.new({:token => Fake.token, :secret => Fake.secret}) }
+  let(:instance) { klass.new({:parent => connection}) }
+
+  describe "#update" do
+    context "with an id" do
+      let(:instance) { klass.new({:parent => connection, :id => 1}) }
+
+      context "with params" do
+        let(:params) { {:name => "Bob"} }
+
+        it "should pass call request as a PUT, passing params" do
+          instance.should_receive(:request).with(:PUT, "/#{instance.id}", params)
+
+          instance.update(params)
+        end
+      end
+
+      context "without params" do
+        it "should pass call request as a PUT, passing params" do
+          instance.should_receive(:request).with(:PUT, "/#{instance.id}", nil)
+
+          instance.update
+        end
+      end
+    end
+
+    context "without an id" do
+      it "should raise an UnavailableMethodError if there is no id" do
+        message = "#{klass.to_s}#update can only be called if there is an id present on this #{klass.to_s} instance"
+        expect { instance.update }.to raise_error TicketEvolution::MethodUnavailableError, message
+      end
+    end
+  end
+
+  describe ".included" do
+    let(:model_klass) { instance.singular_class }
+    let(:model_instance) { model_klass.new(attributes.merge({:connection => connection})) }
+    let(:attributes) { HashWithIndifferentAccess.new(update_base.merge({:one => 1, :two => "two", :three => nil, :id => 1})) }
+    let(:stored_attributes) { attributes.delete_if{|k, v| k == 'id'} }
+    let(:updated_attributes) { HashWithIndifferentAccess.new({:one => "one", :three => 3}) }
+    let(:merged_attributes) { attributes.merge(updated_attributes) }
+
+    it "should set an update_attributes method on it's corresponding TE:Model class which adds to it's attributes and calls #update" do
+      model_instance.should respond_to :update_attributes
+      klass.any_instance.should_receive(:update).with(updated_attributes).and_return(nil)
+      model_instance.update_attributes(updated_attributes)
+      model_instance.attributes.should == merged_attributes
+    end
+
+    it "should set a save method on it's corresponding TE:Model class which calls #update with it's attributes" do
+      model_instance.should respond_to :save
+      klass.any_instance.should_receive(:update).with(stored_attributes).and_return(nil)
+      model_instance.save
+    end
+  end
+end

data/spec/shared_examples/errors.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+shared_examples_for "a ticket_evolution error class" do
+  its(:ancestors) { should include Exception }
+end

data/spec/shared_examples/models.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+shared_examples_for "a ticket_evolution model" do
+  let(:klass) { subject }
+  let(:instance) { klass.new({:connection => Fake.connection}) }
+
+  its(:ancestors) { should include TicketEvolution::Model }
+
+  describe "#attributes" do
+    let(:hash) { { "hash" => { "test" => "1.. 2... 3...." } } }
+
+    it "should return a hash of attribute key/pair values" do
+      instance.one = 1
+      instance.two = 2
+      instance.three = nil
+
+      instance.attributes.should == {"one" => 1, "two" => 2, "three" => nil}
+    end
+
+    it "should return a HashWithIndifferentAccess" do
+      instance.attributes.should be_a HashWithIndifferentAccess
+    end
+
+    it "should convert OpenStruct based objects back into hashes recursively" do
+      instance.hash = hash
+      instance.attributes.should == { "hash" => hash }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+require "ap"
+require File.join(File.dirname(File.expand_path(__FILE__)), '..', 'lib', 'ticket_evolution.rb')
+require 'active_support/ordered_hash' unless RUBY_VERSION =~ /^1\.9/
+
+@spec_path = Pathname.new(File.join(File.dirname(File.expand_path(__FILE__))))
+
+Dir[File.join(@spec_path, 'support/*.rb')].each { |file| require(file) }
+
+RSpec.configure do |config|
+end
+
+require @spec_path + 'fixtures' + 'fake.rb'
+require @spec_path + 'shared_examples' + 'endpoints' + 'class.rb'
+require @spec_path + 'shared_examples' + 'endpoints' + 'create.rb'
+require @spec_path + 'shared_examples' + 'endpoints' + 'deleted.rb'
+require @spec_path + 'shared_examples' + 'endpoints' + 'list.rb'
+require @spec_path + 'shared_examples' + 'endpoints' + 'search.rb'
+require @spec_path + 'shared_examples' + 'endpoints' + 'show.rb'
+require @spec_path + 'shared_examples' + 'endpoints' + 'update.rb'
+require @spec_path + 'shared_examples' + 'errors.rb'
+require @spec_path + 'shared_examples' + 'models.rb'

data/spec/support/connection.rb

@@ -0,0 +1,10 @@
+module ConnectionSupport
+  def connection
+    TicketEvolution::Connection.new(
+      :token => "b2b5a7a33b1a78896ed1b53d81c5c9cc",
+      :secret => "m2bAipNKfNnzz9z88+z2cgDy4Tb+QjIudmpJkJcr"
+    )
+  end
+
+  RSpec.configure {|c| c.include self}
+end

data/spec/support/vcr.rb

@@ -0,0 +1,12 @@
+require 'vcr'
+
+VCR.config do |config|
+  config.cassette_library_dir = File.join(File.dirname(__FILE__), '..', 'fixtures', 'net')
+  config.default_cassette_options = { :record => :none }
+  config.ignore_localhost = true
+  config.stub_with(:webmock)
+end
+
+RSpec.configure do |config|
+  config.extend(VCR::RSpec::Macros)
+end

data/ticketevolution-ruby.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+require File.join(File.dirname(File.expand_path(__FILE__)), 'lib', 'ticket_evolution', 'version')
+
+Gem::Specification.new do |s|
+  s.name        = 'ticketevolution-ruby'
+  s.version     = TicketEvolution::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['David Malin', 'Ticket Evolution']
+  s.email       = ['dev@ticketevolution.com']
+  s.homepage    = 'http://api.ticketevolution.com'
+  s.summary     = 'Integration gem for Ticket Evolution\'s api'
+  s.description = ''
+
+  s.required_rubygems_version = '>= 1.3.5'
+
+  s.add_dependency 'activesupport'
+  s.add_dependency 'i18n'
+  s.add_dependency 'curb'
+  s.add_dependency 'yajl-ruby'
+  s.add_dependency 'multi_json'
+  s.add_dependency 'nokogiri'
+
+  s.add_development_dependency 'rspec', '>= 2.7.1'
+  s.add_development_dependency 'vcr'
+  s.add_development_dependency 'webmock'
+  s.add_development_dependency 'awesome_print'
+  s.add_development_dependency 'rake'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end