zendesk_api 1.13.1 → 1.13.2

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

@@ -1,49 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::Middleware::Request::Retry do
-  def runtime
-    start = Time.now.to_f
-    yield
-    Time.now.to_f - start
-  end
-
-  [429, 503].each do |error_code|
-    it "should wait requisite seconds and then retry request on #{error_code}" do
-      stub_request(:get, %r{blergh}).
-        to_return(:status => 429, :headers => { :retry_after => 1 }).
-        to_return(:status => 200)
-
-      seconds = runtime {
-        expect(client.connection.get("blergh").status).to eq(200)
-      }
-
-      expect(seconds).to be_within(0.2).of(1)
-    end
-  end
-
-  context "with failing request", :prevent_logger_changes do
-    before do
-      stub_request(:get, %r{blergh}).
-        to_return(:status => 503).
-        to_return(:status => 200)
-
-      expect_any_instance_of(ZendeskAPI::Middleware::Request::Retry).to receive(:sleep).exactly(10).times.with(1)
-    end
-
-    it "should wait default timeout seconds and then retry request on error" do
-      expect(runtime {
-        expect(client.connection.get("blergh").status).to eq(200)
-      }).to be <= 0.5
-    end
-
-    it "should print to logger" do
-      expect(client.config.logger).to receive(:warn).at_least(:once)
-      client.connection.get("blergh")
-    end
-
-    it "should not fail without a logger" do
-      client.config.logger = false
-      client.connection.get("blergh")
-    end
-  end
-end

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

