kubeclient 4.7.0 → 4.12.0

data/test/test_process_template.rb

@@ -1,80 +0,0 @@
-require_relative 'test_helper'
-
-# Process Template tests
-class TestProcessTemplate < MiniTest::Test
-  def test_process_template
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    template = {}
-    template[:metadata] = {}
-    template[:metadata][:name] = 'my-template'
-    template[:metadata][:namespace] = 'default'
-    template[:kind] = 'Template'
-    template[:apiVersion] = 'v1'
-    service = {}
-    service[:metadata] = {}
-    service[:metadata][:name] = '${NAME_PREFIX}my-service'
-    service[:kind] = 'Service'
-    service[:apiVersion] = 'v1'
-    template[:objects] = [service]
-    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/"}]}'
-
-    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)
-
-    assert_equal('test/my-service', processed_template['objects'].first['metadata']['name'])
-
-    assert_requested(:post, expected_url, times: 1) do |req|
-      data = JSON.parse(req.body)
-      data['kind'] == 'Template' &&
-        data['apiVersion'] == 'v1' &&
-        data['metadata']['name'] == 'my-template' &&
-        data['metadata']['namespace'] == 'default'
-    end
-  end
-
-  # Ensure _template and _templates methods hit `/templates` rather than
-  # `/processedtemplates` URL.
-  def test_templates_methods
-    stub_request(:get, %r{/apis/template\.openshift\.io/v1$}).to_return(
-      body: open_test_file('template.openshift.io_api_resource_list.json'),
-      status: 200
-    )
-    client = Kubeclient::Client.new('http://localhost:8080/apis/template.openshift.io', 'v1')
-
-    expected_url = 'http://localhost:8080/apis/template.openshift.io/v1/namespaces/default/templates'
-    stub_request(:get, expected_url)
-      .to_return(body: open_test_file('template_list.json'), status: 200)
-    client.get_templates(namespace: 'default')
-    assert_requested(:get, expected_url, times: 1)
-
-    expected_url = 'http://localhost:8080/apis/template.openshift.io/v1/namespaces/default/templates/my-template'
-    stub_request(:get, expected_url)
-      .to_return(body: open_test_file('template.json'), status: 200)
-    client.get_template('my-template', 'default')
-    assert_requested(:get, expected_url, times: 1)
-  end
-
-  def test_no_processedtemplates_methods
-    stub_request(:get, %r{/apis/template\.openshift\.io/v1$}).to_return(
-      body: open_test_file('template.openshift.io_api_resource_list.json'),
-      status: 200
-    )
-    client = Kubeclient::Client.new('http://localhost:8080/apis/template.openshift.io', 'v1')
-    client.discover
-
-    refute_respond_to(client, :get_processedtemplates)
-    refute_respond_to(client, :get_processedtemplate)
-    refute_respond_to(client, :get_processed_templates)
-    refute_respond_to(client, :get_processed_template)
-  end
-end

data/test/test_replication_controller.rb

@@ -1,47 +0,0 @@
-require_relative 'test_helper'
-
-# Replication Controller entity tests
-class TestReplicationController < MiniTest::Test
-  def test_get_from_json_v1
-    stub_core_api_list
-    stub_request(:get, %r{/replicationcontrollers})
-      .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')
-
-    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)
-    assert_equal(3, rc.spec.replicas)
-    assert_equal('guestbook', rc.spec.selector.name)
-
-    assert_requested(:get,
-                     'http://localhost:8080/api/v1/namespaces/default/replicationcontrollers/frontendController',
-                     times: 1)
-  end
-
-  def test_delete_replicaset_cascade
-    stub_core_api_list
-    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

data/test/test_resource_list_without_kind.rb

