zendesk_api 1.13.1 → 1.13.2

data/spec/live/tag_spec.rb

@@ -1,58 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::Tag, :vcr, :not_findable do
-  [organization, topic, ticket].each do |object|
-    under object do
-      before(:each) do
-        parent.tags = %w{tag2 tag3}
-        parent.tags.save!
-      end
-
-      it "can be set" do
-        expect(tags).to eq(%w{tag2 tag3})
-      end
-
-      it "should be removable" do
-        parent.tags.destroy!(:id => "tag2")
-
-        expect(tags).to eq(%w{tag3})
-      end
-
-      it "shouldn't re-save destroyed tags" do
-        parent.tags.first.destroy!
-        parent.tags.save!
-
-        expect(tags).to eq(%w{tag3})
-      end
-
-      it "should be updatable" do
-        parent.tags.update!(:id => "tag4")
-
-        expect(tags).to eq(%w{tag2 tag3 tag4})
-      end
-
-      it "should be savable" do
-        parent.tags << "tag4"
-        parent.tags.save!
-
-        expect(tags).to eq(%w{tag2 tag3 tag4})
-      end
-
-      it "should be modifiable" do
-        parent.tags.delete(ZendeskAPI::Tag.new(nil, :id => "tag2"))
-        parent.tags.save!
-
-        expect(tags).to eq(%w{tag3})
-
-        parent.tags.delete_if {|tag| tag.id == "tag3"}
-        parent.tags.save!
-
-        expect(tags).to be_empty
-      end
-    end
-  end
-
-  def tags
-    parent.tags.fetch!(:reload).map(&:id).sort
-  end
-end

data/spec/live/target_spec.rb

@@ -1,17 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::Target, :delete_after do
-  def valid_attributes
-    {
-      :type => "email_target",
-      :title => "Test Email Target",
-      :email =>  "hello@example.com",
-      :subject => "Test Target"
-    }
-  end
-
-  it_should_be_readable :targets, :create => :true
-  it_should_be_creatable
-  it_should_be_updatable :email, "bye@example.com"
-  it_should_be_deletable
-end

data/spec/live/ticket_field_spec.rb

@@ -1,12 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::TicketField, :delete_after do
-  def valid_attributes
-    { :type => "text", :title => "Age" }
-  end
-
-  it_should_be_creatable
-  it_should_be_updatable :title
-  it_should_be_deletable
-  it_should_be_readable :ticket_fields
-end

data/spec/live/ticket_form_spec.rb

@@ -1,14 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::TicketForm, :delete_after do
-  def valid_attributes
-    { :name => "Ticket Form-o", :position => 9999, :active => false }
-  end
-
-  it_should_be_creatable
-  it_should_be_updatable :name
-  it_should_be_deletable :find => false # Deleted ticket forms are still returned from the show action
-  it_should_be_readable :ticket_forms
-
-  # TODO: clone
-end

data/spec/live/ticket_metrics_spec.rb

@@ -1,6 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::TicketMetric do
-  it_should_be_readable :ticket_metrics
-  it_should_be_readable ticket, :metrics
-end

data/spec/live/ticket_spec.rb