@@ -1,164 +0,0 @@
-require 'core/spec_helper'
-require 'tempfile'
-require 'action_dispatch'
-
-describe ZendeskAPI::Middleware::Request::Upload do
-  subject { ZendeskAPI::Middleware::Request::Upload.new(lambda {|env| env}) }
-  let(:filename) { File.join(File.dirname(__FILE__), "test.jpg") }
-
-  it "should handle no body" do
-    expect(subject.call({})).to eq({})
-  end
-
-  it "should handle body with no file" do
-    expect(subject.call(:body => {})[:body]).to eq({})
-  end
-
-  it "should handle invalid types" do
-    expect(subject.call(:body => { :file => :invalid })[:body]).to eq({})
-  end
-
-  context "with file string" do
-    before(:each) do
-      @env = subject.call(:body => { :file => filename })
-    end
-
-    it "should convert file string to UploadIO" do
-      expect(@env[:body][:uploaded_data]).to be_instance_of(Faraday::UploadIO)
-    end
-
-    it "should remove file string" do
-      expect(@env[:body][:file]).to be_nil
-    end
-
-    it "should add filename if none exist" do
-      expect(@env[:body][:filename]).to eq("test.jpg")
-    end
-
-    context "with filename" do
-      before(:each) do
-        @env = subject.call(:body => { :file => filename, :filename => "test" })
-      end
-
-      it "should not change filename" do
-        expect(@env[:body][:filename]).to_not eq("test.jpg")
-      end
-    end
-  end
-
-  context "with an ActionDispatch::Http::UploadedFile" do
-    before(:each) do
-      @upload = ActionDispatch::Http::UploadedFile.new(:filename => "hello.jpg", :tempfile => Tempfile.new(['hello', '.jpg']))
-      @env = subject.call(:body => { :file => @upload })
-    end
-
-    it "should convert file string to UploadIO" do
-      expect(@env[:body][:uploaded_data]).to be_instance_of(Faraday::UploadIO)
-    end
-
-    it "should remove file string" do
-      expect(@env[:body][:file]).to be_nil
-    end
-
-    it "should add filename if none exist" do
-      expect(@env[:body][:filename]).to eq("hello.jpg")
-    end
-
-    it "should use the content type of the tempfile" do
-      expect(@env[:body][:uploaded_data].content_type).to eq("image/jpeg")
-    end
-
-    context "when path does not resolve a mime_type" do
-      it "should pass correct filename to Faraday::UploadIO" do
-        expect(@env[:body][:filename]).to eq("hello.jpg")
-        expect(@env[:body][:uploaded_data].original_filename).to eq(@env[:body][:filename])
-      end
-
-      it "should use the content_type of ActionDispatch::Http::UploadedFile " do
-        @upload.content_type = 'application/random'
-
-        env = subject.call(:body => { :file => @upload })
-        expect(env[:body][:uploaded_data].content_type).to eq('application/random')
-      end
-    end
-  end
-
-  context "with a Tempfile" do
-    before(:each) do
-      @tempfile = Tempfile.new(File.basename(filename))
-      @env = subject.call(:body => { :file => @tempfile })
-    end
-
-    it "should convert file string to UploadIO" do
-      expect(@env[:body][:uploaded_data]).to be_instance_of(Faraday::UploadIO)
-    end
-
-    it "should remove file string" do
-      expect(@env[:body][:file]).to be_nil
-    end
-
-    it "should add filename if none exist" do
-      expect(@env[:body][:filename]).to eq(File.basename(@tempfile.path))
-    end
-  end
-
-  context "with file instance" do
-    context "top-level" do
-      before(:each) do
-        @env = subject.call(:body => { :file => File.new(filename) })
-      end
-
-      it "should convert file string to UploadIO" do
-        expect(@env[:body][:uploaded_data]).to be_instance_of(Faraday::UploadIO)
-      end
-
-      it "should remove file string" do
-        expect(@env[:body][:file]).to be_nil
-      end
-
-      it "should add filename if none exist" do
-        expect(@env[:body][:filename]).to eq("test.jpg")
-      end
-
-      context "with filename" do
-        before(:each) do
-          @env = subject.call(:body => { :file => File.new(filename), :filename => "test" })
-        end
-
-        it "should not change filename" do
-          expect(@env[:body][:filename]).to_not eq("test.jpg")
-        end
-      end
-    end
-
-    context "underneath a key" do
-      context "only a file" do
-        before(:each) do
-          @env = subject.call(:body => { :user => { :photo => File.new(filename) } })
-        end
-
-        it "should convert file string to UploadIO" do
-          expect(@env[:body][:user][:photo][:uploaded_data]).to be_instance_of(Faraday::UploadIO)
-        end
-
-        it "should add filename if none exist" do
-          expect(@env[:body][:user][:photo][:filename]).to eq("test.jpg")
-        end
-      end
-
-      context "with filename" do
-        before(:each) do
-          @env = subject.call(:body => { :user => { :photo => { :file => File.new(filename), :filename => "test" } } })
-        end
-
-        it "should convert file string to UploadIO" do
-          expect(@env[:body][:user][:photo][:uploaded_data]).to be_instance_of(Faraday::UploadIO)
-        end
-
-        it "should not change filename" do
-          expect(@env[:body][:user][:photo][:filename]).to_not eq("test.jpg")
-        end
-      end
-    end
-  end
-end

data/spec/core/middleware/response/callback_spec.rb

@@ -1,17 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::Middleware::Response::Callback do
-  let(:response) { "TEST" }
-
-  before(:each) do
-    client.insert_callback do |env|
-      env[:body] = response
-    end
-
-    stub_request(:get, %r{test_endpoint}).to_return(:body => JSON.dump({ "ABC" => "DEF" }))
-  end
-
-  it "should call callbacks " do
-    expect(client.connection.get("test_endpoint").body).to eq(response)
-  end
-end

data/spec/core/middleware/response/deflate_spec.rb

@@ -1,21 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::Middleware::Response::Deflate do
-  context "with content-encoding = 'deflate'" do
-    subject { '{ "TESTDATA": true }' }
-
-    before(:each) do
-      stub_request(:get, %r{blergh}).to_return(
-        :headers => {
-          :content_encoding => "deflate",
-          :content_type => "application/json"
-        },
-        :body => Zlib::Deflate.deflate(subject)
-      )
-    end
-
-    it "should inflate returned body" do
-      expect(client.connection.get("blergh").body['TESTDATA']).to be(true)
-    end
-  end
-end

