ticketevolution-ruby 0.5.0

data/spec/lib/ticket_evolution/accounts_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe TicketEvolution::Accounts do
+  let(:klass) { TicketEvolution::Accounts }
+  let(:single_klass) { TicketEvolution::Account }
+
+  it_behaves_like 'a ticket_evolution endpoint class'
+  it_behaves_like 'a list endpoint'
+  it_behaves_like 'a show endpoint'
+
+  context "integration tests" do
+    use_vcr_cassette "endpoints/accounts", :record => :new_episodes
+
+    it "returns an account" do
+      id = 62
+      account = connection.accounts.show(id)
+
+      account.url.should == "/accounts/#{id}"
+      account.currency.should == "USD"
+      account.updated_at.should_not be_nil
+      account.balance.should == "9922.71"
+      account.id.should == id.to_s
+
+      account.client.should == TicketEvolution::Client.new({
+        :connection => connection,
+        "url" => "/clients/3",
+        "name" => "Main Office",
+        "id" => "3"
+      })
+    end
+
+    it "returns a list of accounts" do
+      accounts = connection.accounts.list(:per_page => 4, :page => 5)
+
+      accounts.per_page.should == 4
+      accounts.current_page.should == 5
+      accounts.total_entries.should == 88
+
+      accounts.size.should == 4
+      accounts.each do |account|
+        account.should be_a TicketEvolution::Account
+      end
+    end
+  end
+end

data/spec/lib/ticket_evolution/address_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe TicketEvolution::Address do
+  subject { TicketEvolution::Address }
+
+  it_behaves_like "a ticket_evolution model"
+end

data/spec/lib/ticket_evolution/brokerage_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe TicketEvolution::Brokerage do
+  subject { TicketEvolution::Brokerage }
+
+  it_behaves_like "a ticket_evolution model"
+end

data/spec/lib/ticket_evolution/brokerages_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe TicketEvolution::Brokerages do
+  let(:klass) { TicketEvolution::Brokerages }
+  let(:single_klass) { TicketEvolution::Brokerage }
+
+  it_behaves_like 'a ticket_evolution endpoint class'
+  it_behaves_like 'a list endpoint'
+  it_behaves_like 'a search endpoint'
+  it_behaves_like 'a show endpoint'
+
+  context "integration tests" do
+    use_vcr_cassette "endpoints/brokerages", :record => :new_episodes
+
+    it "returns a brokerage" do
+      brokerage = connection.brokerages.show(2)
+
+      brokerage.should be_a TicketEvolution::Brokerage
+      brokerage.name.should == "Golden Tickets"
+      brokerage.id.should == "2"
+      brokerage.url.should == "/brokerages/2"
+    end
+
+    it "returns a list of brokerages" do
+      brokerages = connection.brokerages.list(:per_page => 3, :page => 4)
+
+      brokerages.per_page.should == 3
+      brokerages.current_page.should == 4
+      brokerages.total_entries.should == 1379
+
+      brokerages.size.should == 3
+      brokerages.each do |brokerage|
+        brokerage.should be_a TicketEvolution::Brokerage
+      end
+    end
+
+    it "searches for a brokerage" do
+      brokerages = connection.brokerages.search(:q => "New York", "page" => 1)
+
+      # FIXME: The search API doesn't return total entries, yet (due to lack of pagination)...
+      brokerages.per_page.should be_nil
+      brokerages.current_page.should be_nil
+      brokerages.total_entries.should be_nil
+
+      brokerages.count.should == 2
+      brokerages.each { |brokerage| brokerage.should be_an_instance_of TicketEvolution::Brokerage }
+      brokerages.first.name.should == "Totally New York"
+    end
+  end
+end

data/spec/lib/ticket_evolution/categories_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe TicketEvolution::Categories do
+  let(:klass) { TicketEvolution::Categories }
+  let(:single_klass) { TicketEvolution::Category }
+
+  it_behaves_like 'a ticket_evolution endpoint class'
+  it_behaves_like 'a deleted endpoint'
+  it_behaves_like 'a list endpoint'
+  it_behaves_like 'a show endpoint'
+
+  describe "integrations" do
+    use_vcr_cassette "endpoints/categories", :record => :new_episodes
+
+    context "#deleted" do
+      it "returns a list of deleted categories" do
+        categories = connection.categories.deleted(:per_page => 2)
+
+        categories.size.should == 1
+        categories.each do |category|
+          category.should be_instance_of TicketEvolution::Category
+        end
+        categories.first.name.should == "Insult Comedy"
+      end
+    end
+  end
+end

