zendesk_api 1.13.1 → 1.13.2

data/spec/core/configuration_spec.rb

@@ -1,28 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::Configuration do
-  subject { ZendeskAPI::Configuration.new }
-
-  it "should properly merge options" do
-    url = "test.host"
-    subject.url = url
-    expect(subject.options[:url]).to eq(url)
-  end
-
-  it "should set accept header properly" do
-    expect(subject.options[:headers][:accept]).to eq('application/json')
-  end
-
-  it "should set user agent header properly" do
-    expect(subject.options[:headers][:user_agent]).to match(/ZendeskAPI Ruby/)
-  end
-
-  it "should set a default open_timeout" do
-    expect(subject.options[:request][:open_timeout]).to eq(10)
-  end
-
-  it "should merge options with client_options" do
-    subject.client_options = {:ssl => false}
-    expect(subject.options[:ssl]).to eq(false)
-  end
-end

data/spec/core/create_resource_spec.rb

@@ -1,39 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::CreateResource do
-  context "create" do
-    let(:attr) { { :test_field => "blah" } }
-    subject { ZendeskAPI::TestResource }
-
-    before(:each) do
-      stub_request(:post, %r{test_resources}).to_return(:body => json)
-    end
-
-    it "should return instance of resource" do
-      expect(subject.create(client, attr)).to be_instance_of(subject)
-    end
-
-    context "with client error" do
-      before(:each) do
-        stub_request(:post, %r{test_resources}).to_return(:status => 500)
-      end
-
-      it "should handle it properly" do
-        expect { silence_logger { expect(subject.create(client, attr)).to be_nil } }.to_not raise_error
-      end
-    end
-  end
-
-  context "create!" do
-    subject { ZendeskAPI::TestResource }
-
-    before(:each) do
-      stub_request(:post, %r{test_resources}).to_return(:status => 500)
-    end
-
-    it "should raise if save fails" do
-      expect { subject.create!(client, :test_field => "blah") }.to raise_error(ZendeskAPI::Error::NetworkError)
-    end
-  end
-end
-

data/spec/core/data_namespace_spec.rb

@@ -1,15 +0,0 @@
-require 'core/spec_helper'
-
-class ZendeskAPI::DataNamespaceTest; end
-
-describe ZendeskAPI::DataNamespace do
-  describe "descendants" do
-    let(:target_klass) { ZendeskAPI::DataNamespaceTest }
-    it "adds class to its descendants list when included" do
-      expect(ZendeskAPI::DataNamespace.descendants).not_to include(target_klass)
-      expect { target_klass.send(:include, ZendeskAPI::DataNamespace) }.
-        to change { ZendeskAPI::DataNamespace.descendants.count }.by(1)
-      expect(ZendeskAPI::DataNamespace.descendants).to include(target_klass)
-    end
-  end
-end

data/spec/core/data_resource_spec.rb

