zendesk_api 0.0.9

data/spec/configuration_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper.rb'
+
+describe ZendeskAPI::Configuration do
+  subject { ZendeskAPI::Configuration.new }
+
+  it "should properly merge options" do
+    url = "test.host"
+    subject.url = url
+    subject.options[:url].should == url
+  end
+
+  it "should set accept header properly" do
+    subject.options[:headers][:accept].should == 'application/json'
+  end
+
+  it "should set user agent header properly" do
+    subject.options[:headers][:user_agent].should =~ /ZendeskAPI API/
+  end
+
+  it "should merge options with client_options" do
+    subject.client_options = {:ssl => false}
+    subject.options[:ssl].should == false
+  end
+end

data/spec/create_resource_spec.rb

@@ -0,0 +1,39 @@
+require '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
+      subject.create(client, attr).should 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 { subject.create(client, attr).should be_nil } }.to_not raise_error
+      end
+    end
+  end
+
+  context "create!" do
+    subject { ZendeskAPI::TestResource }
+
+    before(:each) do
+      subject.should_receive(:create).and_return(nil)
+    end
+
+    it "should raise if save fails" do
+      expect { subject.create!(client, :test_field => "blah") }.to raise_error
+    end
+  end
+end
+

data/spec/data_resource_spec.rb

@@ -0,0 +1,229 @@
+require 'spec_helper'
+
+describe ZendeskAPI::DataResource do
+  context "ZendeskAPI.get_class" do
+    it "should create a new class if there is none" do
+      ZendeskAPI.const_defined?("Blergh").should be_false
+      ZendeskAPI.get_class(:blergh).should == ZendeskAPI::Blergh
+    end
+
+    it "should find the class if it exists" do
+      ZendeskAPI.get_class(:tickets).should == ZendeskAPI::Tickets
+    end
+
+    it "should handle 'nil' be passed in" do
+      ZendeskAPI.get_class(nil).should be_false
+    end
+  end
+
+  specify "singular resource name" do
+    ZendeskAPI::Ticket.singular_resource_name.should == "ticket"
+    ZendeskAPI::TicketField.singular_resource_name.should == "ticket_field"
+  end
+
+  specify "resource name" do
+    ZendeskAPI::Ticket.resource_name.should == "tickets"
+    ZendeskAPI::TicketField.resource_name.should == "ticket_fields"
+    ZendeskAPI::Category.resource_name.should == "categories"
+  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
+        subject.priority.should == "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
+        subject.priority.should == "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 :foo }
+
+    context "class methods" do
+      subject { ZendeskAPI::TestResource }
+      it "should define a method with the same name" do
+        subject.instance_methods.map(&:to_s).should include("foo")
+      end
+
+      it "should create a class if none exists" do
+        ZendeskAPI.const_defined?("Foo").should be_true
+      end
+
+      context "with explicit class name" do
+        before(:all) { ZendeskAPI::TestResource.has :baz, :class => :foo }
+
+        it "should not create a baz class" do
+          ZendeskAPI.const_defined?("Baz").should be_false
+        end
+      end
+    end
+
+    context "instance method" do
+      context "with no side-loading" do
+        subject { ZendeskAPI::TestResource.new(client, :id => 1) }
+        before(:each) { stub_json_request(:get, %r{test_resources/\d+/foo}, json(:foo => {})) }
+
+        it "should attempt to grab the resource from the host" do
+          subject.foo.should be_instance_of(ZendeskAPI::Foo)
+        end
+
+        it "should pass the path on to the resource" do
+          subject.foo.path.should == "foos"
+        end
+
+        context "with a client error" do
+          before(:each) { stub_request(:get, %r{test_resources/\d+/foo}).to_return(:status => 500) }
+
+          it "should handle it properly" do
+            expect { silence_logger{ subject.foo.should be_nil } }.to_not raise_error
+          end
+        end
+        
+        context "with an explicit path set" do
+          before(:each) do
+            ZendeskAPI::TestResource.has :foo, :path => "blergh"
+            stub_json_request(:get, %r{test_resources/\d+/blergh}, json(:foo => {}))
+          end
+
+          it "should call the right path" do
+            subject.foo.should be_instance_of(ZendeskAPI::Foo)
+          end
+        end
+      end
+
+      context "with side-loading of resource" do
+        let(:foo) { { :message => "FOO_OBJ" } }
+        subject { ZendeskAPI::TestResource.new(client, :foo => foo) }
+
+        it "should load foo from the hash" do
+          subject.foo.should be_instance_of(ZendeskAPI::Foo)
+        end
+      end
+
+      context "with side-loading of id" do
+        subject { ZendeskAPI::TestResource.new(client, :foo_id => 1) }
+        before(:each) do
+          stub_json_request(:get, %r{foos/1}, json("foo" => {}))
+        end
+
+        it "should find foo_id and load it from the api" do
+          subject.foo
+        end
+
+        it "should handle nil response from find api" do
+          ZendeskAPI::Foo.should_receive(:find).twice.and_return(nil)
+          subject.foo.should be_nil
+          subject.foo
+        end
+      end
+    end
+  end
+
+  context "has_many" do
+    before(:each) { ZendeskAPI::TestResource.has_many :bars }
+
+    context "class methods" do
+      subject { ZendeskAPI::TestResource }
+      it "should define a method with the same name" do
+        subject.instance_methods.map(&:to_s).should include("bars")
+      end
+
+      it "should create a class if none exists" do
+        ZendeskAPI.const_defined?("Bar").should be_true
+      end
+
+      context "with explicit class name" do
+        before(:each) { ZendeskAPI::TestResource.has_many :cats, :class => :foo }
+
+        it "should not create a baz class" do
+          ZendeskAPI.const_defined?("Cat").should be_false
+        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
+          subject.bars.should be_instance_of(ZendeskAPI::Collection)
+        end
+
+        it "should pass the path on to the resource" do
+          subject.bars.path.should == "test_resources/1/bars"
+        end
+
+        context "with an explicit path set" do
+          before(:each) do
+            ZendeskAPI::TestResource.has_many :bars, :path => "blargh"
+          end
+
+          it "should call the right path" do
+            subject.bars.path.should == "test_resources/1/blargh"
+          end
+        end
+      end
+
+      context "with side-loading of resource" do
+        let(:bars) { [{ :message => "FOO_OBJ" }] }
+        subject { ZendeskAPI::TestResource.new(client, :bars => bars) }
+
+        it "should map bars onto Bar class" do
+          subject.bars.first.should be_instance_of(ZendeskAPI::Bar)
+        end
+      end
+
+      context "with side-loading of id" do
+        let(:bars) { [1, 2, 3] }
+        subject { ZendeskAPI::TestResource.new(client, :bar_ids => bars) }
+
+        it "should find foo_id and load it from the api" do
+          ZendeskAPI::Bar.should_receive(:find).with(client, kind_of(Hash)).exactly(bars.length).times
+          subject.bars
+        end
+
+        it "should handle nil response from find api" do
+          ZendeskAPI::Bar.should_receive(:find).with(client, kind_of(Hash)).exactly(bars.length).times.and_return(nil)
+          subject.bars.should be_empty
+          subject.bars # Test expectations
+        end
+      end
+    end
+  end
+end
+

