zendesk_api 1.13.1 → 1.13.2

data/spec/core/association_spec.rb

@@ -1,256 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::Association do
-  let(:instance) { ZendeskAPI::TestResource.new(client, :id => 1) }
-  let(:child) { ZendeskAPI::TestResource::TestChild.new(client, :id => 1, :test_resource_id => 2) }
-
-  describe "setting/getting" do
-    context "has" do
-      before do
-        ZendeskAPI::TestResource.associations.clear
-        ZendeskAPI::TestResource.has :child, :class => ZendeskAPI::TestResource::TestChild
-      end
-
-      it "should not try and fetch nil child" do
-        instance.child_id = nil
-        expect(instance.child).to be_nil
-      end
-
-      it "should cache an set object" do
-        instance.child = child
-        expect(instance.child).to eq(child)
-      end
-
-      it "should set id on set if it was there" do
-        instance.child_id = nil
-        instance.child = child
-        expect(instance.child_id).to eq(child.id)
-      end
-
-      it "should build a object set via hash" do
-        instance.child = {:id => 2}
-        expect(instance.child.id).to eq(2)
-      end
-
-      it "should build a object set via id" do
-        instance.child = 2
-        expect(instance.child.id).to eq(2)
-      end
-
-      it "should not fetch an unknown object" do
-       expect(instance.child).to be_nil
-      end
-
-      it "should fetch an object known by id" do
-        stub_json_request(:get, %r{test_resources/1/child/5}, json(:test_child => {:id => 5}))
-        instance.child_id = 5
-        expect(instance.child.id).to eq(5)
-      end
-
-      it "should handle client errors" do
-        stub_request(:get, %r{test_resources/1/child/5}).to_return(:status => 500)
-        instance.child_id = 5
-        expect { silence_logger { instance.child } }.to_not raise_error
-      end
-
-      it "should handle resource not found errors" do
-        stub_request(:get, %r{test_resources/1/child/5}).to_return(:status => 404)
-        instance.child_id = 5
-        silence_logger{ expect(instance.child).to be_nil }
-      end
-
-      it "is not used when not used" do
-        expect(instance.child_used?).to eq(false)
-      end
-
-      it "is used when used" do
-        instance.child = child
-        expect(instance.child_used?).to eq(true)
-      end
-    end
-
-    context "has_many" do
-      it "should cache a set object" do
-        instance.children = [child]
-        expect(instance.children.map(&:id)).to eq([1])
-        expect(instance.children).to be_instance_of(ZendeskAPI::Collection)
-      end
-
-      it "should set ids" do
-        instance.children_ids = []
-        instance.children = [child]
-        expect(instance.children_ids).to eq([child.id])
-        expect(instance.children).to be_instance_of(ZendeskAPI::Collection)
-      end
-
-      it "should build and cache objects set via hash" do
-        instance.children = [{:id => 2}]
-        expect(instance.children.map(&:id)).to eq([2])
-        expect(instance.children).to be_instance_of(ZendeskAPI::Collection)
-      end
-
-      it "should build a object set via id" do
-        instance.children = [2]
-        expect(instance.children.map(&:id)).to eq([2])
-        expect(instance.children).to be_instance_of(ZendeskAPI::Collection)
-      end
-
-      it "should fetch unknown objects" do
-        stub_json_request(:get, %r{test_resources/1/children}, json(:test_children => [{:id => 2}, {:id => 3}]))
-        expect(instance.children.map(&:id)).to eq([2,3])
-        expect(instance.children).to be_instance_of(ZendeskAPI::Collection)
-      end
-
-      it "should not change objects" do
-        child = 'foo'
-        children = [child]
-        instance.children = children
-        expect(children[0]).to eq('foo')
-      end
-
-      it "is not used when not used" do
-        expect(instance.children_used?).to eq(false)
-      end
-
-      it "is used when used" do
-        instance.children = [child]
-        expect(instance.children_used?).to eq(true)
-      end
-    end
-  end
-
-  context "class only" do
-    subject { described_class.new(:class => ZendeskAPI::TestResource) }
-
-    it "should generate resource path" do
-      expect(subject.generate_path).to eq("test_resources")
-    end
-
-    context "with an instance" do
-      it "should generate a specific resource path" do
-        expect(subject.generate_path(instance)).to eq("test_resources/1")
-      end
-
-      context "with_id => false" do
-        it "should generate general resource path" do
-          expect(subject.generate_path(instance, :with_id => false)).to eq("test_resources")
-        end
-      end
-
-      context "with an instance that is a new record" do
-        it "should generate general resource path" do
-          expect(subject.generate_path(ZendeskAPI::TestResource.new(client))).to eq("test_resources")
-        end
-      end
-    end
-
-    context "with a specified path" do
-      before(:each) { subject.options[:path] = "blergh" }
-
-      it "should generate general resource path" do
-        expect(subject.generate_path).to eq("blergh")
-      end
-    end
-
-    context "with a passed in id" do
-      it "should generate specific resource path" do
-        opts = { :id => 1 }
-        expect(subject.generate_path(opts)).to eq("test_resources/1")
-        expect(opts).to be_empty
-      end
-    end
-  end
-
-  context "class with a specified parent" do
-    subject { described_class.new(:class => ZendeskAPI::TestResource::TestChild, :parent => instance, :name => :children) }
-
-    it "should generate nested resource path" do
-      expect(subject.generate_path).to eq("test_resources/1/children")
-    end
-
-    context "with an instance" do
-      it "should generate a specific nested resource path" do
-        expect(subject.generate_path(child)).to eq("test_resources/1/children/1")
-      end
-
-      context "with_id => false" do
-        it "should generate nested resource path" do
-          expect(subject.generate_path(child, :with_id => false)).to eq("test_resources/1/children")
-        end
-      end
-    end
-
-    context "when parent has a namespace" do
-      before(:each) do
-        instance.class.namespace 'hello'
-      end
-
-      after(:each) do
-        instance.class.namespace nil
-      end
-
-      it "should generate a specific nested resource path" do
-        expect(subject.generate_path(child)).to eq("hello/test_resources/1/children/1")
-      end
-    end
-
-    context "with a specified path" do
-      before(:each) { subject.options[:path] = "blergh" }
-
-      it "should generate nested resource path" do
-        expect(subject.generate_path).to eq("test_resources/1/blergh")
-      end
-    end
-
-    context "with a path on the association" do
-      before(:each) do
-        association = ZendeskAPI::TestResource.associations.detect {|a| a[:name] == :children}
-        association[:path] = "blergh"
-      end
-
-      it "should generate nested resource path" do
-        expect(subject.generate_path).to eq("test_resources/1/blergh")
-      end
-    end
-
-    context "with no association" do
-      before(:each) do
-        ZendeskAPI::TestResource.associations.clear
-      end
-
-      it "should generate nested resource path" do
-        expect(subject.generate_path).to eq("test_resources/1/test_children")
-      end
-    end
-  end
-
-  context "class with a parent id" do
-    subject { described_class.new(:class => ZendeskAPI::TestResource::TestChild, :name => :children) }
-
-    it "should raise an error if not passed an instance or id" do
-      expect { subject.generate_path }.to raise_error(ArgumentError)
-    end
-
-    it "should generate specific nested resource path" do
-      expect(subject.generate_path(child)).to eq("test_resources/2/children/1")
-    end
-
-    context "with parent id passed in" do
-      it "should generate nested resource path" do
-        opts = { :test_resource_id => 3 }
-        expect(subject.generate_path(opts)).to eq("test_resources/3/children")
-        expect(opts).to be_empty
-      end
-    end
-  end
-
-  context "with a singular resource" do
-    subject { described_class.new(:class => ZendeskAPI::SingularTestResource) }
-
-    context "with an instance" do
-      it "should not generate a specific resource path" do
-        expect(subject.generate_path(ZendeskAPI::SingularTestResource.new(client, :id => 1))).to eq("singular_test_resources")
-      end
-    end
-  end
-end