@@ -1,239 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::DataResource do
-  specify "singular resource name" do
-    expect(ZendeskAPI::Ticket.singular_resource_name).to eq("ticket")
-    expect(ZendeskAPI::TicketField.singular_resource_name).to eq("ticket_field")
-  end
-
-  specify "resource name" do
-    expect(ZendeskAPI::Ticket.resource_name).to eq("tickets")
-    expect(ZendeskAPI::TicketField.resource_name).to eq("ticket_fields")
-    expect(ZendeskAPI::Category.resource_name).to eq("categories")
-  end
-
-  context "association" do
-    subject { ZendeskAPI::TestResource.new(client, :id => 1) }
-    let(:options) {{}}
-
-    before(:each) do
-      ZendeskAPI::TestResource.has :nil, options.merge(:class => ZendeskAPI::NilDataResource)
-    end
-
-    it "should try and find non-existent object" do
-      stub_json_request(:get, %r{test_resources/1/nil}, json(:nil_data_resource => {}))
-
-      expect(subject.nil).to be_instance_of(ZendeskAPI::NilDataResource)
-    end
-
-    context "inline => true" do
-      let(:options) {{ :inline => true }}
-
-      it "should not try and find non-existent object" do
-        subject.nil
-      end
-    end
-  end
-
-  context "user" do
-    context "with first order attributes" do
-      subject { ZendeskAPI::TestResource.new(client) }
-      before(:each) { subject.attributes[:priority] = "normal" }
-
-      it "should be able to access underlying attributes" do
-        expect(subject.priority).to eq("normal")
-      end
-
-      it "should be able to change underlying attributes" do
-        expect { subject.priority = "urgent" }.to_not raise_error
-      end
-
-      it "should be able to iterate over underlying attributes" do
-        expect do
-          subject.map do |k, v|
-            [k.to_sym, v]
-          end
-        end.to_not raise_error
-      end
-    end
-
-    context "with second order attributes" do
-      subject { ZendeskAPI::TestResource.new(client) }
-      before(:each) { subject.priority = "normal" }
-
-      it "should be able to change underlying attributes" do
-        expect(subject.priority).to eq("normal")
-      end
-
-      it "should be able to change underlying attributes" do
-        expect { subject.priority = "urgent" }.to_not raise_error
-      end
-
-      it "should be able to iterate over underlying attributes" do
-        expect do
-          subject.map do |k, v|
-            [k.to_sym, v]
-          end
-        end.to_not raise_error
-      end
-    end
-  end
-
-  context "has" do
-    before(:each) { ZendeskAPI::TestResource.has ZendeskAPI::TestResource }
-
-    context "class methods" do
-      subject { ZendeskAPI::TestResource }
-
-      it "should define a method with the same name" do
-        expect(subject.instance_methods.map(&:to_s)).to include("test_resource")
-      end
-
-      context "with explicit class name" do
-        before(:all) { ZendeskAPI::TestResource.has :baz, :class => ZendeskAPI::TestResource }
-
-        it "should define a method with the same name" do
-          expect(subject.instance_methods.map(&:to_s)).to include("baz")
-        end
-      end
-    end
-
-    context "instance method" do
-      context "with no side-loading" do
-        subject { ZendeskAPI::TestResource.new(client, :id => 1, :test_resource_id => 1) }
-        before(:each) { stub_json_request(:get, %r{test_resources/\d+}, json(:test_resource => {})) }
-
-        it "should attempt to grab the resource from the host" do
-          expect(subject.test_resource).to be_instance_of(ZendeskAPI::TestResource)
-        end
-
-        it "should pass the path on to the resource" do
-          expect(subject.test_resource.path).to eq("test_resources")
-        end
-
-        context "with a client error" do
-          before(:each) { stub_request(:get, %r{test_resources/\d+}).to_return(:status => 500) }
-
-          it "should handle it properly" do
-            expect { silence_logger{ expect(subject.test_resource).to be_nil } }.to_not raise_error
-          end
-        end
-
-        context "with an explicit path set" do
-          before(:each) do
-            ZendeskAPI::TestResource.has ZendeskAPI::TestResource, :path => "blergh"
-            stub_json_request(:get, %r{blergh/\d+}, json(:test_resource => {}))
-          end
-
-          it "should call the right path" do
-            expect(subject.test_resource).to be_instance_of(ZendeskAPI::TestResource)
-          end
-        end
-      end
-
-      context "with side-loading of resource" do
-        let(:test_resource) { { :message => "FOO_OBJ" } }
-        subject { ZendeskAPI::TestResource.new(client, :test_resource => test_resource).test_resource }
-
-        it "should load the correct instance" do
-          expect(subject).to be_instance_of(ZendeskAPI::TestResource)
-        end
-
-        it "should load foo from the hash" do
-          expect(subject.message).to eq("FOO_OBJ")
-        end
-      end
-
-      context "with side-loading of id" do
-        subject { ZendeskAPI::TestResource.new(client, :test_resource_id => 1) }
-        before(:each) do
-          stub_json_request(:get, %r{test_resources/1}, json("test_resource" => {}))
-        end
-
-        it "should find foo_id and load it from the api" do
-          subject.test_resource
-        end
-
-        it "should handle nil response from find api" do
-          expect(ZendeskAPI::TestResource).to receive(:find).twice.and_return(nil)
-          expect(subject.test_resource).to be_nil
-          subject.test_resource
-        end
-      end
-    end
-  end
-
-  context "has_many" do
-    before(:each) { ZendeskAPI::TestResource.has_many ZendeskAPI::TestResource }
-
-    context "class methods" do
-      subject { ZendeskAPI::TestResource }
-
-      it "should define a method with the same name" do
-        expect(subject.instance_methods.map(&:to_s)).to include("test_resources")
-      end
-
-      context "with explicit class name" do
-        before(:each) { ZendeskAPI::TestResource.has_many :cats, :class => ZendeskAPI::TestResource }
-
-        it "should define a method with the same name" do
-          expect(subject.instance_methods.map(&:to_s)).to include("cats")
-        end
-      end
-    end
-
-    context "instance method" do
-      context "with no side-loading" do
-        subject { ZendeskAPI::TestResource.new(client, :id => 1) }
-
-        it "should not attempt to grab the resource from the host" do
-          expect(subject.test_resources).to be_instance_of(ZendeskAPI::Collection)
-        end
-
-        it "should pass the path on to the resource" do
-          expect(subject.test_resources.path).to eq("test_resources/1/test_resources")
-        end
-
-        context "with an explicit path set" do
-          before(:each) do
-            ZendeskAPI::TestResource.has_many ZendeskAPI::TestResource, :path => "blargh"
-          end
-
-          it "should call the right path" do
-            expect(subject.test_resources.path).to eq("test_resources/1/blargh")
-          end
-        end
-      end
-
-      context "with side-loading of resource" do
-        let(:test_resources) { [{ :message => "FOO_OBJ" }] }
-        subject { ZendeskAPI::TestResource.new(client, :test_resources => test_resources).test_resources.first }
-
-        it "should properly create instance" do
-          expect(subject.message).to eq("FOO_OBJ")
-        end
-
-        it "should map bars onto TestResource class" do
-          expect(subject).to be_instance_of(ZendeskAPI::TestResource)
-        end
-      end
-
-      context "with side-loading of id" do
-        let(:test_resource_ids) { [1, 2, 3] }
-        subject { ZendeskAPI::TestResource.new(client, :test_resource_ids => test_resource_ids) }
-
-        it "should find foo_id and load it from the api" do
-          expect(ZendeskAPI::TestResource).to receive(:find).with(client, kind_of(Hash)).exactly(test_resource_ids.length).times
-          subject.test_resources
-        end
-
-        it "should handle nil response from find api" do
-          expect(ZendeskAPI::TestResource).to receive(:find).with(client, kind_of(Hash)).exactly(test_resource_ids.length).times.and_return(nil)
-          expect(subject.test_resources).to be_empty
-          subject.test_resources # Test expectations
-        end
-      end
-    end
-  end
-end
-