data/spec/core/middleware/response/gzip_spec.rb

@@ -1,25 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::Middleware::Response::Gzip do
-  context "with content-encoding = 'gzip'" do
-    subject { '{ "TESTDATA": true }' }
-    before(:each) do
-      encoded_data = StringIO.new
-      gz = Zlib::GzipWriter.new(encoded_data)
-      gz.write(subject)
-      gz.close
-
-      stub_request(:get, %r{blergh}).to_return(
-        :headers => {
-          :content_encoding => "gzip",
-          :content_type => "application/json"
-        },
-        :body => encoded_data.string
-      )
-    end
-
-    it "should inflate returned body" do
-      expect(client.connection.get("blergh").body['TESTDATA']).to be(true)
-    end
-  end
-end

data/spec/core/middleware/response/parse_iso_dates_spec.rb

@@ -1,44 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::Middleware::Response::ParseIsoDates do
-  def fake_response(data)
-    stub_json_request(:get, %r{blergh}, data)
-    response = client.connection.get("blergh")
-    expect(response.status).to eq(200)
-    response
-  end
-
-  let(:parsed){
-    if RUBY_VERSION > "1.9"
-      "2012-02-01 13:14:15 UTC"
-    else
-      "Wed Feb 01 13:14:15 UTC 2012"
-    end
-  }
-
-  it "should parse dates" do
-    expect(fake_response('{"x":"2012-02-01T13:14:15Z"}').body["x"].to_s).to eq(parsed)
-  end
-
-  it "should parse nested dates in hash" do
-    expect(fake_response('{"x":{"y":"2012-02-01T13:14:15Z"}}').body["x"]["y"].to_s).to eq(parsed)
-  end
-
-  it "should parse nested dates in arrays" do
-    expect(fake_response('{"x":[{"y":"2012-02-01T13:14:15Z"}]}').body["x"][0]["y"].to_s).to eq(parsed)
-  end
-
-  it "should not blow up on empty body" do
-    expect(fake_response('').body).to eq('')
-  end
-
-  it "should leave arrays with ids alone" do
-    expect(fake_response('{"x":[1,2,3]}').body).to eq({"x" => [1,2,3]})
-  end
-
-  it "should not parse date-like things" do
-    expect(fake_response('{"x":"2012-02-01T13:14:15Z bla"}').body["x"].to_s).to eq("2012-02-01T13:14:15Z bla")
-    expect(fake_response('{"x":"12012-02-01T13:14:15Z"}').body["x"].to_s).to eq("12012-02-01T13:14:15Z")
-    expect(fake_response(%Q{{"x":"2012-02-01T13:14:15Z\\nfoo"}}).body["x"].to_s).to eq("2012-02-01T13:14:15Z\nfoo")
-  end
-end

data/spec/core/middleware/response/parse_json_spec.rb

@@ -1,53 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::Middleware::Response::ParseJson do
-  context "with another content-type" do
-    before(:each) do
-      stub_request(:get, %r{blergh}).to_return(
-        :headers => {
-          :content_type => "application/xml"
-        },
-        :body => '<nope></nope>'
-      )
-    end
-
-    it "should not return nil body" do
-      expect(client.connection.get("blergh").body).to eql('<nope></nope>')
-    end
-  end
-
-  context "with content-type = 'application/json'" do
-    before(:each) do
-      stub_request(:get, %r{blergh}).to_return(
-        :headers => {
-          :content_type => "application/json"
-        },
-        :body => body
-      )
-    end
-
-    context "with a nil body" do
-      let(:body) { nil }
-
-      it "should return empty body" do
-        expect(client.connection.get("blergh").body).to eql('')
-      end
-    end
-
-    context "with a empty body" do
-      let(:body) { '' }
-
-      it "should return empty body" do
-        expect(client.connection.get("blergh").body).to eql('')
-      end
-    end
-
-    context 'proper json' do
-      let(:body) { '{ "TESTDATA": true }' }
-
-      it "should parse returned body" do
-        expect(client.connection.get("blergh").body['TESTDATA']).to be(true)
-      end
-    end
-  end
-end

