kubeclient 2.5.2 → 3.0.0

data/test/test_limit_range.rb

@@ -1,27 +1,27 @@
-require 'test_helper'
+require_relative 'test_helper'
 
 # LimitRange tests
 class TestLimitRange < MiniTest::Test
   def test_get_from_json_v1
     stub_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
+      .to_return(body: open_test_file('core_api_resource_list.json'), status: 200)
 
     stub_request(:get, %r{/limitranges})
-      .to_return(body: open_test_file('limit_range.json'),
-                 status: 200)
+      .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'
+    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
+    limit_range = client.get_limit_range('limits', 'quota-example')
 
-    assert_instance_of(Kubeclient::LimitRange, limit_range)
+    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)
+    assert_requested(
+      :get,
+      'http://localhost:8080/api/v1/namespaces/quota-example/limitranges/limits',
+      times: 1
+    )
   end
 end

data/test/test_missing_methods.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require_relative 'test_helper'
 
 # Test method_missing, respond_to? and respond_to_missing behaviour
 class TestMissingMethods < MiniTest::Test
@@ -31,11 +31,11 @@ class TestMissingMethods < MiniTest::Test
       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

data/test/test_namespace.rb

@@ -1,27 +1,27 @@
-require 'test_helper'
+require_relative 'test_helper'
 
 # Namespace entity tests
 class TestNamespace < MiniTest::Test
   def test_get_namespace_v1
     stub_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
+      .to_return(body: open_test_file('core_api_resource_list.json'), status: 200)
     stub_request(:get, %r{/namespaces})
-      .to_return(body: open_test_file('namespace.json'),
-                 status: 200)
+      .to_return(body: open_test_file('namespace.json'), status: 200)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
-    namespace = client.get_namespace 'staging'
+    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
+    namespace = client.get_namespace('staging')
 
-    assert_instance_of(Kubeclient::Namespace, namespace)
+    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)
+    assert_requested(
+      :get,
+      'http://localhost:8080/api/v1/namespaces/staging',
+      times: 1
+    )
   end
 
   def test_delete_namespace_v1
@@ -30,33 +30,33 @@ class TestNamespace < MiniTest::Test
     our_namespace.metadata.name = 'staging'
 
     stub_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
+      .to_return(body: open_test_file('core_api_resource_list.json'), status: 200)
     stub_request(:delete, %r{/namespaces})
-      .to_return(status: 200)
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
-    client.delete_namespace our_namespace.metadata.name
-
-    assert_requested(:delete,
-                     'http://localhost:8080/api/v1/namespaces/staging',
-                     times: 1)
+      .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_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
+      .to_return(body: open_test_file('core_api_resource_list.json'), status: 200)
     stub_request(:post, %r{/namespaces})
-      .to_return(body: open_test_file('created_namespace.json'),
-                 status: 201)
+      .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::Namespace, created_namespace)
+    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,19 +1,17 @@
-require 'test_helper'
+require_relative 'test_helper'
 
 # Node entity tests
 class TestNode < MiniTest::Test
   def test_get_from_json_v1
     stub_request(:get, %r{/nodes})
-      .to_return(body: open_test_file('node.json'),
-                 status: 200)
+      .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: 200)
+      .to_return(body: open_test_file('core_api_resource_list.json'), status: 200)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
+    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
     node = client.get_node('127.0.0.1')
 
-    assert_instance_of(Kubeclient::Node, node)
+    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)
@@ -21,12 +19,16 @@ class TestNode < MiniTest::Test
     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)
+    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
@@ -60,11 +62,11 @@ class TestNode < MiniTest::Test
 
     client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
 
-    exception = assert_raises(KubeException) do
+    exception = assert_raises(Kubeclient::HttpError) do
       client.get_node('127.0.0.1', nil, as: :raw)
     end
 
-    assert_instance_of(KubeException, exception)
+    assert_instance_of(Kubeclient::HttpError, exception)
     assert_equal('500 Internal Server Error', exception.message)
   end
 end

data/test/test_persistent_volume.rb

@@ -1,28 +1,30 @@
-require 'test_helper'
+require_relative 'test_helper'
 
 # PersistentVolume tests
 class TestPersistentVolume < MiniTest::Test
   def test_get_from_json_v1
     stub_request(:get, %r{/persistentvolumes})
-      .to_return(body: open_test_file('persistent_volume.json'),
-                 status: 200)
+      .to_return(body: open_test_file('persistent_volume.json'), status: 200)
     stub_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
+      .to_return(body: open_test_file('core_api_resource_list.json'), status: 200)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
-    volume = client.get_persistent_volume 'pv0001'
+    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
+    volume = client.get_persistent_volume('pv0001')
 
-    assert_instance_of(Kubeclient::PersistentVolume, volume)
+    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)
+    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 +1,30 @@
-require 'test_helper'
+require_relative 'test_helper'
 
 # PersistentVolumeClaim tests
 class TestPersistentVolumeClaim < MiniTest::Test
   def test_get_from_json_v1
     stub_request(:get, %r{/persistentvolumeclaims})
-      .to_return(body: open_test_file('persistent_volume_claim.json'),
-                 status: 200)
+      .to_return(body: open_test_file('persistent_volume_claim.json'), status: 200)
     stub_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
+      .to_return(body: open_test_file('core_api_resource_list.json'), status: 200)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
-    claim = client.get_persistent_volume_claim 'myclaim-1', 'default'
+    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
+    claim = client.get_persistent_volume_claim('myclaim-1', 'default')
 