data/spec/core/inflection_spec.rb

@@ -1,7 +0,0 @@
-require 'core/spec_helper'
-
-describe String do
-  specify "the plural of forum if forums" do
-    expect(Inflection.plural("forum")).to eq("forums")
-  end
-end

data/spec/core/lru_cache_spec.rb

@@ -1,26 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::LRUCache do
-  let(:cache){ ZendeskAPI::LRUCache.new(2) }
-
-  it "writes and reads" do
-    expect(cache.write("x", 1)).to eq(1)
-    expect(cache.read("x")).to eq(1)
-  end
-
-  it "drops" do
-    cache.write("x", 1)
-    cache.write("y", 1)
-    cache.write("x", 1)
-    cache.write("z", 1)
-    expect(cache.read("z")).to eq(1)
-    expect(cache.read("x")).to eq(1)
-    expect(cache.read("y")).to eq(nil)
-  end
-
-  it "fetches" do
-    expect(cache.fetch("x"){ 1 }).to eq(1)
-    expect(cache.read("x")).to eq(1)
-    expect(cache.fetch("x"){ 2 }).to eq(1)
-  end
-end

data/spec/core/middleware/request/encode_json_spec.rb

@@ -1,73 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::Middleware::Request::EncodeJson do
-  let(:app) do
-    ZendeskAPI::Middleware::Request::EncodeJson.new(lambda {|x| x})
-  end
-
-  let(:response) { app.call({ :request_headers => {} }.merge(env)) }
-
-  context 'with a nil body' do
-    let(:env) {{ :body => nil }}
-
-    it 'should not return json' do
-      expect(response[:body]).to be_nil
-    end
-  end
-
-  context 'with an empty body' do
-    let(:env) {{ :body => '' }}
-
-    it 'should not return json' do
-      expect(response[:body]).to eq('')
-    end
-  end
-
-  context 'with a proper mime type' do
-    context 'empty' do
-      let(:env) {{ :body => { :a => :b } }}
-
-      it 'encodes json' do
-        expect(response[:body]).to eq(JSON.dump(:a => :b))
-      end
-
-      it 'sets the content type' do
-        expect(response[:request_headers]['Content-Type']).to eq('application/json')
-      end
-    end
-
-    context 'application/json' do
-      let(:env) {{
-        :body => { :a => :b },
-        :request_headers => {
-          'Content-Type' => 'application/json'
-        }
-      }}
-
-      it 'encodes json' do
-        expect(response[:body]).to eq(JSON.dump(:a => :b))
-      end
-
-      it 'keeps the content type' do
-        expect(response[:request_headers]['Content-Type']).to eq('application/json')
-      end
-    end
-
-    context 'application/json; encoding=utf-8' do
-      let(:env) {{
-        :body => { :a => :b },
-        :request_headers => {
-          'Content-Type' => 'application/json; encoding=utf-8'
-        }
-      }}
-
-      it 'encodes json' do
-        expect(response[:body]).to eq(JSON.dump(:a => :b))
-      end
-
-      it 'keeps the content type' do
-        expect(response[:request_headers]['Content-Type']).to eq('application/json; encoding=utf-8')
-      end
-    end
-  end
-end

data/spec/core/middleware/request/etag_cache_spec.rb

@@ -1,21 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::Middleware::Request::EtagCache do
-  it "caches" do
-    client.config.cache.size = 1
-
-    stub_json_request(:get, %r{blergh}, '{"x":1}', :headers => {"Etag" => "x"})
-    first_response = client.connection.get("blergh")
-    expect(first_response.status).to eq(200)
-    expect(first_response.body).to eq({"x"=>1})
-
-    stub_request(:get, %r{blergh}).to_return(:status => 304, :headers => {"Etag" => "x"})
-    response = client.connection.get("blergh")
-    expect(response.status).to eq(304)
-    expect(response.body).to eq({"x"=>1})
-
-    %w{content_encoding content_type content_length etag}.each do |header|
-      expect(response.headers[header]).to eq(first_response.headers[header])
-    end
-  end
-end