@@ -1,136 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::Ticket do
-  def valid_attributes
-    {
-      :type => "question",
-      :subject => "This is a question?",
-      :comment => { :value => "Indeed it is!" },
-      :priority => "normal",
-      :requester_id => user.id,
-      :submitter_id => user.id,
-      :collaborator_ids => [agent.id],
-      :tags => ["awesome", "blossom"]
-    }
-  end
-
-  it_should_be_creatable
-  it_should_be_updatable :subject
-  it_should_be_deletable
-  it_should_be_readable :tickets
-  it_should_be_readable user, :requested_tickets
-  it_should_be_readable agent, :ccd_tickets
-  it_should_be_readable organization, :tickets
-
-  context "recent tickets" do
-    before(:all) do
-      VCR.use_cassette("visit_recent_ticket") do
-        client.tickets.find(id: 1)
-
-        sleep(5)
-      end
-    end
-
-    it_should_be_readable :tickets, :recent
-  end
-
-  describe ".incremental_export" do
-    let(:results) { ZendeskAPI::Ticket.incremental_export(client, Time.at(1023059503)) } # ~ 10 years ago
-
-    around do |example|
-      # 1 request every 5 minutes allowed <-> you can only test 1 call ...
-      VCR.use_cassette("incremental_export") do
-        client.config.retry = false
-
-        example.call
-
-        client.config.retry = true
-      end
-    end
-
-    it "finds tickets after a old date" do
-      expect(results.to_a.first).to be_an_instance_of ZendeskAPI::Ticket
-    end
-
-    it "is able to do next" do
-      first = results.to_a.first
-      stub_json_request(:get, %r{/api/v2/exports/tickets}, json(:results => []))
-
-      results.next
-      expect(results.first).to_not eq(first)
-    end
-  end
-
-  describe ".import" do
-    it "can import" do
-      VCR.use_cassette("ticket_import_can_import") do
-        old = Time.now - 5*365*24*60*60
-        ticket = ZendeskAPI::Ticket.import(client, valid_attributes.merge(:created_at => old.iso8601))
-        expect(ZendeskAPI::Ticket.find(client, :id => ticket.id).created_at.year).to eq(old.year)
-      end
-    end
-
-    it "returns nothing if import fails" do
-      VCR.use_cassette("ticket_import_cannot_import") do
-        silence_logger { expect(ZendeskAPI::Ticket.import(client, {})).to eq(nil) }
-      end
-    end
-  end
-
-  it "can upload while creating" do
-    VCR.use_cassette("ticket_inline_uploads") do
-      ticket = ZendeskAPI::Ticket.new(client, valid_attributes)
-      ticket.comment.uploads << "spec/fixtures/Argentina.gif"
-      ticket.comment.uploads << File.new("spec/fixtures/Argentina.gif")
-
-      ticket.save!
-      expect(ticket.changes).to eq({}) # uploads were set before save
-      expect(ticket.comment.attributes[:uploads].map(&:class)).to eq([String, String]) # upload was sent as tokens
-    end
-  end
-
-  it "can comment while creating" do
-    VCR.use_cassette("ticket_inline_comments") do
-      ticket = ZendeskAPI::Ticket.new(client, valid_attributes)
-      ticket.comment = ZendeskAPI::Ticket::Comment.new(client, :value => "My comment", :public => false)
-      ticket.save!
-
-      expect(ticket.changes).to eq({}) # comment was set before save
-      expect(ticket.attributes[:comment]).to eq({"value" => "My comment", "public" => false})
-    end
-  end
-
-  describe "import race condition" do
-    let(:email) { "test+#{rand(100000)}@test.com" }
-
-    it "should handle it" do
-      VCR.use_cassette("ticket_import_race") do
-        threads = []
-
-        3.times do
-          threads << Thread.new do
-            client.insert_callback do |response|
-              Thread.current[:response] = response
-            end
-
-            ZendeskAPI::Ticket.import(client, :requester => { :email => email, :name => "Hello" }, :subject => "Test", :description => "Test")
-          end
-        end
-
-        threads.map! do |thread|
-          thread.join(5)
-          fail("could not get response in 5 seconds") unless thread[:response]
-          thread[:response][:status]
-        end
-
-        user = client.users.detect {|user| user.email == email}
-        expect(user).to_not be_nil
-
-        user.requested_tickets.each(&:destroy)
-        user.destroy
-
-        expect(threads.all? {|st| [201, 422, 409].include?(st)}).to be(true)
-      end
-    end
-  end
-end

data/spec/live/topic_comment_spec.rb

