kubeclient 4.9.0 → 4.9.3

data/test/test_limit_range.rb

@@ -1,25 +0,0 @@
-require_relative 'test_helper'
-
-# LimitRange tests
-class TestLimitRange < MiniTest::Test
-  def test_get_from_json_v1
-    stub_core_api_list
-    stub_request(:get, %r{/limitranges})
-      .to_return(body: open_test_file('limit_range.json'), status: 200)
-
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    limit_range = client.get_limit_range('limits', 'quota-example')
-
-    assert_instance_of(Kubeclient::Resource, limit_range)
-    assert_equal('limits', limit_range.metadata.name)
-    assert_equal('Container', limit_range.spec.limits[0].type)
-    assert_equal('100m', limit_range.spec.limits[0].default.cpu)
-    assert_equal('512Mi', limit_range.spec.limits[0].default.memory)
-
-    assert_requested(
-      :get,
-      'http://localhost:8080/api/v1/namespaces/quota-example/limitranges/limits',
-      times: 1
-    )
-  end
-end

data/test/test_missing_methods.rb

@@ -1,80 +0,0 @@
-require_relative 'test_helper'
-
-# Test method_missing, respond_to? and respond_to_missing behaviour
-class TestMissingMethods < MiniTest::Test
-  def test_missing
-    stub_core_api_list
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    assert_equal(true, client.respond_to?(:get_pod))
-    assert_equal(true, client.respond_to?(:get_pods))
-    assert_equal(false, client.respond_to?(:get_pie))
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1') # Reset discovery
-    assert_equal(false, client.respond_to?(:get_pie))
-    assert_equal(true, client.respond_to?(:get_pods))
-    assert_equal(true, client.respond_to?(:get_pod))
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1') # Reset discovery
-    assert_instance_of(Method, client.method(:get_pods))
-    assert_raises(NameError) do
-      client.method(:get_pies)
-    end
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1') # Reset discovery
-    assert_raises(NameError) do
-      client.method(:get_pies)
-    end
-    assert_instance_of(Method, client.method(:get_pods))
-
-    stub_request(:get, %r{/api/v1$}).to_return(
-      body: '',
-      status: 404
-    ) # If discovery fails we expect the below raise an exception
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    assert_raises(Kubeclient::HttpError) do
-      client.discover
-    end
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    assert_raises(Kubeclient::HttpError) do
-      client.method(:get_pods)
-    end
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    assert_raises(Kubeclient::HttpError) do
-      client.respond_to?(:get_pods)
-    end
-  end
-
-  def test_nonsuffix_plurals
-    stub_request(:get, %r{/apis/extensions/v1beta1$}).to_return(
-      body: open_test_file('extensions_v1beta1_api_resource_list.json'),
-      status: 200
-    )
-    client = Kubeclient::Client.new('http://localhost:8080/apis/extensions', 'v1beta1')
-    assert_equal(true, client.respond_to?(:get_network_policy))
-    assert_equal(true, client.respond_to?(:get_network_policies))
-    assert_equal(true, client.respond_to?(:get_pod_security_policy))
-    assert_equal(true, client.respond_to?(:get_pod_security_policies))
-  end
-
-  def test_irregular_names
-    stub_core_api_list
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    assert_equal(true, client.respond_to?(:get_endpoint))
-    assert_equal(true, client.respond_to?(:get_endpoints))
-
-    stub_request(:get, %r{/apis/security.openshift.io/v1$}).to_return(
-      body: open_test_file('security.openshift.io_api_resource_list.json'),
-      status: 200
-    )
-    client = Kubeclient::Client.new('http://localhost:8080/apis/security.openshift.io', 'v1')
-    assert_equal(true, client.respond_to?(:get_security_context_constraint))
-    assert_equal(true, client.respond_to?(:get_security_context_constraints))
-  end
-
-  def test_lowercase_kind
-    stub_request(:get, %r{/apis/config.istio.io/v1alpha2$}).to_return(
-      body: open_test_file('config.istio.io_api_resource_list.json'),
-      status: 200
-    )
-    client = Kubeclient::Client.new('http://localhost:8080/apis/config.istio.io', 'v1alpha2')
-    assert_equal(true, client.respond_to?(:get_servicecontrolreport))
-    assert_equal(true, client.respond_to?(:get_servicecontrolreports))
-  end
-end

data/test/test_namespace.rb

