embulk-input-jira 0.2.5 → 0.2.6

data/spec/embulk/input/jira_spec.rb

@@ -1,322 +0,0 @@
-require "spec_helper"
-
-describe Embulk::Input::Jira do
-  let(:username) { "jira-user" }
-  let(:password) { "password" }
-  let(:uri) { "http://jira.example/" }
-  let(:jql) { "PROJECT=#{project_name}" }
-  let(:project_name) { "FOO" }
-
-  describe ".transaction" do
-    subject { described_class.transaction(config, &control) }
-
-    let(:config) { Object.new } # add mock later
-    let(:control) { Proc.new{|task, columns, count| } } # do nothing
-
-    let(:task) do
-      {
-        username: username,
-        password: password,
-        uri: uri,
-        jql: jql,
-        attributes: {
-          "project.key" => :string,
-          "comment.total" => :long
-        },
-        retry_limit: 5,
-        retry_initial_wait_sec: 1,
-      }
-    end
-
-    let(:columns) do
-      [
-        {"name" => "project.key", "type" => "string"},
-        {"name" => "comment.total", "type" => "long"}
-      ]
-    end
-
-    let(:column_structs) do
-      [
-        Embulk::Column.new(nil, "project.key", :string),
-        Embulk::Column.new(nil, "comment.total", :long)
-      ]
-    end
-
-    before do
-      allow(config).to receive(:param).with(:username, :string).and_return(username)
-      allow(config).to receive(:param).with(:password, :string).and_return(password)
-      allow(config).to receive(:param).with(:uri, :string).and_return(uri)
-      allow(config).to receive(:param).with(:jql, :string).and_return(jql)
-      allow(config).to receive(:param).with(:columns, :array).and_return(columns)
-      allow(config).to receive(:param).with(:retry_limit, :integer, default: 5).and_return(5)
-      allow(config).to receive(:param).with(:retry_initial_wait_sec, :integer, default: 1).and_return(1)
-    end
-
-    # NOTE: I should check other factor, but i don't know it...
-    it "calls .resume method with proper parameters" do
-      expect(described_class).to receive(:resume).with(task, column_structs, 1, &control)
-      subject
-    end
-  end
-
-  describe ".resume" do
-    subject { described_class.resume(task, columns, count, &control) }
-
-    let(:task) do
-      {
-        username: username,
-        password: password,
-        uri: uri,
-        jql: jql,
-        attributes: {
-          "project.key" => :string,
-          "comment.total" => :long
-        }
-      }
-    end
-
-    let(:columns) do
-      [
-        Embulk::Column.new(nil, "project.key", :string),
-        Embulk::Column.new(nil, "comment.total", :long)
-      ]
-    end
-
-    let(:count) { 1 }
-    let(:control) { Proc.new{|task, columns, count| } } # do nothing
-
-    let(:next_config_diff) { {} }
-
-    it "returns next_config_diff" do
-      expect(subject).to eq next_config_diff
-    end
-  end
-
-  describe ".guess" do
-    subject { described_class.guess(config) }
-
-    let(:config) { Object.new } # add mock later
-
-    let(:jira_api) { Embulk::Input::JiraApi::Client.new }
-    let(:jira_issues) { [Embulk::Input::JiraApi::Issue.new(attributes)] }
-    let(:attributes) do
-      {
-        "id" => "100",
-        "jira_key" => "FOO-100",
-        "fields" =>
-        {
-          "project" => {
-            "name" => project_name,
-            "key" => project_name,
-          },
-          "comment" => {
-            "total" => 0,
-            "comments" => []
-          }
-        }
-      }
-    end
-
-    let(:guessed_config) do
-      {
-        "columns" => [
-          {name: "comment.comments", type: :string},
-          {name: "comment.total", type: :long},
-          {name: "id", type: :long},
-          {name: "key", type: :string},
-          {name: "project.key", type: :string},
-          {name: "project.name", type: :string},
-        ]
-      }
-    end
-
-    before do
-      allow(jira_api).to receive(:check_user_credential).with(username).and_return(username)
-      allow(jira_api).to receive(:search_issues).with(jql, max_results: described_class::GUESS_RECORDS_COUNT).and_return(jira_issues)
-
-      allow(config).to receive(:param).with(:username, :string).and_return(username)
-      allow(config).to receive(:param).with(:password, :string).and_return(password)
-      allow(config).to receive(:param).with(:uri, :string).and_return(uri)
-      allow(config).to receive(:param).with(:jql, :string).and_return(jql)
-      allow(config).to receive(:param).with(:retry_limit, :integer, anything).and_return(0)
-      allow(config).to receive(:param).with(:retry_initial_wait_sec, :integer, anything).and_return(0)
-    end
-
-    it "setup Embulk::Input::JiraApi::Client" do
-      expect(Embulk::Input::JiraApi::Client).to receive(:setup).and_return(jira_api)
-      subject
-    end
-
-    it "returns guessed config" do
-      allow(Embulk::Input::JiraApi::Client).to receive(:setup).and_return(jira_api)
-
-      expect(subject).to eq guessed_config
-    end
-  end
-
-  describe "#init (.new)" do
-    # NOTE: InputPlugin.initialize calls #init method.
-
-    subject { described_class.new({}, nil, nil, nil) }
-
-    it "setup Embulk::Input::JiraApi::Client" do
-      expect(Embulk::Input::JiraApi::Client).to receive(:setup)
-      subject
-    end
-
-    it "is a Embulk::InputPlugin" do
-      allow(Embulk::Input::JiraApi::Client).to receive(:setup)
-      expect(subject).to be_a(Embulk::InputPlugin)
-    end
-  end
-
-  describe "#run" do
-    subject do
-      allow(plugin).to receive(:logger).and_return(::Logger.new(File::NULL))
-      silence do
-        plugin.run
-      end
-    end
-
-    let(:plugin) { described_class.new(task, nil, nil, page_builder) }
-    let(:jira_api) { Embulk::Input::JiraApi::Client.new }
-    let(:jira_issues) do
-      (1..total_count).map do |i|
-        attributes = fields.merge("id" => i.to_s, "jira_key" => "FOO-#{i}")
-
-        Embulk::Input::JiraApi::Issue.new(attributes)
-      end
-    end
-
-    let(:total_count) { max_result + 10 }
-    let(:max_result) { described_class::PER_PAGE }
-
-
-    let(:page_builder) { Object.new } # add mock later
-    let(:task) do
-      {
-        jql: jql,
-        attributes: {"project.key" => "string"}
-      }
-    end
-
-    let(:fields) do
-      {
-        "fields" =>
-        {
-          "project" => {
-            "key" => project_name,
-          },
-        }
-      }
-    end
-
-    let(:commit_report) { {} }
-    let(:username) { "jira-user" }
-
-    before do
-      allow(jira_api).to receive(:preview?).and_return(false)
-
-      # TODO: create stubs without each `it` expected
-      allow(Embulk::Input::JiraApi::Client).to receive(:setup).and_return(jira_api)
-      allow(jira_api).to receive(:check_user_credential).and_return(username)
-
-      0.step(total_count, max_result) do |start_at|
-        issues = jira_issues[start_at..(start_at + max_result - 1)]
-        allow(jira_api).to receive(:search_issues).with(jql, start_at: start_at).and_return(issues)
-      end
-      allow(jira_api).to receive(:total_count).and_return(total_count)
-
-      allow(page_builder).to receive(:add).with([project_name])
-      allow(page_builder).to receive(:finish)
-    end
-
-    it 'search JIRA issues' do
-      expect(jira_api).to receive(:search_issues)
-      subject
-    end
-
-    it 'page build and finish' do
-      expect(page_builder).to receive(:add).with([project_name]).exactly(total_count).times
-      expect(page_builder).to receive(:finish)
-      subject
-    end
-
-    it 'returns commit report' do
-      expect(subject).to eq commit_report
-    end
-
-  end
-
-  describe "preview" do
-    let(:plugin) { described_class.new(task, nil, nil, page_builder) }
-    let(:task) do
-      {
-        jql: jql,
-        attributes: {"project.key" => "string"}
-      }
-    end
-    let(:page_builder) { double("page_builder") }
-    let(:jira_api) { Embulk::Input::JiraApi::Client.new }
-    let(:jira_issues) { [Embulk::Input::JiraApi::Issue.new(attributes)] }
-    let(:username) { "jira-user" }
-    let(:attributes) do
-      {
-        "id" => "100",
-        "jira_key" => "FOO-100",
-        "fields" =>
-        {
-          "project" => {
-            "name" => project_name,
-            "key" => project_name,
-          },
-          "comment" => {
-            "total" => 0,
-            "comments" => []
-          }
-        }
-      }
-    end
-
-
-    subject { plugin.run }
-
-    before do
-      allow(Embulk::Input::JiraApi::Client).to receive(:setup).and_return(jira_api)
-      allow(plugin).to receive(:logger).and_return(::Logger.new(File::NULL))
-      allow(plugin).to receive(:preview?).and_return(true)
-      allow(jira_api).to receive(:check_user_credential).and_return(username)
-      allow(jira_api).to receive(:search_issues).and_return(jira_issues)
-      allow(page_builder).to receive(:add)
-      allow(page_builder).to receive(:finish)
-    end
-
-    it "max_results with PREVIEW_RECORDS_COUNT" do
-      expect(jira_api).to receive(:search_issues).with(jql, max_results: Embulk::Input::Jira::PREVIEW_RECORDS_COUNT)
-      subject
-    end
-
-    it "call page_builder.add and page_builder.finish" do
-      expect(page_builder).to receive(:add).exactly(jira_issues.length).times
-      expect(page_builder).to receive(:finish)
-      subject
-    end
-  end
-
-  describe ".logger" do
-    let(:logger) { described_class.logger }
-
-    subject { logger }
-
-    it { is_expected.to be_a(Embulk::Logger) }
-  end
-
-  describe "#logger" do
-    let(:instance) { described_class.new({}, nil, nil, nil) }
-    let(:logger) { instance.logger }
-
-    subject { logger }
-
-    it { is_expected.to be_a(Embulk::Logger) }
-  end
-end