data/spec/fixtures/credentials.yml.example

@@ -0,0 +1,3 @@
+username: please.change
+password: me
+url: https://my.zendesk.com/api/v2

data/spec/fixtures/test_resources.rb

@@ -0,0 +1,8 @@
+class ZendeskAPI::TestResource < ZendeskAPI::Resource
+  class TestChild < ZendeskAPI::Resource
+  end
+end
+
+class ZendeskAPI::NilResource < ZendeskAPI::Data; end
+
+class ZendeskAPI::SingularTestResource < ZendeskAPI::SingularResource; end

data/spec/fixtures/zendesk.rb

@@ -0,0 +1,88 @@
+def user
+  @user ||= find_or_create_user "end-user"
+end
+
+def current_user
+  VCR.use_cassette('current_user') do
+    @current_user ||= client.users.find(:id => 'me') 
+  end
+end
+
+def agent
+  @agent ||= find_or_create_user "agent"
+end
+
+def find_or_create_user(role)
+  VCR.use_cassette("valid_user_#{role}") do
+    email = "zendesk-api-client-ruby-#{role}-#{client.config.username}"
+
+    client.users.detect {|u| u.email == email } ||
+    client.users.create(
+      :name => "Test Valid with role #{role}",
+      :verified => true,
+      :email => email,
+      :role => role
+    )
+  end
+end
+
+def topic
+  VCR.use_cassette('valid_topic') do
+    @topic ||= forum.topics.first
+    @topic ||= client.topics.create(
+      :title => "Test Topic",
+      :body => "This is the body of a topic.",
+      :forum_id => forum.id
+    )
+  end
+end
+
+def forum
+  VCR.use_cassette('valid_forum') do
+    @forum ||= client.forums.detect {|f| f.topics.any? }
+    @forum ||= client.forums.create(:name => "Test Forum", :access => "everybody")
+  end
+end
+
+def category
+  VCR.use_cassette('valid_category') do
+    @category ||= client.categories.first
+    @category ||= client.categories.create(:name => "Test Category")
+  end
+end
+
+def ticket
+  VCR.use_cassette('valid_ticket') do
+    @ticket ||= client.tickets.first
+    @ticket ||= client.tickets.create(
+      :subject => "Test Ticket",
+      :description => "This is a test of the emergency alert system.",
+      :requester_id => user.id
+    )
+  end
+end
+
+def suspended_ticket
+  VCR.use_cassette('valid_suspended_ticket') do
+    @suspended_ticket ||= client.suspended_tickets.first
+  end
+end
+
+def group
+  VCR.use_cassette('valid_group') do
+    @ticket ||= client.groups.detect {|g| !g.default}
+    @ticket ||= client.groups.create(:name => "Test Group")
+  end
+end
+
+def organization
+  VCR.use_cassette('valid_organization') do
+    @organization ||= current_user.organization 
+  end
+end
+
+# Global default options, overwritten if using under
+def default_options
+  {}
+end
+