data/spec/core/bulk_actions_spec.rb

@@ -1,69 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::DestroyMany do
-  subject { ZendeskAPI::BulkTestResource }
-
-  context "destroy_many!" do
-    before(:each) do
-      stub_json_request(:delete, %r{bulk_test_resources/destroy_many}, json(:job_status => {:id => 'abc'}))
-      @response = subject.destroy_many!(client, [1,2,3])
-    end
-
-    it 'calls the destroy_many endpoint' do
-      assert_requested(:delete, %r{bulk_test_resources/destroy_many\?ids=1,2,3$})
-    end
-
-    it 'returns a JobStatus' do
-      expect(@response).to be_instance_of(ZendeskAPI::JobStatus)
-      expect(@response.id).to eq('abc')
-    end
-  end
-end
-
-describe ZendeskAPI::CreateMany do
-  subject { ZendeskAPI::BulkTestResource }
-
-  context "create_many!" do
-    let(:attributes) { [{:name => 'A'}, {:name => 'B'}] }
-
-    before(:each) do
-      stub_json_request(:post, %r{bulk_test_resources/create_many}, json(:job_status => {:id => 'def'}))
-      @response = subject.create_many!(client, attributes)
-    end
-
-    it 'calls the create_many endpoint' do
-      assert_requested(:post, %r{bulk_test_resources/create_many},
-        :body => json(:bulk_test_resources => attributes)
-      )
-    end
-
-    it 'returns a JobStatus' do
-      expect(@response).to be_instance_of(ZendeskAPI::JobStatus)
-      expect(@response.id).to eq('def')
-    end
-  end
-
-  describe ZendeskAPI::UpdateMany do
-    subject { ZendeskAPI::BulkTestResource }
-
-    context "update_many!" do
-      let(:attributes) { {:name => 'A', :age => 25} }
-
-      before(:each) do
-        stub_json_request(:put, %r{bulk_test_resources/update_many}, json(:job_status => {:id => 'ghi'}))
-        @response = subject.update_many!(client, [1,2,3], attributes)
-      end
-
-      it 'calls the update_many endpoint' do
-        assert_requested(:put, %r{bulk_test_resources/update_many\?ids=1,2,3$},
-          :body => json(:bulk_test_resource => attributes)
-        )
-      end
-
-      it 'returns a JobStatus' do
-        expect(@response).to be_instance_of(ZendeskAPI::JobStatus)
-        expect(@response.id).to eq('ghi')
-      end
-    end
-  end
-end

