kubeclient 2.5.2 → 3.0.0

data/test/test_resource_list_without_kind.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require_relative 'test_helper'
 
 # Core api resource list without kind tests
 class TestResourceListWithoutKind < MiniTest::Test
@@ -15,19 +15,19 @@ class TestResourceListWithoutKind < MiniTest::Test
         entity: 'pod',
         type: 'Pod',
         name: 'pods',
-        methods: %w(pod pods)
+        methods: %w[pod pods]
       },
       {
         entity: 'node',
         type: 'Node',
         name: 'nodes',
-        methods: %w(node nodes)
+        methods: %w[node nodes]
       },
       {
         entity: 'service',
         type: 'Service',
         name: 'services',
-        methods: %w(service services)
+        methods: %w[service services]
       }
     ].each { |h| assert_entities(client.instance_variable_get(:@entities)[h[:entity]], h) }
 
@@ -49,19 +49,19 @@ class TestResourceListWithoutKind < MiniTest::Test
         entity: 'template',
         type: 'Template',
         name: 'templates',
-        methods: %w(template templates)
+        methods: %w[template templates]
       },
       {
         entity: 'build',
         type: 'Build',
         name: 'builds',
-        methods: %w(build builds)
+        methods: %w[build builds]
       },
       {
         entity: 'project',
         type: 'Project',
         name: 'projects',
-        methods: %w(project projects)
+        methods: %w[project projects]
       }
     ].each { |h| assert_entities(client.instance_variable_get(:@entities)[h[:entity]], h) }
 

data/test/test_resource_quota.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require_relative 'test_helper'
 
 # ResourceQuota tests
 class TestResourceQuota < MiniTest::Test
@@ -10,10 +10,10 @@ class TestResourceQuota < MiniTest::Test
       .to_return(body: open_test_file('resource_quota.json'),
                  status: 200)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
-    quota = client.get_resource_quota 'quota', 'quota-example'
+    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
+    quota = client.get_resource_quota('quota', 'quota-example')
 
-    assert_instance_of(Kubeclient::ResourceQuota, quota)
+    assert_instance_of(Kubeclient::Resource, quota)
     assert_equal('quota', quota.metadata.name)
     assert_equal('20', quota.spec.hard.cpu)
     assert_equal('10', quota.spec.hard.secrets)

data/test/test_secret.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require_relative 'test_helper'
 
 # Namespace entity tests
 class TestSecret < MiniTest::Test
@@ -11,10 +11,10 @@ class TestSecret < MiniTest::Test
       .to_return(body: open_test_file('created_secret.json'),
                  status: 200)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
-    secret = client.get_secret 'test-secret', 'dev'
+    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
+    secret = client.get_secret('test-secret', 'dev')
 
-    assert_instance_of(Kubeclient::Secret, secret)
+    assert_instance_of(Kubeclient::Resource, secret)
     assert_equal('4e38a198-2bcb-11e5-a483-0e840567604d', secret.metadata.uid)
     assert_equal('test-secret', secret.metadata.name)
     assert_equal('v1', secret.apiVersion)
@@ -31,10 +31,11 @@ class TestSecret < MiniTest::Test
                  status: 200)
 
     stub_request(:delete, %r{/secrets})