data/spec/lib/ticket_evolution/category_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe TicketEvolution::Category do
+  subject { TicketEvolution::Category }
+
+  it_behaves_like "a ticket_evolution model"
+end

data/spec/lib/ticket_evolution/client_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe TicketEvolution::Client do
+  subject { TicketEvolution::Client }
+
+  it_behaves_like "a ticket_evolution model"
+end

data/spec/lib/ticket_evolution/clients/addresses_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe TicketEvolution::Clients::Addresses do
+  let(:klass) { TicketEvolution::Clients::Addresses }
+  let(:single_klass) { TicketEvolution::Address }
+  let(:update_base) { {'url' => '/clients/1/addresses/1'} }
+
+  it_behaves_like 'a ticket_evolution endpoint class'
+  it_behaves_like 'a create endpoint'
+  it_behaves_like 'a list endpoint'
+  it_behaves_like 'a show endpoint'
+  it_behaves_like 'an update endpoint'
+end

data/spec/lib/ticket_evolution/clients/credit_cards_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe TicketEvolution::Clients::CreditCards do
+  let(:klass) { TicketEvolution::Clients::CreditCards }
+  let(:single_klass) { TicketEvolution::CreditCard }
+  let(:update_base) { {'url' => '/clients/1/credit_cards/1'} }
+
+  it_behaves_like 'a ticket_evolution endpoint class'
+  it_behaves_like 'a create endpoint'
+  it_behaves_like 'a list endpoint'
+end

data/spec/lib/ticket_evolution/clients/email_addresses_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe TicketEvolution::Clients::EmailAddresses do
+  let(:klass) { TicketEvolution::Clients::EmailAddresses }
+  let(:single_klass) { TicketEvolution::EmailAddress }
+  let(:update_base) { {'url' => '/clients/1/email_addresses/1'} }
+
+  it_behaves_like 'a ticket_evolution endpoint class'
+  it_behaves_like 'a create endpoint'
+  it_behaves_like 'a list endpoint'
+  it_behaves_like 'a show endpoint'
+  it_behaves_like 'an update endpoint'
+end

data/spec/lib/ticket_evolution/clients/phone_numbers_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe TicketEvolution::Clients::PhoneNumbers do
+  let(:klass) { TicketEvolution::Clients::PhoneNumbers }
+  let(:single_klass) { TicketEvolution::PhoneNumber }
+  let(:update_base) { {'url' => '/clients/1/phone_numbers/1'} }
+
+  it_behaves_like 'a ticket_evolution endpoint class'
+  it_behaves_like 'a create endpoint'
+  it_behaves_like 'a list endpoint'
+  it_behaves_like 'a show endpoint'
+  it_behaves_like 'an update endpoint'
+end

data/spec/lib/ticket_evolution/clients_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe TicketEvolution::Clients do
+  let(:klass) { TicketEvolution::Clients }
+  let(:single_klass) { TicketEvolution::Client }
+  let(:update_base) { {} }
+
+  it_behaves_like 'a ticket_evolution endpoint class'
+  it_behaves_like 'a create endpoint'
+  it_behaves_like 'a list endpoint'
+  it_behaves_like 'a show endpoint'
+  it_behaves_like 'an update endpoint'
+
+  describe "integrations" do
+    use_vcr_cassette "endpoints/clients", :record => :new_episodes, :match_requests_on => [:method, :uri, :body]
+
+    context "#create" do
+      it "returns validation errors" do
+        client = connection.clients.create(:name => "")
+        client.should be_an_instance_of TicketEvolution::ApiError
+      end
+
+      it "successfully creates a client" do
+        name = "Comish Gordon"
+        client = connection.clients.create(:name => name)
+
+        client.should be_instance_of TicketEvolution::Client
+        client.id.should be
+        client.name.should == name
+
+        same_client = connection.clients.show(client.id)
+        same_client.id.should == client.id
+        same_client.name.should == name
+      end
+    end
+  end
+end

data/spec/lib/ticket_evolution/configuration_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe TicketEvolution::Configuration do
+  subject { TicketEvolution::Configuration }
+
+  it_behaves_like "a ticket_evolution model"
+end

