kubeclient 0.1.7 → 0.1.8

data/test/json/namespace_exception_b3.json

@@ -0,0 +1,8 @@
+{
+    "kind": "Status",
+    "apiVersion": "v1beta3",
+    "metadata": {},
+    "status": "Failure",
+    "message": "converting  to : type names don't match (Pod, Namespace)",
+    "code": 500
+}

data/test/json/node_b3.json

@@ -4,9 +4,9 @@
     "metadata": {
         "name": "127.0.0.1",
         "selfLink": "/api/v1beta3/nodes/127.0.0.1",
-        "uid": "01018013-a231-11e4-a36b-3c970e4a436a",
-        "resourceVersion": "7",
-        "creationTimestamp": "2015-01-22T14:20:08+02:00"
+        "uid": "041143c5-ce39-11e4-ac24-3c970e4a436a",
+        "resourceVersion": "1724",
+        "creationTimestamp": "2015-03-19T15:08:20+02:00"
     },
     "spec": {
         "capacity": {
@@ -19,9 +19,11 @@
         "conditions": [
             {
                 "kind": "Ready",
-                "status": "Full",
-                "lastTransitionTime": null
+                "status": "None",
+                "lastProbeTime": "2015-03-20T14:16:52+02:00",
+                "lastTransitionTime": "2015-03-19T15:08:20+02:00",
+                "reason": "Node health check failed: kubelet /healthz endpoint returns not ok"
             }
         ]
     }
-}
+}

data/test/json/node_list_b3.json

@@ -0,0 +1,37 @@
+{
+    "kind": "NodeList",
+    "apiVersion": "v1beta3",
+    "metadata": {
+        "selfLink": "/api/v1beta3/nodes",
+        "resourceVersion": "137"
+    },
+    "items": [
+        {
+            "metadata": {
+                "name": "127.0.0.1",
+                "selfLink": "/api/v1beta3/nodes/127.0.0.1",
+                "uid": "041143c5-ce39-11e4-ac24-3c970e4a436a",
+                "resourceVersion": "137",
+                "creationTimestamp": "2015-03-19T15:08:20+02:00"
+            },
+            "spec": {
+                "capacity": {
+                    "cpu": "1",
+                    "memory": "3Gi"
+                }
+            },
+            "status": {
+                "hostIP": "127.0.0.1",
+                "conditions": [
+                    {
+                        "kind": "Ready",
+                        "status": "None",
+                        "lastProbeTime": "2015-03-19T15:29:33+02:00",
+                        "lastTransitionTime": "2015-03-19T15:08:20+02:00",
+                        "reason": "Node health check failed: kubelet /healthz endpoint returns not ok"
+                    }
+                ]
+            }
+        }
+    ]
+}

data/test/json/pod_list_b3.json

@@ -0,0 +1,75 @@
+{
+    "kind": "PodList",
+    "apiVersion": "v1beta3",
+    "metadata": {
+        "selfLink": "/api/v1beta3/pods",
+        "resourceVersion": "1315"
+    },
+    "items": [
+        {
+            "metadata": {
+                "name": "redis-master3",
+                "namespace": "default",
+                "selfLink": "/api/v1beta3/pods/redis-master3?namespace=default",
+                "uid": "1da148b4-cef5-11e4-ac24-3c970e4a436a",
+                "resourceVersion": "1301",
+                "creationTimestamp": "2015-03-20T13:34:48+02:00",
+                "labels": {
+                    "mylabel": "mylabelvalue",
+                    "role": "pod"
+                }
+            },
+            "spec": {
+                "volumes": null,
+                "containers": [
+                    {
+                        "name": "master",
+                        "image": "dockerfile/redis",
+                        "ports": [
+                            {
+                                "hostPort": 6379,
+                                "containerPort": 6379,
+                                "protocol": "TCP"
+                            }
+                        ],
+                        "resources": {
+                            "limits": {
+                                "cpu": "100m"
+                            }
+                        },
+                        "terminationMessagePath": "/dev/termination-log",
+                        "imagePullPolicy": "IfNotPresent",
+                        "capabilities": {}
+                    },
+                    {
+                        "name": "php-redis",
+                        "image": "kubernetes/example-guestbook-php-redis",
+                        "ports": [
+                            {
+                                "hostPort": 8000,
+                                "containerPort": 80,
+                                "protocol": "TCP"
+                            }
+                        ],
+                        "resources": {
+                            "limits": {
+                                "cpu": "100m",
+                                "memory": "50000000"
+                            }
+                        },
+                        "terminationMessagePath": "/dev/termination-log",
+                        "imagePullPolicy": "IfNotPresent",
+                        "capabilities": {}
+                    }
+                ],
+                "restartPolicy": {
+                    "always": {}
+                },
+                "dnsPolicy": "ClusterFirst"
+            },
+            "status": {
+                "phase": "Pending"
+            }
+        }
+    ]
+}

