codeclimate-services 1.6.1 → 1.7.0

data/{test/gitlab_merge_requests_test.rb → spec/cc/service/gitlab_merge_requests_spec.rb}

@@ -1,7 +1,5 @@
-require File.expand_path('../helper', __FILE__)
-
-class TestGitlabMergeRequests < CC::Service::TestCase
-  def test_merge_request_status_pending
+describe CC::Service::GitlabMergeRequests, type: :service do
+  it "merge request status pending" do
     expect_status_update(
       "hal/hal9000",
       "abc123",
@@ -17,7 +15,7 @@ class TestGitlabMergeRequests < CC::Service::TestCase
     )
   end
 
-  def test_merge_request_status_success_detailed
+  it "merge request status success detailed" do
     expect_status_update(
       "hal/hal9000",
       "abc123",
@@ -33,7 +31,7 @@ class TestGitlabMergeRequests < CC::Service::TestCase
     )
   end
 
-  def test_merge_request_status_failure
+  it "merge request status failure" do
     expect_status_update(
       "hal/hal9000",
       "abc123",
@@ -49,7 +47,7 @@ class TestGitlabMergeRequests < CC::Service::TestCase
     )
   end
 
-  def test_merge_request_status_error
+  it "merge request status error" do
     expect_status_update(
       "hal/hal9000",
       "abc123",
@@ -66,7 +64,7 @@ class TestGitlabMergeRequests < CC::Service::TestCase
     )
   end
 
-  def test_merge_request_status_error_message_provided
+  it "merge request status error message provided" do
     expect_status_update(
       "hal/hal9000",
       "abc123",
@@ -83,7 +81,7 @@ class TestGitlabMergeRequests < CC::Service::TestCase
     )
   end
 
-  def test_merge_request_status_skipped
+  it "merge request status skipped" do
     expect_status_update(
       "hal/hal9000",
       "abc123",
@@ -99,7 +97,7 @@ class TestGitlabMergeRequests < CC::Service::TestCase
     )
   end
 
-  def test_merge_request_coverage_status_success
+  it "merge request coverage status success" do
     expect_status_update(
       "hal/hal9000",
       "abc123",
@@ -117,71 +115,68 @@ class TestGitlabMergeRequests < CC::Service::TestCase
     )
   end
 
-  def test_merge_request_status_test_success
-    @stubs.post("api/v3/projects/hal%2Fhal9000/statuses/#{"0" * 40}") { |env| [404, {}, ""] }
+  it "merge request status test success" do
+    http_stubs.post("api/v3/projects/hal%2Fhal9000/statuses/#{"0" * 40}") { |_env| [404, {}, ""] }
 
-    assert receive_test({}, { git_url: "ssh://git@gitlab.com/hal/hal9000.git" })[:ok], "Expected test of pull request to be true"
+    expect(receive_test({}, git_url: "ssh://git@gitlab.com/hal/hal9000.git")[:ok]).to eq(true)
   end
 
-  def test_merge_request_status_test_failure
-    @stubs.post("api/v3/projects/hal%2Fhal9000/statuses/#{"0" * 40}") { |env| [401, {}, ""] }
+  it "merge request status test failure" do
+    http_stubs.post("api/v3/projects/hal%2Fhal9000/statuses/#{"0" * 40}") { |_env| [401, {}, ""] }
 
-    assert_raises(CC::Service::HTTPError) do
-      receive_test({}, { git_url: "ssh://git@gitlab.com/hal/hal9000.git" })
-    end
+    expect { receive_test({}, git_url: "ssh://git@gitlab.com/hal/hal9000.git") }.to raise_error(CC::Service::HTTPError)
   end
 
-  def test_merge_request_unknown_state
-    response = receive_merge_request({}, { state: "unknown" })
+  it "merge request unknown state" do
+    response = receive_merge_request({}, state: "unknown")
 
-    assert_equal({ ok: false, message: "Unknown state" }, response)
+    expect({ ok: false, message: "Unknown state" }).to eq(response)
   end
 
-  def test_different_base_url
-    @stubs.post("api/v3/projects/hal%2Fhal9000/statuses/#{"0" * 40}") do |env|
-      assert env[:url].to_s == "https://gitlab.hal.org/api/v3/projects/hal%2Fhal9000/statuses/#{"0" * 40}"
+  it "different base url" do
+    http_stubs.post("api/v3/projects/hal%2Fhal9000/statuses/#{"0" * 40}") do |env|
+      expect(env[:url].to_s).to eq("https://gitlab.hal.org/api/v3/projects/hal%2Fhal9000/statuses/#{"0" * 40}")
       [404, {}, ""]
     end
 