data/spec/embulk_spec.rb

@@ -1,32 +0,0 @@
-require "spec_helper"
-
-describe Embulk do
-  describe "registerd jira as input plugin" do
-    let(:config) { <<-YAML }
-in:
-  type: jira
-    YAML
-    let(:config_file) { Tempfile.new("embulk-conf") }
-
-    before do
-      config_file.puts config
-      config_file.close
-      allow(org.embulk.spi.Exec).to receive(:isPreview).and_return(true)
-    end
-
-    subject {
-      capture(:out) do
-        # Skip this test because `embulk_run` has been removed
-        # Embulk.run ["preview", config_file.path]
-      end
-    }
-
-    it do
-      # NOTE: can't stub `exit` so stubbing `raise`
-      # https://github.com/embulk/embulk/blob/v0.6.9/lib/embulk/command/embulk_run.rb#L335
-      allow(Embulk).to receive(:raise)
-
-      is_expected.to_not include("InputPlugin 'jira' is not found.")
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,26 +0,0 @@
-require "rubygems"
-require "bundler/setup"
-
-Bundler.require(:runtime, :development)
-
-require "embulk"
-Embulk.setup
-
-Dir["./spec/support/**/*.rb"].each{|file| require file }
-
-if ENV["COVERAGE"]
-  if ENV["CI"]
-    require "codeclimate-test-reporter"
-    CodeClimate::TestReporter.start
-  else
-    require 'simplecov'
-    SimpleCov.start 'test_frameworks'
-  end
-end
-
-$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
-require "embulk/input/jira"
-
-RSpec.configure do |config|
-  config.include StdoutAndErrCapture
-end