@@ -1,78 +0,0 @@
-require_relative 'test_helper'
-
-# Core api resource list without kind tests
-class TestResourceListWithoutKind < MiniTest::Test
-  def test_get_from_json_api_v1
-    stub_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list_without_kind.json'),
-                 status: 200)
-
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    client.discover
-
-    [
-      {
-        entity: 'pod',
-        type: 'Pod',
-        name: 'pods',
-        methods: %w[pod pods]
-      },
-      {
-        entity: 'node',
-        type: 'Node',
-        name: 'nodes',
-        methods: %w[node nodes]
-      },
-      {
-        entity: 'service',
-        type: 'Service',
-        name: 'services',
-        methods: %w[service services]
-      }
-    ].each { |h| assert_entities(client.instance_variable_get(:@entities)[h[:entity]], h) }
-
-    assert_requested(:get,
-                     'http://localhost:8080/api/v1',
-                     times: 1)
-  end
-
-  def test_get_from_json_oapi_v1
-    stub_request(:get, %r{/oapi/v1$})
-      .to_return(body: open_test_file('core_oapi_resource_list_without_kind.json'),
-                 status: 200)
-
-    client = Kubeclient::Client.new('http://localhost:8080/oapi/', 'v1')
-    client.discover
-
-    [
-      {
-        entity: 'template',
-        type: 'Template',
-        name: 'templates',
-        methods: %w[template templates]
-      },
-      {
-        entity: 'build',
-        type: 'Build',
-        name: 'builds',
-        methods: %w[build builds]
-      },
-      {
-        entity: 'project',
-        type: 'Project',
-        name: 'projects',
-        methods: %w[project projects]
-      }
-    ].each { |h| assert_entities(client.instance_variable_get(:@entities)[h[:entity]], h) }
-
-    assert_requested(:get,
-                     'http://localhost:8080/oapi/v1',
-                     times: 1)
-  end
-
-  def assert_entities(entity, h)
-    assert_equal(entity.entity_type, h[:type])
-    assert_equal(entity.resource_name, h[:name])
-    assert_equal(entity.method_names, h[:methods])
-  end
-end

data/test/test_resource_quota.rb

@@ -1,23 +0,0 @@
-require_relative 'test_helper'
-
-# ResourceQuota tests
-class TestResourceQuota < MiniTest::Test
-  def test_get_from_json_v1
-    stub_core_api_list
-    stub_request(:get, %r{/resourcequotas})
-      .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')
-
-    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)
-
-    assert_requested(:get,
-                     'http://localhost:8080/api/v1/namespaces/quota-example/resourcequotas/quota',
-                     times: 1)
-  end
-end

data/test/test_secret.rb

@@ -1,62 +0,0 @@
-require_relative 'test_helper'
-
-# Namespace entity tests
-class TestSecret < MiniTest::Test
-  def test_get_secret_v1
-    stub_core_api_list
-    stub_request(:get, %r{/secrets})
-      .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')
-
-    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)
-    assert_equal('Y2F0J3MgYXJlIGF3ZXNvbWUK', secret.data['super-secret'])
-
-    assert_requested(:get,
-                     'http://localhost:8080/api/v1/namespaces/dev/secrets/test-secret',
-                     times: 1)
-  end
-
-  def test_delete_secret_v1
-    stub_core_api_list
-    stub_request(:delete, %r{/secrets})
-      .to_return(status: 200, body: open_test_file('created_secret.json'))
-
-    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',
-                     times: 1)
-  end
-
-  def test_create_secret_v1
-    stub_core_api_list
-    stub_request(:post, %r{/secrets})
-      .to_return(body: open_test_file('created_secret.json'),
-                 status: 201)
-
-    secret = Kubeclient::Resource.new
-    secret.metadata = {}
-    secret.metadata.name = 'test-secret'
-    secret.metadata.namespace = 'dev'
-    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::Resource, created_secret)
-    assert_equal(secret.metadata.name, created_secret.metadata.name)
-    assert_equal(secret.metadata.namespace, created_secret.metadata.namespace)
-    assert_equal(
-      secret.data['super-secret'],
-      created_secret.data['super-secret']
-    )
-  end
-end

data/test/test_security_context_constraint.rb