data/spec/lib/ticket_evolution/configurations_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe TicketEvolution::Configurations do
+  let(:klass) { TicketEvolution::Configurations }
+  let(:single_klass) { TicketEvolution::Configuration }
+
+  it_behaves_like 'a ticket_evolution endpoint class'
+  it_behaves_like 'a list endpoint'
+  it_behaves_like 'a show endpoint'
+end

data/spec/lib/ticket_evolution/core/api_error_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe TicketEvolution::ApiError do
+  let(:klass) { TicketEvolution::ApiError }
+  let(:response) { Fake.error_response }
+  let(:instance) { klass.new(response) }
+
+  subject { instance }
+
+  its(:error) { should == response.body['error'] }
+  its(:code) { should == response.response_code }
+  its(:message) { should == response.server_message }
+end

data/spec/lib/ticket_evolution/core/base_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe TicketEvolution::Base do
+  let(:klass) { TicketEvolution::Base }
+  let(:sample_klass) { TicketEvolution::Samples }
+  let(:base) { klass.new }
+
+  describe "#method_missing" do
+    it "should attempt to find a class which matches the missing method" do
+      TicketEvolution.should_receive(:const_defined?).with(:NoObjects)
+      expect { base.no_objects }.to raise_error
+    end
+
+    context "when the missing class is found" do
+      it "should instantiate a new instance of the class, passing itself to initialize as :parent" do
+        instance = sample_klass.new({:parent => base})
+        sample_klass.should_receive(:new).with({:parent => base}).and_return(instance)
+        base.samples.should be_a sample_klass
+      end
+    end
+
+    context "when the missing class is not found" do
+      it "should perform as if the method doesn't exist" do
+        message = "undefined method `coconuts' for #{base.inspect}"
+        expect { base.coconuts }.to raise_error NoMethodError, message
+      end
+    end
+  end
+end

data/spec/lib/ticket_evolution/core/builder_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe TicketEvolution::Builder do
+  let(:klass) { TicketEvolution::Builder }
+  let(:instance) { klass.new(params) }
+  let(:params) { {} }
+
+  subject { klass }
+
+  its(:ancestors) { should include OpenStruct }
+
+  describe "#initialize" do
+    let(:params) do
+      {
+        "url" => "/brokerages/2",
+        "natb_member" => true,
+        "name" => "Golden Tickets",
+        "id" => "2",
+        "abbreviation" => "Golden Tickets"
+      }
+    end
+
+    it "should assign each key value pair as attributes" do
+      params.keys.each do |key|
+        instance.send(key).should == params[key]
+      end
+    end
+
+    it "should call #process_datum for each attribute assigned" do
+      params.values.each do |v|
+        klass.any_instance.should_receive(:process_datum).with(v)
+      end
+      instance
+    end
+  end
+
+  describe "#process_datum" do
+    let(:time) { "2011-12-18T17:30:06Z" }
+
+    context "when dealing with a string" do
+      context "formatted as time" do
+        it "should convert the string to a TicketEvolution::Time object" do
+          instance.send(:process_datum, time).should == TicketEvolution::Time.parse(time)
+        end
+      end
+    end
+
+    context "when dealing with a hash" do
+      it "should instantiate a new TicketEvolution::Datum object" do
+        instance.send(:process_datum, {:one => 1}).should be_a TicketEvolution::Datum
+      end
+    end
+
+    context "when dealing with an array" do
+      it "should map arrays, calling itself on each value" do
+        instance.send(:process_datum, [{:one => 1}, time]).should == [
+          TicketEvolution::Datum.new({:one => 1}),
+          TicketEvolution::Time.parse(time)
+        ]
+      end
+    end
+  end
+
+  describe "#class_name_from_url" do
+    it "extracts a TicketEvolution class name from a url, searching segments right to left" do
+      {
+        '/events' => 'TicketEvolution::Events',
+        '/events/12' => 'TicketEvolution::Events',
+        '/events/deleted' => 'TicketEvolution::Events',
+        '/events/21/venues/12' => 'TicketEvolution::Venues'
+      }.each do |given, expected|
+        instance.send(:class_name_from_url, given).should == expected
+      end
+    end
+  end
+
+  describe "#method_missing" do
+    let(:params) { {} }
+
+    describe "with args" do
+      it "should invoke #process_datum with the information received" do
+        instance.should_receive(:process_datum).with(:ing)
+        instance.test = :ing
+        instance.should_receive(:process_datum).with([1,2])
+        instance.array = [1,2]
+      end
+    end
+
+    describe "without args" do
+      it "should fall back on the OpenStruct#method_missing functionality" do
+        instance.test.should == nil
+      end
+    end
+  end
+end