data/spec/support/stdout_and_err_capture.rb

@@ -1,45 +0,0 @@
-module StdoutAndErrCapture
-  def capture(output = :out, &block)
-    _, out = swap_io(output, &block)
-    out
-  end
-
-  def silence(&block)
-    block_result = nil
-    swap_io(:out) do
-      block_result,_ = swap_io(:err, &block)
-    end
-    block_result
-  end
-
-  def swap_io(output = :out, &block)
-    java_import 'java.io.PrintStream'
-    java_import 'java.io.ByteArrayOutputStream'
-    java_import 'java.lang.System'
-
-    ruby_original_stream = output == :out ? $stdout.dup : $stderr.dup
-    java_original_stream = System.send(output) # :out or :err
-    ruby_buf = StringIO.new
-    java_buf = ByteArrayOutputStream.new
-
-    case output
-    when :out
-      $stdout = ruby_buf
-      System.setOut(PrintStream.new(java_buf))
-    when :err
-      $stderr = ruby_buf
-      System.setErr(PrintStream.new(java_buf))
-    end
-
-    [block.call, ruby_buf.string + java_buf.toString]
-  ensure
-    case output
-    when :out
-      $stdout = ruby_original_stream
-      System.setOut(java_original_stream)
-    when :err
-      $stderr = ruby_original_stream
-      System.setErr(java_original_stream)
-    end
-  end
-end