ruboty-k8s 0.1.1 → 0.1.2

data/lib/kubeclient/test/test_resource_quota.rb

@@ -1,25 +0,0 @@
-require 'test_helper'
-
-# ResourceQuota tests
-class TestResourceQuota < 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)
-    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::ResourceQuota, 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/lib/kubeclient/test/test_secret.rb

@@ -1,70 +0,0 @@
-require 'test_helper'
-
-# Namespace entity tests
-class TestSecret < MiniTest::Test
-  def test_get_secret_v1
-    stub_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
-
-    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::Secret, 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_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
-
-    stub_request(:delete, %r{/secrets})
-      .to_return(status: 200)
-
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
-    client.delete_secret 'test-secret', 'dev'
-
-    assert_requested(:delete,
-                     'http://localhost:8080/api/v1/namespaces/dev/secrets/test-secret',
-                     times: 1)
-  end
-
-  def test_create_secret_v1
-    stub_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
-
-    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::Secret, 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/lib/kubeclient/test/test_service.rb

@@ -1,293 +0,0 @@
-require '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_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
-
-    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::Service, 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_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_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
-    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_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
-    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_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
-    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::Service, 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_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
-    stub_request(:delete, %r{/namespaces/default/services})
-      .to_return(status: 200)
-
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
-    client.delete_service our_service.name, 'default'
-
-    assert_requested(:delete,
-                     'http://localhost:8080/api/v1/namespaces/default/services/redis-service',
-                     times: 1)
-  end
-
-  def test_get_service_no_ns
-    stub_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
-    # 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(KubeException) do
-      client.get_service 'redis-slave'
-    end
-    assert_equal(404, exception.error_code)
-  end
-
-  def test_get_service
-    stub_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
-    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_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
-    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'
-    client.update_service 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_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
-    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'
-    client.update_service 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_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
-    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'
-    client.patch_service name, patch, 'development'
-
-    assert_requested(:patch, expected_url, times: 1) do |req|
-      data = JSON.parse(req.body)
-      data['metadata']['annotations']['key'] == 'value'
-    end
-  end
-end

data/lib/kubeclient/test/test_service_account.rb

@@ -1,28 +0,0 @@
-require 'test_helper'
-
-# ServiceAccount tests
-class TestServiceAccount < MiniTest::Test
-  def test_get_from_json_v1
-    stub_request(:get, %r{/serviceaccounts})
-      .to_return(body: open_test_file('service_account.json'),
-                 status: 200)
-    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'
-    account = client.get_service_account 'default'
-
-    assert_instance_of(Kubeclient::ServiceAccount, 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)
-
-    assert_requested(:get,
-                     'http://localhost:8080/api/v1/serviceaccounts/default',
-                     times: 1)
-    assert_requested(:get,
-                     'http://localhost:8080/api/v1',
-                     times: 1)
-  end
-end

data/lib/kubeclient/test/test_watch.rb

@@ -1,119 +0,0 @@
-require 'test_helper'
-
-# Watch entity tests
-class TestWatch < MiniTest::Test
-  def test_watch_pod_success
-    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})
-      .to_return(body: open_test_file('watch_stream.json'),
-                 status: 200)
-
-    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)
-      assert_equal(expected[index]['type'], notice.type)
-      assert_equal('Pod', notice.object.kind)
-      assert_equal('php', notice.object.metadata.name)
-      assert_equal(expected[index]['resourceVersion'],
-                   notice.object.metadata.resourceVersion)
-    end
-  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)
-
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
-    assert_raises KubeException do
-      client.watch_pods.each do
-      end
-    end
-  end
-
-  # Ensure that WatchStream respects a format that's not JSON
-  def test_watch_stream_text
-    url = 'http://www.example.com/foobar'
-    expected_lines = open_test_file('pod_log.txt').read.split("\n")
-
-    stub_request(:get, url)
-      .to_return(body: open_test_file('pod_log.txt'),
-                 status: 200)
-
-    stream = Kubeclient::Common::WatchStream.new(URI.parse(url), {}, format: :txt)
-    stream.to_enum.with_index do |line, index|
-      assert_instance_of(String, line)
-      assert_equal(expected_lines[index], line)
-    end
-  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_request(:get, %r{.*\/watch/events})
-      .to_return(body: open_test_file('watch_stream.json'),
-                 status: 200)
-
-    client = Kubeclient::Client.new api_host, 'v1'
-    results = client.watch_events(version).to_enum
-
-    assert_equal(3, results.count)
-    assert_requested(:get,
-                     "#{api_host}/v1/watch/events?resourceVersion=#{version}",
-                     times: 1)
-  end
-
-  def test_watch_with_label_selector
-    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_request(:get, %r{.*\/watch/events})
-      .to_return(body: open_test_file('watch_stream.json'),
-                 status: 200)
-
-    client = Kubeclient::Client.new api_host, 'v1'
-    results = client.watch_events(label_selector: selector).to_enum
-
-    assert_equal(3, results.count)
-    assert_requested(:get,
-                     "#{api_host}/v1/watch/events?labelSelector=#{selector}",
-                     times: 1)
-  end
-
-  def test_watch_with_field_selector
-    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_request(:get, %r{.*\/watch/events})
-      .to_return(body: open_test_file('watch_stream.json'),
-                 status: 200)
-
-    client = Kubeclient::Client.new api_host, 'v1'
-    results = client.watch_events(field_selector: selector).to_enum
-
-    assert_equal(3, results.count)
-    assert_requested(:get,
-                     "#{api_host}/v1/watch/events?fieldSelector=#{selector}",
-                     times: 1)
-  end
-end