kubeclient 0.5.1 → 0.6.0

data/test/json/{service_update_b3.json → service_update.json}

@@ -1,7 +1,7 @@
 {
    "status" : {},
    "kind" : "Service",
-   "apiVersion" : "v1beta3",
+   "apiVersion" : "v1",
    "spec" : {
       "ports" : [
          {
@@ -11,7 +11,7 @@
             "protocol" : "TCP"
          }
       ],
-      "portalIP" : "1.2.3.4"
+      "clusterIP" : "1.2.3.4"
    },
    "metadata" : {
       "name" : "my_service",

data/test/json/watch_stream.json

@@ -0,0 +1,3 @@
+{"type":"ADDED","object":{"kind":"Pod","apiVersion":"v1","metadata":{"name":"php","namespace":"default","selfLink":"/api/v1/pods/php","uid":"e75f2c07-b047-11e4-89e4-525400c903c1","resourceVersion":"1389","creationTimestamp":"2015-02-09T05:39:19-05:00","labels":{"name":"foo"}},"spec":{"volumes":null,"containers":[{"name":"nginx","image":"dockerfile/nginx","ports":[{"hostPort":9090,"containerPort":80,"protocol":"TCP"}],"resources":{},"livenessProbe":{"httpGet":{"path":"/index.html","port":"9090"},"initialDelaySeconds":30},"terminationMessagePath":"/dev/termination-log","imagePullPolicy":"IfNotPresent","securityContext":{"capabilities":{}}}],"restartPolicy":{"always":{}},"dnsPolicy":"ClusterFirst"},"status":{"phase":"Pending"}}}
+{"type":"MODIFIED","object":{"kind":"Pod","apiVersion":"v1","metadata":{"name":"php","namespace":"default","selfLink":"/api/v1/pods/php","uid":"e75f2c07-b047-11e4-89e4-525400c903c1","resourceVersion":"1390","creationTimestamp":"2015-02-09T05:39:19-05:00","labels":{"name":"foo"}},"spec":{"volumes":null,"containers":[{"name":"nginx","image":"dockerfile/nginx","ports":[{"hostPort":9090,"containerPort":80,"protocol":"TCP"}],"resources":{},"livenessProbe":{"httpGet":{"path":"/index.html","port":"9090"},"initialDelaySeconds":30},"terminationMessagePath":"/dev/termination-log","imagePullPolicy":"IfNotPresent","securityContext":{"capabilities":{}}}],"restartPolicy":{"always":{}},"dnsPolicy":"ClusterFirst"},"status":{"phase":"Pending","host":"127.0.0.1"}}}
+{"type":"DELETED","object":{"kind":"Pod","apiVersion":"v1","metadata":{"name":"php","namespace":"default","selfLink":"/api/v1/pods/php","uid":"e75f2c07-b047-11e4-89e4-525400c903c1","resourceVersion":"1398","creationTimestamp":"2015-02-09T05:39:19-05:00","labels":{"name":"foo"}},"spec":{"volumes":null,"containers":[{"name":"nginx","image":"dockerfile/nginx","ports":[{"hostPort":9090,"containerPort":80,"protocol":"TCP"}],"resources":{},"livenessProbe":{"httpGet":{"path":"/index.html","port":"9090"},"initialDelaySeconds":30},"terminationMessagePath":"/dev/termination-log","imagePullPolicy":"IfNotPresent","securityContext":{"capabilities":{}}}],"restartPolicy":{"always":{}},"dnsPolicy":"ClusterFirst"},"status":{"phase":"Pending","host":"127.0.0.1"}}}

data/test/test_guestbook_go.rb

@@ -0,0 +1,233 @@
+require 'test_helper'
+require 'vcr'
+
+# creation of google's example of guest book
+class CreateGuestbookGo < MiniTest::Test
+  def test_create_guestbook_entities
+    VCR.configure do |c|
+      c.cassette_library_dir = 'test/cassettes'
+      c.hook_into :webmock
+    end
+
+    # WebMock.allow_net_connect!
+    VCR.use_cassette('kubernetes_guestbook') do # , record: :new_episodes) do
+      client = Kubeclient::Client.new 'http://10.35.0.23:8080/api/', 'v1'
+
+      testing_ns = Kubeclient::Namespace.new
+      testing_ns.metadata = {}
+      testing_ns.metadata.name = 'kubeclient-ns'
+
+      # delete in case they existed before so creation can be tested
+      delete_namespace(client, testing_ns.metadata.name)
+      delete_services(client, testing_ns.metadata.name,
+                      ['guestbook', 'redis-master', 'redis-slave'])
+      delete_replication_controllers(client, testing_ns.metadata.name,
+                                     ['guestbook', 'redis-master', 'redis-slave'])
+
+      client.create_namespace testing_ns
+      services = create_services(client, testing_ns.metadata.name)
+      replicators = create_replication_controllers(client, testing_ns.metadata.name)
+
+      get_namespaces(client)
+      get_services(client, testing_ns.metadata.name)
+      get_replication_controllers(client, testing_ns.metadata.name)
+
+      delete_services(client, testing_ns.metadata.name, services)
+      delete_replication_controllers(client, testing_ns.metadata.name, replicators)
+
+      client.delete_namespace testing_ns.metadata.name
+    end
+  end
+
+  def delete_namespace(client, namespace_name)
+    client.delete_namespace namespace_name
+    rescue KubeException => exception
+      assert_instance_of(KubeException, exception)
+      assert_equal(404, exception.error_code)
+  end
+
+  def get_namespaces(client)
+    namespaces = client.get_namespaces
+    assert(true, namespaces.size > 2)
+  end
+
+  def get_services(client, ns)
+    retrieved_services = client.get_services(namespace: ns)
+    assert_equal(3, retrieved_services.size)
+  end
+
+  def get_replication_controllers(client, ns)
+    retrieved_replicators = client.get_replication_controllers(namespace: ns)
+    assert_equal(3, retrieved_replicators.size)
+  end
+
+  def create_services(client, ns)
+    guestbook_service = client.create_service guestbook_service(ns)
+    redis_service = client.create_service redis_service(ns)
+    redis_slave_service = client.create_service redis_slave_service(ns)
+    [guestbook_service, redis_service, redis_slave_service]
+  end
+
+  def create_replication_controllers(client, namespace)
+    rc = client.create_replication_controller guestbook_rc(namespace)
+    rc2 = client.create_replication_controller redis_master_rc(namespace)
+    rc3 = client.create_replication_controller redis_slave_rc(namespace)
+    [rc, rc2, rc3]
+  end
+
+  def delete_services(client, namespace, services)
+    # if the entity is not found, no need to fail the test
+    services.each do |service|
+      begin
+        if service.instance_of?(Kubeclient::Service)
+          client.delete_service service.metadata.name, namespace
+        else
+          # it's just a string - service name
+          client.delete_service service, namespace
+        end
+      rescue KubeException => exception
+        assert_instance_of(KubeException, exception)
+        assert_equal(404, exception.error_code)
+      end
+    end
+  end
+
+  def delete_replication_controllers(client, namespace, replication_controllers)
+    # if the entity is not found, no need to fail the test
+    replication_controllers.each do |rc|
+      begin
+        if rc.instance_of?(Kubeclient::ReplicationController)
+          client.delete_replication_controller rc.metadata.name, namespace
+        else
+          # it's just a string - rc name
+          client.delete_replication_controller rc, namespace
+        end
+      rescue KubeException => exception
+        assert_instance_of(KubeException, exception)
+        assert_equal(404, exception.error_code)
+      end
+    end
+  end
+
+  private
+
+  def construct_base_rc(namespace)
+    rc = Kubeclient::ReplicationController.new
+    rc.metadata = {}
+    rc.metadata.namespace = namespace
+    rc.metadata.labels = {}
+    rc.spec = {}
+    rc.spec.selector = {}
+    rc.spec.template = {}
+    rc.spec.template.metadata = {}
+    rc.spec.template.spec = {}
+    rc.spec.template.metadata.labels = {}
+    rc
+  end
+
+  def redis_master_rc(namespace)
+    rc = construct_base_rc(namespace)
+    rc.metadata.name = 'redis-master'
+    rc.metadata.labels.app = 'redis'
+    rc.metadata.labels.role = 'master'
+    rc.spec.replicas = 1
+    rc.spec.selector.app = 'redis'
+    rc.spec.selector.role = 'master'
+    rc.spec.template.metadata.labels.app = 'redis'
+    rc.spec.template.metadata.labels.role = 'master'
+    rc.spec.template.spec.containers = [{ 'name' => 'redis-master',
+                                          'image' => 'redis',
+                                          'ports' => [{ 'name' => 'redis-server',
+                                                        'containerPort' => 6379 }] }]
+    rc
+  end
+
+  def redis_slave_rc(namespace)
+    rc = construct_base_rc(namespace)
+    rc.metadata.name = 'redis-slave'
+    rc.metadata.labels.app = 'redis'
+    rc.metadata.labels.role = 'slave'
+    rc.spec.replicas = 2
+    rc.spec.selector.app = 'redis'
+    rc.spec.selector.role = 'slave'
+    rc.spec.template.metadata.labels.app = 'redis'
+    rc.spec.template.metadata.labels.role = 'slave'
+    rc.spec.template.spec.containers = [{ 'name'          => 'redis-slave',
+                                          'image'         => 'kubernetes/redis-slave:v2',
+                                          'ports'         => [{ 'name'          => 'redis-server',
+                                                                'containerPort' => 6379 }
+                                                             ] }]
+    rc
+  end
+
+  def guestbook_rc(namespace)
+    rc = construct_base_rc(namespace)
+    rc.metadata.name = 'guestbook'
+    rc.metadata.labels.app = 'guestbook'
+    rc.metadata.labels.role = 'slave'
+    rc.spec.replicas = 3
+    rc.spec.selector.app = 'guestbook'
+    rc.spec.template.metadata.labels.app = 'guestbook'
+    rc.spec.template.spec.containers = [{ 'name'     => 'guestbook',
+                                          'image'    => 'kubernetes/guestbook:v2',
+                                          'ports'    => [{ 'name'          => 'http-server',
+                                                           'containerPort' => 3000 }]
+                                        }]
+
+    rc
+  end
+
+  def base_service(namespace)
+    our_service = Kubeclient::Service.new
+    our_service.metadata = {}
+    our_service.metadata.namespace = namespace
+    our_service.metadata.labels = {}
+    our_service.spec = {}
+    our_service.spec.selector = {}
+    our_service
+  end
+
+  def redis_slave_service(namespace)
+    our_service = base_service(namespace)
+    our_service.metadata.name = 'redis-slave'
+    our_service.metadata.labels.app = 'redis'
+    our_service.metadata.labels.role = 'slave'
+
+    our_service.spec.ports = [{ 'port' => 6379,
+                                'targetPort' => 'redis-server'
+                              }]
+
+    our_service.spec.selector.app = 'redis'
+    our_service.spec.selector.role = 'slave'
+    our_service
+  end
+
+  def redis_service(namespace)
+    our_service = base_service(namespace)
+    our_service.metadata.name = 'redis-master'
+    our_service.metadata.labels.app = 'redis'
+    our_service.metadata.labels.role = 'master'
+
+    our_service.spec.ports = [{ 'port' => 6379,
+                                'targetPort' => 'redis-server'
+                              }]
+
+    our_service.spec.selector.app = 'redis'
+    our_service.spec.selector.role = 'master'
+    our_service
+  end
+
+  def guestbook_service(namespace)
+    our_service = base_service(namespace)
+    our_service.metadata.name = 'guestbook'
+    our_service.metadata.labels.name = 'guestbook'
+
+    our_service.spec.ports = [{ 'port' => 3000,
+                                'targetPort' => 'http-server'
+                              }]
+
+    our_service.spec.selector.app = 'guestbook'
+    our_service.type = 'LoadBalancer'
+    our_service
+  end
+end

data/test/test_kubeclient.rb

@@ -27,24 +27,24 @@ class KubeClientTest < MiniTest::Test
     uri.hostname = 'localhost'
     client = Kubeclient::Client.new uri
     rest_client = client.rest_client
-    assert_equal 'http://localhost:8080/api/v1beta3', rest_client.url.to_s
+    assert_equal 'http://localhost:8080/api/v1', rest_client.url.to_s
   end
 
   def test_no_path_in_uri
-    client = Kubeclient::Client.new 'http://localhost:8080', 'v1beta3'
+    client = Kubeclient::Client.new 'http://localhost:8080', 'v1'
     rest_client = client.rest_client
-    assert_equal 'http://localhost:8080/api/v1beta3', rest_client.url.to_s
+    assert_equal 'http://localhost:8080/api/v1', rest_client.url.to_s
   end
 
   def test_no_version_passed
     client = Kubeclient::Client.new 'http://localhost:8080'
     rest_client = client.rest_client
-    assert_equal 'http://localhost:8080/api/v1beta3', rest_client.url.to_s
+    assert_equal 'http://localhost:8080/api/v1', rest_client.url.to_s
   end
 
   def test_exception
     stub_request(:post, %r{/services})
-      .to_return(body: open_test_json_file('namespace_exception_b3.json'),
+      .to_return(body: open_test_json_file('namespace_exception.json'),
                  status: 409)
 
     service = Kubeclient::Service.new
@@ -71,7 +71,7 @@ class KubeClientTest < MiniTest::Test
     stub_request(:get, 'http://localhost:8080/api')
       .to_return(status: 200, body: open_test_json_file('versions_list.json'))
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
+    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
     response = client.api
     assert_includes(response, 'versions')
   end
@@ -145,7 +145,7 @@ class KubeClientTest < MiniTest::Test
       .to_return(body: open_test_json_file('service_illegal_json_404.json'),
                  status: 404)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
+    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
 
     exception = assert_raises(KubeException) do
       client.get_services
@@ -158,10 +158,10 @@ class KubeClientTest < MiniTest::Test
 
   def test_entity_list
     stub_request(:get, %r{/services})
-      .to_return(body: open_test_json_file('entity_list_b3.json'),
+      .to_return(body: open_test_json_file('entity_list.json'),
                  status: 200)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
+    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
     services = client.get_services
 
     refute_empty(services)
@@ -172,16 +172,16 @@ class KubeClientTest < MiniTest::Test
     assert_instance_of(Kubeclient::Service, services[1])
 
     assert_requested(:get,
-                     'http://localhost:8080/api/v1beta3/services',
+                     'http://localhost:8080/api/v1/services',
                      times: 1)
   end
 
   def test_empty_list
     stub_request(:get, %r{/pods})
-      .to_return(body: open_test_json_file('empty_pod_list_b3.json'),
+      .to_return(body: open_test_json_file('empty_pod_list.json'),
                  status: 200)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
+    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
     pods = client.get_pods
     assert_instance_of(Kubeclient::Common::EntityList, pods)
     assert_equal(0, pods.size)
@@ -189,34 +189,33 @@ class KubeClientTest < MiniTest::Test
 
   def test_get_all
     stub_request(:get, %r{/services})
-      .to_return(body: open_test_json_file('service_list_b3.json'),
+      .to_return(body: open_test_json_file('service_list.json'),
                  status: 200)
 
     stub_request(:get, %r{/pods})
-      .to_return(body: open_test_json_file('pod_list_b3.json'),
+      .to_return(body: open_test_json_file('pod_list.json'),
                  status: 200)
 
     stub_request(:get, %r{/nodes})
-      .to_return(body: open_test_json_file('node_list_b3.json'),
+      .to_return(body: open_test_json_file('node_list.json'),
                  status: 200)
 
     stub_request(:get, %r{/replicationcontrollers})
-      .to_return(body: open_test_json_file('replication_controller_list_' \
-                                    'b3.json'), status: 200)
+      .to_return(body: open_test_json_file('replication_controller_list.json'), status: 200)
 
     stub_request(:get, %r{/events})
-      .to_return(body: open_test_json_file('event_list_b3.json'), status: 200)
+      .to_return(body: open_test_json_file('event_list.json'), status: 200)
 
     stub_request(:get, %r{/endpoints})
-      .to_return(body: open_test_json_file('endpoint_list_b3.json'),
+      .to_return(body: open_test_json_file('endpoint_list.json'),
                  status: 200)
 
     stub_request(:get, %r{/namespaces})
-      .to_return(body: open_test_json_file('namespace_list_b3.json'),
+      .to_return(body: open_test_json_file('namespace_list.json'),
                  status: 200)
 
     stub_request(:get, %r{/secrets})
-      .to_return(body: open_test_json_file('secret_list_b3.json'),
+      .to_return(body: open_test_json_file('secret_list.json'),
                  status: 200)
 
     stub_request(:get, %r{/resourcequotas})
@@ -235,7 +234,7 @@ class KubeClientTest < MiniTest::Test
       .to_return(body: open_test_json_file('persistent_volume_claim_list.json'),
                  status: 200)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
+    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
     result = client.all_entities
     assert_equal(12, result.keys.size)
     assert_instance_of(Kubeclient::Common::EntityList, result['node'])
@@ -259,9 +258,9 @@ class KubeClientTest < MiniTest::Test
   end
 
   def test_api_bearer_token_with_params_success
-    stub_request(:get, 'http://localhost:8080/api/v1beta3/pods?labelSelector=name=redis-master')
+    stub_request(:get, 'http://localhost:8080/api/v1/pods?labelSelector=name=redis-master')
       .with(headers: { Authorization: 'Bearer valid_token' })
-      .to_return(body: open_test_json_file('pod_list_b3.json'),
+      .to_return(body: open_test_json_file('pod_list.json'),
                  status: 200)
 
     client = Kubeclient::Client.new 'http://localhost:8080/api/',
@@ -276,9 +275,9 @@ class KubeClientTest < MiniTest::Test
   end
 
   def test_api_bearer_token_success
-    stub_request(:get, 'http://localhost:8080/api/v1beta3/pods')
+    stub_request(:get, 'http://localhost:8080/api/v1/pods')
       .with(headers: { Authorization: 'Bearer valid_token' })
-      .to_return(body: open_test_json_file('pod_list_b3.json'),
+      .to_return(body: open_test_json_file('pod_list.json'),
                  status: 200)
 
     client = Kubeclient::Client.new 'http://localhost:8080/api/',
@@ -293,10 +292,10 @@ class KubeClientTest < MiniTest::Test
   end
 
   def test_api_bearer_token_failure
-    error_message = '"/api/v1beta3/pods" is forbidden because ' \
+    error_message = '"/api/v1/pods" is forbidden because ' \
                     'system:anonymous cannot list on pods in'
 
-    stub_request(:get, 'http://localhost:8080/api/v1beta3/pods')
+    stub_request(:get, 'http://localhost:8080/api/v1/pods')
       .with(headers: { Authorization: 'Bearer invalid_token' })
       .to_raise(KubeException.new(403, error_message))
 
@@ -311,8 +310,8 @@ class KubeClientTest < MiniTest::Test
   end
 
   def test_api_basic_auth_success
-    stub_request(:get, 'http://username:password@localhost:8080/api/v1beta3/pods')
-      .to_return(body: open_test_json_file('pod_list_b3.json'),
+    stub_request(:get, 'http://username:password@localhost:8080/api/v1/pods')
+      .to_return(body: open_test_json_file('pod_list.json'),
                  status: 200)
 
     client = Kubeclient::Client.new 'http://localhost:8080/api/',
@@ -326,13 +325,13 @@ class KubeClientTest < MiniTest::Test
     assert_equal('Pod', pods.kind)
     assert_equal(1, pods.size)
     assert_requested(:get,
-                     'http://username:password@localhost:8080/api/v1beta3/pods',
+                     'http://username:password@localhost:8080/api/v1/pods',
                      times: 1)
   end
 
   def test_api_basic_auth_back_comp_success
-    stub_request(:get, 'http://username:password@localhost:8080/api/v1beta3/pods')
-      .to_return(body: open_test_json_file('pod_list_b3.json'),
+    stub_request(:get, 'http://username:password@localhost:8080/api/v1/pods')
+      .to_return(body: open_test_json_file('pod_list.json'),
                  status: 200)
 
     client = Kubeclient::Client.new 'http://localhost:8080/api/',
@@ -346,14 +345,14 @@ class KubeClientTest < MiniTest::Test
     assert_equal('Pod', pods.kind)
     assert_equal(1, pods.size)
     assert_requested(:get,
-                     'http://username:password@localhost:8080/api/v1beta3/pods',
+                     'http://username:password@localhost:8080/api/v1/pods',
                      times: 1)
   end
 
   def test_api_basic_auth_failure
     error_message = 'HTTP status code 401, 401 Unauthorized'
 
-    stub_request(:get, 'http://username:password@localhost:8080/api/v1beta3/pods')
+    stub_request(:get, 'http://username:password@localhost:8080/api/v1/pods')
       .to_raise(KubeException.new(401, error_message))
 
     client = Kubeclient::Client.new 'http://localhost:8080/api/',
@@ -366,7 +365,7 @@ class KubeClientTest < MiniTest::Test
     assert_equal(401, exception.error_code)
     assert_equal(error_message, exception.message)
     assert_requested(:get,
-                     'http://username:password@localhost:8080/api/v1beta3/pods',
+                     'http://username:password@localhost:8080/api/v1/pods',
                      times: 1)
   end
 
@@ -443,9 +442,9 @@ class KubeClientTest < MiniTest::Test
   end
 
   def test_api_bearer_token_file_success
-    stub_request(:get, 'http://localhost:8080/api/v1beta3/pods')
+    stub_request(:get, 'http://localhost:8080/api/v1/pods')
       .with(headers: { Authorization: 'Bearer valid_token' })
-      .to_return(body: open_test_json_file('pod_list_b3.json'),
+      .to_return(body: open_test_json_file('pod_list.json'),
                  status: 200)
 
     file = File.join(File.dirname(__FILE__), 'valid_token_file')