kubeclient 0.3.0 → 4.9.2

data/test/json/service_b3.json

@@ -1,33 +0,0 @@
-{
-    "kind": "Service",
-    "apiVersion": "v1beta3",
-    "metadata": {
-        "name": "redis-slave",
-        "namespace": "development",
-        "selfLink": "/api/v1beta3/namespaces/development/services/redis-slave",
-        "uid": "bdb80a8f-db93-11e4-b293-f8b156af4ae1",
-        "resourceVersion": "2815",
-        "creationTimestamp": "2015-04-05T13:00:31Z",
-        "labels": {
-            "name": "redis",
-            "role": "slave"
-        }
-    },
-    "spec": {
-        "ports": [
-            {
-                "name": "",
-                "protocol": "TCP",
-                "port": 6379,
-                "targetPort": "redis-server"
-            }
-        ],
-        "selector": {
-            "name": "redis",
-            "role": "slave"
-        },
-        "portalIP": "10.0.0.140",
-        "sessionAffinity": "None"
-    },
-    "status": {}
-}

data/test/json/service_illegal_json_404.json

@@ -1 +0,0 @@
-404: Page Not Found

data/test/json/service_list_b3.json

@@ -1,97 +0,0 @@
-{
-    "kind": "ServiceList",
-    "apiVersion": "v1beta3",
-    "metadata": {
-        "selfLink": "/api/v1beta3/services",
-        "resourceVersion": "36727"
-    },
-    "items": [
-        {
-            "metadata": {
-                "name": "kubernetes",
-                "namespace": "default",
-                "selfLink": "/api/v1beta3/namespaces/default/services/kubernetes",
-                "uid": "b6606490-db86-11e4-b293-f8b156af4ae1",
-                "resourceVersion": "6",
-                "creationTimestamp": "2015-04-05T11:27:15Z",
-                "labels": {
-                    "component": "apiserver",
-                    "provider": "kubernetes"
-                }
-            },
-            "spec": {
-                "ports": [
-                    {
-                        "name": "",
-                        "protocol": "TCP",
-                        "port": 443,
-                        "targetPort": 443
-                    }
-                ],
-                "selector": null,
-                "portalIP": "10.0.0.2",
-                "sessionAffinity": "None"
-            },
-            "status": {}
-        },
-        {
-            "metadata": {
-                "name": "kubernetes-ro",
-                "namespace": "default",
-                "selfLink": "/api/v1beta3/namespaces/default/services/kubernetes-ro",
-                "uid": "b6606694-db86-11e4-b293-f8b156af4ae1",
-                "resourceVersion": "5",
-                "creationTimestamp": "2015-04-05T11:27:15Z",
-                "labels": {
-                    "component": "apiserver",
-                    "provider": "kubernetes"
-                }
-            },
-            "spec": {
-                "ports": [
-                    {
-                        "name": "",
-                        "protocol": "TCP",
-                        "port": 80,
-                        "targetPort": 80
-                    }
-                ],
-                "selector": null,
-                "portalIP": "10.0.0.1",
-                "sessionAffinity": "None"
-            },
-            "status": {}
-        },
-        {
-            "metadata": {
-                "name": "redis-slave",
-                "namespace": "development",
-                "selfLink": "/api/v1beta3/namespaces/development/services/redis-slave",
-                "uid": "bdb80a8f-db93-11e4-b293-f8b156af4ae1",
-                "resourceVersion": "2815",
-                "creationTimestamp": "2015-04-05T13:00:31Z",
-                "labels": {
-                    "name": "redis",
-                    "role": "slave"
-                }
-            },
-            "spec": {
-                "ports": [
-                    {
-                        "name": "",
-                        "protocol": "TCP",
-                        "port": 6379,
-                        "targetPort": "redis-server"
-                    }
-                ],
-                "selector": {
-                    "name": "redis",
-                    "role": "slave"
-                },
-                "portalIP": "10.0.0.140",
-                "sessionAffinity": "None"
-            },
-            "status": {}
-        }
-    ]
-}

data/test/json/service_update_b3.json