@@ -1,59 +0,0 @@
-require_relative 'test_helper'
-
-# Namespace entity tests
-class TestNamespace < MiniTest::Test
-  def test_get_namespace_v1
-    stub_core_api_list
-    stub_request(:get, %r{/namespaces})
-      .to_return(body: open_test_file('namespace.json'), status: 200)
-
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    namespace = client.get_namespace('staging')
-
-    assert_instance_of(Kubeclient::Resource, 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('v1', namespace.apiVersion)
-
-    assert_requested(
-      :get,
-      'http://localhost:8080/api/v1/namespaces/staging',
-      times: 1
-    )
-  end
-
-  def test_delete_namespace_v1
-    our_namespace = Kubeclient::Resource.new
-    our_namespace.metadata = {}
-    our_namespace.metadata.name = 'staging'
-
-    stub_core_api_list
-    stub_request(:delete, %r{/namespaces})
-      .to_return(body: open_test_file('namespace.json'), status: 200)
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    our_namespace = client.delete_namespace(our_namespace.metadata.name)
-    assert_kind_of(RecursiveOpenStruct, our_namespace)
-
-    assert_requested(
-      :delete,
-      'http://localhost:8080/api/v1/namespaces/staging',
-      times: 1
-    )
-  end
-
-  def test_create_namespace
-    stub_core_api_list
-    stub_request(:post, %r{/namespaces})
-      .to_return(body: open_test_file('created_namespace.json'), status: 201)
-
-    namespace = Kubeclient::Resource.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::Resource, created_namespace)
-    assert_equal(namespace.metadata.name, created_namespace.metadata.name)
-  end
-end

data/test/test_node.rb