data/spec/lru_cache_spec.rb

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

data/spec/macros/resource_macros.rb

@@ -0,0 +1,157 @@
+module ResourceMacros
+  def under(object, &blk)
+    context "under a #{object.class.singular_resource_name}" do
+      let(:default_options) { { "#{object.class.singular_resource_name}_id" => object.id } }
+      instance_eval(&blk)
+    end
+  end
+
+  def it_should_be_creatable(options={})
+    context "creation" do
+      use_vcr_cassette
+      subject { described_class }
+
+      before(:all) do
+        VCR.use_cassette("#{described_class.to_s}_create") do
+          @object = described_class.create(client, valid_attributes.merge(default_options))
+        end
+      end
+
+      it "should have an id" do
+        @object.should_not be_nil
+        @object.send(options[:id] || :id).should_not be_nil
+      end
+
+      it "should be findable", :unless => metadata[:not_findable] do
+        options = default_options
+        options.merge!(:id => @object.id) unless described_class.ancestors.include?(ZendeskAPI::SingularResource)
+        described_class.find(client, options).should == @object
+      end 
+
+      after(:all) do
+        VCR.use_cassette("#{described_class.to_s}_create_delete") do
+          @object.destroy
+        end
+      end if metadata[:delete_after]
+    end
+  end
+
+  def it_should_be_updatable(attribute, value = "TESTDATA")
+    context "update" do
+      use_vcr_cassette
+
+      before(:all) do
+        VCR.use_cassette("#{described_class.to_s}_update_create") do
+          @object = described_class.create(client, valid_attributes.merge(default_options))
+        end
+      end
+
+      before(:each) do
+        @object.send("#{attribute}=", value)
+      end
+
+      it "should be savable" do
+        @object.save.should be_true
+      end
+
+      context "after save" do
+        before(:each) do
+          @object.save
+        end
+
+        it "should keep attributes" do
+          @object.send(attribute).should == value 
+        end
+
+        it "should be findable", :unless => metadata[:not_findable] do
+          options = default_options
+          options.merge!(:id => @object.id) unless described_class.ancestors.include?(ZendeskAPI::SingularResource)
+          described_class.find(client, options).should == @object
+        end 
+      end
+
+      after(:all, :if => metadata[:delete_after]) do
+        VCR.use_cassette("#{described_class.to_s}_update_delete") do
+          @object.destroy
+        end
+      end
+    end
+  end
+
+  def it_should_be_deletable(options = {})
+    context "deletion" do
+      use_vcr_cassette
+
+      before(:all) do
+        if options[:object]
+          @object = options.delete(:object)
+        else
+          VCR.use_cassette("#{described_class.to_s}_delete_create") do
+            @object = described_class.create(client, valid_attributes.merge(default_options))
+          end
+        end
+      end
+
+      it "should be destroyable" do
+        @object.destroy.should be_true
+        @object.destroyed?.should be_true
+
+        if (!options.key?(:find) || options[:find]) && !example.metadata[:not_findable]
+          opts = default_options
+          opts.merge!(:id => @object.id) unless described_class.ancestors.include?(ZendeskAPI::SingularResource)
+          obj = silence_logger{ described_class.find(client, opts) }
+
+          if options[:find]
+            obj.send(options[:find].first).should == options[:find].last
+          else
+            obj.should be_nil
+          end
+        end
+      end
+    end
+  end
+
+  def it_should_be_readable(*args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    create = !!options.delete(:create)
+    klass = args.first.is_a?(ZendeskAPI::DataResource) ? args.shift : client
+    context_name = "read_#{klass.class}_#{args.join("_")}"
+
+    context context_name do
+      use_vcr_cassette
+
+      before(:all) do
+        VCR.use_cassette("#{described_class.to_s}_#{context_name}_create") do
+          @object = described_class.create!(client, valid_attributes.merge(default_options))
+        end
+      end if create
+
+      after(:all) do
+        VCR.use_cassette("#{described_class.to_s}_#{context_name}_delete") do
+          @object.destroy
+        end
+      end if create 
+
+      it "should be findable" do
+        result = klass
+        args.each {|a| result = result.send(a, options) }
+
+        if result.is_a?(ZendeskAPI::Collection)
+          result.fetch(true).should_not be_empty
+          result.fetch.should include(@object) if create
+          object = result.first
+        else
+          result.should_not be_nil
+          result.should == @object if create
+          object = result
+        end
+
+        if described_class.respond_to?(:find) && !example.metadata[:not_findable]
+          options = default_options
+          options.merge!(:id => object.id) unless described_class.ancestors.include?(ZendeskAPI::SingularResource)
+          described_class.find(client, options).should_not be_nil 
+        end
+      end
+    end
+  end
+end