-    assert_instance_of(Kubeclient::PersistentVolumeClaim, claim)
+    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)
+    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,27 +1,29 @@
-require 'test_helper'
+require_relative 'test_helper'
 
 # Pod entity tests
 class TestPod < MiniTest::Test
   def test_get_from_json_v1
     stub_request(:get, %r{/pods})
-      .to_return(body: open_test_file('pod.json'),
-                 status: 200)
+      .to_return(body: open_test_file('pod.json'), status: 200)
     stub_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
+      .to_return(body: open_test_file('core_api_resource_list.json'), status: 200)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
-    pod = client.get_pod 'redis-master-pod', 'default'
+    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
+    pod = client.get_pod('redis-master-pod', 'default')
 
-    assert_instance_of(Kubeclient::Pod, pod)
+    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)
+    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
 end

data/test/test_pod_log.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require_relative 'test_helper'
 
 # Pod log tests
 class TestPodLog < MiniTest::Test
@@ -7,7 +7,7 @@ class TestPodLog < MiniTest::Test
       .to_return(body: open_test_file('pod_log.txt'),
                  status: 200)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
+    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)
@@ -22,7 +22,7 @@ class TestPodLog < MiniTest::Test
       .to_return(body: open_test_file('pod_log.txt'),
                  status: 200)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
+    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)
@@ -39,7 +39,7 @@ class TestPodLog < MiniTest::Test
       .to_return(body: open_test_file('pod_log.txt'),
                  status: 200)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
+    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|

data/test/test_process_template.rb

@@ -1,9 +1,9 @@
-require 'test_helper'
+require_relative 'test_helper'
 
 # Process Template tests
 class TestProcessTemplate < MiniTest::Test
   def test_process_template
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
+    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
     template = {}
     template[:metadata] = {}
     template[:metadata][:name] = 'my-template'
@@ -19,17 +19,17 @@ class TestProcessTemplate < MiniTest::Test
     param = { name: 'NAME_PREFIX', value: 'test/' }
     template[:parameters] = [param]
 
-    req_body = "{\"metadata\":{\"name\":\"my-template\",\"namespace\":\"default\"},"\
-    "\"kind\":\"Template\",\"apiVersion\":\"v1\",\"objects\":[{\"metadata\":"\
-    "{\"name\":\"${NAME_PREFIX}my-service\"},\"kind\":\"Service\",\"apiVersion\":\"v1\"}],"\
-    "\"parameters\":[{\"name\":\"NAME_PREFIX\",\"value\":\"test/\"}]}"
+    req_body = '{"metadata":{"name":"my-template","namespace":"default"},' \
+      '"kind":"Template","apiVersion":"v1","objects":[{"metadata":' \
+      '{"name":"${NAME_PREFIX}my-service"},"kind":"Service","apiVersion":"v1"}],' \
+      '"parameters":[{"name":"NAME_PREFIX","value":"test/"}]}'
 
     expected_url = 'http://localhost:8080/api/v1/namespaces/default/processedtemplates'
     stub_request(:post, expected_url)
       .with(body: req_body, headers: { 'Content-Type' => 'application/json' })
       .to_return(body: open_test_file('processed_template.json'), status: 200)
 
-    processed_template = client.process_template template
+    processed_template = client.process_template(template)
 
     assert_equal('test/my-service', processed_template['objects'].first['metadata']['name'])
 

data/test/test_replication_controller.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require_relative 'test_helper'
 
 # Replication Controller entity tests
 class TestReplicationController < MiniTest::Test
@@ -10,10 +10,10 @@ class TestReplicationController < MiniTest::Test
       .to_return(body: open_test_file('replication_controller.json'),
                  status: 200)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
-    rc = client.get_replication_controller 'frontendController', 'default'
+    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
+    rc = client.get_replication_controller('frontendController', 'default')
 
-    assert_instance_of(Kubeclient::ReplicationController, rc)
+    assert_instance_of(Kubeclient::Resource, rc)
     assert_equal('guestbook-controller', rc.metadata.name)
     assert_equal('c71aa4c0-a240-11e4-a265-3c970e4a436a', rc.metadata.uid)
     assert_equal('default', rc.metadata.namespace)
@@ -24,4 +24,29 @@ class TestReplicationController < MiniTest::Test
                      'http://localhost:8080/api/v1/namespaces/default/replicationcontrollers/frontendController',
                      times: 1)
   end
+
+  def test_delete_replicaset_cascade
+    stub_request(:get, %r{/api/v1$})
+      .to_return(body: open_test_file('core_api_resource_list.json'),
+                 status: 200)
+
+    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
+    opts = Kubeclient::Resource.new(
+      apiVersion: 'meta/v1',
+      gracePeriodSeconds: 0,
+      kind: 'DeleteOptions',
+      propagationPolicy: 'Foreground'
+    )
+
+    stub_request(:delete,
+                 'http://localhost:8080/api/v1/namespaces/default/replicationcontrollers/frontendController')
+      .with(body: opts.to_hash.to_json)
+      .to_return(status: 200, body: open_test_file('replication_controller.json'), headers: {})
+    rc = client.delete_replication_controller('frontendController', 'default', delete_options: opts)
+    assert_kind_of(RecursiveOpenStruct, rc)
+
+    assert_requested(:delete,
+                     'http://localhost:8080/api/v1/namespaces/default/replicationcontrollers/frontendController',
+                     times: 1)
+  end
 end