-    assert receive_test({ base_url: "https://gitlab.hal.org" }, { git_url: "ssh://git@gitlab.com/hal/hal9000.git" })[:ok], "Expected test of pull request to be true"
+    expect(receive_test({ base_url: "https://gitlab.hal.org" }, git_url: "ssh://git@gitlab.com/hal/hal9000.git")[:ok]).to eq(true)
   end
 
   private
 
   def expect_status_update(repo, commit_sha, params)
-    @stubs.post "api/v3/projects/#{CGI.escape(repo)}/statuses/#{commit_sha}" do |env|
-      assert_equal "123", env[:request_headers]["PRIVATE-TOKEN"]
+    http_stubs.post "api/v3/projects/#{CGI.escape(repo)}/statuses/#{commit_sha}" do |env|
+      expect(env[:request_headers]["PRIVATE-TOKEN"]).to eq("123")
 
       body = JSON.parse(env[:body])
 
       params.each do |k, v|
-        assert v === body[k],
-          "Unexpected value for #{k}. #{v.inspect} !== #{body[k].inspect}"
+        expect(v).to match(body[k])
       end
     end
   end
 
   def receive_merge_request(config, event_data)
-    receive(
+    service_receive(
       CC::Service::GitlabMergeRequests,
       { access_token: "123" }.merge(config),
-      { name: "pull_request", issue_comparison_counts: {'fixed' => 1, 'new' => 2} }.merge(event_data)
+      { name: "pull_request", issue_comparison_counts: { "fixed" => 1, "new" => 2 } }.merge(event_data),
     )
   end
 
   def receive_merge_request_coverage(config, event_data)
-    receive(
+    service_receive(
       CC::Service::GitlabMergeRequests,
       { access_token: "123" }.merge(config),
-      { name: "pull_request_coverage", issue_comparison_counts: {'fixed' => 1, 'new' => 2} }.merge(event_data)
+      { name: "pull_request_coverage", issue_comparison_counts: { "fixed" => 1, "new" => 2 } }.merge(event_data),
     )
   end
 
   def receive_test(config, event_data = {})
-    receive(
+    service_receive(
       CC::Service::GitlabMergeRequests,
       { oauth_token: "123" }.merge(config),
-      { name: "test", issue_comparison_counts: {'fixed' => 1, 'new' => 2} }.merge(event_data)
+      { name: "test", issue_comparison_counts: { "fixed" => 1, "new" => 2 } }.merge(event_data),
     )
   end
 end

data/{test/hipchat_test.rb → spec/cc/service/hipchat_spec.rb}

@@ -1,62 +1,60 @@
-require File.expand_path('../helper', __FILE__)
-
-class TestHipChat < CC::Service::TestCase
-  def test_test_hook
+describe CC::Service::HipChat, type: :service do
+  it "test hook" do
     assert_hipchat_receives(
       "green",
       { name: "test", repo_name: "Rails" },
-      "[Rails] This is a test of the HipChat service hook"
+      "[Rails] This is a test of the HipChat service hook",
     )
   end
 
-  def test_coverage_improved
+  it "coverage improved" do
     e = event(:coverage, to: 90.2, from: 80)
 
     assert_hipchat_receives("green", e, [
       "[Example]",
       "<a href=\"https://codeclimate.com/repos/1/feed\">Test coverage</a>",
       "has improved to 90.2% (+10.2%)",
-      "(<a href=\"https://codeclimate.com/repos/1/compare\">Compare</a>)"
+      "(<a href=\"https://codeclimate.com/repos/1/compare\">Compare</a>)",
     ].join(" "))
   end
 
-  def test_coverage_declined
+  it "coverage declined" do
     e = event(:coverage, to: 88.6, from: 94.6)
 
     assert_hipchat_receives("red", e, [
       "[Example]",
       "<a href=\"https://codeclimate.com/repos/1/feed\">Test coverage</a>",
       "has declined to 88.6% (-6.0%)",
-      "(<a href=\"https://codeclimate.com/repos/1/compare\">Compare</a>)"
+      "(<a href=\"https://codeclimate.com/repos/1/compare\">Compare</a>)",
     ].join(" "))
   end
 
-  def test_quality_improved
+  it "quality improved" do
     e = event(:quality, to: "A", from: "B")
 
     assert_hipchat_receives("green", e, [
       "[Example]",
       "<a href=\"https://codeclimate.com/repos/1/feed\">User</a>",
       "has improved from a B to an A",
-      "(<a href=\"https://codeclimate.com/repos/1/compare\">Compare</a>)"
+      "(<a href=\"https://codeclimate.com/repos/1/compare\">Compare</a>)",
     ].join(" "))
   end
 
-  def test_quality_declined_without_compare_url
+  it "quality declined without compare url" do
     e = event(:quality, to: "D", from: "C")
 
     assert_hipchat_receives("red", e, [
       "[Example]",
       "<a href=\"https://codeclimate.com/repos/1/feed\">User</a>",
       "has declined from a C to a D",
-      "(<a href=\"https://codeclimate.com/repos/1/compare\">Compare</a>)"
+      "(<a href=\"https://codeclimate.com/repos/1/compare\">Compare</a>)",
     ].join(" "))
   end
 
-  def test_single_vulnerability
+  it "single vulnerability" do
     e = event(:vulnerability, vulnerabilities: [
-      { "warning_type" => "critical" }
-    ])
+                { "warning_type" => "critical" },
+              ])
 
     assert_hipchat_receives("red", e, [
       "[Example]",
@@ -65,11 +63,11 @@ class TestHipChat < CC::Service::TestCase
     ].join(" "))
   end
 
-  def test_single_vulnerability_with_location
+  it "single vulnerability with location" do
     e = event(:vulnerability, vulnerabilities: [{
-      "warning_type" => "critical",
-      "location" => "app/user.rb line 120"
-    }])
+                "warning_type" => "critical",
+                "location" => "app/user.rb line 120",
+              }])
 
     assert_hipchat_receives("red", e, [
       "[Example]",
@@ -78,14 +76,14 @@ class TestHipChat < CC::Service::TestCase
     ].join(" "))
   end
 