data/test/json/replication_controller_list_b3.json

@@ -0,0 +1,64 @@
+{
+    "kind": "ReplicationControllerList",
+    "apiVersion": "v1beta3",
+    "metadata": {
+        "selfLink": "/api/v1beta3/namespaces/default/replicationcontrollers",
+        "resourceVersion": "1636"
+    },
+    "items": [
+        {
+            "metadata": {
+                "name": "redis-master-controller",
+                "namespace": "default",
+                "selfLink": "/api/v1beta3/namespaces/default/replicationcontrollers/redis-master-controller?namespace=default",
+                "uid": "108eb547-cefa-11e4-ac24-3c970e4a436a",
+                "resourceVersion": "1631",
+                "creationTimestamp": "2015-03-20T14:10:14+02:00",
+                "labels": {
+                    "name": "redis-master"
+                }
+            },
+            "spec": {
+                "replicas": 1,
+                "selector": {
+                    "name": "redis-master"
+                },
+                "template": {
+                    "metadata": {
+                        "creationTimestamp": null,
+                        "labels": {
+                            "app": "redis",
+                            "name": "redis-master"
+                        }
+                    },
+                    "spec": {
+                        "volumes": null,
+                        "containers": [
+                            {
+                                "name": "redis-master",
+                                "image": "dockerfile/redis",
+                                "ports": [
+                                    {
+                                        "containerPort": 6379,
+                                        "protocol": "TCP"
+                                    }
+                                ],
+                                "resources": {},
+                                "terminationMessagePath": "/dev/termination-log",
+                                "imagePullPolicy": "IfNotPresent",
+                                "capabilities": {}
+                            }
+                        ],
+                        "restartPolicy": {
+                            "always": {}
+                        },
+                        "dnsPolicy": "ClusterFirst"
+                    }
+                }
+            },
+            "status": {
+                "replicas": 1
+            }
+        }
+    ]
+}

data/test/json/service_illegal_json_404.json

@@ -0,0 +1 @@
+404: Page Not Found

data/test/json/versions_list.json

@@ -0,0 +1,7 @@
+{
+    "versions": [
+        "v1beta1",
+        "v1beta2",
+        "v1beta3"
+    ]
+}

data/test/test_kubeclient.rb

@@ -7,7 +7,7 @@ end
 # Kubernetes client entity tests
 class KubeClientTest < MiniTest::Test
   def test_json
-    our_object = Service.new
+    our_object = Kubeclient::Service.new
     our_object.foo = 'bar'
     our_object.nested = {}
     our_object.nested.again = {}
@@ -20,42 +20,122 @@ class KubeClientTest < MiniTest::Test
     assert_equal(expected, JSON.parse(JSON.dump(our_object.to_h)))
   end
 
+  def test_pass_uri
+    # URI::Generic#hostname= was added in ruby 1.9.3 and will automatically
+    # wrap an ipv6 address in []
+    uri = URI::HTTP.build(port: 8080)
+    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
+  end
+
+  def test_no_path_in_uri
+    client = Kubeclient::Client.new 'http://localhost:8080', 'v1beta3'
+    rest_client = client.rest_client
+    assert_equal 'http://localhost:8080/api/v1beta3', 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
+  end
+
   def test_exception
     stub_request(:post, /\/services/)