-      .to_return(status: 200)
+      .to_return(status: 200, body: open_test_file('created_secret.json'))
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
-    client.delete_secret 'test-secret', 'dev'
+    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
+    secret = client.delete_secret('test-secret', 'dev')
+    assert_kind_of(RecursiveOpenStruct, secret)
 
     assert_requested(:delete,
                      'http://localhost:8080/api/v1/namespaces/dev/secrets/test-secret',
@@ -57,9 +58,9 @@ class TestSecret < MiniTest::Test
     secret.data = {}
     secret.data['super-secret'] = 'Y2F0J3MgYXJlIGF3ZXNvbWUK'
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/'
-    created_secret = client.create_secret secret
-    assert_instance_of(Kubeclient::Secret, created_secret)
+    client = Kubeclient::Client.new('http://localhost:8080/api/')
+    created_secret = client.create_secret(secret)
+    assert_instance_of(Kubeclient::Resource, created_secret)
     assert_equal(secret.metadata.name, created_secret.metadata.name)
     assert_equal(secret.metadata.namespace, created_secret.metadata.namespace)
     assert_equal(

data/test/test_service.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require_relative 'test_helper'
 
 # Service entity tests
 class TestService < MiniTest::Test
@@ -11,17 +11,18 @@ class TestService < MiniTest::Test
     our_service.metadata.labels.name = 'guestbook'
 
     our_service.spec = {}
-    our_service.spec.ports = [{ 'port' => 3000,
-                                'targetPort' => 'http-server',
-                                'protocol' => 'TCP'
+    our_service.spec.ports = [{
+      'port' => 3000,
+      'targetPort' => 'http-server',
+      'protocol' => 'TCP'
     }]
 
     assert_equal('guestbook', our_service.metadata.labels.name)
 
     hash = our_service.to_h
 
-    assert_equal our_service.metadata.labels.name,
-                 hash[:metadata][:labels][:name]
+    assert_equal(our_service.metadata.labels.name,
+                 hash[:metadata][:labels][:name])
 
     expected_url = 'http://localhost:8080/api/v1/namespaces/staging/services'
     stub_request(:get, %r{/api/v1$})
@@ -31,15 +32,15 @@ class TestService < MiniTest::Test
     stub_request(:post, expected_url)
       .to_return(body: open_test_file('created_service.json'), status: 201)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/'
-    created = client.create_service our_service
+    client = Kubeclient::Client.new('http://localhost:8080/api/')
+    created = client.create_service(our_service)
 
-    assert_instance_of(Kubeclient::Service, created)
+    assert_instance_of(Kubeclient::Resource, created)
     assert_equal(created.metadata.name, our_service.metadata.name)
     assert_equal(created.spec.ports.size, our_service.spec.ports.size)
 
     # Check that original entity_config is not modified by kind/apiVersion patches:
-    assert_equal(our_service.kind, nil)
+    assert_nil(our_service.kind)
 
     assert_requested(:post, expected_url, times: 1) do |req|
       data = JSON.parse(req.body)
@@ -72,8 +73,8 @@ class TestService < MiniTest::Test
     stub_request(:post, expected_url)
       .to_return(body: open_test_file('created_service.json'), status: 201)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/'
-    client.create_service service
+    client = Kubeclient::Client.new('http://localhost:8080/api/')
+    client.create_service(service)
 
     assert_requested(:post, expected_url, times: 1) do |req|
       data = JSON.parse(req.body)
@@ -107,8 +108,8 @@ class TestService < MiniTest::Test
     stub_request(:post, %r{namespaces/staging/services})
       .to_return(body: open_test_file('created_service.json'), status: 201)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/'
-    client.create_service service
+    client = Kubeclient::Client.new('http://localhost:8080/api/')
+    client.create_service(service)
 
     assert_requested(:post, expected_url, times: 1) do |req|
       data = JSON.parse(req.body)
@@ -128,10 +129,10 @@ class TestService < MiniTest::Test
       .to_return(body: open_test_file('service.json'),
                  status: 200)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/'
-    service = client.get_service 'redis-slave', 'development'
+    client = Kubeclient::Client.new('http://localhost:8080/api/')
+    service = client.get_service('redis-slave', 'development')
 
-    assert_instance_of(Kubeclient::Service, service)
+    assert_instance_of(Kubeclient::Resource, service)
     assert_equal('2015-04-05T13:00:31Z',
                  service.metadata.creationTimestamp)
     assert_equal('bdb80a8f-db93-11e4-b293-f8b156af4ae1', service.metadata.uid)
@@ -163,10 +164,11 @@ class TestService < MiniTest::Test
       .to_return(body: open_test_file('core_api_resource_list.json'),
                  status: 200)
     stub_request(:delete, %r{/namespaces/default/services})
-      .to_return(status: 200)
+      .to_return(body: open_test_file('service.json'), status: 200)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
-    client.delete_service our_service.name, 'default'
+    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
+    our_service = client.delete_service(our_service.name, 'default')
+    assert_kind_of(RecursiveOpenStruct, our_service)
 
     assert_requested(:delete,
                      'http://localhost:8080/api/v1/namespaces/default/services/redis-service',
@@ -182,10 +184,10 @@ class TestService < MiniTest::Test
     stub_request(:get, %r{/services/redis-slave})
       .to_return(status: 404)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/'
+    client = Kubeclient::Client.new('http://localhost:8080/api/')
 
-    exception = assert_raises(KubeException) do
-      client.get_service 'redis-slave'
+    exception = assert_raises(Kubeclient::HttpError) do
+      client.get_service('redis-slave')
     end
     assert_equal(404, exception.error_code)
   end
@@ -198,8 +200,8 @@ class TestService < MiniTest::Test
       .to_return(body: open_test_file('service.json'),
                  status: 200)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/'
-    service = client.get_service 'redis-slave', 'development'
+    client = Kubeclient::Client.new('http://localhost:8080/api/')
+    service = client.get_service('redis-slave', 'development')
     assert_equal('redis-slave', service.metadata.name)
 
     assert_requested(:get,
@@ -222,8 +224,9 @@ class TestService < MiniTest::Test
     stub_request(:put, expected_url)
       .to_return(body: open_test_file('service_update.json'), status: 201)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
-    client.update_service service
+    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
+    service = client.update_service(service)
+    assert_kind_of(RecursiveOpenStruct, service)
 
     assert_requested(:put, expected_url, times: 1) do |req|
       data = JSON.parse(req.body)
@@ -248,8 +251,9 @@ class TestService < MiniTest::Test
     stub_request(:put, expected_url)
       .to_return(body: open_test_file('service_update.json'), status: 201)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
-    client.update_service service
+    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
+    service = client.update_service(service)
+    assert_kind_of(RecursiveOpenStruct, service)
 
     assert_requested(:put, expected_url, times: 1) do |req|
       data = JSON.parse(req.body)
@@ -281,8 +285,9 @@ class TestService < MiniTest::Test
       }
     }
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
-    client.patch_service name, patch, 'development'
+    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
+    service = client.patch_service(name, patch, 'development')
+    assert_kind_of(RecursiveOpenStruct, service)
 
     assert_requested(:patch, expected_url, times: 1) do |req|
       data = JSON.parse(req.body)

data/test/test_service_account.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require_relative 'test_helper'
 
 # ServiceAccount tests
 class TestServiceAccount < MiniTest::Test
@@ -10,10 +10,10 @@ class TestServiceAccount < MiniTest::Test
       .to_return(body: open_test_file('core_api_resource_list.json'),
                  status: 200)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
-    account = client.get_service_account 'default'
+    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
+    account = client.get_service_account('default')
 
-    assert_instance_of(Kubeclient::ServiceAccount, account)
+    assert_instance_of(Kubeclient::Resource, account)
     assert_equal('default', account.metadata.name)
     assert_equal('default-token-6s23q', account.secrets[0].name)
     assert_equal('default-dockercfg-62tf3', account.secrets[1].name)

data/test/test_watch.rb

@@ -1,23 +1,21 @@
-require 'test_helper'
+require_relative 'test_helper'
 
 # Watch entity tests
 class TestWatch < MiniTest::Test
   def test_watch_pod_success
+    stub_resource_list
+
     expected = [
       { 'type' => 'ADDED', 'resourceVersion' => '1389' },
       { 'type' => 'MODIFIED', 'resourceVersion' => '1390' },
       { 'type' => 'DELETED', 'resourceVersion' => '1398' }
     ]
 
-    stub_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
-
-    stub_request(:get, %r{.*\/watch/pods})
+    stub_request(:get, %r{/watch/pods})
       .to_return(body: open_test_file('watch_stream.json'),
                  status: 200)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
+    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
 
     client.watch_pods.to_enum.with_index do |notice, index|
       assert_instance_of(Kubeclient::Common::WatchNotice, notice)
@@ -29,14 +27,27 @@ class TestWatch < MiniTest::Test
     end
   end
 
+  def test_watch_pod_raw
+    stub_resource_list
+
+    stub_request(:get, %r{/watch/pods}).to_return(
+      body: open_test_file('watch_stream.json'),
+      status: 200
+    )
+
+    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
+
+    got = nil
+    client.watch_pods(as: :raw).each { |notice| got = notice }
+    assert_match(/\A{"type":"DELETED"/, got)
+  end
+
   def test_watch_pod_failure
-    stub_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
-    stub_request(:get, %r{.*\/watch/pods}).to_return(status: 404)
+    stub_resource_list
+    stub_request(:get, %r{/watch/pods}).to_return(status: 404)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
-    assert_raises KubeException do
+    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
+    assert_raises(Kubeclient::HttpError) do
       client.watch_pods.each do
       end
     end
@@ -51,24 +62,33 @@ class TestWatch < MiniTest::Test
       .to_return(body: open_test_file('pod_log.txt'),
                  status: 200)
 
-    stream = Kubeclient::Common::WatchStream.new(URI.parse(url), {}, format: :txt)
+    stream = Kubeclient::Common::WatchStream.new(URI.parse(url), {}, as: :raw)
     stream.to_enum.with_index do |line, index|
       assert_instance_of(String, line)
       assert_equal(expected_lines[index], line)
     end
   end
 
+  # Ensure that WatchStream respects a format that's not JSON
+  def test_watch_stream_unknown
+    url = 'http://www.example.com/foobar'
+    stub_request(:get, url)
+      .to_return(body: open_test_file('pod_log.txt'),
+                 status: 200)
+
+    stream = Kubeclient::Common::WatchStream.new(URI.parse(url), {}, as: :foo)
+    assert_raises(NotImplementedError) { stream.each {} }
+  end
+
   def test_watch_with_resource_version
     api_host = 'http://localhost:8080/api'
     version = '1995'
-    stub_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
+    stub_resource_list
     stub_request(:get, %r{.*\/watch/events})
       .to_return(body: open_test_file('watch_stream.json'),
                  status: 200)
 
-    client = Kubeclient::Client.new api_host, 'v1'
+    client = Kubeclient::Client.new(api_host, 'v1')
     results = client.watch_events(version).to_enum
 
     assert_equal(3, results.count)
@@ -81,14 +101,12 @@ class TestWatch < MiniTest::Test
     api_host = 'http://localhost:8080/api'
     selector = 'name=redis-master'
 
-    stub_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
+    stub_resource_list
     stub_request(:get, %r{.*\/watch/events})
       .to_return(body: open_test_file('watch_stream.json'),
                  status: 200)
 
-    client = Kubeclient::Client.new api_host, 'v1'
+    client = Kubeclient::Client.new(api_host, 'v1')
     results = client.watch_events(label_selector: selector).to_enum
 
     assert_equal(3, results.count)
@@ -101,14 +119,12 @@ class TestWatch < MiniTest::Test
     api_host = 'http://localhost:8080/api'
     selector = 'involvedObject.kind=Pod'
 
-    stub_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
+    stub_resource_list
     stub_request(:get, %r{.*\/watch/events})
       .to_return(body: open_test_file('watch_stream.json'),
                  status: 200)
 
-    client = Kubeclient::Client.new api_host, 'v1'
+    client = Kubeclient::Client.new(api_host, 'v1')
     results = client.watch_events(field_selector: selector).to_enum
 
     assert_equal(3, results.count)
@@ -120,9 +136,7 @@ class TestWatch < MiniTest::Test
   def test_watch_with_finish_and_ebadf
     api_host = 'http://localhost:8080/api'
 
-    stub_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
+    stub_resource_list
     stub_request(:get, %r{.*\/watch/events})
       .to_return(body: open_test_file('watch_stream.json'), status: 200)
 
@@ -137,4 +151,13 @@ class TestWatch < MiniTest::Test
 
     assert_requested(:get, "#{api_host}/v1/watch/events", times: 1)
   end
+
+  private
+
+  def stub_resource_list
+    stub_request(:get, %r{/api/v1$}).to_return(
+      body: open_test_file('core_api_resource_list.json'),
+      status: 200
+    )
+  end
 end