data/spec/core/middleware/response/raise_error_spec.rb

@@ -1,128 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::Middleware::Response::RaiseError do
-  context "with a failed connection" do
-    context "connection failed" do
-      before(:each) do
-        stub_request(:any, /.*/).to_raise(Faraday::Error::ConnectionFailed)
-      end
-
-      it "should raise NetworkError" do
-        expect { client.connection.get "/non_existent" }.to raise_error(ZendeskAPI::Error::NetworkError)
-      end
-    end
-
-    context "connection timeout" do
-      before(:each) do
-        stub_request(:any, /.*/).to_timeout
-      end
-
-      it "should raise NetworkError" do
-        expect { client.connection.get "/non_existent" }.to raise_error(ZendeskAPI::Error::NetworkError)
-      end
-    end
-  end
-
-  context "status errors" do
-    let(:body) { "" }
-
-    before(:each) do
-      stub_request(:any, /.*/).to_return(:status => status, :body => body,
-        :headers => { :content_type => "application/json" })
-    end
-
-    context "with status = 404" do
-      let(:status) { 404 }
-
-      it "should raise RecordNotFound when status is 404" do
-        expect { client.connection.get "/non_existent" }.to raise_error(ZendeskAPI::Error::RecordNotFound)
-      end
-    end
-
-    context "with status in 400...600" do
-      let(:status) { 500 }
-
-      it "should raise NetworkError" do
-        expect { client.connection.get "/non_existent" }.to raise_error(ZendeskAPI::Error::NetworkError)
-      end
-    end
-
-    context "with status in 1XX" do
-      let(:status) { 100 }
-
-      it "should raise NetworkError" do
-        expect { client.connection.get "/non_existent" }.to raise_error(ZendeskAPI::Error::NetworkError)
-      end
-    end
-
-    context "with status = 304" do
-      let(:status) { 304 }
-
-      it "should not raise" do
-        client.connection.get "/abcdef"
-      end
-    end
-
-    context "with status in 3XX" do
-      let(:status) { 302 }
-
-      it "should raise NetworkError" do
-        expect { client.connection.get "/non_existent" }.to raise_error(ZendeskAPI::Error::NetworkError)
-      end
-    end
-
-    context "with status = 422" do
-      let(:status) { 422 }
-
-      it "should raise RecordInvalid" do
-        expect { client.connection.get "/non_existent" }.to raise_error(ZendeskAPI::Error::RecordInvalid)
-      end
-
-      context "with a body" do
-        let(:body) { JSON.dump(:details => "hello") }
-
-        it "should return RecordInvalid with proper message" do
-          begin
-            client.connection.get "/non_existent"
-          rescue ZendeskAPI::Error::RecordInvalid => e
-            expect(e.errors).to eq("hello")
-            expect(e.to_s).to eq("ZendeskAPI::Error::RecordInvalid: hello")
-          else
-            fail # didn't raise an error
-          end
-        end
-      end
-    end
-
-    context "with status = 413" do
-      let(:status) { 413 }
-
-      it "should raise RecordInvalid" do
-        expect { client.connection.get "/non_existent" }.to raise_error(ZendeskAPI::Error::RecordInvalid)
-      end
-
-      context "with a body" do
-        let(:body) { JSON.dump(:description => "big file is big") }
-
-        it "should return RecordInvalid with proper message" do
-          begin
-            client.connection.get "/non_existent"
-          rescue ZendeskAPI::Error::RecordInvalid => e
-            expect(e.errors).to eq("big file is big")
-            expect(e.to_s).to eq("ZendeskAPI::Error::RecordInvalid: big file is big")
-          else
-            fail # didn't raise an error
-          end
-        end
-      end
-    end
-
-    context "with status = 200" do
-      let(:status) { 200 }
-
-      it "should not raise" do
-        client.connection.get "/abcdef"
-      end
-    end
-  end
-end