Python utils.is_reachable函数代码示例

 def test_get_by_labels_nonexistent(self):
     name = "yopod-{0}".format(str(uuid.uuid4()))
     config = K8sConfig(kubeconfig=utils.kubeconfig_fallback)
     if utils.is_reachable(config.api_host):
         pods = K8sPod.get_by_labels(config=config, labels={'name': name})
         self.assertIsInstance(pods, list)
         self.assertEqual(0, len(pods))

 def test_list_nonexistent(self):
     name = "yopod-{0}".format(str(uuid.uuid4()))
     pod = utils.create_pod(name=name)
     if utils.is_reachable(pod.config.api_host):
         p = pod.list()
         self.assertIsInstance(p, list)
         self.assertEqual(0, len(p))

 def test_create(self):
     name = "yosecret-{0}".format(str(uuid.uuid4()))
     secret = utils.create_secret(name=name)
     if utils.is_reachable(secret.config.api_host):
         secret.create()
         _list = secret.list()
         self.assertEqual(2, len(_list))  # service-account-token + 1

 def test_get_nonexistent(self):
     name = "yoservice"
     svc = utils.create_service(name=name)
     if utils.is_reachable(svc.config.api_host):
         try:
             svc.get()
         except Exception as err:
             self.assertIsInstance(err, NotFoundException)

 def test_update_nothing_changed(self):
     name = "yo-{0}".format(unicode(uuid.uuid4().get_hex()[:16]))
     svc = utils.create_service(name=name)
     svc.add_port(name="redis", port=5432, target_port=5432, protocol="tcp")
     if utils.is_reachable(svc.config.api_host):
         from_create = svc.create()
         from_update = svc.update()
         self.assertEqual(from_create, from_update)

 def test_get_by_name_nonexistent(self):
     name = "yo-{0}".format(unicode(uuid.uuid4().get_hex()[:16]))
     svc = utils.create_service(name=name)
     svc.add_port(name="redis", port=5432, target_port=5432, protocol="tcp")
     if utils.is_reachable(svc.config.api_host):
         _list = K8sService.get_by_name(config=svc.config, name=name)
         self.assertIsInstance(_list, list)
         self.assertEqual(0, len(_list))

 def test_get_pod_status_nonexistent(self):
     name = "yopod-{0}".format(str(uuid.uuid4()))
     config = K8sConfig(kubeconfig=utils.kubeconfig_fallback)
     pod = utils.create_pod(name=name)
     if utils.is_reachable(pod.config.api_host):
         try:
             pod.get_status()
         except Exception as err:
             self.assertIsInstance(err, NotFoundException)

 def test_get(self):
     name = "yo-{0}".format(unicode(uuid.uuid4().get_hex()[:16]))
     svc = utils.create_service(name=name)
     svc.add_port(name="redis", port=5432, target_port=5432, protocol="tcp")
     if utils.is_reachable(svc.config.api_host):
         svc.create()
         from_get = svc.get()
         self.assertIsInstance(from_get, K8sService)
         self.assertEqual(svc, from_get)

 def test_delete_nonexistent(self):
     name = "yo-{0}".format(unicode(uuid.uuid4().get_hex()[:16]))
     svc = utils.create_service(name=name)
     svc.add_port(name="redis", port=5432, target_port=5432, protocol="tcp")
     if utils.is_reachable(svc.config.api_host):
         try:
             svc.delete()
         except Exception as err:
             self.assertIsInstance(err, NotFoundException)

 def test_is_ready(self):
     name = "yocontainer"
     container = utils.create_container(name=name)
     name = "yopod-{0}".format(str(uuid.uuid4()))
     pod = utils.create_pod(name=name)
     pod.add_container(container)
     if utils.is_reachable(pod.config.api_host):
         p = pod.create()
         self.assertTrue(p.is_ready())

 def test_pod_add_volume_hostpath_no_path_specified(self):
     name = "yoname"
     obj = utils.create_pod(name=name)
     config = utils.create_config()
     vol = K8sVolume(config=config, name=name, mount_path="/var/test", type="hostPath")
     if utils.is_reachable(config.api_host):
         with self.assertRaises(UnprocessableEntityException):
             obj.add_volume(vol)
             obj.create()

 def test_get_doesnt_exist(self):
     name = "yosecret"
     secret = utils.create_secret(name=name)
     if utils.is_reachable(secret.config.api_host):
         try:
             secret.get()
             self.fail("Should not fail.")
         except Exception as err:
             self.assertIsInstance(err, NotFoundException)

 def test_delete_nonexistent(self):
     name = "yosecret-{0}".format(str(uuid.uuid4()))
     secret = utils.create_secret(name=name)
     if utils.is_reachable(secret.config.api_host):
         try:
             secret.delete()
             self.fail("Should not fail.")
         except Exception as err:
             self.assertIsInstance(err, NotFoundException)

 def test_list_without_create(self):
     name = "yo-{0}".format(unicode(uuid.uuid4().get_hex()[:16]))
     svc = utils.create_service(name=name)
     svc.add_port(name="redis", port=5432, target_port=5432, protocol="tcp")
     if utils.is_reachable(svc.config.api_host):
         _list = svc.list()
         self.assertIsInstance(_list, list)
         self.assertEqual(1, len(_list))  # api server exists already
         self.assertIsInstance(_list[0], dict)

 def test_object_rc_list_from_scratch(self):
     config = K8sConfig(kubeconfig=utils.kubeconfig_fallback)
     if config.api_host is not None and utils.is_reachable(config.api_host):
         ot = "ReplicationController"
         name = "yomama"
         obj = utils.create_object(config=config, name=name, obj_type=ot)
         r = obj.list()
         self.assertIsNotNone(r)
         self.assertEqual(0, len(r))