-      .to_return(body: open_test_json_file('service_exception_b1.json'),
+      .to_return(body: open_test_json_file('namespace_exception_b3.json'),
                  status: 409)
 
-    service = Service.new
+    service = Kubeclient::Service.new
     service.id = 'redisslave'
     service.port = 80
     service.container_port = 6379
     service.protocol = 'TCP'
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta1'
+    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
 
     exception = assert_raises(KubeException) do
       service = client.create_service service
     end
 
     assert_instance_of(KubeException, exception)
-    assert_equal('service redisslave already exists', exception.message)
+    assert_equal("converting  to : type names don't match (Pod, Namespace)",
+                 exception.message)
     assert_equal(409, exception.error_code)
   end
 
+  def test_api
+    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'
+    response = client.api
+    assert_includes(response, 'versions')
+  end
+
+  def test_api_valid
+    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'
+    assert client.api_valid?
+  end
+
+  def test_api_valid_with_invalid_json
+    stub_request(:get, 'http://localhost:8080/api/')
+      .to_return(status: 200, body: '{}')
+
+    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
+    refute client.api_valid?
+  end
+
+  def test_api_valid_with_bad_endpoint
+    stub_request(:get, 'http://localhost:8080/api/')
+      .to_return(status: [404, 'Resource Not Found'])
+
+    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
+    assert_raises(KubeException) { client.api_valid? }
+  end
+
+  def test_api_valid_with_non_json
+    stub_request(:get, 'http://localhost:8080/api/')
+      .to_return(status: 200, body: '<html></html>')
+
+    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
+    assert_raises(JSON::ParserError) { client.api_valid? }
+  end
+
+  def test_nonjson_exception
+    stub_request(:get, /\/servic/)
+      .to_return(body: open_test_json_file('service_illegal_json_404.json'),
+                 status: 404)
+
+    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
+
+    exception = assert_raises(KubeException) do
+      client.get_services
+    end
+
+    assert_instance_of(KubeException, exception)
+    assert_equal('404 Resource Not Found', exception.message)
+    assert_equal(404, exception.error_code)
+  end
+
   def test_entity_list
     stub_request(:get, /\/services/)
-      .to_return(body: open_test_json_file('entity_list_b1.json'),
+      .to_return(body: open_test_json_file('entity_list_b3.json'),
                  status: 200)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta1'
+    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
     services = client.get_services
 
     refute_empty(services)
-    assert_instance_of(EntityList, services)
+    assert_instance_of(Kubeclient::EntityList, services)
     assert_equal('Service', services.kind)
     assert_equal(2, services.size)
-    assert_instance_of(Service, services[0])
-    assert_instance_of(Service, services[1])
+    assert_instance_of(Kubeclient::Service, services[0])
+    assert_instance_of(Kubeclient::Service, services[1])
   end
 
   def test_empty_list
@@ -65,26 +145,26 @@ class KubeClientTest < MiniTest::Test
 
     client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
     pods = client.get_pods
-    assert_instance_of(EntityList, pods)
+    assert_instance_of(Kubeclient::EntityList, pods)
     assert_equal(0, pods.size)
   end
 
   def test_get_all
     stub_request(:get, /\/services/)
-      .to_return(body: open_test_json_file('get_all_services_b1.json'),
+      .to_return(body: open_test_json_file('get_all_services_b3.json'),
                  status: 200)
 
     stub_request(:get, /\/pods/)
-      .to_return(body: open_test_json_file('get_all_pods_b1.json'),
+      .to_return(body: open_test_json_file('pod_list_b3.json'),
                  status: 200)
 
     stub_request(:get, /\/nodes/)
-      .to_return(body: open_test_json_file('get_all_nodes_b1.json'),
+      .to_return(body: open_test_json_file('node_list_b3.json'),
                  status: 200)
 
-    stub_request(:get, /\/replicationControllers/)
-      .to_return(body: open_test_json_file('get_all_replication_b1.json'),
-                 status: 200)
+    stub_request(:get, /\/replicationcontrollers/)
+      .to_return(body: open_test_json_file('replication_controller_list_' \
+                                    'b3.json'), status: 200)
 
     stub_request(:get, /\/events/)
       .to_return(body: open_test_json_file('event_list_b3.json'), status: 200)
@@ -97,20 +177,20 @@ class KubeClientTest < MiniTest::Test
       .to_return(body: open_test_json_file('namespace_list_b3.json'),
                  status: 200)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta1'
+    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
     result = client.all_entities
     assert_equal(7, result.keys.size)
-    assert_instance_of(EntityList, result['node'])
-    assert_instance_of(EntityList, result['service'])
-    assert_instance_of(EntityList, result['replication_controller'])
-    assert_instance_of(EntityList, result['pod'])
-    assert_instance_of(EntityList, result['event'])
-    assert_instance_of(EntityList, result['namespace'])
-    assert_instance_of(Service, result['service'][0])
-    assert_instance_of(Node, result['node'][0])
-    assert_instance_of(Event, result['event'][0])
-    assert_instance_of(Endpoint, result['endpoint'][0])
-    assert_instance_of(Namespace, result['namespace'][0])
+    assert_instance_of(Kubeclient::EntityList, result['node'])
+    assert_instance_of(Kubeclient::EntityList, result['service'])
+    assert_instance_of(Kubeclient::EntityList, result['replication_controller'])
+    assert_instance_of(Kubeclient::EntityList, result['pod'])
+    assert_instance_of(Kubeclient::EntityList, result['event'])
+    assert_instance_of(Kubeclient::EntityList, result['namespace'])
+    assert_instance_of(Kubeclient::Service, result['service'][0])
+    assert_instance_of(Kubeclient::Node, result['node'][0])
+    assert_instance_of(Kubeclient::Event, result['event'][0])
+    assert_instance_of(Kubeclient::Endpoint, result['endpoint'][0])
+    assert_instance_of(Kubeclient::Namespace, result['namespace'][0])
   end
 
   private

data/test/test_namespace.rb

@@ -10,7 +10,7 @@ class TestNamespace < MiniTest::Test
     client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
     namespace = client.get_namespace 'staging'
 
-    assert_instance_of(Namespace, namespace)
+    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)
@@ -18,7 +18,7 @@ class TestNamespace < MiniTest::Test
   end
 
   def test_delete_namespace_v1beta3
-    our_namespace = Namespace.new
+    our_namespace = Kubeclient::Namespace.new
     our_namespace.name = 'staging'
 
     stub_request(:delete, /\/namespaces/)