embulk-input-jira 0.2.5 → 0.2.6

data/spec/embulk/input/jira_api/client_spec.rb

@@ -1,224 +0,0 @@
-require "spec_helper"
-
-describe Embulk::Input::JiraApi::Client do
-  describe ".setup" do
-    subject { Embulk::Input::JiraApi::Client.setup {}  }
-
-    it "returns Embulk::Input::JiraApi::Client instance" do
-      expect(subject.is_a?(Embulk::Input::JiraApi::Client)).to be_truthy
-    end
-
-    it "calls Jiralicious.configure" do
-      allow(Jiralicious).to receive(:configure)
-    end
-  end
-
-  describe "#search" do
-    let(:jql) { "project=FOO" }
-    let(:api) { Embulk::Input::JiraApi::Client.new }
-
-    subject { api.search(jql) }
-
-    it do
-      allow(Jiralicious).to receive(:search).with(jql)
-    end
-
-    describe "retry and timeout" do
-      before do
-        allow(Timeout).to receive(:timeout) { raise Timeout::Error }
-        allow(api).to receive(:sleep)
-      end
-
-      it "retry DEFAULT_SEARCH_RETRY_TIMES times then raise error" do
-        expect(Timeout).to receive(:timeout).exactly(Embulk::Input::JiraApi::Client::DEFAULT_SEARCH_RETRY_TIMES + 1)
-        expect { subject }.to raise_error
-      end
-    end
-  end
-
-  describe "#search_issues" do
-    let(:jql) { "project=FOO" }
-    let(:jira_api) { Embulk::Input::JiraApi::Client.new }
-    let(:title_401) { "Unauthorized (401)"}
-    let(:multi_json_error) {MultiJson::ParseError.build(StandardError.new("<title>#{title_401}</title>"), {})}
-    let(:results) do
-      [
-        {
-          "id" => 1,
-          "jira_key" => "FOO-1",
-          "fields" =>
-          {
-            "summary" => "issue summary",
-            "project" =>
-            {
-              "key" => "FO1"
-            }
-          }
-        },
-        {
-          "id" => 2,
-          "jira_key" => "FOO-2",
-          "fields" =>
-          {
-            "summary" => "jira issue",
-            "project" =>
-            {
-              "key" => "FO2"
-            }
-          }
-        }
-      ]
-    end
-
-    subject { jira_api.search_issues(jql) }
-
-    it "Search issues successfully" do
-      allow(Jiralicious).to receive_message_chain(:search, :issues_raw).and_return(results)
-      allow(jira_api).to receive(:find_issue).and_return(results.first)
-
-      expect(subject).to be_kind_of Array
-      expect(subject.map(&:class)).to match_array [Embulk::Input::JiraApi::Issue, Embulk::Input::JiraApi::Issue]
-    end
-
-    it "Search issues successfully when first item success - 401 - second items success" do
-      allow(Jiralicious).to receive_message_chain(:search, :issues_raw).and_return(results)
-      allow(jira_api).to receive(:find_issue).and_return(results.first).and_raise(multi_json_error).and_return(results.first)
-
-      expect(subject).to be_kind_of Array
-      expect(subject.map(&:class)).to match_array [Embulk::Input::JiraApi::Issue, Embulk::Input::JiraApi::Issue]
-    end
-
-    it "Search issues successfully when 401 - first and second items success" do
-      allow(Jiralicious).to receive_message_chain(:search, :issues_raw).and_return(results)
-      allow(jira_api).to receive(:find_issue).and_raise(multi_json_error).and_return(results.first)
-
-      expect(subject).to be_kind_of Array
-      expect(subject.map(&:class)).to match_array [Embulk::Input::JiraApi::Issue, Embulk::Input::JiraApi::Issue]
-    end
-
-    it "Search issues got 401 due to high concurrent load issues" do
-      allow(Jiralicious).to receive_message_chain(:search, :issues_raw).and_return(results)
-      allow(jira_api).to receive(:find_issue).and_raise(multi_json_error)
-      allow(jira_api).to receive(:sleep)
-
-      expect { subject }.to raise_error(StandardError, title_401)
-    end
-  end
-
-  describe "#total_count" do
-    subject { jira_api.total_count(jql) }
-
-    let(:jira_api) { Embulk::Input::JiraApi::Client.new }
-    let(:jql) { "project=FOO" }
-    let(:results) { Object.new } # add mock later
-    let(:results_count) { 5 }
-
-    before do
-      allow(results).to receive(:num_results).and_return(results_count)
-    end
-
-    it "calls Embulk::Input::JiraApi::Client#search with proper arguments" do
-      expect(jira_api).to receive(:search).with(jql, max_results: 1).and_return(results)
-      subject
-    end
-
-    it "returns issues count" do
-      allow(jira_api).to receive(:search).with(jql, max_results: 1).and_return(results)
-      expect(subject).to eq results_count
-    end
-  end
-
-  describe "#timeout_and_retry" do
-    let(:wait) { 1 }
-    let(:retry_times) { 3 }
-    let(:jira_api) { Embulk::Input::JiraApi::Client.new }
-    let(:block) { proc{ "it works" } }
-
-    subject { jira_api.send(:timeout_and_retry, wait, retry_times, &block) }
-
-    before do
-      allow(jira_api).to receive(:sleep)
-    end
-
-    it "return given block result if timeout is not occured" do
-      expect(subject).to eq block.call
-    end
-
-    it "Always timeout, raise error after N times retry" do
-      allow(Timeout).to receive(:timeout) { raise Timeout::Error }
-
-      expect(Timeout).to receive(:timeout).with(wait).exactly(retry_times + 1).times
-      expect { subject }.to raise_error(Timeout::Error)
-    end
-
-    describe "invalid JSON response" do
-      let(:block) { proc{ MultiJson.load("<title>#{title}</title>")} }
-      before { allow(Embulk.logger).to receive(:warn) }
-
-      # Disable this test to enable retry for 401
-      # context "Unauthorized" do
-      #   let(:title) { "Unauthorized (401)" }
-      #
-      #   it do
-      #     expect { subject }.to raise_error(Embulk::ConfigError)
-      #   end
-      # end
-
-      context "Unavailable" do
-        let(:title) { "Atlassian Cloud Notifications - Page Unavailable"}
-
-        it do
-          expect { subject }.to raise_error(StandardError, title)
-        end
-      end
-    end
-  end
-
-  describe "#calculate_rate_limit" do
-    let(:jira_api) { Embulk::Input::JiraApi::Client.new }
-    it "current_limit = 50, all_items = 50, fail_items=50, times=1" do
-      current_limit = 50
-      all_items = 50
-      fail_items = 50
-      times = 1
-      expected_result = Embulk::Input::JiraApi::Client::MIN_RATE_LIMIT
-      expect(jira_api.calculate_rate_limit(current_limit, all_items, fail_items, times)).to eq expected_result
-    end
-
-    it "current_limit = 50, all_items = 50, fail_items=20, times=1" do
-      current_limit = 50
-      all_items = 50
-      fail_items = 20
-      times = 1
-      expected_result = 20
-      expect(jira_api.calculate_rate_limit(current_limit, all_items, fail_items, times)).to eq expected_result
-    end
-
-    it "current_limit = MIN_RATE_LIMIT, all_items = 50, fail_items=20, times=2" do
-      current_limit = Embulk::Input::JiraApi::Client::MIN_RATE_LIMIT
-      all_items = 50
-      fail_items = 20
-      times = 2
-      expected_result = Embulk::Input::JiraApi::Client::MIN_RATE_LIMIT
-      expect(jira_api.calculate_rate_limit(current_limit, all_items, fail_items, times)).to eq expected_result
-    end
-
-    it "current_limit = 10, all_items = 30, fail_items=25, times=2" do
-      current_limit = 10
-      all_items = 30
-      fail_items = 25
-      times = 2
-      expected_result = 5
-      expect(jira_api.calculate_rate_limit(current_limit, all_items, fail_items, times)).to eq expected_result
-    end
-
-    it "current_limit = 50, all_items = 50, fail_items=20, times=DEFAULT_SEARCH_RETRY_TIMES/2" do
-      current_limit = 50
-      all_items = 50
-      fail_items = 20
-      times = Embulk::Input::JiraApi::Client::DEFAULT_SEARCH_RETRY_TIMES/2
-      expected_result = Embulk::Input::JiraApi::Client::MIN_RATE_LIMIT
-      expect(jira_api.calculate_rate_limit(current_limit, all_items, fail_items, times)).to eq expected_result
-    end
-  end
-end