-  def test_multiple_vulnerabilities
+  it "multiple vulnerabilities" do
     e = event(:vulnerability, warning_type: "critical", vulnerabilities: [{
-      "warning_type" => "unused",
-      "location" => "unused"
-    }, {
-      "warning_type" => "unused",
-      "location" => "unused"
-    }])
+                "warning_type" => "unused",
+                "location" => "unused",
+              }, {
+                "warning_type" => "unused",
+                "location" => "unused",
+              }])
 
     assert_hipchat_receives("red", e, [
       "[Example]",
@@ -94,37 +92,37 @@ class TestHipChat < CC::Service::TestCase
     ].join(" "))
   end
 
-  def test_receive_test
-    @stubs.post '/v1/rooms/message' do |env|
-      [200, {}, '']
+  it "receive test" do
+    http_stubs.post "/v1/rooms/message" do |_env|
+      [200, {}, ""]
     end
 
     response = receive_event(name: "test")
 
-    assert_equal "Test message sent", response[:message]
+    expect(response[:message]).to eq("Test message sent")
   end
 
   private
 
   def assert_hipchat_receives(color, event_data, expected_body)
-    @stubs.post '/v1/rooms/message' do |env|
+    http_stubs.post "/v1/rooms/message" do |env|
       body = Hash[URI.decode_www_form(env[:body])]
-      assert_equal "token", body["auth_token"]
-      assert_equal "123", body["room_id"]
-      assert_equal "true", body["notify"]
-      assert_equal color, body["color"]
-      assert_equal expected_body, body["message"]
-      [200, {}, '']
+      expect(body["auth_token"]).to eq("token")
+      expect(body["room_id"]).to eq("123")
+      expect(body["notify"]).to eq("true")
+      expect(body["color"]).to eq(color)
+      expect(body["message"]).to eq(expected_body)
+      [200, {}, ""]
     end
 
     receive_event(event_data)
   end
 
   def receive_event(event_data = nil)