@@ -1,52 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::Topic::TopicComment do
-  def valid_attributes
-    { :body => "Texty-text, text." }
-  end
-
-  under topic do
-    it_should_be_creatable
-    it_should_be_updatable :body
-    it_should_be_deletable
-    it_should_be_readable topic, :comments
-  end
-
-  describe ".import" do
-    it "can import" do
-      VCR.use_cassette("topic_comment_import_can_import") do
-        old = Time.now - 4*365*24*60*60
-        comment = ZendeskAPI::Topic::TopicComment.import(client, valid_attributes.merge(:created_at => old, :topic_id => topic.id))
-        expect(ZendeskAPI::Topic::TopicComment.find(client, comment).created_at.year).to eq(old.year)
-      end
-    end
-
-    it "returns nothing if import fails" do
-      VCR.use_cassette("topic_comment_import_cannot_import") do
-        silence_logger { expect(ZendeskAPI::Topic::TopicComment.import(client, {})).to eq(nil) }
-      end
-    end
-  end
-
-  it "can upload while creating" do
-    VCR.use_cassette("topic_comment_inline_uploads") do
-      comment = ZendeskAPI::Topic::TopicComment.new(client, valid_attributes.merge(:topic_id => topic.id))
-      comment.uploads << "spec/fixtures/Argentina.gif"
-      comment.uploads << File.new("spec/fixtures/Argentina.gif")
-
-      comment.save!
-      expect(comment.changes).to eq({}) # uploads were set before save
-      expect(comment.attributes[:uploads].map(&:class)).to eq([String, String]) # upload was sent as tokens
-    end
-  end
-end
-
-describe ZendeskAPI::User::TopicComment do
-  def valid_attributes
-    { :body => "Texty-text, text."}
-  end
-
-  under current_user do
-    it_should_be_readable current_user, :topic_comments
-  end
-end

data/spec/live/topic_spec.rb

@@ -1,46 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::Topic do
-  def valid_attributes
-    {
-      :forum_id => forum.id, :title => "My Topic",
-      :body => "The mayan calendar ends December 31st. Coincidence? I think not."
-    }
-  end
-
-  it_should_be_creatable
-  it_should_be_updatable :title
-  it_should_be_deletable :create => true
-  it_should_be_readable :topics
-  it_should_be_readable current_user, :topics
-  it_should_be_readable forum, :topics
-  #it_should_be_readable :topics, :show_many, :verb => :post, :ids =>
-
-  describe ".import" do
-    it "can import" do
-      VCR.use_cassette("topic_import_can_import") do
-        old = Time.now - 5*365*24*60*60
-        topic = ZendeskAPI::Topic.import(client, valid_attributes.merge(:created_at => old))
-        expect(ZendeskAPI::Topic.find(client, topic).created_at.year).to eq(old.year)
-      end
-    end
-
-    it "returns nothing if import fails" do
-      VCR.use_cassette("topic_import_cannot_import") do
-        silence_logger { expect(ZendeskAPI::Topic.import(client, {})).to eq(nil) }
-      end
-    end
-  end
-
-  it "can upload while creating" do
-    VCR.use_cassette("topic_inline_uploads") do
-      topic = ZendeskAPI::Topic.new(client, valid_attributes)
-      topic.uploads << "spec/fixtures/Argentina.gif"
-      topic.uploads << File.new("spec/fixtures/Argentina.gif")
-
-      topic.save!
-      expect(topic.changes).to eq({}) # uploads were set before save
-      expect(topic.attributes[:uploads].map(&:class)).to eq([String, String]) # upload was sent as tokens
-    end
-  end
-end

data/spec/live/topic_subscription_spec.rb

@@ -1,12 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::TopicSubscription, :delete_after do
-  def valid_attributes
-    { :topic_id => topic.id, :user_id => user.id }
-  end
-
-  it_should_be_creatable
-  it_should_be_deletable
-  it_should_be_readable topic, :subscriptions, :create => true
-  it_should_be_readable user, :topic_subscriptions, :create => true
-end

