kubeclient-rollback-dev 2.3.0

data/test/test_namespace.rb

@@ -0,0 +1,61 @@
+require '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)
+    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::Namespace, 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_request(:get, %r{/api/v1$})
+      .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
+    )
+  end
+
+  def test_create_namespace
+    stub_request(:get, %r{/api/v1$})
+      .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)
+
+    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)
+    assert_equal(namespace.metadata.name, created_namespace.metadata.name)
+  end
+end

data/test/test_node.rb

@@ -0,0 +1,33 @@
+require '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)
+    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'
+    node = client.get_node('127.0.0.1')
+
+    assert_instance_of(Kubeclient::Node, 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
+end

data/test/test_persistent_volume.rb

@@ -0,0 +1,30 @@
+require '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)
+    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'
+    volume = client.get_persistent_volume 'pv0001'
+
+    assert_instance_of(Kubeclient::PersistentVolume, 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

@@ -0,0 +1,30 @@
+require '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)
+    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'
+    claim = client.get_persistent_volume_claim 'myclaim-1', 'default'
+
+    assert_instance_of(Kubeclient::PersistentVolumeClaim, 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

@@ -0,0 +1,29 @@
+require '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)
+    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'
+    pod = client.get_pod 'redis-master-pod', 'default'
+
+    assert_instance_of(Kubeclient::Pod, 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
+end

data/test/test_pod_log.rb

@@ -0,0 +1,50 @@
+require '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_watch_pod_log
+    expected_lines = open_test_file('pod_log.txt').read.split("\n")
+
+    stub_request(:get, %r{/namespaces/default/pods/[a-z0-9-]+/log\?.*follow})
+      .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
+end

data/test/test_process_template.rb

@@ -0,0 +1,44 @@
+require '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
+end

data/test/test_replication_controller.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+# Replication Controller entity tests
+class TestReplicationController < 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{/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::ReplicationController, 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
+end

data/test/test_resource_list_without_kind.rb

@@ -0,0 +1,78 @@
+require '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

@@ -0,0 +1,25 @@
+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/test/test_secret.rb

@@ -0,0 +1,70 @@
+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