-    receive(
+    service_receive(
       CC::Service::HipChat,
       { auth_token: "token", room_id: "123", notify: true },
-      event_data || event(:quality, from: "C", to: "D")
+      event_data || event(:quality, from: "C", to: "D"),
     )
   end
 end

data/spec/cc/service/invocation/error_handling_spec.rb

@@ -0,0 +1,49 @@
+describe CC::Service::Invocation::WithErrorHandling do
+  it "success returns upstream result" do
+    handler = CC::Service::Invocation::WithErrorHandling.new(
+      -> { :success },
+      FakeLogger.new,
+      "not important",
+    )
+
+    expect(handler.call).to eq(:success)
+  end
+
+  it "http errors return relevant data" do
+    logger = FakeLogger.new
+    env = {
+      status: 401,
+      params: "params",
+      url: "url",
+    }
+
+    handler = CC::Service::Invocation::WithErrorHandling.new(
+      -> { raise CC::Service::HTTPError.new("foo", env) },
+      logger,
+      "prefix",
+    )
+
+    result = handler.call
+    expect(result[:ok]).to eq(false)
+    expect(result[:status]).to eq(401)
+    expect(result[:params]).to eq("params")
+    expect(result[:endpoint_url]).to eq("url")
+    expect(result[:message]).to eq("foo")
+    expect(result[:log_message]).to eq("Exception invoking service: [prefix] (CC::Service::HTTPError) foo. Response: <nil>")
+  end
+
+  it "error returns a hash with explanations" do
+    logger = FakeLogger.new
+
+    handler = CC::Service::Invocation::WithErrorHandling.new(
+      -> { raise ArgumentError, "lol" },
+      logger,
+      "prefix",
+    )
+
+    result = handler.call
+    expect(result[:ok]).to eq(false)
+    expect(result[:message]).to eq("lol")
+    expect(result[:log_message]).to eq("Exception invoking service: [prefix] (ArgumentError) lol")
+  end
+end

data/spec/cc/service/invocation/return_values_spec.rb

@@ -0,0 +1,19 @@
+describe CC::Service::Invocation::WithReturnValues do
+  it "success returns upstream result" do
+    handler = CC::Service::Invocation::WithReturnValues.new(
+      -> { :return_value },
+      "error message",
+    )
+
+    expect(handler.call).to eq(:return_value)
+  end
+
+  it "empty results returns hash" do
+    handler = CC::Service::Invocation::WithReturnValues.new(
+      -> { nil },
+      "error message",
+    )
+
+    expect({ ok: false, message: "error message" }).to eq(handler.call)
+  end
+end

data/spec/cc/service/invocation/with_metrics_spec.rb

@@ -0,0 +1,18 @@
+describe CC::Service::Invocation::WithMetrics, type: :service do
+  class FakeInvocation
+    def call
+      raise CC::Service::HTTPError.new("Whoa", {})
+    end
+  end
+
+  it "statsd error key" do
+    statsd = double(:statsd)
+    allow(statsd).to receive(:timing)
+    expect(statsd).to receive(:increment).with("services.errors.githubpullrequests.cc-service-http_error")
+    begin
+      CC::Service::Invocation::WithMetrics.new(FakeInvocation.new, statsd, "githubpullrequests").call
+    rescue CC::Service::HTTPError
+      #noop
+    end
+  end
+end

data/{test/invocation_test.rb → spec/cc/service/invocation_spec.rb}

@@ -1,38 +1,36 @@
-require File.expand_path('../helper', __FILE__)
-
-class TestInvocation < Test::Unit::TestCase
-  def test_success
+describe CC::Service::Invocation do
+  it "success" do
     service = FakeService.new(:some_result)
 
     result = CC::Service::Invocation.invoke(service)
 
-    assert_equal 1, service.receive_count
-    assert_equal :some_result, result
+    expect(service.receive_count).to eq(1)
+    expect(result).to eq(:some_result)
   end
 
-  def test_success_with_return_values
+  it "success with return values" do
     service = FakeService.new(:some_result)
 
     result = CC::Service::Invocation.invoke(service) do |i|
       i.with :return_values, "error"
     end
 
-    assert_equal 1, service.receive_count
-    assert_equal :some_result, result
+    expect(service.receive_count).to eq(1)
+    expect(result).to eq(:some_result)
   end
 
-  def test_failure_with_return_values
+  it "failure with return values" do
     service = FakeService.new(nil)
 
     result = CC::Service::Invocation.invoke(service) do |i|
       i.with :return_values, "error"
     end
 
-    assert_equal 1, service.receive_count
-    assert_equal( {ok: false, message: "error"}, result )
+    expect(service.receive_count).to eq(1)
+    expect({ ok: false, message: "error" }).to eq(result)
   end
 
-  def test_retries
+  it "retries" do
     service = FakeService.new
     service.fake_error = RuntimeError.new
     error_occurred = false
@@ -45,22 +43,22 @@ class TestInvocation < Test::Unit::TestCase
       error_occurred = true
     end
 
-    assert error_occurred
-    assert_equal 1 + 3, service.receive_count
+    expect(error_occurred).not_to be_nil
+    expect(service.receive_count).to eq(1 + 3)
   end
 
-  def test_metrics
+  it "metrics" do
     statsd = FakeStatsd.new
 
     CC::Service::Invocation.invoke(FakeService.new) do |i|
       i.with :metrics, statsd, "a_prefix"
     end
 
-    assert_equal 1, statsd.incremented_keys.length
-    assert_equal "services.invocations.a_prefix", statsd.incremented_keys.first
+    expect(statsd.incremented_keys.length).to eq(1)
+    expect(statsd.incremented_keys.first).to eq("services.invocations.a_prefix")
   end
 
-  def test_metrics_on_errors
+  it "metrics on errors" do
     statsd = FakeStatsd.new
     service = FakeService.new
     service.fake_error = RuntimeError.new
@@ -74,12 +72,12 @@ class TestInvocation < Test::Unit::TestCase
       error_occurred = true
     end
 
-    assert error_occurred
-    assert_equal 1, statsd.incremented_keys.length
-    assert_match(/^services\.errors\.a_prefix/, statsd.incremented_keys.first)
+    expect(error_occurred).not_to be_nil
+    expect(statsd.incremented_keys.length).to eq(1)
+    expect(statsd.incremented_keys.first).to match(/^services\.errors\.a_prefix/)
   end
 
-  def test_user_message
+  it "user message" do
     service = FakeService.new
     service.fake_error = CC::Service::HTTPError.new("Boom", {})
     service.override_user_message = "Hey do this"
@@ -89,11 +87,11 @@ class TestInvocation < Test::Unit::TestCase
       i.with :error_handling, logger, "a_prefix"
     end
 
-    assert_equal "Hey do this", result[:message]
-    assert_match(/Boom/, result[:log_message])
+    expect(result[:message]).to eq("Hey do this")
+    expect(result[:log_message]).to match(/Boom/)
   end
 
-  def test_error_handling
+  it "error handling" do
     service = FakeService.new
     service.fake_error = RuntimeError.new("Boom")
     logger = FakeLogger.new
@@ -102,12 +100,12 @@ class TestInvocation < Test::Unit::TestCase
       i.with :error_handling, logger, "a_prefix"
     end
 
-    assert_equal({ok: false, message: "Boom", log_message: "Exception invoking service: [a_prefix] (RuntimeError) Boom"}, result)
-    assert_equal 1, logger.logged_errors.length
-    assert_match(/^Exception invoking service: \[a_prefix\]/, logger.logged_errors.first)
+    expect({ ok: false, message: "Boom", log_message: "Exception invoking service: [a_prefix] (RuntimeError) Boom" }).to eq(result)
+    expect(logger.logged_errors.length).to eq(1)
+    expect(logger.logged_errors.first).to match(/^Exception invoking service: \[a_prefix\]/)
   end
 
-  def test_multiple_middleware
+  it "multiple middleware" do
     service = FakeService.new
     service.fake_error = RuntimeError.new("Boom")
     logger = FakeLogger.new
@@ -117,9 +115,9 @@ class TestInvocation < Test::Unit::TestCase
       i.with :error_handling, logger
     end
 
-    assert_equal({ok: false, message: "Boom", log_message: "Exception invoking service: (RuntimeError) Boom"}, result)
-    assert_equal 1 + 3, service.receive_count
-    assert_equal 1, logger.logged_errors.length
+    expect({ ok: false, message: "Boom", log_message: "Exception invoking service: (RuntimeError) Boom" }).to eq(result)
+    expect(service.receive_count).to eq(1 + 3)
+    expect(logger.logged_errors.length).to eq(1)
   end
 
   private
@@ -163,5 +161,4 @@ class TestInvocation < Test::Unit::TestCase
     def timing(key, value)
     end
   end
-
 end