zendesk_api 1.13.1 → 1.13.2

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

@@ -1,19 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::Middleware::Response::SanitizeResponse 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
-
-  describe 'with bad characters' do
-    let(:response) { fake_response("{\"x\":\"2012-02-01T13:14:15Z\", \"y\":\"\u0315\u0316\u01333\u0270\u022712awesome!\ud83d\udc4d\"}") }
-
-    it 'removes bad characters' do
-      expect(response.body.to_s.valid_encoding?).to be(true)
-      expect(response.body['y'].to_s).to eq("\u0315\u0316\u01333\u0270\u022712awesome!")
-    end
-  end
-end

data/spec/core/read_resource_spec.rb

@@ -1,97 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::ReadResource do
-  context "find" do
-    let(:id) { 1 }
-    subject { ZendeskAPI::TestResource }
-
-    context "normal request" do
-      before(:each) do
-        stub_json_request(:get, %r{test_resources/#{id}}, json("test_resource" => {}))
-      end
-
-      it "should return instance of resource" do
-        expect(subject.find(client, :id => id)).to be_instance_of(subject)
-      end
-    end
-
-    it "should blow up without an id which would build an invalid url" do
-      expect{
-        ZendeskAPI::User.find(client, :foo => :bar)
-      }.to raise_error("No :id given")
-    end
-
-    context "with overriden handle_response" do
-      subject do
-        Class.new(ZendeskAPI::TestResource) do
-          def self.singular_resource_name
-            'hello'
-          end
-
-          def handle_response(response)
-            @attributes.replace(response.body)
-          end
-        end
-      end
-
-      before(:each) do
-        stub_json_request(:get, %r{hellos/#{id}}, json(:testing => 1))
-      end
-
-      it "should return instance of resource" do
-        object = subject.find(client, :id => id)
-        expect(object).to be_instance_of(subject)
-        expect(object.testing).to eq(1)
-      end
-    end
-
-    context "with side loads" do
-      before(:each) do
-        stub_json_request(:get, %r{test_resources/#{id}\?include=nil_resource}, json(
-          "test_resource" => { :id => 1, :nil_resource_id => 2 },
-          "nil_resources" => [{ :id => 1, :name => :bye }, { :id => 2, :name => :hi }]
-        ))
-
-        subject.has ZendeskAPI::NilResource
-        @resource = subject.find(client, :id => id, :include => :nil_resource)
-      end
-
-      it "should side load nil resource" do
-        expect(@resource.nil_resource.name).to eq("hi")
-      end
-    end
-
-    context "with client error" do
-      it "should handle 500 properly" do
-        stub_request(:get, %r{test_resources/#{id}}).to_return(:status => 500)
-        expect(subject.find(client, :id => id)).to eq(nil)
-      end
-
-      it "should handle 404 properly" do
-        stub_request(:get, %r{test_resources/#{id}}).to_return(:status => 404)
-        expect(subject.find(client, :id => id)).to eq(nil)
-      end
-    end
-  end
-
-  context "#reload!" do
-    let(:id) { 2 }
-
-    subject { ZendeskAPI::TestResource.new(client, :id => id, :name => 'Old Name') }
-
-    before(:each) do
-      stub_json_request(:get, %r{test_resources/#{id}}, json("test_resource" => {:id => id, :name => "New Name" }))
-    end
-
-    it "reloads the data" do
-      expect(subject.name).to eq('Old Name')
-      assert_not_requested(:get, %r{test_resources/#{id}})
-
-      subject.reload!
-
-      assert_requested(:get, %r{test_resources/#{id}})
-      expect(subject.name).to eq('New Name')
-    end
-  end
-end
-

data/spec/core/resource_spec.rb

@@ -1,541 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::Resource do
-  context "initialize" do
-    context "with :global as part of attributes" do
-      it "should set @global_params" do
-        resource = ZendeskAPI::TestResource.new(client, { :global => { :something => 'hey' }})
-        expect(resource.instance_variable_get(:@global_params)).to eq({ :something => 'hey' })
-      end
-    end
-  end
-
-  context "#update" do
-    context "class method" do
-      let(:id) { 1 }
-      subject { ZendeskAPI::TestResource }
-
-      before(:each) do
-        stub_json_request(:put, %r{test_resources/#{id}}).with(:body => json({ :test_resource => { :test => :hello } }))
-      end
-
-      it "should return instance of resource" do
-        expect(subject.update(client, :id => id, :test => :hello)).to be_truthy
-      end
-
-      context "with global params" do
-        before(:each) do
-          stub_json_request(:put, %r{test_resources/#{id}}).with(:body => json({ :test_resource => { :test => :hello }, :something => "something"}))
-        end
-
-        it "should return instance of resource" do
-          expect(subject.update(client, :id => id, :test => :hello, :global => {:something => "something"})).to be_truthy
-        end
-      end
-
-      context "with client error" do
-        before(:each) do
-          stub_request(:put, %r{test_resources/#{id}}).to_return(:status => 500)
-        end
-
-        it "should handle it properly" do
-          expect { silence_logger{ expect(subject.update(client, :id => id)).to be(false) } }.to_not raise_error
-        end
-      end
-    end
-  end
-
-  context "#destroy" do
-    context "class method" do
-      let(:id) { 1 }
-      subject { ZendeskAPI::TestResource }
-
-      before(:each) do
-        stub_json_request(:delete, %r{test_resources/#{id}})
-      end
-
-      it "should return instance of resource" do
-        expect(subject.destroy(client, :id => id)).to be(true)
-      end
-
-      context "with client error" do
-        before(:each) do
-          stub_request(:delete, %r{test_resources/#{id}}).to_return(:status => 500)
-        end
-
-        it "should handle it properly" do
-          expect { silence_logger{ expect(subject.destroy(client, :id => id)).to be(false) } }.to_not raise_error
-        end
-      end
-    end
-
-    context "instance method" do
-      subject { ZendeskAPI::TestResource.new(client, :id => 1) }
-
-      before(:each) do
-        stub_request(:delete, %r{test_resources}).to_return(:status => 200)
-      end
-
-      it "should return true and set destroyed" do
-        expect(subject.destroy).to be(true)
-        expect(subject.destroyed?).to be(true)
-        expect(subject.destroy).to be(false)
-      end
-
-      context "with client error" do
-        before(:each) do
-          stub_request(:delete, %r{test_resources}).to_return(:status => 500)
-        end
-
-        it "should return false and not set destroyed" do
-          silence_logger{ expect(subject.destroy).to be(false) }
-          expect(subject.destroyed?).to be(false)
-        end
-      end
-    end
-  end
-
-  context "#save!" do
-    subject { ZendeskAPI::TestResource.new(client, :id => 1) }
-
-    before(:each) do
-      stub_request(:put, %r{test_resources/1}).to_return(:status => 422)
-    end
-
-    it "should raise if save fails" do
-      expect { subject.save! }.to raise_error(ZendeskAPI::Error::RecordInvalid)
-    end
-  end
-
-  context "#save" do
-    let(:id) { 1 }
-    let(:attr) { { :param => "test" } }
-    subject { ZendeskAPI::TestResource.new(client, attr.merge(:id => id)) }
-
-    before :each do
-      stub_json_request(:put, %r{test_resources/#{id}}, json(:test_resource => { :param => "abc" }))
-    end
-
-    it "should not save if already destroyed" do
-      expect(subject).to receive(:destroyed?).and_return(true)
-      expect(subject.save).to be(false)
-    end
-
-    it "should not be a new record with an id" do
-      expect(subject.new_record?).to be(false)
-    end
-
-    it "should put on save" do
-      expect(subject.save).to be(true)
-      expect(subject[:param]).to eq("abc")
-    end
-
-    context "with unused associations" do
-      before do
-        ZendeskAPI::TestResource.associations.clear
-        ZendeskAPI::TestResource.has :child, :class => ZendeskAPI::TestResource::TestChild
-        ZendeskAPI::TestResource.has_many :children, :class => ZendeskAPI::TestResource::TestChild
-      end
-
-      it "should not touch them" do
-        expect(subject.save).to eq(true)
-      end
-    end
-
-    context "with client error" do
-      before :each do
-        stub_request(:put, %r{test_resources/1}).to_return(:status => 500)
-      end
-
-      it "should be properly handled" do
-        expect { silence_logger { expect(subject.save).to be(false) } }.to_not raise_error
-      end
-    end
-
-    context "new record" do
-      subject { ZendeskAPI::TestResource.new(client, attr) }
-
-      before :each do
-        stub_json_request(:post, %r{test_resources}, json(:test_resource => attr.merge(:id => id)), :status => 201)
-      end
-
-      it "should be true without an id" do
-        expect(subject.new_record?).to be(true)
-      end
-
-      it "should be false after creating" do
-        expect(subject.save).to be(true)
-        expect(subject.new_record?).to be(false)
-        expect(subject.id).to eq(id)
-      end
-    end
-
-    context "with nested associations to save" do
-      context "has" do
-        before(:each) do
-          ZendeskAPI::TestResource.associations.clear
-          ZendeskAPI::TestResource.has :child, :class => ZendeskAPI::TestResource::TestChild
-          stub_json_request(:put, %r{test_resources})
-          subject.child = { :id => 2 }
-        end
-
-        it "should call save on the association" do
-          subject.child.foo = "bar"
-          expect(subject.child).to receive(:save)
-
-          subject.save
-
-          expect(subject.instance_variable_get(:@child)).to be_nil
-        end
-
-        it "should not call save on the association if they are synced" do
-          expect(subject.child).to_not receive(:save)
-
-          subject.save
-
-          expect(subject.instance_variable_get(:@child)).to be_nil
-        end
-      end
-
-      context "has_many" do
-        before(:each) do
-          ZendeskAPI::TestResource.associations.clear
-          ZendeskAPI::TestResource.has_many :children, :class => ZendeskAPI::TestResource::TestChild
-
-          stub_json_request(:put, %r{test_resources})
-          stub_json_request(:get, %r{children}, json(:test_children => []))
-        end
-
-        it "should reset children_ids on save" do
-          subject.children = [2, 3]
-          subject.children_ids = [1]
-          subject.save
-          expect(subject.children_ids).to eq([2,3])
-          expect(subject.instance_variable_get(:@children)).to be_nil
-        end
-
-        it "should not save the associated objects when there are no changes" do
-          subject.children = [2]
-          expect(subject.children.first).to_not receive(:save)
-          subject.save
-          expect(subject.instance_variable_get(:@children)).to be_nil
-        end
-
-        it "should save the associated objects when it is new" do
-          subject.children = [{:foo => "bar"}]
-          expect(subject.children.first).to receive(:save)
-          subject.save
-          expect(subject.instance_variable_get(:@children)).to be_nil
-        end
-
-        it "should not save the associated objects when it is set via full hash" do
-          subject.children = [{:id => 1, :foo => "bar"}]
-          expect(subject.children.first).to_not receive(:save)
-          subject.save
-          expect(subject.instance_variable_get(:@children)).to be_nil
-        end
-
-        it "should save the associated objects when it is changes" do
-          subject.children = [{:id => 1}]
-          subject.children.first.foo = "bar"
-          expect(subject.children.first).to receive(:save)
-          subject.save
-          expect(subject.instance_variable_get(:@children)).to be_nil
-        end
-      end
-
-      context "inline" do
-        before(:each) do
-          class ZendeskAPI::NilResource
-            def to_param; "TESTDATA"; end
-          end
-
-          ZendeskAPI::TestResource.associations.clear
-        end
-
-        context "true" do
-          before(:each) do
-            ZendeskAPI::TestResource.has :nil, :class => ZendeskAPI::NilResource, :inline => true
-
-            subject.nil = { :abc => :def }
-          end
-
-          it "should save param data" do
-            subject.save_associations
-
-            expect(subject.attributes[:nil]).to eq("TESTDATA")
-          end
-
-          it "should not save param data when unchanged" do
-            subject.nil.clear_changes
-            subject.save_associations
-
-            expect(subject.attributes[:nil]).to be_nil
-          end
-        end
-
-        context "create" do
-          before(:each) do
-            ZendeskAPI::TestResource.has :nil, :class => ZendeskAPI::NilResource, :inline => :create
-            subject.nil = { :abc => :def }
-          end
-
-          context "with a new record" do
-            before(:each) do
-              subject.id = nil
-              subject.save_associations
-            end
-
-            it "should save param data" do
-              expect(subject.attributes[:nil]).to eq("TESTDATA")
-            end
-          end
-
-          context "with a saved record" do
-            before(:each) do
-              subject.save_associations
-            end
-
-            it "should not save param data" do
-              expect(subject.attributes[:nil]).to be_nil
-            end
-          end
-        end
-      end
-    end
-  end
-
-  context "on any" do
-    let(:method) { "test_any_method" }
-
-    before(:each) do
-      ZendeskAPI::TestResource.any method
-    end
-
-    context "class method" do
-      subject { ZendeskAPI::TestResource }
-
-      it "should create a method of the same name" do
-        expect(subject.instance_methods.map(&:to_s)).to include(method)
-      end
-    end
-
-    context "instance method" do
-      subject { ZendeskAPI::TestResource.new(client, :id => 1) }
-
-      it "throws an argumenterror without a :verb" do
-        expect { subject.send(method) }.to raise_error(ArgumentError)
-      end
-
-      context "with an array response" do
-        before(:each) do
-          stub_json_request(:put, %r{test_resources/1/#{method}}, json(:test_resources => [{ :id => 1, :method => method }]))
-        end
-
-        it "should return true" do
-          expect(subject.send(method, :verb => :put)).to be(true)
-        end
-
-        it "should update the attributes if they exist" do
-          subject.send(method, :verb => :put)
-          expect(subject[:method]).to eq(method)
-        end
-      end
-
-      context "with a resource response" do
-        before(:each) do
-          stub_json_request(:put, %r{test_resources/1/#{method}}, json(:test_resource => { :id => 1, :method => method }))
-        end
-
-        it "should return true" do
-          expect(subject.send(method, :verb => :put)).to be(true)
-        end
-
-        it "should update the attributes if they exist" do
-          subject.send(method, :verb => :put)
-          expect(subject[:method]).to eq(method)
-        end
-      end
-
-      context "with client error" do
-        before(:each) do
-          stub_request(:put, %r{test_resources/1/#{method}}).to_return(:status => 500)
-        end
-
-        it "doesn't raise without bang" do
-          silence_logger { expect(subject.send("#{method}", :verb => :put)).to be(false) }
-        end
-
-        it "raises with bang" do
-          expect { silence_logger{ subject.send("#{method}!", :verb => :put) } }.to raise_error(ZendeskAPI::Error::ClientError)
-        end
-      end
-    end
-  end
-
-  %w{put post delete}.each do |verb|
-    context "on #{verb}" do
-      let(:method) { "test_#{verb}_method" }
-      before(:each) do
-        ZendeskAPI::TestResource.send(verb, method)
-      end
-
-      context "class method" do
-        subject { ZendeskAPI::TestResource }
-
-        it "should create a method of the same name" do
-          expect(subject.instance_methods.map(&:to_s)).to include(method)
-        end
-      end
-
-      context "instance method" do
-        subject { ZendeskAPI::TestResource.new(client, :id => 1) }
-
-        context "with an array response" do
-          before(:each) do
-            stub_json_request(verb.to_sym, %r{test_resources/1/#{method}}, json(:test_resources => [{ :id => 1, :method => method }]))
-          end
-
-          it "should return true" do
-            expect(subject.send(method)).to be(true)
-          end
-
-          it "should update the attributes if they exist" do
-            subject.send(method)
-            expect(subject[:method]).to eq(method)
-          end
-        end
-
-        context "with a resource response" do
-          before(:each) do
-            stub_json_request(verb.to_sym, %r{test_resources/1/#{method}}, json(:test_resource => { :id => 1, :method => method }))
-          end
-
-          it "should return true" do
-            expect(subject.send(method)).to be(true)
-          end
-
-          it "should update the attributes if they exist" do
-            subject.send(method)
-            expect(subject[:method]).to eq(method)
-          end
-        end
-
-        context "with client error" do
-          before(:each) do
-            stub_request(verb.to_sym, %r{test_resources/1/#{method}}).to_return(:status => 500)
-          end
-
-          it "doesn't raise without bang" do
-            silence_logger { expect(subject.send("#{method}")).to be(false) }
-          end
-
-          it "raises with bang" do
-            expect { silence_logger{ subject.send("#{method}!") } }.to raise_error(ZendeskAPI::Error::ClientError)
-          end
-        end
-      end
-    end
-  end
-
-  context "#inspect" do
-    it "should display nicely" do
-      expect(ZendeskAPI::User.new(client, :foo => :bar).inspect).to eq("#<ZendeskAPI::User {\"foo\"=>:bar}>")
-    end
-  end
-
-  context "#to_json" do
-    subject { ZendeskAPI::TestResource.new(client, :id => 1) }
-
-    it "should call #to_json on @attributes" do
-      expect(subject.attributes).to receive(:to_json)
-      subject.to_json
-    end
-  end
-
-  context "#==" do
-    it "is same when id is same" do
-      expect(ZendeskAPI::TestResource.new(client, :id => 1, "bar" => "baz")).to eq(ZendeskAPI::TestResource.new(client, :id => 1, "foo" => "bar"))
-    end
-
-    it "is same when object_id is same" do
-      object = ZendeskAPI::TestResource.new(client, "bar" => "baz")
-      expect(object).to eq(object)
-    end
-
-    it "is different when both have no id" do
-      expect(ZendeskAPI::TestResource.new(client)).to_not eq(ZendeskAPI::TestResource.new(client))
-    end
-
-    it "is different when id is different" do
-      expect(ZendeskAPI::TestResource.new(client, :id => 2)).to_not eq(ZendeskAPI::TestResource.new(client, :id => 1))
-    end
-
-    it "is same when class is Data" do
-      expect(ZendeskAPI::TestResource.new(client, :id => 2)).to eq(ZendeskAPI::TestResource::TestChild.new(client, :id => 2))
-    end
-
-    it "is same when class is Integer" do
-      expect(ZendeskAPI::TestResource.new(client, :id => 2)).to eq(2)
-    end
-
-    it "is different when class is Integer" do
-      expect(ZendeskAPI::TestResource.new(client, :id => 2)).to_not eq(3)
-    end
-
-    it "is different when other is no resource" do
-      expect(ZendeskAPI::TestResource.new(client, :id => 2)).to_not eq(nil)
-    end
-
-    it "warns about weird comparissons" do
-      object = ZendeskAPI::TestResource.new(client, :id => 2)
-      expect(object).to receive(:warn)
-      expect(object).to_not eq("xxx")
-    end
-  end
-
-  context "SingularTestResource" do
-    context "#find" do
-      before do
-        stub_json_request(:get, %r{/singular_test_resource})
-      end
-
-      it "should not require an id" do
-        expect do
-          ZendeskAPI::SingularTestResource.find(client)
-        end.to_not raise_error
-      end
-    end
-
-    context "#update" do
-      before do
-        stub_json_request(:put, %r{/singular_test_resource})
-      end
-
-      it "should always PUT" do
-        ZendeskAPI::SingularTestResource.update(client, :test => :test)
-      end
-    end
-  end
-
-  context "Ticket#assignee" do
-    subject { ZendeskAPI::Ticket.new(client, :id => 1, :assignee_id => nil) }
-
-    it "should not try and make a request" do
-      expect(subject.assignee).to be_nil
-    end
-  end
-
-  context "#new" do
-    it "builds with hash" do
-      object = ZendeskAPI::TestResource.new(client, {})
-      expect(object.attributes).to eq({})
-    end
-
-    it "fails to build with nil (e.g. empty response from server)" do
-      expect{
-        ZendeskAPI::TestResource.new(client, nil)
-      }.to raise_error(/Expected a Hash/i)
-    end
-  end
-end