@@ -1,62 +0,0 @@
-require_relative 'test_helper'
-
-# kind: 'SecurityContextConstraints' entity tests.
-# This is one of the unusual `kind`s that are already plural (https://github.com/kubernetes/kubernetes/issues/8115).
-# We force singular in method names like 'create_endpoint',
-# but `kind` should remain plural as in kubernetes.
-class TestSecurityContextConstraints < MiniTest::Test
-  def test_create_security_context_constraint
-    stub_request(:get, %r{/apis/security.openshift.io/v1$}).to_return(
-      body: open_test_file('security.openshift.io_api_resource_list.json'),
-      status: 200
-    )
-
-    testing_scc = Kubeclient::Resource.new(
-      metadata: {
-        name: 'teleportation'
-      },
-      runAsUser: {
-        type: 'MustRunAs'
-      },
-      seLinuxContext: {
-        type: 'MustRunAs'
-      }
-    )
-    req_body = '{"metadata":{"name":"teleportation"},"runAsUser":{"type":"MustRunAs"},' \
-      '"seLinuxContext":{"type":"MustRunAs"},' \
-      '"kind":"SecurityContextConstraints","apiVersion":"security.openshift.io/v1"}'
-
-    stub_request(:post, 'http://localhost:8080/apis/security.openshift.io/v1/securitycontextconstraints')
-      .with(body: req_body)
-      .to_return(body: open_test_file('created_security_context_constraint.json'), status: 201)
-
-    client = Kubeclient::Client.new('http://localhost:8080/apis/security.openshift.io', 'v1')
-    created_scc = client.create_security_context_constraint(testing_scc)
-    assert_equal('SecurityContextConstraints', created_scc.kind)
-    assert_equal('security.openshift.io/v1', created_scc.apiVersion)
-
-    client = Kubeclient::Client.new('http://localhost:8080/apis/security.openshift.io', 'v1',
-                                    as: :parsed_symbolized)
-    created_scc = client.create_security_context_constraint(testing_scc)
-    assert_equal('SecurityContextConstraints', created_scc[:kind])
-    assert_equal('security.openshift.io/v1', created_scc[:apiVersion])
-  end
-
-  def test_get_security_context_constraints
-    stub_request(:get, %r{/apis/security.openshift.io/v1$}).to_return(
-      body: open_test_file('security.openshift.io_api_resource_list.json'),
-      status: 200
-    )
-    stub_request(:get, %r{/securitycontextconstraints})
-      .to_return(body: open_test_file('security_context_constraint_list.json'), status: 200)
-    client = Kubeclient::Client.new('http://localhost:8080/apis/security.openshift.io', 'v1')
-
-    collection = client.get_security_context_constraints(as: :parsed_symbolized)
-    assert_equal('SecurityContextConstraintsList', collection[:kind])
-    assert_equal('security.openshift.io/v1', collection[:apiVersion])
-
-    # Stripping of 'List' in collection.kind RecursiveOpenStruct mode only is historic.
-    collection = client.get_security_context_constraints
-    assert_equal('SecurityContextConstraints', collection.kind)
-  end
-end

data/test/test_service.rb

