def test_init_with_invalid_name(self):
     name = object()
     try:
         utils.create_service(name=name)
         self.fail("Should not fail.")
     except Exception as err:
         self.assertIsInstance(err, SyntaxError)

 def test_set_service_type(self):
     name = "yoservice"
     svc = utils.create_service(name=name)
     for i in ['ClusterIP', 'NodePort', 'LoadBalancer']:
         svc.set_service_type(i)
         self.assertIn('type', svc.model.model['spec'])
         self.assertEqual(i, svc.model.model['spec']['type'])

 def test_get_labels(self):
     name = "yoservice"
     svc = utils.create_service(name=name)
     labels_in = {'yokey': 'yovalue'}
     svc.set_labels(labels_in)
     labels_out = svc.get_labels()
     self.assertEqual(labels_in, labels_out)

 def test_set_load_balancer_ip(self):
     name = "yoservice"
     svc = utils.create_service(name=name)
     lbip = "192.168.99.100"
     svc.set_load_balancer_ip(lbip)
     self.assertIn('loadBalancerIP', svc.model.model['spec'])
     self.assertEqual(lbip, svc.model.model['spec']['loadBalancerIP'])

 def test_add_selector(self):
     name = "yoservice"
     svc = utils.create_service(name=name)
     sel = {'abc': 'def'}
     svc.add_selector(selector=sel)
     self.assertIn('selector', svc.model.model['spec'])
     self.assertEqual(sel, svc.model.model['spec']['selector'])

 def test_get_meta_generation(self):
     name = "yoservice"
     svc = utils.create_service(name=name)
     gen_in = 2
     svc.set_meta_generation(gen_in)
     gen_out = svc.get_meta_generation()
     self.assertEqual(gen_in, gen_out)

 def test_get_meta_creation_timestamp(self):
     name = "yoservice"
     svc = utils.create_service(name=name)
     tstamp_in = "yotimestamp"
     svc.set_meta_creation_timestamp(tstamp_in)
     tstamp_out = svc.get_meta_creation_timestamp()
     self.assertEqual(tstamp_in, tstamp_out)

 def test_set_session_affinity(self):
     name = "yoservice"
     svc = utils.create_service(name=name)
     for i in ['None', 'ClientIP']:
         svc.set_session_affinity(i)
         self.assertIn('sessionAffinity', svc.model.model['spec'])
         self.assertEqual(i, svc.model.model['spec']['sessionAffinity'])

 def test_get_meta_resource_version(self):
     name = "yoservice"
     svc = utils.create_service(name=name)
     ver_in = "yoversion"
     svc.set_meta_resource_version(ver_in)
     ver_out = svc.get_meta_resource_version()
     self.assertEqual(ver_in, ver_out)

 def test_set_external_ip(self):
     name = "yoservice"
     svc = utils.create_service(name=name)
     eips = ["192.168.99.100"]
     svc.set_external_ips(eips)
     self.assertIn('externalIPs', svc.model.model['spec'])
     self.assertEqual(eips, svc.model.model['spec']['externalIPs'])

 def test_set_annotations(self):
     name = "yoservice"
     svc = utils.create_service(name=name)
     anns = {'yokey': 'yovalue'}
     svc.set_annotations(anns)
     self.assertIn('annotations', svc.model.model['metadata'])
     self.assertEqual(anns, svc.model.model['metadata']['annotations'])

 def test_set_cluster_ip(self):
     name = "yoservice"
     svc = utils.create_service(name=name)
     cip = "192.168.99.100"
     svc.set_cluster_ip(cip)
     self.assertIn('clusterIP', svc.model.model['spec'])
     self.assertEqual(cip, svc.model.model['spec']['clusterIP'])

 def test_get_meta_self_link(self):
     name = "yoservice"
     svc = utils.create_service(name=name)
     slink_in = "yoselflink"
     svc.set_meta_self_link(slink_in)
     slink_out = svc.get_meta_self_link()
     self.assertEqual(slink_in, slink_out)

 def test_get_meta_uid(self):
     name = "yoservice"
     svc = utils.create_service(name=name)
     uid_in = "yoselflink"
     svc.set_meta_uid(uid_in)
     uid_out = svc.get_meta_uid()
     self.assertEqual(uid_in, uid_out)

 def test_struct_service(self):
     name = "yoname"
     svc = utils.create_service(name=name)
     self.assertIsInstance(svc, K8sService)
     self.assertIsInstance(svc.model, Service)
     self.assertIsInstance(svc.model.model, dict)
     self.assertIsInstance(svc.model.svc_metadata, ObjectMeta)

 def test_struct_service_model(self):
     name = "yoname"
     svc = utils.create_service(name=name)
     model = svc.model.model
     self.assertIsInstance(model, dict)
     self.assertEqual(4, len(model))
     for i in ['apiVersion', 'kind', 'metadata', 'spec']:
         self.assertIn(i, model)
     for i in ['apiVersion', 'kind']:
         self.assertIsInstance(model[i], str)
     for i in ['metadata', 'spec']:
         self.assertIsInstance(model[i], dict)
     self.assertEqual(3, len(model['metadata']))
     for i in ['labels', 'name', 'namespace']:
         self.assertIn(i, model['metadata'])
     self.assertIsInstance(model['metadata']['labels'], dict)
     for i in ['name', 'namespace']:
         self.assertIsInstance(model['metadata'][i], str)
     self.assertEqual(4, len(model['spec']))
     for i in ['ports', 'selector', 'sessionAffinity', 'type']:
         self.assertIn(i, model['spec'])
     self.assertIsInstance(model['spec']['ports'], list)
     self.assertIsInstance(model['spec']['selector'], dict)
     for i in ['sessionAffinity', 'type']:
         self.assertIsInstance(model['spec'][i], str)

 def test_set_labels(self):
     name = "yoservice"
     svc = utils.create_service(name=name)
     labels = {'yokey': 'yovalue'}
     svc.set_labels(labels)
     self.assertIn('labels', svc.model.model['metadata'])
     self.assertEqual(labels, svc.model.model['metadata']['labels'])

 def test_get_external_ips(self):
     name = "yoservice"
     svc = utils.create_service(name=name)
     eips_in = ["192.168.99.100"]
     svc.set_external_ips(eips_in)
     eips_out = svc.get_external_ips()
     self.assertEqual(eips_in, eips_out)

 def test_get_cluster_ip(self):
     name = "yoservice"
     svc = utils.create_service(name=name)
     cip_in = "192.168.99.100"
     svc.set_cluster_ip(cip_in)
     cip_out = svc.get_cluster_ip()
     self.assertEqual(cip_in, cip_out)

 def test_set_labels_none_arg(self):
     name = "yoservice"
     svc = utils.create_service(name=name)
     try:
         svc.set_labels()
         self.fail('Should not fail.')
     except Exception as err:
         self.assertIsInstance(err, SyntaxError)