ruboty-k8s 0.1.0 → 0.1.1

data/lib/kubeclient/test/json/service_account_list.json

@@ -0,0 +1,82 @@
+{
+    "kind": "List",
+    "apiVersion": "v1",
+    "metadata": {},
+    "items": [
+        {
+            "kind": "ServiceAccount",
+            "apiVersion": "v1",
+            "metadata": {
+                "name": "builder",
+                "namespace": "default",
+                "selfLink": "/api/v1/namespaces/default/serviceaccounts/builder",
+                "uid": "d40655f6-6bf0-11e5-843a-525400f8b93e",
+                "resourceVersion": "133",
+                "creationTimestamp": "2015-10-06T06:09:39Z"
+            },
+            "secrets": [
+                {
+                    "name": "builder-token-5v6z2"
+                },
+                {
+                    "name": "builder-dockercfg-qe2re"
+                }
+            ],
+            "imagePullSecrets": [
+                {
+                    "name": "builder-dockercfg-qe2re"
+                }
+            ]
+        },
+        {
+            "kind": "ServiceAccount",
+            "apiVersion": "v1",
+            "metadata": {
+                "name": "default",
+                "namespace": "default",
+                "selfLink": "/api/v1/namespaces/default/serviceaccounts/default",
+                "uid": "d3d773f4-6bf0-11e5-843a-525400f8b93e",
+                "resourceVersion": "94",
+                "creationTimestamp": "2015-10-06T06:09:39Z"
+            },
+            "secrets": [
+                {
+                    "name": "default-token-6s23q"
+                },
+                {
+                    "name": "default-dockercfg-62tf3"
+                }
+            ],
+            "imagePullSecrets": [
+                {
+                    "name": "default-dockercfg-62tf3"
+                }
+            ]
+        },
+        {
+            "kind": "ServiceAccount",
+            "apiVersion": "v1",
+            "metadata": {
+                "name": "deployer",
+                "namespace": "default",
+                "selfLink": "/api/v1/namespaces/default/serviceaccounts/deployer",
+                "uid": "d41d385e-6bf0-11e5-843a-525400f8b93e",
+                "resourceVersion": "137",
+                "creationTimestamp": "2015-10-06T06:09:39Z"
+            },
+            "secrets": [
+                {
+                    "name": "deployer-token-h3i57"
+                },
+                {
+                    "name": "deployer-dockercfg-qgjjj"
+                }
+            ],
+            "imagePullSecrets": [
+                {
+                    "name": "deployer-dockercfg-qgjjj"
+                }
+            ]
+        }
+    ]
+}

data/lib/kubeclient/test/json/service_illegal_json_404.json

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

data/lib/kubeclient/test/json/service_list.json

@@ -0,0 +1,97 @@
+{
+    "kind": "ServiceList",
+    "apiVersion": "v1",
+    "metadata": {
+        "selfLink": "/api/v1/services",
+        "resourceVersion": "36727"
+    },
+    "items": [
+        {
+            "metadata": {
+                "name": "kubernetes",
+                "namespace": "default",
+                "selfLink": "/api/v1/namespaces/default/services/kubernetes",
+                "uid": "b6606490-db86-11e4-b293-f8b156af4ae1",
+                "resourceVersion": "6",
+                "creationTimestamp": "2015-04-05T11:27:15Z",
+                "labels": {
+                    "component": "apiserver",
+                    "provider": "kubernetes"
+                }
+            },
+            "spec": {
+                "ports": [
+                    {
+                        "name": "",
+                        "protocol": "TCP",
+                        "port": 443,
+                        "targetPort": 443
+                    }
+                ],
+                "selector": null,
+                "clusterIP": "10.0.0.2",
+                "sessionAffinity": "None"
+            },
+            "status": {}
+        },
+        {
+            "metadata": {
+                "name": "kubernetes-ro",
+                "namespace": "default",
+                "selfLink": "/api/v1/namespaces/default/services/kubernetes-ro",
+                "uid": "b6606694-db86-11e4-b293-f8b156af4ae1",
+                "resourceVersion": "5",
+                "creationTimestamp": "2015-04-05T11:27:15Z",
+                "labels": {
+                    "component": "apiserver",
+                    "provider": "kubernetes"
+                }
+            },
+            "spec": {
+                "ports": [
+                    {
+                        "name": "",
+                        "protocol": "TCP",
+                        "port": 80,
+                        "targetPort": 80
+                    }
+                ],
+                "selector": null,
+                "clusterIP": "10.0.0.1",
+                "sessionAffinity": "None"
+            },
+            "status": {}
+        },
+        {
+            "metadata": {
+                "name": "redis-slave",
+                "namespace": "development",
+                "selfLink": "/api/v1/namespaces/development/services/redis-slave",
+                "uid": "bdb80a8f-db93-11e4-b293-f8b156af4ae1",
+                "resourceVersion": "2815",
+                "creationTimestamp": "2015-04-05T13:00:31Z",
+                "labels": {
+                    "name": "redis",
+                    "role": "slave"
+                }
+            },
+            "spec": {
+                "ports": [
+                    {
+                        "name": "",
+                        "protocol": "TCP",
+                        "port": 6379,
+                        "targetPort": "redis-server"
+                    }
+                ],
+                "selector": {
+                    "name": "redis",
+                    "role": "slave"
+                },
+                "clusterIP": "10.0.0.140",
+                "sessionAffinity": "None"
+            },
+            "status": {}
+        }
+    ]
+}