@@ -1,330 +0,0 @@
-require_relative 'test_helper'
-
-# Service entity tests
-class TestService < MiniTest::Test
-  def test_construct_our_own_service
-    our_service = Kubeclient::Resource.new
-    our_service.metadata = {}
-    our_service.metadata.name = 'guestbook'
-    our_service.metadata.namespace = 'staging'
-    our_service.metadata.labels = {}
-    our_service.metadata.labels.name = 'guestbook'
-
-    our_service.spec = {}
-    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])
-
-    expected_url = 'http://localhost:8080/api/v1/namespaces/staging/services'
-    stub_core_api_list
-    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)
-
-    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_nil(our_service.kind)
-
-    assert_requested(:post, expected_url, times: 1) do |req|
-      data = JSON.parse(req.body)
-      data['kind'] == 'Service' &&
-        data['apiVersion'] == 'v1' &&
-        data['metadata']['name'] == 'guestbook' &&
-        data['metadata']['namespace'] == 'staging'
-    end
-  end
-
-  def test_construct_service_from_symbol_keys
-    service = Kubeclient::Resource.new
-    service.metadata = {
-      labels: { tier: 'frontend' },
-      name: 'test-service',
-      namespace: 'staging'
-    }
-    service.spec = {
-      ports: [{
-        port: 3000,
-        targetPort: 'http-server',
-        protocol: 'TCP'
-      }]
-    }
-
-    expected_url = 'http://localhost:8080/api/v1/namespaces/staging/services'
-    stub_core_api_list
-    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)
-
-    assert_requested(:post, expected_url, times: 1) do |req|
-      data = JSON.parse(req.body)
-      data['kind'] == 'Service' &&
-        data['apiVersion'] == 'v1' &&
-        data['metadata']['name'] == 'test-service' &&
-        data['metadata']['labels']['tier'] == 'frontend' &&
-        data['metadata']['namespace'] == 'staging'
-    end
-  end
-
-  def test_construct_service_from_string_keys
-    service = Kubeclient::Resource.new
-    service.metadata = {
-      'labels' => { 'tier' => 'frontend' },
-      'name' => 'test-service',
-      'namespace' => 'staging'
-    }
-    service.spec = {
-      'ports' => [{
-        'port' => 3000,
-        'targetPort' => 'http-server',
-        'protocol' => 'TCP'
-      }]
-    }
-
-    stub_core_api_list
-    expected_url = 'http://localhost:8080/api/v1/namespaces/staging/services'
-    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)
-
-    assert_requested(:post, expected_url, times: 1) do |req|
-      data = JSON.parse(req.body)
-      data['kind'] == 'Service' &&
-        data['apiVersion'] == 'v1' &&
-        data['metadata']['name'] == 'test-service' &&
-        data['metadata']['labels']['tier'] == 'frontend' &&
-        data['metadata']['namespace'] == 'staging'
-    end
-  end
-
-  def test_conversion_from_json_v1
-    stub_core_api_list
-    stub_request(:get, %r{/services})
-      .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')
-
-    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)
-    assert_equal('redis-slave', service.metadata.name)
-    assert_equal('2815', service.metadata.resourceVersion)
-    assert_equal('v1', service.apiVersion)
-    assert_equal('10.0.0.140', service.spec.clusterIP)
-    assert_equal('development', service.metadata.namespace)
-
-    assert_equal('TCP', service.spec.ports[0].protocol)
-    assert_equal(6379, service.spec.ports[0].port)
-    assert_equal('', service.spec.ports[0].name)
-    assert_equal('redis-server', service.spec.ports[0].targetPort)
-
-    assert_requested(:get,
-                     'http://localhost:8080/api/v1/namespaces/development/services/redis-slave',
-                     times: 1)
-  end
-
-  def test_delete_service
-    our_service = Kubeclient::Resource.new
-    our_service.name = 'redis-service'
-    # TODO, new ports assignment to be added
-    our_service.labels = {}
-    our_service.labels.component = 'apiserver'
-    our_service.labels.provider = 'kubernetes'
-
-    stub_core_api_list
-    stub_request(:delete, %r{/namespaces/default/services})
-      .to_return(body: open_test_file('service.json'), status: 200)
-
-    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',
-                     times: 1)
-  end
-
-  def test_get_service_no_ns
-    stub_core_api_list
-    # when not specifying namespace for entities which
-    # are not node or namespace, the request will fail
-    stub_request(:get, %r{/services/redis-slave})
-      .to_return(status: 404)
-
-    client = Kubeclient::Client.new('http://localhost:8080/api/')
-
-    exception = assert_raises(Kubeclient::HttpError) do
-      client.get_service('redis-slave')
-    end
-    assert_equal(404, exception.error_code)
-  end
-
-  def test_get_service
-    stub_core_api_list
-    stub_request(:get, %r{/namespaces/development/services/redis-slave})
-      .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')
-    assert_equal('redis-slave', service.metadata.name)
-
-    assert_requested(:get,
-                     'http://localhost:8080/api/v1/namespaces/development/services/redis-slave',
-                     times: 1)
-  end
-
-  def test_update_service
-    service = Kubeclient::Resource.new
-    name = 'my_service'
-
-    service.metadata = {}
-    service.metadata.name      = name
-    service.metadata.namespace = 'development'
-
-    stub_core_api_list
-    expected_url = "http://localhost:8080/api/v1/namespaces/development/services/#{name}"
-    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')
-    service = client.update_service(service)
-    assert_kind_of(RecursiveOpenStruct, service)
-
-    assert_requested(:put, expected_url, times: 1) do |req|
-      data = JSON.parse(req.body)
-      data['metadata']['name'] == name &&
-        data['metadata']['namespace'] == 'development'
-    end
-  end
-
-  def test_update_service_with_string_keys
-    service = Kubeclient::Resource.new
-    name = 'my_service'
-
-    service.metadata = {
-      'name' => name,
-      'namespace' => 'development'
-    }
-
-    stub_core_api_list
-    expected_url = "http://localhost:8080/api/v1/namespaces/development/services/#{name}"
-    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')
-    service = client.update_service(service)
-    assert_kind_of(RecursiveOpenStruct, service)
-
-    assert_requested(:put, expected_url, times: 1) do |req|
-      data = JSON.parse(req.body)
-      data['metadata']['name'] == name &&
-        data['metadata']['namespace'] == 'development'
-    end
-  end
-
-  def test_patch_service
-    service = Kubeclient::Resource.new
-    name = 'my_service'
-
-    service.metadata = {}
-    service.metadata.name      = name
-    service.metadata.namespace = 'development'
-
-    stub_core_api_list
-    expected_url = "http://localhost:8080/api/v1/namespaces/development/services/#{name}"
-    stub_request(:patch, expected_url)
-      .to_return(body: open_test_file('service_patch.json'), status: 200)
-
-    patch = {
-      metadata: {
-        annotations: {
-          key: 'value'
-        }
-      }
-    }
-
-    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['metadata']['annotations']['key'] == 'value'
-    end
-  end
-
-  def test_json_patch_service
-    service = Kubeclient::Resource.new
-    name = 'my-service'
-
-    service.metadata = {}
-    service.metadata.name      = name
-    service.metadata.namespace = 'development'
-
-    stub_core_api_list
-    expected_url = "http://localhost:8080/api/v1/namespaces/development/services/#{name}"
-    stub_request(:patch, expected_url)
-      .to_return(body: open_test_file('service_json_patch.json'), status: 200)
-
-    patch = [
-      { 'op' => 'add', 'path' => '/spec/type', 'value' => 'LoadBalancer' }
-    ]
-
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    service = client.json_patch_service(name, patch, 'development')
-    assert_kind_of(RecursiveOpenStruct, service)
-
-    assert_requested(:patch, expected_url, times: 1) do |req|
-      data = JSON.parse(req.body)
-      req.headers['Content-Type'] == 'application/json-patch+json' &&
-        data == patch
-    end
-  end
-
-  def test_merge_patch_service
-    service = Kubeclient::Resource.new
-    name = 'my-service'
-
-    service.metadata = {}
-    service.metadata.name      = name
-    service.metadata.namespace = 'development'
-
-    stub_core_api_list
-    expected_url = "http://localhost:8080/api/v1/namespaces/development/services/#{name}"
-    stub_request(:patch, expected_url)
-      .to_return(body: open_test_file('service_merge_patch.json'), status: 200)
-
-    patch = { spec: { type: 'NodePort' } }
-
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    service = client.merge_patch_service(name, patch, 'development')
-    assert_kind_of(RecursiveOpenStruct, service)
-
-    assert_requested(:patch, expected_url, times: 1) do |req|
-      data = JSON.parse(req.body)
-      req.headers['Content-Type'] == 'application/merge-patch+json' &&
-        data['spec']['type'] == 'NodePort'
-    end
-  end
-end