@@ -1,70 +0,0 @@
-require_relative 'test_helper'
-
-# Node entity tests
-class TestNode < MiniTest::Test
-  def test_get_from_json_v1
-    stub_core_api_list
-    stub_request(:get, %r{/nodes})
-      .to_return(body: open_test_file('node.json'), status: 200)
-
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    node = client.get_node('127.0.0.1')
-
-    assert_instance_of(Kubeclient::Resource, 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('v1', node.apiVersion)
-    assert_equal('2015-03-19T15:08:20+02:00', node.metadata.creationTimestamp)
-
-    assert_requested(
-      :get,
-      'http://localhost:8080/api/v1',
-      times: 1
-    )
-    assert_requested(
-      :get,
-      'http://localhost:8080/api/v1/nodes/127.0.0.1',
-      times: 1
-    )
-  end
-
-  def test_get_from_json_v1_raw
-    stub_core_api_list
-    stub_request(:get, %r{/nodes})
-      .to_return(body: open_test_file('node.json'), status: 200)
-
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    response = client.get_node('127.0.0.1', nil, as: :raw)
-
-    assert_equal(open_test_file('node.json').read, response)
-
-    assert_requested(
-      :get,
-      'http://localhost:8080/api/v1',
-      times: 1
-    )
-    assert_requested(
-      :get,
-      'http://localhost:8080/api/v1/nodes/127.0.0.1',
-      times: 1
-    )
-  end
-
-  def test_get_from_json_v1_raw_error
-    stub_request(:get, %r{/nodes})
-      .to_return(body: open_test_file('node.json'), status: 200)
-    stub_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'), status: 500)
-
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-
-    exception = assert_raises(Kubeclient::HttpError) do
-      client.get_node('127.0.0.1', nil, as: :raw)
-    end
-
-    assert_instance_of(Kubeclient::HttpError, exception)
-    assert_equal('500 Internal Server Error', exception.message)
-  end
-end

data/test/test_oidc_auth_provider.rb

@@ -1,103 +0,0 @@
-require_relative 'test_helper'
-require 'openid_connect'
-
-class OIDCAuthProviderTest < MiniTest::Test
-  def setup
-    @client_id = 'client_id'
-    @client_secret = 'client_secret'
-    @idp_issuer_url = 'idp_issuer_url'
-    @refresh_token = 'refresh_token'
-    @id_token = 'id_token'
-    @new_id_token = 'new_id_token'
-  end
-
-  def test_expired_token
-    OpenIDConnect::Discovery::Provider::Config.stub(:discover!, discovery_mock) do
-      OpenIDConnect::ResponseObject::IdToken.stub(:decode, id_token_mock(Time.now.to_i - 7200)) do
-        OpenIDConnect::Client.stub(:new, openid_client_mock) do
-          retrieved_id_token = Kubeclient::OIDCAuthProvider.token(
-            'client-id' => @client_id,
-            'client-secret' => @client_secret,
-            'id-token' => @id_token,
-            'idp-issuer-url' => @idp_issuer_url,
-            'refresh-token' => @refresh_token
-          )
-          assert_equal(@new_id_token, retrieved_id_token)
-        end
-      end
-    end
-  end
-
-  def test_valid_token
-    OpenIDConnect::Discovery::Provider::Config.stub(:discover!, discovery_mock) do
-      OpenIDConnect::ResponseObject::IdToken.stub(:decode, id_token_mock(Time.now.to_i + 7200)) do
-        retrieved_id_token = Kubeclient::OIDCAuthProvider.token(
-          'client-id' => @client_id,
-          'client-secret' => @client_secret,
-          'id-token' => @id_token,
-          'idp-issuer-url' => @idp_issuer_url,
-          'refresh-token' => @refresh_token
-        )
-        assert_equal(@id_token, retrieved_id_token)
-      end
-    end
-  end
-
-  def test_missing_id_token
-    OpenIDConnect::Discovery::Provider::Config.stub(:discover!, discovery_mock) do
-      OpenIDConnect::Client.stub(:new, openid_client_mock) do
-        retrieved_id_token = Kubeclient::OIDCAuthProvider.token(
-          'client-id' => @client_id,
-          'client-secret' => @client_secret,
-          'idp-issuer-url' => @idp_issuer_url,
-          'refresh-token' => @refresh_token
-        )
-        assert_equal(@new_id_token, retrieved_id_token)
-      end
-    end
-  end
-
-  def test_token_with_unknown_kid
-    OpenIDConnect::Discovery::Provider::Config.stub(:discover!, discovery_mock) do
-      OpenIDConnect::ResponseObject::IdToken.stub(
-        :decode, ->(_token, _jwks) { raise JSON::JWK::Set::KidNotFound }
-      ) do
-        OpenIDConnect::Client.stub(:new, openid_client_mock) do
-          retrieved_id_token = Kubeclient::OIDCAuthProvider.token(
-            'client-id' => @client_id,
-            'client-secret' => @client_secret,
-            'id-token' => @id_token,
-            'idp-issuer-url' => @idp_issuer_url,
-            'refresh-token' => @refresh_token
-          )
-          assert_equal(@new_id_token, retrieved_id_token)
-        end
-      end
-    end
-  end
-
-  private
-
-  def openid_client_mock
-    access_token = Minitest::Mock.new
-    access_token.expect(@id_token, @new_id_token)
-
-    openid_client = Minitest::Mock.new
-    openid_client.expect(:refresh_token=, nil, [@refresh_token])
-    openid_client.expect(:access_token!, access_token)
-  end
-
-  def id_token_mock(expiry)
-    id_token_mock = Minitest::Mock.new
-    id_token_mock.expect(:exp, expiry)
-  end
-
-  def discovery_mock
-    discovery = Minitest::Mock.new
-    discovery.expect(:jwks, 'jwks')
-    discovery.expect(:authorization_endpoint, 'authz_endpoint')
-    discovery.expect(:token_endpoint, 'token_endpoint')
-    discovery.expect(:userinfo_endpoint, 'userinfo_endpoint')
-    discovery
-  end
-end

data/test/test_persistent_volume.rb

@@ -1,29 +0,0 @@
-require_relative 'test_helper'
-
-# PersistentVolume tests
-class TestPersistentVolume < MiniTest::Test
-  def test_get_from_json_v1
-    stub_core_api_list
-    stub_request(:get, %r{/persistentvolumes})
-      .to_return(body: open_test_file('persistent_volume.json'), status: 200)
-
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    volume = client.get_persistent_volume('pv0001')
-
-    assert_instance_of(Kubeclient::Resource, volume)
-    assert_equal('pv0001', volume.metadata.name)
-    assert_equal('10Gi', volume.spec.capacity.storage)
-    assert_equal('/tmp/data01', volume.spec.hostPath.path)
-
-    assert_requested(
-      :get,
-      'http://localhost:8080/api/v1',
-      times: 1
-    )
-    assert_requested(
-      :get,
-      'http://localhost:8080/api/v1/persistentvolumes/pv0001',
-      times: 1
-    )
-  end
-end

data/test/test_persistent_volume_claim.rb

@@ -1,28 +0,0 @@
-require_relative 'test_helper'
-
-# PersistentVolumeClaim tests
-class TestPersistentVolumeClaim < MiniTest::Test
-  def test_get_from_json_v1
-    stub_core_api_list
-    stub_request(:get, %r{/persistentvolumeclaims})
-      .to_return(body: open_test_file('persistent_volume_claim.json'), status: 200)
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    claim = client.get_persistent_volume_claim('myclaim-1', 'default')
-
-    assert_instance_of(Kubeclient::Resource, claim)
-    assert_equal('myclaim-1', claim.metadata.name)
-    assert_equal('3Gi', claim.spec.resources.requests.storage)
-    assert_equal('pv0001', claim.spec.volumeName)
-
-    assert_requested(
-      :get,
-      'http://localhost:8080/api/v1',
-      times: 1
-    )
-    assert_requested(
-      :get,
-      'http://localhost:8080/api/v1/namespaces/default/persistentvolumeclaims/myclaim-1',
-      times: 1
-    )
-  end
-end

data/test/test_pod.rb

@@ -1,81 +0,0 @@
-require_relative 'test_helper'
-
-# Pod entity tests
-class TestPod < MiniTest::Test
-  def test_get_from_json_v1
-    stub_core_api_list
-    stub_request(:get, %r{/pods})
-      .to_return(body: open_test_file('pod.json'), status: 200)
-
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    pod = client.get_pod('redis-master-pod', 'default')
-
-    assert_instance_of(Kubeclient::Resource, pod)
-    assert_equal('redis-master3', pod.metadata.name)
-    assert_equal('dockerfile/redis', pod.spec.containers[0]['image'])
-
-    assert_requested(
-      :get,
-      'http://localhost:8080/api/v1',
-      times: 1
-    )
-    assert_requested(
-      :get,
-      'http://localhost:8080/api/v1/namespaces/default/pods/redis-master-pod',
-      times: 1
-    )
-  end
-
-  def test_get_chunks
-    stub_core_api_list
-    stub_request(:get, %r{/pods})
-      .to_return(body: open_test_file('pods_1.json'), status: 200)
-
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    pods = client.get_pods(limit: 2)
-
-    assert_equal(2, pods.count)
-    assert_equal('eyJ2IjoibWV0YS5rOHMua', pods.continue)
-
-    continue = pods.continue
-
-    stub_request(:get, %r{/pods})
-      .to_return(body: open_test_file('pods_2.json'), status: 200)
-
-    pods = client.get_pods(limit: 2, continue: continue)
-    assert_equal(2, pods.count)
-    assert_nil(pods.continue)
-
-    assert_requested(
-      :get,
-      'http://localhost:8080/api/v1',
-      times: 1
-    )
-    assert_requested(
-      :get,
-      'http://localhost:8080/api/v1/pods?limit=2',
-      times: 1
-    )
-    assert_requested(
-      :get,
-      "http://localhost:8080/api/v1/pods?continue=#{continue}&limit=2",
-      times: 1
-    )
-  end
-
-  def test_get_chunks_410_gone
-    stub_core_api_list
-    stub_request(:get, %r{/pods})
-      .to_return(body: open_test_file('pods_410.json'), status: 410)
-
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-
-    err = assert_raises Kubeclient::HttpError do
-      client.get_pods(limit: 2, continue: 'eyJ2IjoibWV0YS5')
-    end
-
-    assert_equal(err.message,
-                 "The provided from parameter is too old to display a consistent list result. \
-You must start a new list without the from.")
-  end
-end

data/test/test_pod_log.rb

@@ -1,157 +0,0 @@
-require_relative 'test_helper'
-
-# Pod log tests
-class TestPodLog < MiniTest::Test
-  def test_get_pod_log
-    stub_request(:get, %r{/namespaces/default/pods/[a-z0-9-]+/log})
-      .to_return(body: open_test_file('pod_log.txt'),
-                 status: 200)
-
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    retrieved_log = client.get_pod_log('redis-master-pod', 'default')
-
-    assert_equal(open_test_file('pod_log.txt').read, retrieved_log)
-
-    assert_requested(:get,
-                     'http://localhost:8080/api/v1/namespaces/default/pods/redis-master-pod/log',
-                     times: 1)
-  end
-
-  def test_get_pod_log_container
-    stub_request(:get, %r{/namespaces/default/pods/[a-z0-9-]+/log})
-      .to_return(body: open_test_file('pod_log.txt'),
-                 status: 200)
-
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    retrieved_log = client.get_pod_log('redis-master-pod', 'default', container: 'ruby')
-
-    assert_equal(open_test_file('pod_log.txt').read, retrieved_log)
-
-    assert_requested(:get,
-                     'http://localhost:8080/api/v1/namespaces/default/pods/redis-master-pod/log?container=ruby',
-                     times: 1)
-  end
-
-  def test_get_pod_log_since_time
-    stub_request(:get, %r{/namespaces/default/pods/[a-z0-9-]+/log})
-      .to_return(body: open_test_file('pod_log.txt'),
-                 status: 200)
-
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    retrieved_log = client.get_pod_log('redis-master-pod',
-                                       'default',
-                                       timestamps: true,
-                                       since_time: '2018-04-27T18:30:17.480321984Z')
-
-    assert_equal(open_test_file('pod_log.txt').read, retrieved_log)
-
-    assert_requested(:get,
-                     'http://localhost:8080/api/v1/namespaces/default/pods/redis-master-pod/log?sinceTime=2018-04-27T18:30:17.480321984Z&timestamps=true',
-                     times: 1)
-  end
-
-  def test_get_pod_log_tail_lines
-    selected_lines = open_test_file('pod_log.txt').to_a[-2..1].join
-
-    stub_request(:get, %r{/namespaces/default/pods/[a-z0-9-]+/log})
-      .to_return(body: selected_lines,
-                 status: 200)
-
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    retrieved_log = client.get_pod_log('redis-master-pod',
-                                       'default',
-                                       tail_lines: 2)
-
-    assert_equal(selected_lines, retrieved_log)
-
-    assert_requested(:get,
-                     'http://localhost:8080/api/v1/namespaces/default/pods/redis-master-pod/log?tailLines=2',
-                     times: 1)
-  end
-
-  def test_get_pod_limit_bytes
-    selected_bytes = open_test_file('pod_log.txt').read(10)
-
-    stub_request(:get, %r{/namespaces/default/pods/[a-z0-9-]+/log})
-      .to_return(body: selected_bytes,
-                 status: 200)
-
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    retrieved_log = client.get_pod_log('redis-master-pod',
-                                       'default',
-                                       limit_bytes: 10)
-
-    assert_equal(selected_bytes, retrieved_log)
-
-    assert_requested(:get,
-                     'http://localhost:8080/api/v1/namespaces/default/pods/redis-master-pod/log?limitBytes=10',
-                     times: 1)
-  end
-
-  def test_watch_pod_log
-    file = open_test_file('pod_log.txt')
-    expected_lines = file.read.split("\n")
-
-    stub_request(:get, %r{/namespaces/default/pods/[a-z0-9-]+/log\?.*follow})
-      .to_return(body: file, status: 200)
-
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-
-    stream = client.watch_pod_log('redis-master-pod', 'default')
-    stream.to_enum.with_index do |notice, index|
-      assert_instance_of(String, notice)
-      assert_equal(expected_lines[index], notice)
-    end
-  end
-
-  def test_watch_pod_log_with_block
-    file = open_test_file('pod_log.txt')
-    first = file.readlines.first.chomp
-
-    stub_request(:get, %r{/namespaces/default/pods/[a-z0-9-]+/log\?.*follow})
-      .to_return(body: file, status: 200)
-
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-
-    client.watch_pod_log('redis-master-pod', 'default') do |line|
-      assert_equal first, line
-      break
-    end
-  end
-
-  def test_watch_pod_log_follow_redirect
-    expected_lines = open_test_file('pod_log.txt').read.split("\n")
-    redirect = 'http://localhost:1234/api/namespaces/default/pods/redis-master-pod/log'
-
-    stub_request(:get, %r{/namespaces/default/pods/[a-z0-9-]+/log\?.*follow})
-      .to_return(status: 302, headers: { location: redirect })
-
-    stub_request(:get, redirect)
-      .to_return(body: open_test_file('pod_log.txt'),
-                 status: 200)
-
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    stream = client.watch_pod_log('redis-master-pod', 'default')
-    stream.to_enum.with_index do |notice, index|
-      assert_instance_of(String, notice)
-      assert_equal(expected_lines[index], notice)
-    end
-  end
-
-  def test_watch_pod_log_max_redirect
-    redirect = 'http://localhost:1234/api/namespaces/default/pods/redis-master-pod/log'
-
-    stub_request(:get, %r{/namespaces/default/pods/[a-z0-9-]+/log\?.*follow})
-      .to_return(status: 302, headers: { location: redirect })
-
-    stub_request(:get, redirect)
-      .to_return(body: open_test_file('pod_log.txt'),
-                 status: 200)
-
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1', http_max_redirects: 0)
-    assert_raises(Kubeclient::HttpError) do
-      client.watch_pod_log('redis-master-pod', 'default').each do
-      end
-    end
-  end
-end