data/lib/kubeclient/test/json/service_patch.json

@@ -0,0 +1,25 @@
+{
+  "status" : {},
+  "kind" : "Service",
+  "apiVersion" : "v1",
+  "spec" : {
+    "ports" : [
+      {
+        "targetPort" : 80,
+        "nodePort" : 0,
+        "port" : 80,
+        "protocol" : "TCP"
+      }
+    ],
+    "clusterIP" : "1.2.3.4"
+  },
+  "metadata" : {
+    "name" : "my_service",
+    "creationTimestamp" : null,
+    "namespace" : "development",
+    "resourceVersion" : "2",
+    "annotations" : {
+      "key" : "value"
+    }
+  }
+}

data/lib/kubeclient/test/json/service_update.json

@@ -0,0 +1,22 @@
+{
+   "status" : {},
+   "kind" : "Service",
+   "apiVersion" : "v1",
+   "spec" : {
+      "ports" : [
+         {
+            "targetPort" : 80,
+            "nodePort" : 0,
+            "port" : 80,
+            "protocol" : "TCP"
+         }
+      ],
+      "clusterIP" : "1.2.3.4"
+   },
+   "metadata" : {
+      "name" : "my_service",
+      "creationTimestamp" : null,
+      "namespace" : "default",
+      "resourceVersion" : "2"
+   }
+}

data/lib/kubeclient/test/json/versions_list.json

@@ -0,0 +1,6 @@
+{
+    "versions": [
+        "v1beta3",
+        "v1"
+    ]
+}

data/lib/kubeclient/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/lib/kubeclient/test/test_common.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+# Unit tests for the common module
+class CommonTest < MiniTest::Test
+  def test_underscore_entity
+    %w(
+      Pod pod
+      Service service
+      ReplicationController replication_controller
+      Node node
+      Event event
+      Endpoint endpoint
+      Namespace namespace
+      Secret secret
+      ResourceQuota resource_quota
+      LimitRange limit_range
+      PersistentVolume persistent_volume
+      PersistentVolumeClaim persistent_volume_claim
+      ComponentStatus component_status
+      ServiceAccount service_account
+      Project project
+      Route route
+      ClusterRoleBinding cluster_role_binding
+      Build build
+      BuildConfig build_config
+      Image image
+      ImageStream image_stream
+    ).each_slice(2) do |singular, plural|
+      assert_equal(Kubeclient::ClientMixin.underscore_entity(singular), plural)
+    end
+  end
+end