data/spec/embulk/input/jira_api/issue_spec.rb

@@ -1,394 +0,0 @@
-require "spec_helper"
-
-describe Embulk::Input::JiraApi::Issue do
-  describe ".initialize" do
-    context "when argument has 'fields' key" do
-      let(:issue_attributes) do
-        {
-          "id" => 1,
-          "jira_key" => "PRO-1",
-          "fields" =>
-          {
-            "summary" => "jira issue",
-            "project" =>
-            {
-              "key" => "FOO",
-            },
-          }
-        }
-      end
-
-      it "has @id with argument['id']" do
-        expect(Embulk::Input::JiraApi::Issue.new(issue_attributes).id).to eq issue_attributes["id"]
-      end
-
-      it "has @key with argument['jira_key']" do
-        expect(Embulk::Input::JiraApi::Issue.new(issue_attributes).key).to eq issue_attributes["jira_key"]
-      end
-
-      it "has @fields with argument['fields']" do
-        expect(Embulk::Input::JiraApi::Issue.new(issue_attributes).fields).to eq issue_attributes["fields"]
-      end
-    end
-
-    context "when argument doesn't have 'fields' key" do
-      let(:issue_attributes) do
-        {}
-      end
-
-      it "raises error" do
-        expect { Embulk::Input::JiraApi::Issue.new(issue_attributes) }.to raise_error
-      end
-    end
-  end
-
-  describe "#[]" do
-    subject { Embulk::Input::JiraApi::Issue.new(issue_attributes)[attribute_name] }
-
-    let(:issue_attributes) do
-      {
-        "id" => "1",
-        "jira_key" => "FOO-1",
-        "fields" => fields_attributes
-      }
-    end
-
-    context "when target attribute_name is especially key" do
-      let(:fields_attributes) { {} }
-
-      context 'id' do
-        let(:attribute_name) { 'id' }
-
-        it "returns issue id" do
-          expect(subject).to eq "1"
-        end
-      end
-
-      context 'key' do
-        let(:attribute_name) { 'key' }
-
-        it "returns issue key" do
-          expect(subject).to eq "FOO-1"
-        end
-      end
-    end
-
-    context "when fields_attributes is empty Hash" do
-      let(:fields_attributes) { {} }
-
-      let(:attribute_name) { 'key1' }
-
-      it "returns nil" do
-        expect(subject).to eq nil
-      end
-    end
-
-    context "when fields_attributes is empty Hash including Array" do
-      let(:fields_attributes) { { 'key1' => [] } }
-
-      let(:attribute_name) { 'key1' }
-
-      it "returns empty Array" do
-        expect(subject).to eq []
-      end
-    end
-
-    context "when fields_attributes is Hash" do
-      let(:fields_attributes) do
-        {'key' => 'value'}
-      end
-
-      let(:attribute_name) { 'key' }
-
-      it "returns 'value'" do
-        expect(subject).to eq "FOO-1"
-      end
-    end
-
-    context "when fields_attributes is `{'key1' => {'key2' => 'value2', 'key3' => 'value3'}}`" do
-      let(:fields_attributes) do
-        {'key1' => {'key2' => 'value2', 'key3' => 'value3'}}
-      end
-
-      context "when attribute_name is 'key1'" do
-        let(:attribute_name) { 'key1' }
-
-        it "returns key1's JSON" do
-          expect(subject).to eq({'key2' => 'value2', 'key3' => 'value3'}.to_json)
-        end
-      end
-
-      context "when attribute_name is 'key1.key2'" do
-        let(:attribute_name) { 'key1.key2' }
-
-        it "returns 'value2'" do
-          expect(subject).to eq 'value2'
-        end
-      end
-    end
-
-    context "when fields_attributes is `{'key1' => [{'key2' => 'value2-1'}, {'key2' => 'value2-2'}]}`" do
-      let(:fields_attributes) do
-        {'key1' => [{'key2' => 'value2-1'}, {'key2' => 'value2-2'}]}
-      end
-
-      context "when attribute_name is 'key1'" do
-        let(:attribute_name) { 'key1' }
-
-        it "returns JSON array" do
-          expect(subject).to eq '{"key2":"value2-1"},{"key2":"value2-2"}'
-        end
-      end
-
-      context "when attribute_name is 'key1.key2'" do
-        let(:attribute_name) { 'key1.key2' }
-
-        it "returns CSV values assigned by 'key2' key" do
-          expect(subject).to eq 'value2-1,value2-2'
-        end
-      end
-    end
-
-    context "when fields_attributes is `{'key1' => [{'key2' => 'value2-1'}, nil]}`" do
-      let(:fields_attributes) do
-        {'key1' => [{'key2' => 'value2-1'}, nil]}
-      end
-
-      context "when attribute_name is 'key1'" do
-        let(:attribute_name) { 'key1' }
-
-        it "returns CSV value including null" do
-          expect(subject).to eq '{"key2":"value2-1"},null'
-        end
-      end
-
-      context "when attribute_name is 'key1.key2'" do
-        let(:attribute_name) { 'key1.key2' }
-
-        it "returns JSON array including null" do
-          expect(subject).to eq 'value2-1,null'
-        end
-      end
-    end
-
-    context "when fields_attributes is `{'key1' => ['element1', 'element2', 'element3']}`" do
-      let(:fields_attributes) do
-        {
-          'key1' => ['element1', 'element2', 'element3'],
-        }
-      end
-
-      let(:attribute_name) { 'key1' }
-
-      it "returns CSV values assigned by 'key1'" do
-        expect(subject).to eq 'element1,element2,element3'
-      end
-    end
-  end
-
-  describe "#to_record" do
-    subject do
-      Embulk::Input::JiraApi::Issue.new(issue_attributes).to_record
-    end
-
-    shared_examples 'return guessed record' do
-      it do
-        expect(subject).to eq expected_record
-      end
-    end
-
-    let(:issue_attributes) do
-      {"jira_key" => "FOO-1", "id" => "1", "fields" => fields_attributes}
-    end
-
-    let(:expected_record) do
-      {
-        "key" => "FOO-1",
-        "id" => "1"
-      }.merge(exptected_record_from_fields)
-    end
-
-    context "when fields_attributes is `{'key' => 'value'}`" do
-      let(:fields_attributes) do
-        {'key' => 'value'}
-      end
-
-      let(:exptected_record_from_fields) do
-        {'key' => 'value'}
-      end
-
-      it_behaves_like "return guessed record"
-    end
-
-    context "when fields_attributes is `{'key1' => {'key2' => 'value2', 'key3' => 'value3'}}`" do
-      let(:fields_attributes) do
-        {
-          'key1' => {
-            'key2' => 'value2',
-            'key3' => 'value3',
-          }
-        }
-      end
-
-      let(:exptected_record_from_fields) do
-        {
-          "key1.key2" => "value2",
-          "key1.key3" => "value3"
-        }
-      end
-
-      it_behaves_like "return guessed record"
-    end
-
-    context "when fields_attributes is `{'key1' => {'key2' => {'key3' => last_child}}}`" do
-      let(:fields_attributes) do
-        {'key1' => {'key2' => {'key3' => last_child}}}
-      end
-
-      context "when last_child is String" do
-        let(:last_child) do
-          "String"
-        end
-
-        let(:exptected_record_from_fields) do
-          {"key1.key2.key3" => "String"}
-        end
-
-        it_behaves_like "return guessed record"
-      end
-
-      context "when last_child has 'key' key" do
-        let(:last_child) do
-          {"key" => "BAR-1"}
-        end
-
-        let(:exptected_record_from_fields) do
-          {"key1.key2.key3.key" => "BAR-1"}
-        end
-
-        it_behaves_like "return guessed record"
-      end
-
-      context "when last_child has 'id' key" do
-        let(:last_child) do
-          {"id" => "20"}
-        end
-
-        let(:exptected_record_from_fields) do
-          {"key1.key2.key3.id" => "20"}
-        end
-
-        it_behaves_like "return guessed record"
-      end
-
-      context "when last_child has 'name' key" do
-        let(:last_child) do
-          {"name" => "Foo name"}
-        end
-
-        let(:exptected_record_from_fields) do
-          {"key1.key2.key3.name" => "Foo name"}
-        end
-
-        it_behaves_like "return guessed record"
-      end
-
-      context "when last_child has another key except 'key', 'id', 'name'" do
-        let(:last_child) do
-          {"customfield_0001" => "value0001"}
-        end
-
-        let(:exptected_record_from_fields) do
-          {"key1.key2.key3" => "{\"customfield_0001\":\"value0001\"}"}
-        end
-
-        it_behaves_like "return guessed record"
-      end
-
-      context "when last_child Hash Array" do
-        let(:last_child) do
-          [
-            {"key4" => "value4", "key5" => "value5-1"},
-            {"key6" => "value6", "key5" => "value5-2"},
-          ]
-        end
-
-        let(:exptected_record_from_fields) do
-          {"key1.key2.key3" => '{"key4":["value4",null],"key5":["value5-1","value5-2"],"key6":[null,"value6"]}'}
-        end
-
-        it_behaves_like "return guessed record"
-      end
-    end
-
-    context "when fields_attributes is `{'key1' => ['element1-1', 'element1-2', 'element1-3'], 'key2' => ['element2-1', 'element2-2', 'element2-3']}`" do
-      let(:fields_attributes) do
-        {
-          'key1' => ['element1-1', 'element1-2', 'element1-3'],
-          'key2' => ['element2-1', 'element2-2', 'element2-3'],
-        }
-      end
-
-      let(:exptected_record_from_fields) do
-        {
-          'key1' => '"element1-1,element1-2,element1-3"',
-          'key2' => '"element2-1,element2-2,element2-3"',
-        }
-      end
-
-      it_behaves_like "return guessed record"
-    end
-
-    context "when fields_attributes is `{'key' => []}`" do
-      let(:fields_attributes) do
-        {'key' => []}
-      end
-
-      let(:exptected_record_from_fields) do
-        {"key" => '""'}
-      end
-
-      it_behaves_like "return guessed record"
-    end
-
-    context "when fields_attributes is `{'key1' => { 'key2' => [{'key3' => 'value3-1'}, {'key3'=> 'value3-2'}]}}`" do
-      let(:fields_attributes) do
-        {
-          'key1' => {
-            'key2' => [
-              {'key3' => 'value3-1'}, {'key3'=> 'value3-2'},
-            ]
-          }
-        }
-      end
-
-      let(:exptected_record_from_fields) do
-        {
-          "key1.key2.key3" => '"value3-1,value3-2"',
-        }
-      end
-
-      it_behaves_like "return guessed record"
-    end
-
-    context "when fields_attributes is `{'key1' => { 'key2' => ['element2-1', 'element2-2', 'element2-3'], 'key3' => ['element3-1', 'element3-2', 'element3-3']}}`" do
-      let(:fields_attributes) do
-        {
-          'key1' => {
-            'key2' => ['element2-1', 'element2-2', 'element2-3'],
-            'key3' => ['element3-1', 'element3-2', 'element3-3']
-          }
-        }
-      end
-
-      let(:exptected_record_from_fields) do
-        {
-          "key1.key2" => '"element2-1,element2-2,element2-3"',
-          "key1.key3" => '"element3-1,element3-2,element3-3"',
-        }
-      end
-
-      it_behaves_like "return guessed record"
-    end
-  end
-end