class TestYMLImporterGroups(TestCase):
@classmethod
def setUpClass(self):
file = 'data/tests/test_groups.yml'
self.importer = YMLImporter()
self.microtosca = self.importer.Import(file)
def test_team1(self):
t1 = self.microtosca.get_group("team1")
self.assertEqual(len(t1.members),2)
self.assertIsInstance(t1, Team)
def test_team2(self):
t2 = self.microtosca.get_group("team2")
self.assertEqual(len(t2.members),3)
self.assertIsInstance(t2, Team)
def test_team3(self):
t3 = self.microtosca.get_group("team3")
self.assertEqual(len(t3.members),2)
self.assertIsInstance(t3, Team)
def test_edge(self):
edge = self.microtosca.get_group("edgenodes")
self.assertEqual(len(edge.members), 3) # Datastore node cannot be into an Edge group
self.assertIsInstance(edge, Edge)
def analyse(ymlfile):
"""
Analyse a microTOSCA YML
"""
importer = YMLImporter()
model = importer.Import(ymlfile)
builder = MicroToscaAnalyserBuilder(model)
analyser = builder.add_all_sniffers().build()
res = analyser.run()
click.echo(res)
def ymltojson(ymlfile, jsonfile):
"""
Transform a microTOSCA YML file to JSON
"""
yml_importer = YMLImporter()
json_exporter = JSONExporter()
mmodel = yml_importer.Import(ymlfile)
jsonString = json_exporter.Export(mmodel)
with open(jsonfile, 'w') as outfile:
json.dump(jsonString, outfile, indent=4)
class TestYMLImporterNodes(TestCase):
@classmethod
def setUpClass(self):
file = 'data/tests/test_nodes.yml'
self.importer = YMLImporter()
self.microtosca = self.importer.Import(file)
def test_service(self):
s1 = self.microtosca['my_service']
self.assertIsInstance(s1, Service)
self.assertEqual(s1.name, "my_service")
def test_database(self):
db = self.microtosca['my_datastore']
self.assertIsInstance(db, Datastore)
self.assertEqual(db.name, "my_datastore")
def test_messagebroker(self):
mb = self.microtosca['my_messagebroker']
self.assertIsInstance(mb, MessageBroker)
self.assertEqual(mb.name, "my_messagebroker")
def test_messagerouter(self):
mr = self.microtosca['my_messagerouter']
self.assertIsInstance(mr, MessageRouter)
self.assertEqual(mr.name, "my_messagerouter")
self.assertEqual(mr.label, "MR")
def test_kservice(self):
mr = self.microtosca['my_kservice']
self.assertIsInstance(mr, KService)
self.assertEqual(mr.name, "my_kservice")
def test_kproxy(self):
mr = self.microtosca['my_kproxy']
self.assertIsInstance(mr, KProxy)
self.assertEqual(mr.name, "my_kproxy")
def test_kingress(self):
mr = self.microtosca['my_kingress']
self.assertIsInstance(mr, KIngress)
self.assertEqual(mr.name, "my_kingress")
def setUpClass(self):
file = 'data/tests/test_sniffer_wbsi.yml'
loader = YMLImporter()
self.micro_model = loader.Import(file)
self.wbsiSniffer = WobblyServiceInteractionSmellSniffer()
def setUpClass(self):
file = 'data/tests/test_groups.yml'
importer = YMLImporter()
self.microtosca = importer.Import(file)
self.exporter = YMLExporter()
class TestYMLImporter(TestCase):
@classmethod
def setUpClass(self):
file = 'data/examples/hello-world/helloworld.yml'
self.importer = YMLImporter()
self.microtosca = self.importer.Import(file)
def test_number_nodes(self):
self.assertEqual(len(list(self.microtosca.nodes)), 5)
def test_get_node_by_name(self):
self.assertEqual(self.microtosca['shipping'].name, "shipping")
def test_get_services(self):
self.assertEqual(len(list(self.microtosca.services)), 2)
def test_database(self):
db = self.microtosca['shipping']
self.assertIsInstance(db, Service)
def test_shipping_interactions(self):
shipping = self.microtosca["shipping"]
rels = [link.target.name for link in shipping.interactions]
self.assertCountEqual(rels, ['rabbitmq', 'order_db'])
def test_order_interactions(self):
order = self.microtosca["order"]
rels = [link.target.name for link in order.interactions]
self.assertCountEqual(rels,
['shipping', 'order_db', 'rabbitmq', 'shipping'])
def test_gateway_interactions(self):
order = self.microtosca["gateway"]
rels = [link.target.name for link in order.interactions]
self.assertCountEqual(rels, ['shipping'])
def test_shipping_incoming_interactions(self):
shipping = self.microtosca["shipping"]
rels = [link.source.name for link in shipping.incoming_interactions]
self.assertCountEqual(rels, ['order', 'order', 'gateway'])
def test_order_incoming_interactions(self):
order = self.microtosca["order"]
rels = [link.source.name for link in order.incoming_interactions]
self.assertCountEqual(rels, [])
def test_rabbitmq_incoming_interactions(self):
rabbitmq = self.microtosca["rabbitmq"]
rels = [link.source.name for link in rabbitmq.incoming_interactions]
self.assertCountEqual(rels, ['shipping', 'order'])
def test_orderdb_incoming_interactions(self):
order_db = self.microtosca["order_db"]
rels = [link.source.name for link in order_db.incoming_interactions]
self.assertCountEqual(rels, ['shipping', 'order'])
def test_timedout_relationship(self):
order = self.microtosca["order"]
shipping = self.microtosca["shipping"]
link_to_shipping = [
link for link in order.interactions if link.target == shipping
]
self.assertTrue(link_to_shipping[0].timeout)
def test_edge_group(self):
group = self.microtosca.get_group('edgenodes')
self.assertEqual(group.name, "edgenodes")
self.assertEqual(self.microtosca['shipping'] in group, True)
self.assertEqual('shipping' in group, True)
self.assertEqual(self.microtosca['rabbitmq'] in group, False)
self.assertEqual('rabbitmq' in group, False)
members = [m.name for m in group.members]
self.assertCountEqual(members, ['shipping', 'order', 'gateway'])
def test_squad_group(self):
squad = self.microtosca.get_group('team1')
self.assertEqual(squad.name, "team1")
self.assertEqual(self.microtosca['shipping'] in squad, True)
self.assertEqual('shipping' in squad, True)
self.assertEqual(self.microtosca['rabbitmq'] in squad, True)
self.assertEqual('rabbitmq' in squad, True)
self.assertEqual(self.microtosca['order'] in squad, False)
self.assertEqual('order' in squad, False)
self.assertCountEqual([m.name for m in squad.members],
['shipping', 'rabbitmq'])
squad = self.microtosca.get_group('team2')
self.assertEqual(squad.name, "team2")
self.assertCountEqual([m.name for m in squad.members],
['order', 'order_db'])
class TestYMLImporterRelationshipProperties(TestCase):
@classmethod
def setUpClass(self):
file = 'data/tests/test_relationships_properties.yml'
self.importer = YMLImporter()
self.microtosca = self.importer.Import(file)
def test_relationship_empty(self):
link = self._load_relationship_from_source_to_target(
"source", "target")
self.assertFalse(link.timeout)
self.assertFalse(link.circuit_breaker)
self.assertFalse(link.dynamic_discovery)
def test_relationship_t(self):
link = self._load_relationship_from_source_to_target(
"source", "target_t")
self.assertTrue(link.timeout)
self.assertFalse(link.circuit_breaker)
self.assertFalse(link.dynamic_discovery)
def test_relationship_c(self):
link = self._load_relationship_from_source_to_target(
"source", "target_c")
self.assertFalse(link.timeout)
self.assertTrue(link.circuit_breaker)
self.assertFalse(link.dynamic_discovery)
def test_relationship_d(self):
link = self._load_relationship_from_source_to_target(
"source", "target_d")
self.assertFalse(link.timeout)
self.assertFalse(link.circuit_breaker)
self.assertTrue(link.dynamic_discovery)
def test_relationship_tc(self):
link = self._load_relationship_from_source_to_target(
"source", "target_tc")
self.assertTrue(link.timeout)
self.assertTrue(link.circuit_breaker)
self.assertFalse(link.dynamic_discovery)
def test_relationship_td(self):
link = self._load_relationship_from_source_to_target(
"source", "target_td")
self.assertTrue(link.timeout)
self.assertFalse(link.circuit_breaker)
self.assertTrue(link.dynamic_discovery)
def test_relationship_cd(self):
link = self._load_relationship_from_source_to_target(
"source", "target_cd")
self.assertFalse(link.timeout)
self.assertTrue(link.circuit_breaker)
self.assertTrue(link.dynamic_discovery)
def test_relationship_tcd(self):
link = self._load_relationship_from_source_to_target(
"source", "target_tcd")
self.assertTrue(link.timeout)
self.assertTrue(link.circuit_breaker)
self.assertTrue(link.dynamic_discovery)
def test_multiple_relatsionship(self):
source = self.microtosca["source_same"]
target = self.microtosca["target_same"]
links_to_target = [
link for link in source.interactions if link.target == target
]
self.assertEqual(len(links_to_target), 8)
self.assertFalse(links_to_target[0] == links_to_target[1])
self.assertTrue(links_to_target[0] == links_to_target[0])
def test_get_relationship_template_t(self):
rel = self.importer._get_relationship_template_by_name(
YML_RELATIONSHIP_T)
self.assertDictEqual(
rel, {
"type": MICROTOSCA_RELATIONSHIPS_INTERACT_WITH,
"properties": {
MICROTOSCA_RELATIONSHIPS_INTERACT_WITH_TIMEOUT_PROPERTY:
True
}
})
def test_get_relationship_template_c(self):
rel = self.importer._get_relationship_template_by_name(
YML_RELATIONSHIP_C)
self.assertDictEqual(
rel, {
"type": MICROTOSCA_RELATIONSHIPS_INTERACT_WITH,
"properties": {
MICROTOSCA_RELATIONSHIPS_INTERACT_WITH_CIRCUIT_BREAKER_PROPERTY:
True
}
})
def test_get_relationship_template_d(self):
rel = self.importer._get_relationship_template_by_name(
YML_RELATIONSHIP_D)
self.assertDictEqual(
rel, {
"type": MICROTOSCA_RELATIONSHIPS_INTERACT_WITH,
"properties": {
MICROTOSCA_RELATIONSHIPS_INTERACT_WITH_DYNAMIC_DISCOVEY_PROPERTY:
True
}
})
def test_get_relationship_template_tc(self):
rel = self.importer._get_relationship_template_by_name(
YML_RELATIONSHIP_TC)
self.assertDictEqual(
rel, {
"type": MICROTOSCA_RELATIONSHIPS_INTERACT_WITH,
"properties": {
MICROTOSCA_RELATIONSHIPS_INTERACT_WITH_TIMEOUT_PROPERTY:
True,
MICROTOSCA_RELATIONSHIPS_INTERACT_WITH_CIRCUIT_BREAKER_PROPERTY:
True
}
})
def test_get_relationship_template_td(self):
rel = self.importer._get_relationship_template_by_name(
YML_RELATIONSHIP_TD)
self.assertDictEqual(
rel, {
"type": MICROTOSCA_RELATIONSHIPS_INTERACT_WITH,
"properties": {
MICROTOSCA_RELATIONSHIPS_INTERACT_WITH_TIMEOUT_PROPERTY:
True,
MICROTOSCA_RELATIONSHIPS_INTERACT_WITH_DYNAMIC_DISCOVEY_PROPERTY:
True
}
})
def test_get_relationship_template_cd(self):
rel = self.importer._get_relationship_template_by_name(
YML_RELATIONSHIP_CD)
self.assertDictEqual(
rel, {
"type": MICROTOSCA_RELATIONSHIPS_INTERACT_WITH,
"properties": {
MICROTOSCA_RELATIONSHIPS_INTERACT_WITH_CIRCUIT_BREAKER_PROPERTY:
True,
MICROTOSCA_RELATIONSHIPS_INTERACT_WITH_DYNAMIC_DISCOVEY_PROPERTY:
True
}
})
def test_get_relationship_template_tcd(self):
rel = self.importer._get_relationship_template_by_name(
YML_RELATIONSHIP_TCD)
self.assertDictEqual(
rel, {
"type": MICROTOSCA_RELATIONSHIPS_INTERACT_WITH,
"properties": {
MICROTOSCA_RELATIONSHIPS_INTERACT_WITH_TIMEOUT_PROPERTY:
True,
MICROTOSCA_RELATIONSHIPS_INTERACT_WITH_CIRCUIT_BREAKER_PROPERTY:
True,
MICROTOSCA_RELATIONSHIPS_INTERACT_WITH_DYNAMIC_DISCOVEY_PROPERTY:
True
}
})
def test_get_relationship_template_raise(self):
with self.assertRaises(ImporterError):
self.importer._get_relationship_template_by_name("notexist")
def _load_relationship_from_source_to_target(self, source_name,
target_name):
source = self.microtosca[source_name]
target = self.microtosca[target_name]
links_to_target = [
link for link in source.interactions if link.target == target
]
self.assertEqual(len(links_to_target), 1)
return links_to_target[0]
def setUpClass(self):
file = 'data/tests/test_sniffer_ctdm.yml'
loader = YMLImporter()
self.micro_model = loader.Import(file)
self.ctdmSniffer = CrossTeamDataManagementSmellSniffer(
self.micro_model)
def setUpClass(self):
file = 'data/examples/hello-world/helloworld.yml'
loader = YMLImporter()
self.micro_object = loader.Import(file)
#**********************************
# VALIDATOR: Open stack
# *********************************
tosca = ToscaTemplate(path_to_yml, None)
if tosca.version:
print("\nversion: " + tosca.version)
#********************************
# LOADER: yml, json
#*******************************
# Yml loader
loader = YMLImporter()
micro_model = loader.Import(path_to_yml)
#JSON loader
# loader = JSONImporter()
# micro_model = loader.Import(path_to_json)
#********************************
# MICRO MODEL
#*******************************
# add node
# s = Service(name="new")
# s.add_deployment_time(micro_model["order"])
# s.add_run_time(micro_model["order_db"])
# micro_model.add_node(s)
# remove node
def setUpClass(self):
file = 'data/tests/test_sniffer_ebsi.yml'
loader = YMLImporter()
self.micro_model = loader.Import(file)
self.ebsiSniffer = EndpointBasedServiceInteractionSmellSniffer()
def setUpClass(self):
file = 'data/tests/test_relationships_properties.yml'
importer = YMLImporter()
self.microtosca = importer.Import(file)
self.exporter = YMLExporter()
def setUpClass(self):
file = 'data/tests/test_sniffer_shpr.yml'
loader = YMLImporter()
self.micro_model = loader.Import(file)
self.shprSniffer = SharedPersistencySmellSniffer()
def setUpClass(self):
file = 'data/tests/test_nodes.yml'
loader = YMLImporter()
self.microtosca = loader.Import(file)
self.tranformer = YMLExporter()