data/lib/kubeclient/test/test_component_status.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+# ComponentStatus tests
+class TestComponentStatus < MiniTest::Test
+  def test_get_from_json_v3
+    stub_request(:get, %r{/componentstatuses})
+      .to_return(body: open_test_file('component_status.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'
+    component_status = client.get_component_status 'etcd-0', 'default'
+
+    assert_instance_of(Kubeclient::ComponentStatus, component_status)
+    assert_equal('etcd-0', component_status.metadata.name)
+    assert_equal('Healthy', component_status.conditions[0].type)
+    assert_equal('True', component_status.conditions[0].status)
+
+    assert_requested(
+      :get,
+      'http://localhost:8080/api/v1',
+      times: 1
+    )
+    assert_requested(
+      :get,
+      'http://localhost:8080/api/v1/namespaces/default/componentstatuses/etcd-0',
+      times: 1
+    )
+  end
+end

data/lib/kubeclient/test/test_config.rb

@@ -0,0 +1,72 @@
+require 'test_helper'
+
+def test_config_file(name)
+  File.new(File.join(File.dirname(__FILE__), 'config', name))
+end
+
+# Testing Kubernetes client configuration
+class KubeClientConfigTest < MiniTest::Test
+  def test_allinone
+    config = Kubeclient::Config.read(test_config_file('allinone.kubeconfig'))
+    assert_equal(['default/localhost:8443/system:admin'], config.contexts)
+    check_context(config.context, ssl: true)
+  end
+
+  def test_external
+    config = Kubeclient::Config.read(test_config_file('external.kubeconfig'))
+    assert_equal(['default/localhost:8443/system:admin'], config.contexts)
+    check_context(config.context, ssl: true)
+  end
+
+  def test_nouser
+    config = Kubeclient::Config.read(test_config_file('nouser.kubeconfig'))
+    assert_equal(['default/localhost:8443/nouser'], config.contexts)
+    check_context(config.context, ssl: false)
+  end
+
+  def test_user_token
+    config = Kubeclient::Config.read(test_config_file('userauth.kubeconfig'))
+    assert_equal(['localhost/system:admin:token', 'localhost/system:admin:userpass'],
+                 config.contexts)
+    context = config.context('localhost/system:admin:token')
+    check_context(context, ssl: false)
+    assert_equal('0123456789ABCDEF0123456789ABCDEF', context.auth_options[:bearer_token])
+  end
+
+  def test_user_password
+    config = Kubeclient::Config.read(test_config_file('userauth.kubeconfig'))
+    assert_equal(['localhost/system:admin:token', 'localhost/system:admin:userpass'],
+                 config.contexts)
+    context = config.context('localhost/system:admin:userpass')
+    check_context(context, ssl: false)
+    assert_equal('admin', context.auth_options[:username])
+    assert_equal('pAssw0rd123', context.auth_options[:password])
+  end
+
+  private
+
+  def check_context(context, ssl: true)
+    assert_equal('https://localhost:8443', context.api_endpoint)
+    assert_equal('v1', context.api_version)
+    if ssl
+      assert_equal(OpenSSL::SSL::VERIFY_PEER, context.ssl_options[:verify_ssl])
+      assert_kind_of(OpenSSL::X509::Store, context.ssl_options[:cert_store])
+      assert_kind_of(OpenSSL::X509::Certificate, context.ssl_options[:client_cert])
+      assert_kind_of(OpenSSL::PKey::RSA, context.ssl_options[:client_key])
+      # When certificates expire the quickest way to recreate them is using
+      # an OpenShift tool (100% compatible with kubernetes):
+      #
+      #   $ oc adm ca create-master-certs --hostnames=localhost
+      #
+      # At the time of this writing the files to be updated are:
+      #
+      #   test/config/allinone.kubeconfig
+      #   test/config/external-ca.pem
+      #   test/config/external-cert.pem
+      #   test/config/external-key.rsa
+      assert(context.ssl_options[:cert_store].verify(context.ssl_options[:client_cert]))
+    else
+      assert_equal(OpenSSL::SSL::VERIFY_NONE, context.ssl_options[:verify_ssl])
+    end
+  end
+end

data/lib/kubeclient/test/test_endpoint.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+# Endpoint entity tests
+class TestEndpoint < MiniTest::Test
+  def test_create_endpoint
+    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'
+    testing_ep = Kubeclient::Resource.new
+    testing_ep.metadata = {}
+    testing_ep.metadata.name = 'myendpoint'
+    testing_ep.metadata.namespace = 'default'
+    testing_ep.subsets = [
+      {
+        'addresses' => [{ 'ip' => '172.17.0.25' }],
+        'ports' => [{ 'name' => 'https', 'port' => 6443, 'protocol' => 'TCP' }]
+      }
+    ]
+
+    req_body = '{"metadata":{"name":"myendpoint","namespace":"default"},' \
+      '"subsets":[{"addresses":[{"ip":"172.17.0.25"}],"ports":[{"name":"https",' \
+      '"port":6443,"protocol":"TCP"}]}],"kind":"Endpoints","apiVersion":"v1"}'
+
+    stub_request(:post, 'http://localhost:8080/api/v1/namespaces/default/endpoints')
+      .with(body: req_body)
+      .to_return(body: open_test_file('created_endpoint.json'), status: 201)
+
+    created_ep = client.create_endpoint testing_ep
+    assert_equal('Endpoints', created_ep.kind)
+  end
+end

data/lib/kubeclient/test/test_guestbook_go.rb

@@ -0,0 +1,238 @@
+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::Resource.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/lib/kubeclient/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'minitest/autorun'
+require 'webmock/minitest'
+require 'json'
+require 'kubeclient'
+
+# Assumes test files will be in a subdirectory with the same name as the
+# file suffix.  e.g. a file named foo.json would be a "json" subdirectory.
+def open_test_file(name)
+  File.new(File.join(File.dirname(__FILE__), name.split('.').last, name))
+end