@@ -1,22 +0,0 @@
-{
-   "status" : {},
-   "kind" : "Service",
-   "apiVersion" : "v1beta3",
-   "spec" : {
-      "ports" : [
-         {
-            "targetPort" : 80,
-            "nodePort" : 0,
-            "port" : 80,
-            "protocol" : "TCP"
-         }
-      ],
-      "portalIP" : "1.2.3.4"
-   },
-   "metadata" : {
-      "name" : "my_service",
-      "creationTimestamp" : null,
-      "namespace" : "default",
-      "resourceVersion" : "2"
-   }
-}

data/test/json/versions_list.json

@@ -1,6 +0,0 @@
-{
-    "versions": [
-        "v1beta3",
-        "v1"
-    ]
-}

data/test/json/watch_stream_b3.json

@@ -1,3 +0,0 @@
-{"type":"ADDED","object":{"kind":"Pod","apiVersion":"v1beta3","metadata":{"name":"php","namespace":"default","selfLink":"/api/v1beta3/pods/php","uid":"e75f2c07-b047-11e4-89e4-525400c903c1","resourceVersion":"1389","creationTimestamp":"2015-02-09T05:39:19-05:00","labels":{"name":"foo"}},"spec":{"volumes":null,"containers":[{"name":"nginx","image":"dockerfile/nginx","ports":[{"hostPort":9090,"containerPort":80,"protocol":"TCP"}],"resources":{},"livenessProbe":{"httpGet":{"path":"/index.html","port":"9090"},"initialDelaySeconds":30},"terminationMessagePath":"/dev/termination-log","imagePullPolicy":"IfNotPresent","capabilities":{}}],"restartPolicy":{"always":{}},"dnsPolicy":"ClusterFirst"},"status":{"phase":"Pending"}}}
-{"type":"MODIFIED","object":{"kind":"Pod","apiVersion":"v1beta3","metadata":{"name":"php","namespace":"default","selfLink":"/api/v1beta3/pods/php","uid":"e75f2c07-b047-11e4-89e4-525400c903c1","resourceVersion":"1390","creationTimestamp":"2015-02-09T05:39:19-05:00","labels":{"name":"foo"}},"spec":{"volumes":null,"containers":[{"name":"nginx","image":"dockerfile/nginx","ports":[{"hostPort":9090,"containerPort":80,"protocol":"TCP"}],"resources":{},"livenessProbe":{"httpGet":{"path":"/index.html","port":"9090"},"initialDelaySeconds":30},"terminationMessagePath":"/dev/termination-log","imagePullPolicy":"IfNotPresent","capabilities":{}}],"restartPolicy":{"always":{}},"dnsPolicy":"ClusterFirst"},"status":{"phase":"Pending","host":"127.0.0.1"}}}
-{"type":"DELETED","object":{"kind":"Pod","apiVersion":"v1beta3","metadata":{"name":"php","namespace":"default","selfLink":"/api/v1beta3/pods/php","uid":"e75f2c07-b047-11e4-89e4-525400c903c1","resourceVersion":"1398","creationTimestamp":"2015-02-09T05:39:19-05:00","labels":{"name":"foo"}},"spec":{"volumes":null,"containers":[{"name":"nginx","image":"dockerfile/nginx","ports":[{"hostPort":9090,"containerPort":80,"protocol":"TCP"}],"resources":{},"livenessProbe":{"httpGet":{"path":"/index.html","port":"9090"},"initialDelaySeconds":30},"terminationMessagePath":"/dev/termination-log","imagePullPolicy":"IfNotPresent","capabilities":{}}],"restartPolicy":{"always":{}},"dnsPolicy":"ClusterFirst"},"status":{"phase":"Pending","host":"127.0.0.1"}}}

data/test/test_helper.rb

@@ -1,4 +0,0 @@
-require 'minitest/autorun'
-require 'webmock/minitest'
-require 'json'
-require 'kubeclient'

data/test/test_kubeclient.rb