data/spec/live/topic_vote_spec.rb

@@ -1,13 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::Topic::TopicVote, :delete_after do
-  def valid_attributes
-    { :topic_id => topic.id }
-  end
-
-  under topic do
-    it_should_be_creatable
-    it_should_be_deletable
-    it_should_be_readable topic, :votes, :create => true
-  end
-end

data/spec/live/trigger_spec.rb

@@ -1,23 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::Trigger, :delete_after do
-  def valid_attributes
-    {
-      :title => "my test trigger",
-      :conditions => {
-        :all => [{ :field => "status", :operator => "is", :value => "open" }]
-      },
-      :actions => [{ :field => "status", :value => "solved" }]
-    }
-  end
-
-  it_should_be_readable :triggers
-  it_should_be_readable :triggers, :active
-
-  it_should_be_creatable
-  it_should_be_updatable :conditions, {
-    "any" => [],
-    "all" => [{ "field" => "priority", "operator" => "is", "value" => "low" }]
-  }
-  it_should_be_deletable
-end

data/spec/live/upload_spec.rb

@@ -1,10 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::Upload, :not_findable do
-  def valid_attributes
-    { :file => "spec/fixtures/Argentina.gif" }
-  end
-
-  it_should_be_creatable
-  it_should_be_deletable
-end

data/spec/live/user_field_spec.rb

@@ -1,12 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::UserField, :delete_after do
-  def valid_attributes
-    { :type => "text", :title => "Age", :key => "age" }
-  end
-
-  it_should_be_creatable
-  it_should_be_updatable :title, "key"
-  it_should_be_deletable
-  it_should_be_readable :user_fields, :create => true
-end

data/spec/live/user_spec.rb

@@ -1,71 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::User, :delete_after do
-  def valid_attributes
-    { :name => "Test U.", :email => "test@example.org" }
-  end
-
-  it_should_be_creatable
-  it_should_be_updatable :name
-  it_should_be_deletable :find => [:active?, false]
-  it_should_be_readable :users
-  it_should_be_readable organization, :users
-
-  it "should be able to find by email" do
-    VCR.use_cassette("user_find_by_email") do
-      expect(client.users.search(:query => current_user.email).to_a).to eq([current_user])
-    end
-  end
-
-  context "passwords", :vcr do
-    let(:password) { client.config.password || ENV['PASSWORD'] }
-
-    it "sets the password" do
-      agent.set_password!(:password => password)
-    end
-
-    it "changes the password" do
-      current_user.change_password!(:previous_password => password, :password => password)
-    end
-  end
-
-  context "side-loading" do
-    context "no permission set" do
-      subject do
-        VCR.use_cassette("user_admin_role") { client.users.find(:id => 20014182, :include => :roles) }
-      end
-
-      it "should include role" do
-        if subject
-          expect(subject.changes.key?(:role_id)).to be(false)
-          expect(subject.role).to_not be_nil
-          expect(subject.role.id).to be_nil
-          expect(subject.role.name).to eq("admin")
-          expect(subject.role.configuration).to_not be_nil
-
-          expect(subject.custom_role).to be_nil
-        end
-      end
-    end
-
-    context "permission set" do
-      subject do
-        VCR.use_cassette("user_permission_set") { client.users.find(:id => 20014327, :include => :roles) }
-      end
-
-      it "should include role" do
-        if subject
-          expect(subject.changes.key?(:role_id)).to be(false)
-          expect(subject.role).to_not be_nil
-          expect(subject.role.id).to be_nil
-          expect(subject.role.name).to eq("agent")
-
-          expect(subject.custom_role).to_not be_nil
-          expect(subject.custom_role.id).to eq(3692)
-          expect(subject.custom_role.name).to eq("Staff")
-          expect(subject.custom_role.configuration).to_not be_nil
-        end
-      end
-    end
-  end
-end