ruboty-k8s 0.1.1 → 0.1.2

data/lib/kubeclient/test/test_limit_range.rb

@@ -1,27 +0,0 @@
-require '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)
-
-    stub_request(:get, %r{/limitranges})
-      .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'
-
-    assert_instance_of(Kubeclient::LimitRange, 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
-    )
-  end
-end

data/lib/kubeclient/test/test_missing_methods.rb

@@ -1,42 +0,0 @@
-require 'test_helper'
-
-# Test method_missing, respond_to? and respond_to_missing behaviour
-class TestMissingMethods < MiniTest::Test
-  def test_missing
-    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')
-    assert_equal(true, client.respond_to?(:get_pod))
-    assert_equal(true, client.respond_to?(:get_pods))
-    assert_equal(false, client.respond_to?(:get_pie))
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1') # Reset discovery
-    assert_equal(false, client.respond_to?(:get_pie))
-    assert_equal(true, client.respond_to?(:get_pods))
-    assert_equal(true, client.respond_to?(:get_pod))
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1') # Reset discovery
-    assert_instance_of(Method, client.method(:get_pods))
-    assert_raises(NameError) do
-      client.method(:get_pies)
-    end
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1') # Reset discovery
-    assert_raises(NameError) do
-      client.method(:get_pies)
-    end
-    assert_instance_of(Method, client.method(:get_pods))
-
-    stub_request(:get, %r{/api/v1$}).to_return(
-      body: '',
-      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
-      client.method(:get_pods)
-    end
-    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
-    assert_raises(KubeException) do
-      client.respond_to?(:get_pods)
-    end
-  end
-end

data/lib/kubeclient/test/test_namespace.rb

@@ -1,61 +0,0 @@
-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/lib/kubeclient/test/test_node.rb

@@ -1,33 +0,0 @@
-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/lib/kubeclient/test/test_persistent_volume.rb

@@ -1,30 +0,0 @@
-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/lib/kubeclient/test/test_persistent_volume_claim.rb

@@ -1,30 +0,0 @@
-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/lib/kubeclient/test/test_pod.rb

@@ -1,29 +0,0 @@
-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/lib/kubeclient/test/test_pod_log.rb

@@ -1,50 +0,0 @@
-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/lib/kubeclient/test/test_process_template.rb

@@ -1,44 +0,0 @@
-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/lib/kubeclient/test/test_replication_controller.rb

@@ -1,27 +0,0 @@
-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/lib/kubeclient/test/test_resource_list_without_kind.rb

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