@@ -1,407 +0,0 @@
-require 'test_helper'
-
-def open_test_json_file(name)
-  File.new(File.join(File.dirname(__FILE__), 'json', name))
-end
-
-# Kubernetes client entity tests
-class KubeClientTest < MiniTest::Test
-  def test_json
-    our_object = Kubeclient::Service.new
-    our_object.foo = 'bar'
-    our_object.nested = {}
-    our_object.nested.again = {}
-    our_object.nested.again.again = {}
-    our_object.nested.again.again.name = 'aaron'
-
-    expected = { 'foo' => 'bar', 'nested' => { 'again' => { 'again' =>
-                 { 'name' => 'aaron' } } } }
-
-    assert_equal(expected, JSON.parse(JSON.dump(our_object.to_h)))
-  end
-
-  def test_pass_uri
-    # URI::Generic#hostname= was added in ruby 1.9.3 and will automatically
-    # wrap an ipv6 address in []
-    uri = URI::HTTP.build(port: 8080)
-    uri.hostname = 'localhost'
-    client = Kubeclient::Client.new uri
-    rest_client = client.rest_client
-    assert_equal 'http://localhost:8080/api/v1beta3', rest_client.url.to_s
-  end
-
-  def test_no_path_in_uri
-    client = Kubeclient::Client.new 'http://localhost:8080', 'v1beta3'
-    rest_client = client.rest_client
-    assert_equal 'http://localhost:8080/api/v1beta3', rest_client.url.to_s
-  end
-
-  def test_no_version_passed
-    client = Kubeclient::Client.new 'http://localhost:8080'
-    rest_client = client.rest_client
-    assert_equal 'http://localhost:8080/api/v1beta3', rest_client.url.to_s
-  end
-
-  def test_exception
-    stub_request(:post, %r{/services})
-      .to_return(body: open_test_json_file('namespace_exception_b3.json'),
-                 status: 409)
-
-    service = Kubeclient::Service.new
-    service.metadata = {}
-    service.metadata.name = 'redisslave'
-    service.metadata.namespace = 'default'
-    # service.port = 80
-    # service.container_port = 6379
-    # service.protocol = 'TCP'
-
-    client = Kubeclient::Client.new 'http://localhost:8080/api/'
-
-    exception = assert_raises(KubeException) do
-      service = client.create_service service
-    end
-
-    assert_instance_of(KubeException, exception)
-    assert_equal("converting  to : type names don't match (Pod, Namespace)",
-                 exception.message)
-    assert_equal(409, exception.error_code)
-  end
-
-  def test_api
-    stub_request(:get, 'http://localhost:8080/api')
-      .to_return(status: 200, body: open_test_json_file('versions_list.json'))
-
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
-    response = client.api
-    assert_includes(response, 'versions')
-  end
-
-  def test_api_ssl_failure
-    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_valid
-    stub_request(:get, 'http://localhost:8080/api')
-      .to_return(status: 200, body: open_test_json_file('versions_list.json'))
-
-    args = ['http://localhost:8080/api/']
-
-    [nil, 'v1beta3', 'v1'].each do |version|
-      client = Kubeclient::Client.new(*(version ? args + [version] : args))
-      assert client.api_valid?
-    end
-  end
-
-  def test_api_valid_with_invalid_version
-    stub_request(:get, 'http://localhost:8080/api')
-      .to_return(status: 200, body: open_test_json_file('versions_list.json'))
-
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'foobar1'
-    refute client.api_valid?
-  end
-
-  def test_api_valid_with_unreported_versions
-    stub_request(:get, 'http://localhost:8080/api')
-      .to_return(status: 200, body: '{}')
-
-    client = Kubeclient::Client.new 'http://localhost:8080/api/'
-    refute client.api_valid?
-  end
-
-  def test_api_valid_with_invalid_json
-    stub_request(:get, 'http://localhost:8080/api')
-      .to_return(status: 200, body: '[]')
-
-    client = Kubeclient::Client.new 'http://localhost:8080/api/'
-    refute client.api_valid?
-  end
-
-  def test_api_valid_with_bad_endpoint
-    stub_request(:get, 'http://localhost:8080/api')
-      .to_return(status: [404, 'Resource Not Found'])
-
-    client = Kubeclient::Client.new 'http://localhost:8080/api/'
-    assert_raises(KubeException) { client.api_valid? }
-  end
-
-  def test_api_valid_with_non_json
-    stub_request(:get, 'http://localhost:8080/api')
-      .to_return(status: 200, body: '<html></html>')
-
-    client = Kubeclient::Client.new 'http://localhost:8080/api/'
-    assert_raises(JSON::ParserError) { client.api_valid? }
-  end
-
-  def test_nonjson_exception
-    stub_request(:get, %r{/servic})
-      .to_return(body: open_test_json_file('service_illegal_json_404.json'),
-                 status: 404)
-
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
-
-    exception = assert_raises(KubeException) do
-      client.get_services
-    end
-
-    assert_instance_of(KubeException, exception)
-    assert_equal('404 Resource Not Found', exception.message)
-    assert_equal(404, exception.error_code)
-  end
-
-  def test_entity_list
-    stub_request(:get, %r{/services})
-      .to_return(body: open_test_json_file('entity_list_b3.json'),
-                 status: 200)
-
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
-    services = client.get_services
-
-    refute_empty(services)
-    assert_instance_of(Kubeclient::Common::EntityList, services)
-    assert_equal('Service', services.kind)
-    assert_equal(2, services.size)
-    assert_instance_of(Kubeclient::Service, services[0])
-    assert_instance_of(Kubeclient::Service, services[1])
-
-    assert_requested(:get,
-                     'http://localhost:8080/api/v1beta3/services',
-                     times: 1)
-  end
-
-  def test_empty_list
-    stub_request(:get, %r{/pods})
-      .to_return(body: open_test_json_file('empty_pod_list_b3.json'),
-                 status: 200)
-
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
-    pods = client.get_pods
-    assert_instance_of(Kubeclient::Common::EntityList, pods)
-    assert_equal(0, pods.size)
-  end
-
-  def test_get_all
-    stub_request(:get, %r{/services})
-      .to_return(body: open_test_json_file('service_list_b3.json'),
-                 status: 200)
-
-    stub_request(:get, %r{/pods})
-      .to_return(body: open_test_json_file('pod_list_b3.json'),
-                 status: 200)
-
-    stub_request(:get, %r{/nodes})
-      .to_return(body: open_test_json_file('node_list_b3.json'),
-                 status: 200)
-
-    stub_request(:get, %r{/replicationcontrollers})
-      .to_return(body: open_test_json_file('replication_controller_list_' \
-                                    'b3.json'), status: 200)
-
-    stub_request(:get, %r{/events})
-      .to_return(body: open_test_json_file('event_list_b3.json'), status: 200)
-
-    stub_request(:get, %r{/endpoints})
-      .to_return(body: open_test_json_file('endpoint_list_b3.json'),
-                 status: 200)
-
-    stub_request(:get, %r{/namespaces})
-      .to_return(body: open_test_json_file('namespace_list_b3.json'),
-                 status: 200)
-
-    stub_request(:get, %r{/secrets})
-      .to_return(body: open_test_json_file('secret_list_b3.json'),
-                 status: 200)
-
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
-    result = client.all_entities
-    assert_equal(8, result.keys.size)
-    assert_instance_of(Kubeclient::Common::EntityList, result['node'])
-    assert_instance_of(Kubeclient::Common::EntityList, result['service'])
-    assert_instance_of(Kubeclient::Common::EntityList,
-                       result['replication_controller'])
-    assert_instance_of(Kubeclient::Common::EntityList, result['pod'])
-    assert_instance_of(Kubeclient::Common::EntityList, result['event'])
-    assert_instance_of(Kubeclient::Common::EntityList, result['namespace'])
-    assert_instance_of(Kubeclient::Common::EntityList, result['secret'])
-    assert_instance_of(Kubeclient::Service, result['service'][0])
-    assert_instance_of(Kubeclient::Node, result['node'][0])
-    assert_instance_of(Kubeclient::Event, result['event'][0])
-    assert_instance_of(Kubeclient::Endpoint, result['endpoint'][0])
-    assert_instance_of(Kubeclient::Namespace, result['namespace'][0])
-    assert_instance_of(Kubeclient::Secret, result['secret'][0])
-  end
-
-  def test_api_bearer_token_with_params_success
-    stub_request(:get, 'http://localhost:8080/api/v1beta3/pods?labelSelector=name=redis-master')
-      .with(headers: { Authorization: 'Bearer valid_token' })
-      .to_return(body: open_test_json_file('pod_list_b3.json'),
-                 status: 200)
-
-    client = Kubeclient::Client.new 'http://localhost:8080/api/',
-                                    auth_options: {
-                                      bearer_token: 'valid_token'
-                                    }
-
-    pods = client.get_pods(label_selector: 'name=redis-master')
-
-    assert_equal('Pod', pods.kind)
-    assert_equal(1, pods.size)
-  end
-
-  def test_api_bearer_token_success
-    stub_request(:get, 'http://localhost:8080/api/v1beta3/pods')
-      .with(headers: { Authorization: 'Bearer valid_token' })
-      .to_return(body: open_test_json_file('pod_list_b3.json'),
-                 status: 200)
-
-    client = Kubeclient::Client.new 'http://localhost:8080/api/',
-                                    auth_options: {
-                                      bearer_token: 'valid_token'
-                                    }
-
-    pods = client.get_pods
-
-    assert_equal('Pod', pods.kind)
-    assert_equal(1, pods.size)
-  end
-
-  def test_api_bearer_token_failure
-    error_message = '"/api/v1beta3/pods" is forbidden because ' \
-                    'system:anonymous cannot list on pods in'
-
-    stub_request(:get, 'http://localhost:8080/api/v1beta3/pods')
-      .with(headers: { Authorization: 'Bearer invalid_token' })
-      .to_raise(KubeException.new(403, error_message))
-
-    client = Kubeclient::Client.new 'http://localhost:8080/api/',
-                                    auth_options: {
-                                      bearer_token: 'invalid_token'
-                                    }
-
-    exception = assert_raises(KubeException) { client.get_pods }
-    assert_equal(403, exception.error_code)
-    assert_equal(error_message, exception.message)
-  end
-
-  def test_api_basic_auth_success
-    stub_request(:get, 'http://username:password@localhost:8080/api/v1beta3/pods')
-      .to_return(body: open_test_json_file('pod_list_b3.json'),
-                 status: 200)
-
-    client = Kubeclient::Client.new 'http://localhost:8080/api/',
-                                    auth_options: {
-                                      user: 'username',
-                                      password: 'password'
-                                    }
-
-    pods = client.get_pods
-
-    assert_equal('Pod', pods.kind)
-    assert_equal(1, pods.size)
-    assert_requested(:get,
-                     'http://username:password@localhost:8080/api/v1beta3/pods',
-                     times: 1)
-  end
-
-  def test_api_basic_auth_failure
-    error_message = 'HTTP status code 401, 401 Unauthorized'
-
-    stub_request(:get, 'http://username:password@localhost:8080/api/v1beta3/pods')
-      .to_raise(KubeException.new(401, error_message))
-
-    client = Kubeclient::Client.new 'http://localhost:8080/api/',
-                                    auth_options: {
-                                      user: 'username',
-                                      password: 'password'
-                                    }
-
-    exception = assert_raises(KubeException) { client.get_pods }
-    assert_equal(401, exception.error_code)
-    assert_equal(error_message, exception.message)
-    assert_requested(:get,
-                     'http://username:password@localhost:8080/api/v1beta3/pods',
-                     times: 1)
-  end
-
-  def test_init_user_no_password
-    expected_msg = 'Basic auth requires both user & password'
-    exception = assert_raises(ArgumentError) do
-      Kubeclient::Client.new 'http://localhost:8080',
-                             auth_options: {
-                               user: 'username'
-                             }
-    end
-    assert_equal expected_msg, exception.message
-  end
-
-  def test_init_user_and_bearer_token
-    expected_msg = 'Invalid auth options: specify only one of user/password,' \
-                   ' bearer_token or bearer_token_file'
-    exception = assert_raises(ArgumentError) do
-      Kubeclient::Client.new 'http://localhost:8080',
-                             auth_options: {
-                               user: 'username',
-                               bearer_token: 'token'
-                             }
-    end
-    assert_equal expected_msg, exception.message
-  end
-
-  def test_bearer_token_and_bearer_token_file
-    expected_msg = 'Invalid auth options: specify only one of user/password,' \
-                   ' bearer_token or bearer_token_file'
-    exception = assert_raises(ArgumentError) do
-      Kubeclient::Client.new 'http://localhost:8080',
-                             auth_options: {
-                               bearer_token: 'token',
-                               bearer_token_file: 'token-file'
-                             }
-    end
-    assert_equal expected_msg, exception.message
-  end
-
-  def test_bearer_token_file_not_exist
-    expected_msg = 'Token file token-file does not exist'
-    exception = assert_raises(ArgumentError) do
-      Kubeclient::Client.new 'http://localhost:8080',
-                             auth_options: {
-                               bearer_token_file: 'token-file'
-                             }
-    end
-    assert_equal expected_msg, exception.message
-  end
-
-  def test_api_bearer_token_file_success
-    stub_request(:get, 'http://localhost:8080/api/v1beta3/pods')
-      .with(headers: { Authorization: 'Bearer valid_token' })
-      .to_return(body: open_test_json_file('pod_list_b3.json'),
-                 status: 200)
-
-    file = File.join(File.dirname(__FILE__), 'valid_token_file')
-    client = Kubeclient::Client.new 'http://localhost:8080/api/',
-                                    auth_options: {
-                                      bearer_token_file: file
-                                    }
-
-    pods = client.get_pods
-
-    assert_equal('Pod', pods.kind)
-    assert_equal(1, pods.size)
-  end
-
-  private
-
-  # dup method creates a shallow copy which is not good in this case
-  # since rename_keys changes the input hash
-  # hence need to create a deep_copy
-  def deep_copy(hash)
-    Marshal.load(Marshal.dump(hash))
-  end
-end

