Merge pull request ManageIQ#195 from grosser/grosser/exception

move exception into Kubeclient namespace
# Conflicts:
#	README.md
#	lib/kubeclient/common.rb

README.md

@@ -154,7 +154,7 @@ You can find information about tokens in [this guide](http://kubernetes.io/docs/
 
 ### Non-blocking IO
 
-You can also use kubeclient with non-blocking sockets such as Celluloid::IO, see [here](https://github.com/httprb/http/wiki/Parallel-requests-with-Celluloid%3A%3AIO) 
+You can also use kubeclient with non-blocking sockets such as Celluloid::IO, see [here](https://github.com/httprb/http/wiki/Parallel-requests-with-Celluloid%3A%3AIO)
 for details. For example:
 
 ```ruby
@@ -460,6 +460,10 @@ client.process_template template
 
 ## Upgrading
 
+#### past version 2.0
+
+Replace `KubeException` with `Kubeclient::HttpException`
+
 #### past version 1.2.0
 Replace Specific Entity class references:
 

lib/kubeclient.rb

@@ -2,7 +2,7 @@
 require 'json'
 require 'rest-client'
 require 'kubeclient/entity_list'
-require 'kubeclient/kube_exception'
+require 'kubeclient/http_error'
 require 'kubeclient/watch_notice'
 require 'kubeclient/watch_stream'
 require 'kubeclient/common'

lib/kubeclient/common.rb

@@ -114,7 +114,7 @@ def handle_exception
         {}
       end
       err_message = json_error_msg['message'] || e.message
-      raise KubeException.new(e.http_code, err_message, e.response)
+      raise Kubeclient::HttpError.new(e.http_code, err_message, e.response)
     end
 
     def discover
@@ -370,7 +370,7 @@ def all_entities(options = {})
         method_name = "get_#{entity.method_names[1]}"
         begin
           result_hash[entity.method_names[0]] = send(method_name, options)
-        rescue KubeException
+        rescue Kubeclient::HttpError
           next # do not fail due to resources not supporting get
         end
       end

lib/kubeclient/kube_exception.rb → lib/kubeclient/http_error.rb

@@ -1,4 +1,5 @@
-# Kubernetes HTTP Exceptions
+# TODO: remove this on next major version bump
+# Deprected http exception
 class KubeException < StandardError
   attr_reader :error_code, :message, :response
 
@@ -16,3 +17,9 @@ def to_s
     string
   end
 end
+
+module Kubeclient
+  # Exception that is raised when a http request fails
+  class HttpError < KubeException
+  end
+end

lib/kubeclient/watch_stream.rb

@@ -17,7 +17,7 @@ def each
         @http_client = build_client
         response = @http_client.request(:get, @uri, build_client_options)
         unless response.code < 300
-          raise KubeException.new(response.code, response.reason, response)
+          raise Kubeclient::HttpError.new(response.code, response.reason, response)
         end
 
         buffer = ''

test/test_config.rb

@@ -1,31 +1,27 @@
 require 'test_helper'
 
-def test_config_file(name)
-  File.new(File.join(File.dirname(__FILE__), 'config', name))
-end
-
 # Testing Kubernetes client configuration
-class KubeClientConfigTest < MiniTest::Test
+class KubeclientConfigTest < MiniTest::Test
   def test_allinone
-    config = Kubeclient::Config.read(test_config_file('allinone.kubeconfig'))
+    config = Kubeclient::Config.read(config_file('allinone.kubeconfig'))
     assert_equal(['default/localhost:8443/system:admin'], config.contexts)
     check_context(config.context, ssl: true)
   end
 
   def test_external
-    config = Kubeclient::Config.read(test_config_file('external.kubeconfig'))
+    config = Kubeclient::Config.read(config_file('external.kubeconfig'))
     assert_equal(['default/localhost:8443/system:admin'], config.contexts)
     check_context(config.context, ssl: true)
   end
 
   def test_nouser
-    config = Kubeclient::Config.read(test_config_file('nouser.kubeconfig'))
+    config = Kubeclient::Config.read(config_file('nouser.kubeconfig'))
     assert_equal(['default/localhost:8443/nouser'], config.contexts)
     check_context(config.context, ssl: false)
   end
 
   def test_user_token
-    config = Kubeclient::Config.read(test_config_file('userauth.kubeconfig'))
+    config = Kubeclient::Config.read(config_file('userauth.kubeconfig'))
     assert_equal(['localhost/system:admin:token', 'localhost/system:admin:userpass'],
                  config.contexts)
     context = config.context('localhost/system:admin:token')
@@ -34,7 +30,7 @@ def test_user_token
   end
 
   def test_user_password
-    config = Kubeclient::Config.read(test_config_file('userauth.kubeconfig'))
+    config = Kubeclient::Config.read(config_file('userauth.kubeconfig'))
     assert_equal(['localhost/system:admin:token', 'localhost/system:admin:userpass'],
                  config.contexts)
     context = config.context('localhost/system:admin:userpass')
@@ -69,4 +65,8 @@ def check_context(context, ssl: true)
       assert_equal(OpenSSL::SSL::VERIFY_NONE, context.ssl_options[:verify_ssl])
     end
   end
+
+  def config_file(name)
+    File.new(File.join(File.dirname(__FILE__), 'config', name))
+  end
 end

test/test_guestbook_go.rb

@@ -45,8 +45,8 @@ def test_create_guestbook_entities
 
   def delete_namespace(client, namespace_name)
     client.delete_namespace(namespace_name)
-  rescue KubeException => exception
-    assert_instance_of(KubeException, exception)
+  rescue Kubeclient::HttpError => exception
+    assert_instance_of(Kubeclient::HttpError, exception)
     assert_equal(404, exception.error_code)
   end
 
@@ -89,8 +89,8 @@ def delete_services(client, namespace, services)
           # it's just a string - service name
           client.delete_service(service, namespace)
         end
-      rescue KubeException => exception
-        assert_instance_of(KubeException, exception)
+      rescue Kubeclient::HttpError => exception
+        assert_instance_of(Kubeclient::HttpError, exception)
         assert_equal(404, exception.error_code)
       end
     end
@@ -106,8 +106,8 @@ def delete_replication_controllers(client, namespace, replication_controllers)
           # it's just a string - rc name
           client.delete_replication_controller(rc, namespace)
         end
-      rescue KubeException => exception
-        assert_instance_of(KubeException, exception)
+      rescue Kubeclient::HttpError => exception
+        assert_instance_of(Kubeclient::HttpError, exception)
         assert_equal(404, exception.error_code)
       end
     end

test/test_kubeclient.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 # Kubernetes client entity tests
-class KubeClientTest < MiniTest::Test
+class KubeclientTest < MiniTest::Test
   def test_json
     our_object = Kubeclient::Resource.new
     our_object.foo = 'bar'
@@ -71,18 +71,30 @@ def test_exception
 
     client = Kubeclient::Client.new('http://localhost:8080/api/')
 
-    exception = assert_raises(KubeException) do
+    exception = assert_raises(Kubeclient::HttpError) do
       service = client.create_service(service)
     end
 
-    assert_instance_of(KubeException, exception)
+    assert_instance_of(Kubeclient::HttpError, exception)
     assert_equal("converting  to : type names don't match (Pod, Namespace)",
                  exception.message)
 
     assert_includes(exception.to_s, ' for POST http://localhost:8080/api')
     assert_equal(409, exception.error_code)
   end
 
+  def test_deprecated_exception
+    error_message = 'certificate verify failed'
+
+    stub_request(:get, 'http://localhost:8080/api')
+      .to_raise(OpenSSL::SSL::SSLError.new(error_message))
+
+    client = Kubeclient::Client.new('http://localhost:8080/api/')
+
+    exception = assert_raises(KubeException) { client.api }
+    assert_equal(error_message, exception.message)
+  end
+
   def test_api
     stub_request(:get, 'http://localhost:8080/api')
       .to_return(status: 200, body: open_test_file('versions_list.json'))
@@ -100,7 +112,7 @@ def test_api_ssl_failure
 
     client = Kubeclient::Client.new('http://localhost:8080/api/')
 
-    exception = assert_raises(KubeException) { client.api }
+    exception = assert_raises(Kubeclient::HttpError) { client.api }
     assert_equal(error_message, exception.message)
   end
 
@@ -154,7 +166,7 @@ def test_api_valid_with_bad_endpoint
       .to_return(status: [404, 'Resource Not Found'])
 
     client = Kubeclient::Client.new('http://localhost:8080/api/')
-    assert_raises(KubeException) { client.api_valid? }
+    assert_raises(Kubeclient::HttpError) { client.api_valid? }
   end
 
   def test_api_valid_with_non_json
@@ -173,11 +185,11 @@ def test_nonjson_exception
 
     client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
 
-    exception = assert_raises(KubeException) do
+    exception = assert_raises(Kubeclient::HttpError) do
       client.get_services
     end
 
-    assert_instance_of(KubeException, exception)
+    assert_instance_of(Kubeclient::HttpError, exception)
     assert(exception.message.include?('Not Found'))
     assert_equal(404, exception.error_code)
   end
@@ -491,14 +503,14 @@ def test_api_bearer_token_failure
 
     stub_request(:get, 'http://localhost:8080/api/v1')
       .with(headers: { Authorization: 'Bearer invalid_token' })
-      .to_raise(KubeException.new(403, error_message, response))
+      .to_raise(Kubeclient::HttpError.new(403, error_message, response))
 
     client = Kubeclient::Client.new(
       'http://localhost:8080/api/',
       auth_options: { bearer_token: 'invalid_token' }
     )
 
-    exception = assert_raises(KubeException) { client.get_pods }
+    exception = assert_raises(Kubeclient::HttpError) { client.get_pods }
     assert_equal(403, exception.error_code)
     assert_equal(error_message, exception.message)
     assert_equal(response, exception.response)
@@ -570,14 +582,14 @@ def test_api_basic_auth_failure
     response = OpenStruct.new(code: 401, message: '401 Unauthorized')
 
     stub_request(:get, 'http://username:password@localhost:8080/api/v1')
-      .to_raise(KubeException.new(401, error_message, response))
+      .to_raise(Kubeclient::HttpError.new(401, error_message, response))
 
     client = Kubeclient::Client.new(
       'http://localhost:8080/api/',
       auth_options: { username: 'username', password: 'password' }
     )
 
-    exception = assert_raises(KubeException) { client.get_pods }
+    exception = assert_raises(Kubeclient::HttpError) { client.get_pods }
     assert_equal(401, exception.error_code)
     assert_equal(error_message, exception.message)
     assert_equal(response, exception.response)

test/test_missing_methods.rb

@@ -31,11 +31,11 @@ def test_missing
       status: 404
     ) # If discovery fails we expect the below raise an exception
     client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    assert_raises(KubeException) do
+    assert_raises(Kubeclient::HttpError) do
       client.method(:get_pods)
     end
     client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    assert_raises(KubeException) do
+    assert_raises(Kubeclient::HttpError) do
       client.respond_to?(:get_pods)
     end
   end

test/test_service.rb

@@ -185,7 +185,7 @@ def test_get_service_no_ns
 
     client = Kubeclient::Client.new('http://localhost:8080/api/')
 
-    exception = assert_raises(KubeException) do
+    exception = assert_raises(Kubeclient::HttpError) do
       client.get_service('redis-slave')
     end
     assert_equal(404, exception.error_code)

test/test_watch.rb

@@ -36,7 +36,7 @@ def test_watch_pod_failure
     stub_request(:get, %r{.*\/watch/pods}).to_return(status: 404)
 
     client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    assert_raises(KubeException) do
+    assert_raises(Kubeclient::HttpError) do
       client.watch_pods.each do
       end
     end