data/spec/core/client_spec.rb

@@ -1,280 +0,0 @@
-require 'core/spec_helper'
-
-class SimpleClient < ZendeskAPI::Client
-  def build_connection
-    "FOO"
-  end
-end
-
-describe ZendeskAPI::Client do
-  subject { client }
-
-  context "#initialize" do
-    it "should require a block" do
-      expect { ZendeskAPI::Client.new }.to raise_error(ArgumentError)
-    end
-
-    it "should raise an exception when url isn't ssl" do
-      expect do
-        ZendeskAPI::Client.new do |config|
-          config.url = "http://www.google.com"
-        end
-      end.to raise_error(ArgumentError)
-    end
-
-    it "should not raise an exception when url isn't ssl and allow_http is set to true" do
-      expect do
-        ZendeskAPI::Client.new do |config|
-          config.allow_http = true
-          config.url = "http://www.google.com/"
-        end
-      end.to_not raise_error
-    end
-
-    it "should handle valid url" do
-      expect do
-        ZendeskAPI::Client.new do |config|
-          config.url = "https://example.zendesk.com/api/v2"
-        end.to_not raise_error
-      end
-    end
-
-    context "basic_auth" do
-      subject do
-        ZendeskAPI::Client.new do |config|
-          config.url = "https://example.zendesk.com/api/v2"
-          config.username = "hello"
-          config.password = "token"
-        end
-      end
-
-      it "should build basic auth middleware" do
-        expect(subject.connection.builder.handlers.index(Faraday::Request::BasicAuthentication)).to_not be_nil
-      end
-
-      it "should not build token middleware" do
-        expect(subject.connection.headers["Authorization"]).to be_nil
-      end
-    end
-
-    context "access token" do
-      subject do
-        ZendeskAPI::Client.new do |config|
-          config.url = "https://example.zendesk.com/api/v2"
-          config.access_token = "hello"
-        end
-      end
-
-      it "should not build basic auth middleware" do
-        expect(subject.connection.builder.handlers.index(Faraday::Request::BasicAuthentication)).to be_nil
-      end
-
-      it "should build token middleware" do
-        expect(subject.connection.headers["Authorization"]).to match(/Bearer/)
-      end
-    end
-
-    context "#token" do
-      let(:client) do
-        ZendeskAPI::Client.new do |config|
-          config.url = "https://example.zendesk.com/api/v2"
-          config.username = username
-          config.token = "token"
-        end
-      end
-
-      subject { client.config }
-      let(:username) { "hello" }
-
-      context "with a username with /token" do
-        let(:username) { "hello/token" }
-
-        it "should not add /token to the username" do
-          expect(subject.username).to eq("hello/token")
-        end
-      end
-
-      context "with no password" do
-        it "should build basic auth middleware" do
-          expect(client.connection.builder.handlers.index(Faraday::Request::BasicAuthentication)).to_not be_nil
-        end
-
-        it "should not build token middleware" do
-          expect(client.connection.builder.handlers.index(Faraday::Request::TokenAuthentication)).to be_nil
-        end
-
-        it "should copy token to password" do
-          expect(subject.token).to eq(subject.password)
-        end
-
-        it "should add /token to the username" do
-          expect(subject.username).to eq("hello/token")
-        end
-      end
-    end
-
-    context "#logger" do
-      before(:each) do
-        @client = ZendeskAPI::Client.new do |config|
-          config.url = "https://example.zendesk.com/api/v2"
-          config.logger = subject
-        end
-
-        stub_request(:get, %r{/bs$}).to_return(:status => 200)
-      end
-
-      context "with true value" do
-        subject { true }
-
-        it "should log in faraday" do
-          expect(@client.connection.builder.handlers).to include(ZendeskAPI::Middleware::Response::Logger)
-        end
-
-        context "with a request" do
-          it "should log" do
-            expect(client.config.logger).to receive(:info).at_least(:once)
-            @client.connection.get('/bs')
-          end
-        end
-      end
-
-      context "with false value" do
-        subject { false }
-
-        it "should not log" do
-          expect(@client.connection.builder.handlers).to_not include(ZendeskAPI::Middleware::Response::Logger)
-        end
-      end
-
-      context "with a nil value" do
-        subject { nil }
-
-        it "should log" do
-          expect(@client.connection.builder.handlers).to include(ZendeskAPI::Middleware::Response::Logger)
-        end
-      end
-
-      context "with a logger" do
-        let(:out){ StringIO.new }
-        subject { Logger.new(out) }
-
-        it "should log" do
-          expect(@client.connection.builder.handlers).to include(ZendeskAPI::Middleware::Response::Logger)
-        end
-
-        context "with a request" do
-          it "should log to the subject" do
-            expect(out).to receive(:write).at_least(:once)
-            @client.connection.get('/bs')
-          end
-        end
-      end
-    end
-  end
-
-  context "#current_user" do
-    before(:each) do
-      stub_json_request(:get, %r{users/me}, json("user" => {}))
-    end
-
-    it "should be a user instance" do
-      expect(client.current_user).to be_instance_of(ZendeskAPI::User)
-    end
-  end
-
-  context "#connection" do
-    it "should initially be false" do
-      expect(subject.instance_variable_get(:@connection)).to be_falsey
-    end
-
-    it "connection should be initialized on first call to #connection" do
-      expect(subject.connection).to be_instance_of(Faraday::Connection)
-    end
-  end
-
-  context "resources" do
-    it "should return an instance of ZendeskAPI::Collection if there is no method" do
-      expect(subject.instance_variable_get(:@resource_cache)["tickets"]).to be_nil
-
-      expect(subject.tickets).to be_instance_of(ZendeskAPI::Collection)
-
-      expect(subject.instance_variable_get(:@resource_cache)["tickets"]).to_not be_empty
-      expect(subject.instance_variable_get(:@resource_cache)["tickets"][:class]).to eq(ZendeskAPI::Ticket)
-      expect(subject.instance_variable_get(:@resource_cache)["tickets"][:cache]).to be_instance_of(ZendeskAPI::LRUCache)
-
-      expect(ZendeskAPI).to_not receive(:const_get)
-      expect(subject.tickets).to be_instance_of(ZendeskAPI::Collection)
-    end
-
-    it "should not cache calls with different options" do
-      expect(subject.search(:query => 'abc')).to_not eq(subject.search(:query => '123'))
-    end
-
-    it "should not cache calls with :reload => true options" do
-      expect(subject.search(:query => 'abc')).to_not eq(subject.search(:query => 'abc', :reload => true))
-    end
-
-    it "should not pass reload to the underlying collection" do
-      collection = subject.search(:query => 'abc', :reload => true)
-      expect(collection.options.key?(:reload)).to be(false)
-    end
-
-    it "should cache calls with the same options" do
-      expect(subject.search(:query => 'abc')).to eq(subject.search(:query => 'abc'))
-    end
-
-    it "should respond_to? for valid resources" do
-      expect(subject.respond_to?(:tickets)).to eq(true)
-    end
-
-    it "should respond_to? for valid cached resources" do
-      subject.tickets
-
-      expect(subject.respond_to?(:tickets)).to eq(true)
-    end
-
-    it "should respond_to? for actual instance methods" do
-      expect(subject.respond_to?(:set_default_logger, true)).to eq(true)
-      expect(subject.respond_to?(:set_default_logger)).to eq(false)
-    end
-
-    it "should not respond_to? invalid resources" do
-      expect(subject.respond_to?(:nope)).to eq(false)
-    end
-
-    it "delegates voice correctly" do
-      expect(subject.voice.greetings).to be_instance_of(ZendeskAPI::Collection)
-    end
-
-    it "looks in the appropriate namespaces" do
-      expect(subject.greetings.association.options['class']).to eq(ZendeskAPI::Voice::Greeting)
-    end
-
-    it 'raises if the resource does not exist' do
-      expect { subject.random_resource }.to raise_error(RuntimeError)
-    end
-  end
-
-  it "can be subclassed" do
-    client = SimpleClient.new do |config|
-      config.allow_http = true
-    end
-    expect(client.config.allow_http).to eq(true)
-    expect(client.connection).to eq("FOO")
-    expect(client.connection.object_id).to eq(client.connection.object_id) # it's cached
-  end
-
-  context ZendeskAPI::Voice do
-    it "defers to voice delegator" do
-      expect(subject).to receive(:phone_numbers).once
-      subject.voice.phone_numbers
-    end
-
-    it "manages namespace correctly" do
-      expect(client.addresses.path).to match(/channels\/voice\/addresses/)
-      expect(client.phone_numbers.path).to match(/channels\/voice\/phone_numbers/)
-      expect(client.greetings.path).to match(/channels\/voice\/greetings/)
-      expect(client.greeting_categories.path).to match(/channels\/voice\/greeting_categories/)
-    end
-  end
-end