data/test/test_namespace.rb

@@ -1,53 +0,0 @@
-require 'test_helper'
-
-# Namespace entity tests
-class TestNamespace < MiniTest::Test
-  def test_get_namespace_v1beta3
-    stub_request(:get, %r{/namespaces})
-      .to_return(body: open_test_json_file('namespace_b3.json'),
-                 status: 200)
-
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
-    namespace = client.get_namespace 'staging'
-
-    assert_instance_of(Kubeclient::Namespace, namespace)
-    assert_equal('e388bc10-c021-11e4-a514-3c970e4a436a', namespace.metadata.uid)
-    assert_equal('staging', namespace.metadata.name)
-    assert_equal('1168', namespace.metadata.resourceVersion)
-    assert_equal('v1beta3', namespace.apiVersion)
-
-    assert_requested(:get,
-                     'http://localhost:8080/api/v1beta3/namespaces/staging',
-                     times: 1)
-  end
-
-  def test_delete_namespace_v1beta3
-    our_namespace = Kubeclient::Namespace.new
-    our_namespace.name = 'staging'
-
-    stub_request(:delete, %r{/namespaces})
-      .to_return(status: 200)
-
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
-    client.delete_namespace our_namespace.name
-
-    assert_requested(:delete,
-                     'http://localhost:8080/api/v1beta3/namespaces/staging',
-                     times: 1)
-  end
-
-  def test_create_namespace
-    stub_request(:post, %r{/namespaces})
-      .to_return(body: open_test_json_file('created_namespace_b3.json'),
-                 status: 201)
-
-    namespace = Kubeclient::Namespace.new
-    namespace.metadata = {}
-    namespace.metadata.name = 'development'
-
-    client = Kubeclient::Client.new 'http://localhost:8080/api/'
-    created_namespace = client.create_namespace namespace
-    assert_instance_of(Kubeclient::Namespace, created_namespace)
-    assert_equal(namespace.metadata.name, created_namespace.metadata.name)
-  end
-end

data/test/test_node.rb

@@ -1,25 +0,0 @@
-require 'test_helper'
-
-# Node entity tests
-class TestNode < MiniTest::Test
-  def test_get_from_json_v3
-    stub_request(:get, %r{/nodes})
-      .to_return(body: open_test_json_file('node_b3.json'),
-                 status: 200)
-
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
-    node = client.get_node('127.0.0.1')
-
-    assert_instance_of(Kubeclient::Node, node)
-
-    assert_equal('041143c5-ce39-11e4-ac24-3c970e4a436a', node.metadata.uid)
-    assert_equal('127.0.0.1', node.metadata.name)
-    assert_equal('1724', node.metadata.resourceVersion)
-    assert_equal('v1beta3', node.apiVersion)
-    assert_equal('2015-03-19T15:08:20+02:00', node.metadata.creationTimestamp)
-
-    assert_requested(:get,
-                     'http://localhost:8080/api/v1beta3/nodes/127.0.0.1',
-                     times: 1)
-  end
-end