data/spec/lib/ticket_evolution/core/collection_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe TicketEvolution::Collection do
+  subject { TicketEvolution::Collection.build_from_response(response, 'brokerages', TicketEvolution::Brokerage) }
+  let(:response) { Fake.list_response }
+
+  context "#build_from_response" do
+    it { should be_instance_of(TicketEvolution::Collection) }
+    it { should be_kind_of(Enumerable) }
+    its(:per_page) { should == 2 }
+    its(:total_entries) { should == 1379 }
+    its(:current_page) { should == 1 }
+  end
+
+  context "#each" do
+    it "iterates through all the entries" do
+      subject.size.should == 2
+      subject.each do |entry|
+        entry.should be_instance_of TicketEvolution::Brokerage
+      end
+    end
+  end
+end

data/spec/lib/ticket_evolution/core/connection_spec.rb

@@ -0,0 +1,220 @@
+require 'spec_helper'
+
+describe TicketEvolution::Connection do
+  let(:klass) { TicketEvolution::Connection }
+  let(:default_options) do
+    HashWithIndifferentAccess.new({
+      :version => klass.oldest_version_in_service,
+      :mode => :sandbox,
+      :ssl_verify => true
+    })
+  end
+  let(:basic_options) do
+    {
+      :token => Fake.token,
+      :secret => Fake.secret
+    }
+  end
+  let(:valid_options) { default_options.merge(basic_options) }
+
+  subject { klass }
+
+  its(:ancestors) { should include TicketEvolution::Base }
+
+  describe ".default_options" do
+    subject { klass.default_options }
+
+    it { should == default_options }
+  end
+
+  describe ".expected_options" do
+    subject { klass.expected_options }
+
+    it { should =~ valid_options.keys }
+  end
+
+  describe ".oldest_version_in_service" do
+    subject { klass.oldest_version_in_service }
+
+    it { should be_a Fixnum }
+  end
+
+  describe "#initialize" do
+    let(:expected_options) { klass.expected_options }
+
+    context "with valid options" do
+      it "should copy to options passed to the default options" do
+        klass.new(basic_options).instance_eval {
+          @config
+        }.should == valid_options
+      end
+    end
+
+    context "with ssl_verify" do
+      context "if passed" do
+        let(:options) { valid_options.merge(:ssl_verify => false) }
+
+        it "sets the Curl::Easy to that value" do
+          connection = klass.new(options)
+          easy = connection.build_request(:GET, '/')
+          easy.ssl_verify_host?.should be_false
+          easy.ssl_verify_peer?.should be_false
+        end
+      end
+
+      context "if not passed" do
+        it "does not set anything on the Curl::Easy object" do
+          connection = klass.new(valid_options)
+          easy = connection.build_request(:GET, '/')
+          easy.ssl_verify_host?.should be_true
+          easy.ssl_verify_peer?.should be_true
+        end
+      end
+    end
+
+    context "without any options" do
+      it "should raise an error notifying the user of the missing options" do
+        message = "Missing: #{(expected_options - default_options.keys).join(', ')}"
+        expect {
+          klass.new
+        }.to raise_error TicketEvolution::InvalidConfiguration, message
+      end
+    end
+
+    context "with invalid options" do
+      it "should raise an error if the token is not formatted correctly" do
+        expect {
+          klass.new(valid_options.merge({:token => "invalid"}))
+        }.to raise_error TicketEvolution::InvalidConfiguration, "Invalid Token Format"
+      end
+
+      it "should raise an error if the token is not formatted correctly" do
+        expect {
+          klass.new(valid_options.merge({:secret => "invalid"}))
+        }.to raise_error TicketEvolution::InvalidConfiguration, "Invalid Secret Format"
+      end
+
+      it "should raise an error if attempting to use an expired version" do
+        oldest_version = klass.oldest_version_in_service - 1
+        expect {
+          klass.new(valid_options.merge({:version => oldest_version}))
+        }.to raise_error TicketEvolution::InvalidConfiguration, "Please Use API Version #{klass.oldest_version_in_service} or Above"
+      end
+
+      it "should not error if bad options are passed in" do
+        expect {
+          klass.new(valid_options.merge(:invalid => :option))
+        }.to_not raise_error
+      end
+    end
+  end
+
+  describe ".url_base" do
+    subject { klass.url_base }
+
+    it { should == "ticketevolution.com" }
+  end
+
+  describe ".protocol" do
+    subject { klass.protocol }
+
+    it { should == "https" }
+  end
+
+  describe "#url" do
+    context "production" do
+      subject { klass.new(valid_options.merge({:mode => :production}))}
+
+      its(:url) { should == "https://api.ticketevolution.com" }
+    end
+
+    context "sandbox" do
+      subject { klass.new(valid_options) }
+
+      its(:url) { should == "https://api.sandbox.ticketevolution.com" }
+    end
+  end
+
+  describe "#sign" do
+    let(:path) { "/test" }
+
+    describe "without params" do
+      let(:connection) { klass.new(valid_options.merge({:secret => "/3uZ9bXNe/6rxEBmlGLvoRXrcSzRDMfyJSewhlrc"})) }
+
+      it "should sign a get request" do
+        connection.sign(:GET, path).should == "1Ra2c8cbuw1G5Pw8BWaowDlMcxwMte8y/sL+vW2H4mY="
+      end
+
+      it "should sign a post request" do
+        connection.sign(:POST, path).should == "pXqUawURysCxiIvPXCgTaQ1k5Nue0bAVHIyhrxJRmI0="
+      end
+
+      it "should sign a put request" do
+        connection.sign(:PUT, path).should == "+INyuqXHZv3+ybyGM/mQIJVJ6RslR/xUAmcauZnHWBo="
+      end
+
+      it "should sign a delete request" do
+        connection.sign(:DELETE, path).should == "Mwr4Z+hveuo8ITaYwaRQ/QdxYotpw97ZH1JfJmblVQY="
+      end
+    end
+
+    describe "with params" do
+      let(:params) do
+        if RUBY_VERSION =~ /^1\.9/
+          {
+            :one => 1,
+            :two => "two",
+            :three => :three
+          }
+        else
+          p = ActiveSupport::OrderedHash.new
+          p[:one] = 1
+          p[:two] = "two"
+          p[:three] = "three"
+          p
+        end
+      end
+      let(:connection) { klass.new(valid_options.merge({:secret => "/3uZ9bXNe/6rxEBmlGLvoRXrcSzRDMfyJSewhlrc"})) }
+
+      it "should sign a get request" do
+        connection.sign(:GET, path, params).should == "8eaaqg6d4DJ2SEWkCvkdhc05dITmpNbUrcbN75UBGMA="
+      end
+
+      it "should sign a post request" do
+        connection.sign(:POST, path, params).should == "6PMaU8JQ5kH4PZLl8agJrZRZqnn65UGcCUA80E2dTDg="
+      end
+
+      it "should sign a put request" do
+        connection.sign(:PUT, path, params).should == "JEwlN3cuRXnb6rQlaorVYtlbGbBQRXs792YGQaH5BoM="
+      end
+
+      it "should sign a delete request" do
+        connection.sign(:DELETE, path, params).should == "aHXaOzCmuVttO2qSnaH5Ku4SN2q/ukoxz2FIbCRWmeY="
+      end
+    end
+  end
+
+  describe "#build_request" do
+    let(:headers) do
+      {
+        "Accept" => "application/vnd.ticketevolution.api+json; version=#{valid_options[:version]}",
+        "X-Signature" => "8eaaqg6d4DJ2SEWkCvkdhc05dITmpNbUrcbN75UBGMA=",
+        "X-Token" => valid_options[:token]
+      }
+    end
+    let(:params) do
+      {
+        :one => 1,
+        :two => "two",
+        :three => :three
+      }
+    end
+    let(:url) { "https://api.sandbox.ticketevolution.com/test?one=1&three=three&two=two" }
+
+    subject { klass.new(valid_options.merge(:secret => "/3uZ9bXNe/6rxEBmlGLvoRXrcSzRDMfyJSewhlrc")).build_request(:GET, '/test', params) }
+
+    it { should be_a Curl::Easy }
+    its(:headers) { should == headers }
+    its(:url) { should == url }
+  end
+end

data/spec/lib/ticket_evolution/core/datum_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe TicketEvolution::Datum do
+  let(:klass) { TicketEvolution::Datum }
+  let(:instance) { klass.new }
+
+  subject { klass }
+
+  its(:ancestors) { should include TicketEvolution::Builder }
+
+  it "should respond to []" do
+    instance.test = :testing
+    instance[:test].should == :testing
+  end
+end