def setUp(self):
self.discovery_container = DiscoveryContainer()
metadata_manager = MetadataManager(["qualifier"])
self.metadata_container = metadata_manager.read_metadata_from_strings(
"Unknown", AdditionalPropertiesPatchTest.METADATA)
self.discovery_container = DiscoveryContainer()
def test_iter_all(self):
metadata_manager = MetadataManager(["qualifier"])
discovery_container = DiscoveryContainer(
metadata_container=metadata_manager.read_metadata_from_strings("Unknown", self.TEST_METADATA))
chassis1_2 = {
"@odata.context": "/redfish/v1/$metadata#Chassis/Members/$entity",
"@odata.id": "/redfish/v1/Chassis/Rack1",
"@odata.type": "#Chassis.v1_2_0.Chassis",
"ChassisType": "Rack",
}
discovery_container.add_resource(ApiResource("/redfish/v1/Chassis/Rack1", 'netloc',chassis1_2, "Chassis.v1_2_0.Chassis"))
self.assertEqual(1, len(list(discovery_container.iter_all("Chassis.v1_2_0.Chassis"))))
self.assertEqual(1, len(list(discovery_container.iter_all("Chassis.v1_0_0.Chassis"))))
self.assertEqual(1, len(list(discovery_container.iter_all("Chassis.Chassis"))))
self.assertEqual(1, len(list(discovery_container.iter_all("Resource.v1_0_0.Resource"))))
self.assertEqual(1, len(list(discovery_container.iter_all("Resource.Resource"))))
chassis1_0 = {
"@odata.context": "/redfish/v1/$metadata#Chassis/Members/$entity",
"@odata.id": "/redfish/v1/Chassis/Module1",
"@odata.type": "#Chassis.v1_0_0.Chassis",
"ChassisType": "Module",
}
discovery_container.add_resource(ApiResource("/redfish/v1/Chassis/Module1",
'netloc', chassis1_0,
"Chassis.v1_0_0.Chassis"))
self.assertEqual(1, len(list(discovery_container.iter_all("Chassis.v1_2_0.Chassis"))))
self.assertEqual(2, len(list(discovery_container.iter_all("Chassis.v1_0_0.Chassis"))))
self.assertEqual(2, len(list(discovery_container.iter_all("Chassis.Chassis"))))
self.assertEqual(2, len(list(discovery_container.iter_all("Resource.v1_0_0.Resource"))))
self.assertEqual(2, len(list(discovery_container.iter_all("Resource.Resource"))))
def setUp(self):
metadata_manager = MetadataManager(["qualifier"], )
self.metadata_container = metadata_manager.read_metadata_from_strings("Unknown", METADATA)
self.discovery_container = DiscoveryContainer()
self.discovery_container.add_resource(ApiResource("/redfish/v1/Managers/RMC",
'netloc', RESOURCE,
"#Manager.1.0.0.Manager"))
def test_property_invalid_collection(self):
METADATA = """
<Schema xmlns="http://docs.oasis-open.org/odata/ns/edm" Namespace="MyNamespace.v1_0_0">
<EntityType Name="MyEntity">
<Property name="property_name" type="Collection(MyComplexType)">
</Property>
</EntityType>
<ComplexType Name="MyComplexType">
<Property Name="Name" Nullable="false" Type="Edm.String"/>
</ComplexType>
</Schema>
"""
discovery_container = DiscoveryContainer()
metadata_manager = MetadataManager(["qualifier"])
metadata_container = metadata_manager.read_metadata_from_strings("Unknown", METADATA)
EntityJson = {
"@odata.type": "MyNamespace.v1_0_0.MyEntity",
"property_name" : {'a' : {'x' : 1}, 'b' : {'y' : 2}}
}
entity_type = EntityJson["@odata.type"]
with StdoutCapture() as output:
self.assertEqual(ValidationStatus.FAILED, metadata_container.entities[entity_type].validate(EntityJson, ''))
self.assertIn('ERROR::Property ->property_name is expected to be collection, but it is not'
'', output.raw)
def test_entity_sees_inherited_properties(self):
metadata = """
<Schema xmlns="http://docs.oasis-open.org/odata/ns/edm" Namespace="A">
<EntityType Name="Resource" Abstract="false">
<Property Name="GrandpaProperty" Type="Resource.Description">
<Annotation Term="OData.Permissions" EnumMember="OData.Permission/Read"/>
</Property>
</EntityType>
</Schema>
<Schema xmlns="http://docs.oasis-open.org/odata/ns/edm" Namespace="B">
<EntityType Name="Resource" BaseType="A.Resource" Abstract="false">
<Property Name="DaddyProperty" Type="Resource.Id" Nullable="false">
<Annotation Term="OData.Permissions" EnumMember="OData.Permission/Read"/>
</Property>
</EntityType>
</Schema>
<Schema xmlns="http://docs.oasis-open.org/odata/ns/edm" Namespace="C">
<EntityType Name="Resource" BaseType="B.Resource" Abstract="false">
<Property Name="KidProperty" Type="Resource.Id" Nullable="false">
<Annotation Term="OData.Permissions" EnumMember="OData.Permission/Read"/>
</Property>
</EntityType>
</Schema>
"""
metadata_manager = MetadataManager(["qualifier"])
metadata_container = metadata_manager.read_metadata_from_strings(metadata)
resource_definition = metadata_container.entities['C.Resource']
properties = resource_definition.properties
self.assertIn('KidProperty', properties)
self.assertIn('DaddyProperty', properties)
self.assertIn('GrandpaProperty', properties)
def setUp(self):
metadata_manager = MetadataManager(["qualifier"])
self.metadata_container = metadata_manager.read_metadata_from_strings("Unknown", METADATA)
self.discovery_container = DiscoveryContainer()
self.discovery_container.add_resource(ApiResource("/redfish/v1/Fabrics/1/Endpoints/8",
'netloc', RESOURCE,
"#Endpoint.v1_0_0.Endpoint"))
def test_discovery_from_nested_additional_properties(self):
metadata = """
<Schema xmlns="http://docs.oasis-open.org/odata/ns/edm" Namespace="N">
<EntityType Name="Outer" Abstract="false">
<Annotation Term="OData.AdditionalProperties" Bool="true"/>
<Property Name="Oem" Type="N.Oem">
</Property>
</EntityType>
<ComplexType Name="Oem" Abstract="false">
<Annotation Term="OData.AdditionalProperties" Bool="true"/>
</ComplexType>
<ComplexType Name="Inner" Abstract="false">
<NavigationProperty Name="Link" Type="N.Referenced" ContainsTarget="true">
</NavigationProperty>
</ComplexType>
<EntityType Name="Referenced" Abstract="false">
</EntityType>
</Schema>
"""
resource = \
{
"@odata.id": "resource.id",
"@odata.type": "#N.Outer",
"Oem": {
"additional_property": {
"@odata.type": "#N.Inner",
"Link": {
"@odata.id": "/this/is/the/link/to/be/discovered"
},
}
}
}
referenced = \
{
"@odata.id": "referenced.id",
"@odata.type": "#N.Referenced",
}
metadata_manager = MetadataManager(["qualifier"])
metadata_container = metadata_manager.read_metadata_from_strings("Unknown", metadata)
discovery_container = DiscoveryContainer()
configuration = Configuration(
**dict(UseSSL='True', ApiEndpoint=API_ENDPOINT))
api_explorer = ApiExplorer(metadata_container, configuration)
with mock.patch(
'cts_core.discovery.api_explorer.ApiExplorer._get_resource') as get_resource:
get_resource.side_effect = [(Link('link', 'netloc'), RequestStatus.SUCCESS, resource, None),
(Link('link', 'netloc'), RequestStatus.SUCCESS, referenced, None)]
with StdoutCapture() as output:
api_explorer.discover("/outer", "N.Outer", discovery_container)
self.assertEqual(2, get_resource.call_count)
self.assertNotIn("ERROR::", '\n'.join(output))
def test_discovery_from_nested_additional_properties(self):
metadata = """
<Schema xmlns="http://docs.oasis-open.org/odata/ns/edm" Namespace="N">
<EntityType Name="Outer" Abstract="false">
<Annotation Term="OData.AdditionalProperties" Bool="true"/>
<Property Name="Oem" Type="N.Oem">
</Property>
</EntityType>
<ComplexType Name="Oem" Abstract="false">
<Annotation Term="OData.AdditionalProperties" Bool="true"/>
</ComplexType>
<ComplexType Name="Inner" Abstract="false">
<NavigationProperty Name="Link" Type="N.Referenced" ContainsTarget="true">
</NavigationProperty>
</ComplexType>
<EntityType Name="Referenced" Abstract="false">
</EntityType>
</Schema>
"""
resource = \
{
"@odata.id": "resource.id",
"@odata.type": "#N.Outer",
"Oem": {
"additional_property": {
"@odata.type": "#N.Inner",
"Link": {
"@odata.id": "/this/is/the/link/to/be/discovered"
},
}
}
}
referenced = \
{
"@odata.id": "referenced.id",
"@odata.type": "#N.Referenced",
}
metadata_manager = MetadataManager(["qualifier"])
metadata_container = metadata_manager.read_metadata_from_strings("Unknown", metadata)
discovery_container = DiscoveryContainer()
configuration = Configuration(
**dict(UseSSL='True', ApiEndpoint=API_ENDPOINT))
api_explorer = ApiExplorer(metadata_container, configuration)
with mock.patch(
'cts_core.discovery.api_explorer.ApiExplorer._get_resource') as get_resource:
get_resource.side_effect = [(Link('link', 'netloc'), RequestStatus.SUCCESS, resource, None),
(Link('link', 'netloc'), RequestStatus.SUCCESS, referenced, None)]
with StdoutCapture() as output:
api_explorer.discover("/outer", "N.Outer", discovery_container)
self.assertEqual(2, get_resource.call_count)
self.assertNotIn("ERROR::", '\n'.join(output))
def load(self):
MetadataManager.SERVICE_TO_DIR = {
"dummy": "example_metadata"
}
metadata_manager = MetadataManager([])
metadata_manager._metadata_home = Mock(return_value=os.path.dirname(os.path.realpath(__file__)))
metadata_manager.read_metadata_for_services("dummy")
return metadata_manager.metadata_container
def setUp(self):
metadata_manager = MetadataManager(["qualifier"])
self.metadata_container = metadata_manager.read_metadata_from_strings(
METADATA)
self.discovery_container = DiscoveryContainer()
self.discovery_container.add_resource(
ApiResource("/redfish/v1/Fabrics/1/Endpoints/8", 'netloc',
RESOURCE, "#Endpoint.v1_0_0.Endpoint"))
def test_validate_elements_of_collection_with_elements_referenced_by_out_of_range_json_pointer(self):
metadata = """
<Schema xmlns="http://docs.oasis-open.org/odata/ns/edm" Namespace="N">
<EntityType Name="Outer" Abstract="false">
<NavigationProperty Name="MyCollection" Type="Collection(ReferencedEntity)" ContainsTarget="true">
<Annotation Term="OData.Permissions" EnumMember="OData.Permission/Read"/>
</NavigationProperty>
</EntityType>
<EntityType Name="ReferencedEntity" Abstract="false">
<Property Name="name" Type="Edm.String"/>
</EntityType>
</Schema>
"""
resource = \
{
"@odata.id": "resource.id",
"@odata.type": "N.Outer",
"MyCollection": [
{
"@odata.id": "/outer#MyCollection/0"
},
{
"@odata.id": "/outer#MyCollection/2" # pointer out of range
}
]
}
metadata_manager = MetadataManager(["qualifier"])
metadata_container = metadata_manager.read_metadata_from_strings("Unknown", metadata)
discovery_container = DiscoveryContainer()
configuration = Configuration(**dict(UseSSL='True', ApiEndpoint=API_ENDPOINT))
api_explorer = ApiExplorer(metadata_container, configuration)
with mock.patch('cts_core.commons.api_caller.ApiCaller.get_resource') as get_resource:
get_resource.side_effect = [(Link('url1', 'netloc'), RequestStatus.SUCCESS, ReturnCodes.OK, resource,
Link('url1', 'netloc')),
(Link('url2', 'netloc'), RequestStatus.SUCCESS, ReturnCodes.OK, resource,
Link('url2', 'netloc')),
(Link('url3', 'netloc'), RequestStatus.SUCCESS, ReturnCodes.OK, resource,
Link('url3', 'netloc'))]
with StdoutCapture() as output:
api_explorer.discover("/outer", "N.Outer", discovery_container)
self.assertEqual(3, get_resource.call_count)
self.assertIn(
'ERROR::JSON pointer exception while dereferencing /MyCollection/2',
';'.join(output))
requirements = [
]
validator = MetadataGetValidator(metadata_container, requirements)
with StdoutCapture() as output:
self.assertEqual(ValidationStatus.PASSED, validator.validate(discovery_container))
self.assertEqual(0, len(re.findall('ERROR::', ';'.join(output))))
def test_handle_collection_with_typeless_elements_referenced_by_json_pointer(
self):
metadata = """
<Schema xmlns="http://docs.oasis-open.org/odata/ns/edm" Namespace="N">
<EntityType Name="Outer" Abstract="false">
<NavigationProperty Name="MyCollection" Type="Collection(ReferencedEntity)" ContainsTarget="true">
<Annotation Term="OData.Permissions" EnumMember="OData.Permission/Read"/>
</NavigationProperty>
</EntityType>
<EntityType Name="ReferencedEntity" Abstract="false">
<Property Name="name" Type="Edm.String"/>
</EntityType>
</Schema>
"""
resource = \
{
"@odata.id": "resource.id",
"@odata.type": "N.Outer",
"MyCollection": [
{
# implicit odata.type = ReferencedEntity
"@odata.id": "/outer#MyCollection/0",
"name": "MyName 0"
},
{
# implicit odata_type = ReferencedEntity
"@odata.id": "/outer#MyCollection/1",
"name": "MyName 1"
}
]
}
metadata_manager = MetadataManager(["qualifier"])
metadata_container = metadata_manager.read_metadata_from_strings(
metadata)
discovery_container = DiscoveryContainer()
configuration = Configuration(
**dict(UseSSL='True', ApiEndpoint=API_ENDPOINT))
api_explorer = ApiExplorer(metadata_container, configuration)
with mock.patch('cts_core.commons.api_caller.ApiCaller.get_resource'
) as get_resource:
get_resource.side_effect = [(Link('link',
'netloc'), RequestStatus.SUCCESS,
ReturnCodes.OK, resource, None),
(Link('link',
'netloc'), RequestStatus.SUCCESS,
ReturnCodes.OK, resource, None),
(Link('link',
'netloc'), RequestStatus.SUCCESS,
ReturnCodes.OK, resource, None)]
with StdoutCapture() as output:
api_explorer.discover("/outer", "N.Outer", discovery_container)
self.assertEqual(3, get_resource.call_count)
self.assertEqual(0, len(re.findall('ERROR::', ';'.join(output))))
def load(self, metadata_ref, qualifiers):
if os.path.isfile(metadata_ref):
metadata_manager = MetadataManager(qualifiers)
configuration = get_configuration_from_file(metadata_ref)
if configuration is None:
return None
if metadata_manager.download_metadata(Configuration(**configuration)):
return metadata_manager.metadata_container
return None
def load(self, metadata_ref, qualifiers):
try:
metadata_ref = self._autocomplete_name(metadata_ref)
except KeyError:
pass
metadata_manager = MetadataManager(qualifiers)
if metadata_manager.read_metadata_for_services(metadata_ref):
return metadata_manager.metadata_container
return None
def load(self, metadata_ref, qualifiers):
try:
metadata_ref = self._autocomplete_name(metadata_ref)
except KeyError:
pass
metadata_manager = MetadataManager(qualifiers)
if metadata_manager.read_metadata_for_services(metadata_ref):
return metadata_manager.metadata_container
return None
def load(self, metadata_ref, qualifiers):
if os.path.isfile(metadata_ref):
metadata_manager = MetadataManager(qualifiers)
configuration = get_configuration_from_file(metadata_ref)
if configuration is None:
return None
if metadata_manager.download_metadata(
Configuration(**configuration)):
return metadata_manager.metadata_container
return None
def run(self):
metadata_manager = MetadataManager(self.configuration)
metadata_manager.load_files()
metadata_container = metadata_manager.load_metadata_properties()
api_explorer = ApiExplorer("/redfish/v1/", "ServiceRoot.ServiceRoot", metadata_container, self.configuration)
discovery_container = api_explorer.process_with_resource(DiscoveryContainer())
discovery_container.keys()
status = MetadataPatchValidator(metadata_container, self.configuration).validate(discovery_container)
self.set_status(status)
def setUp(self):
metadata_manager = MetadataManager(["qualifier"])
self.metadata_container = metadata_manager.read_metadata_from_strings(
METADATA)
self.discovery_container = DiscoveryContainer(
metadata_container=self.metadata_container)
self.validator = HierarchyValidator(self.discovery_container,
self.metadata_container,
MetadataConstants2_1)
self.builder = ResourceBuilder(self.discovery_container)
def test_iter_all(self):
metadata_manager = MetadataManager(["qualifier"])
discovery_container = DiscoveryContainer(
metadata_container=metadata_manager.read_metadata_from_strings(
"Unknown", self.TEST_METADATA))
chassis1_2 = {
"@odata.context": "/redfish/v1/$metadata#Chassis/Members/$entity",
"@odata.id": "/redfish/v1/Chassis/Rack1",
"@odata.type": "#Chassis.v1_2_0.Chassis",
"ChassisType": "Rack",
}
discovery_container.add_resource(
ApiResource("/redfish/v1/Chassis/Rack1", 'netloc', chassis1_2,
"Chassis.v1_2_0.Chassis"))
self.assertEqual(
1,
len(list(discovery_container.iter_all("Chassis.v1_2_0.Chassis"))))
self.assertEqual(
1,
len(list(discovery_container.iter_all("Chassis.v1_0_0.Chassis"))))
self.assertEqual(
1, len(list(discovery_container.iter_all("Chassis.Chassis"))))
self.assertEqual(
1,
len(list(
discovery_container.iter_all("Resource.v1_0_0.Resource"))))
self.assertEqual(
1, len(list(discovery_container.iter_all("Resource.Resource"))))
chassis1_0 = {
"@odata.context": "/redfish/v1/$metadata#Chassis/Members/$entity",
"@odata.id": "/redfish/v1/Chassis/Module1",
"@odata.type": "#Chassis.v1_0_0.Chassis",
"ChassisType": "Module",
}
discovery_container.add_resource(
ApiResource("/redfish/v1/Chassis/Module1", 'netloc', chassis1_0,
"Chassis.v1_0_0.Chassis"))
self.assertEqual(
1,
len(list(discovery_container.iter_all("Chassis.v1_2_0.Chassis"))))
self.assertEqual(
2,
len(list(discovery_container.iter_all("Chassis.v1_0_0.Chassis"))))
self.assertEqual(
2, len(list(discovery_container.iter_all("Chassis.Chassis"))))
self.assertEqual(
2,
len(list(
discovery_container.iter_all("Resource.v1_0_0.Resource"))))
self.assertEqual(
2, len(list(discovery_container.iter_all("Resource.Resource"))))
def setUp(self):
self.discovery_container = DiscoveryContainer()
metadata_manager = MetadataManager(["qualifier"])
self.metadata_container = metadata_manager.read_metadata_from_strings(METADATA)
HardwareCheckList.MetadataConstants = MetadataConstants2_2
self.checklist = HardwareCheckList(dict())
#monkey patch
self.checklist._load_metadata = lambda : self.metadata_container
def test_handle_collection_with_typeless_elements_referenced_by_json_pointer(self):
metadata = """
<Schema xmlns="http://docs.oasis-open.org/odata/ns/edm" Namespace="N">
<EntityType Name="Outer" Abstract="false">
<NavigationProperty Name="MyCollection" Type="Collection(ReferencedEntity)" ContainsTarget="true">
<Annotation Term="OData.Permissions" EnumMember="OData.Permission/Read"/>
</NavigationProperty>
</EntityType>
<EntityType Name="ReferencedEntity" Abstract="false">
<Property Name="name" Type="Edm.String"/>
</EntityType>
</Schema>
"""
resource = \
{
"@odata.id": "resource.id",
"@odata.type": "N.Outer",
"MyCollection": [
{
# implicit odata.type = ReferencedEntity
"@odata.id": "/outer#MyCollection/0",
"name": "MyName 0"
},
{
# implicit odata_type = ReferencedEntity
"@odata.id": "/outer#MyCollection/1",
"name": "MyName 1"
}
]
}
metadata_manager = MetadataManager(["qualifier"])
metadata_container = metadata_manager.read_metadata_from_strings("Unknown", metadata)
discovery_container = DiscoveryContainer()
configuration = Configuration(
**dict(UseSSL='True', ApiEndpoint=API_ENDPOINT))
api_explorer = ApiExplorer(metadata_container, configuration)
with mock.patch('cts_core.commons.api_caller.ApiCaller.get_resource') as get_resource:
get_resource.side_effect = [(Link('link', 'netloc'), RequestStatus.SUCCESS,
ReturnCodes.OK, resource, None),
(Link('link', 'netloc'), RequestStatus.SUCCESS,
ReturnCodes.OK, resource, None),
(Link('link', 'netloc'), RequestStatus.SUCCESS,
ReturnCodes.OK, resource, None)]
with StdoutCapture() as output:
api_explorer.discover("/outer", "N.Outer", discovery_container)
self.assertEqual(3, get_resource.call_count)
self.assertEqual(0, len(re.findall('ERROR::', ';'.join(output))))
def test_follow_references_when_loading_remote_matadata(self):
configuration = Configuration(
**dict(UseSSL='True', ApiEndpoint=API_ENDPOINT))
manager = MetadataManager([])
with StdoutCapture() as output:
with patch("cts_core.commons.api_caller.ApiCaller.get_xml") as get_xml:
get_xml.side_effect = [(None, RequestStatus.SUCCESS, 200, METADATA_ROOT, None),
(None, RequestStatus.SUCCESS, 200, METADATA_ROOT, None)]
manager.download_metadata(configuration)
arguments = [arg[0][0] for arg in get_xml.call_args_list]
self.assertGreater(len([a for a in arguments if "Org.OData.Core.V1.xml" in a]), 0)
self.assertEqual(-1, output.raw.find("ERROR::"))
def run(self):
print self.configuration.__dict__
metadata_manager = MetadataManager(self.configuration)
metadata_manager.load_files()
metadata_container = metadata_manager.load_metadata_properties()
api_explorer = ApiExplorer("/redfish/v1/", "ServiceRoot.ServiceRoot", metadata_container, self.configuration)
discovery_container = api_explorer.process_with_resource(DiscoveryContainer())
discovery_container.keys()
status = MetadataPatchValidator(metadata_container, self.configuration).validate(discovery_container)
if status:
self.set_status_passed()
else:
self.set_status_failed()
def test_should_pass_if_entity_type_declared_on_ignore_list_with_asterix(self):
metadata_manager = MetadataManager(['qualifier'], ignore_types=["N.*"])
self.metadata_container = metadata_manager.read_metadata_from_strings('Unknown', METADATA)
self.discovery_container = DiscoveryContainer()
self.discovery_container.add_resource(ApiResource('/redfish/resource1',
'netloc',
RESOURCE_WITH_INVALID_PROPERTY_VALUE,
'#N.R'))
requirements = []
validator = MetadataGetValidator(self.metadata_container, requirements)
self.assertEqual(ValidationStatus.PASSED, validator.validate(self.discovery_container))
def test_should_pass_if_property_of_incorrect_type_declared_on_ignore_list(self):
metadata_manager = MetadataManager(["qualifier"], ignore_types=["N.ObjectWithNumericProperty"])
self.metadata_container = metadata_manager.read_metadata_from_strings("Unknown", METADATA)
self.discovery_container = DiscoveryContainer()
self.discovery_container.add_resource(ApiResource("/redfish/resource1",
'netloc', RESOURCE_WITH_INVALID_PROPERTY_VALUE,
"#N.R"))
requirements = [
]
validator = MetadataGetValidator(self.metadata_container, requirements)
self.assertEqual(ValidationStatus.PASSED, validator.validate(self.discovery_container))
def test_should_pass_when_unknown_complex_type_mapped_on_known_type(self):
metadata_manager = MetadataManager(["qualifier"], map_types={"A" : "B", "unknown.complex.type" : "N.ObjectWithNumericProperty"})
self.metadata_container = metadata_manager.read_metadata_from_strings("Unknown", METADATA)
self.discovery_container = DiscoveryContainer()
self.discovery_container.add_resource(ApiResource("/redfish/resource1",
'netloc', RESOURCE_WITH_UNKNOWN_COMPLEX_TYPE,
"#N.R"))
requirements = [
]
validator = MetadataGetValidator(self.metadata_container, requirements)
self.assertEqual(ValidationStatus.PASSED, validator.validate(self.discovery_container))
def test_should_pass_with_correct_resource(self):
metadata_manager = MetadataManager(["qualifier"])
self.metadata_container = metadata_manager.read_metadata_from_strings("Unknown", METADATA)
self.discovery_container = DiscoveryContainer()
self.discovery_container.add_resource(ApiResource("/redfish/resource1",
'netloc', RESOURCE_CORRECT,
"#N.R"))
requirements = [
]
validator = MetadataGetValidator(self.metadata_container, requirements)
with StdoutCapture() as output:
self.assertEqual(ValidationStatus.PASSED, validator.validate(self.discovery_container))
def test_should_pass_if_entity_type_declared_on_ignore_list(self):
metadata_manager = MetadataManager(["qualifier"], ignore_types=["N.R"])
self.metadata_container = metadata_manager.read_metadata_from_strings(
"Unknown", METADATA)
self.discovery_container = DiscoveryContainer()
self.discovery_container.add_resource(
ApiResource("/redfish/resource1", 'netloc',
RESOURCE_WITH_INVALID_PROPERTY_VALUE, "#N.R"))
requirements = []
validator = MetadataGetValidator(self.metadata_container, requirements)
self.assertEqual(ValidationStatus.PASSED,
validator.validate(self.discovery_container))
def _load_metadata(self):
qualifiers, services = self.get_services_and_qualifiers()
metadata_manager = MetadataManager(qualifiers,
ignore_types=self.ignore_types,
map_types=self.map_types)
if self.configuration.MetadataDirectory:
cts_warning("CTS is configured to use custom metadata from: {dir}",
dir=self.configuration.MetadataDirectory)
metadata_container = self._load_custom_metadata(
metadata_manager, self.configuration.MetadataDirectory)
elif self.configuration.RedfishMetadata:
cts_warning(
"CTS is configured to use Redfish metadata: {metadata_version}",
metadata_version=self.configuration.RedfishMetadata)
metadata_container = \
self._load_custom_metadata(metadata_manager, '/'.join((Constants.METADATA_REDFISH_DIR,
str(self.configuration.RedfishMetadata))))
else:
metadata_container = self._load_built_in_metadata(
metadata_manager, services)
if metadata_container is not None:
metadata_container.print_types()
return metadata_container
def test_should_pass_with_correct_resource(self):
metadata_manager = MetadataManager(["qualifier"])
self.metadata_container = metadata_manager.read_metadata_from_strings(
"Unknown", METADATA)
self.discovery_container = DiscoveryContainer()
self.discovery_container.add_resource(
ApiResource("/redfish/resource1", 'netloc', RESOURCE_CORRECT,
"#N.R"))
requirements = []
validator = MetadataGetValidator(self.metadata_container, requirements)
with StdoutCapture() as output:
self.assertEqual(ValidationStatus.PASSED,
validator.validate(self.discovery_container))
def test_should_fail_bacause_of_unknown_complex_type(self):
metadata_manager = MetadataManager(["qualifier"])
self.metadata_container = metadata_manager.read_metadata_from_strings("Unknown", METADATA)
self.discovery_container = DiscoveryContainer()
self.discovery_container.add_resource(ApiResource("/redfish/resource1",
'netloc', RESOURCE_WITH_UNKNOWN_COMPLEX_TYPE,
"#N.R"))
requirements = [
]
validator = MetadataGetValidator(self.metadata_container, requirements)
with StdoutCapture() as output:
self.assertEqual(ValidationStatus.FAILED, validator.validate(self.discovery_container))
self.assertIn('Reference to unknown type unknown.complex.type', '\n'.join(output))
def test_should_not_patch_if_property_annotation_is_non_trivial_and_alternative_implementation_not_known(
self):
"""
when additional property of type 'ComplexType' does have annotation Term Nontriavial should not be patched
"""
metadata_manager = MetadataManager(["qualifier"])
metadata_container = metadata_manager.read_metadata_from_strings(
AdditionalPropertiesPatchTest.METADATA)
entity_json = {
"@odata.type": "MyNamespace.v1_0_0.MyEntity",
"Outer": {
"@odata.type": "MyNamespace.v1_0_0.OuterComplexType",
"Name": "OuterName",
"InnerToValidate": {
"@odata.type": "MyNamespace.v1_0_0.InnerComplexType",
"Name": "This name property is required"
}
}
}
self.discovery_container.add_resource(
ApiResource("/redfish/v1/Managers/RMC", "netloc", entity_json,
"#MyNamespace.v1_0_0.MyEntity"))
with mock.patch('cts_core.commons.api_caller.ApiCaller.__init__'
) as api_caller_init_mock:
api_caller_init_mock.return_value = None
validator = MetadataPatchValidator(metadata_container, None,
PatchingStrategy2_2())
# this ValidationStatus.BLOCKED should be not affect final ValidationStatus
validator._verify_property = MagicMock(
return_value=(ValidationStatus.BLOCKED, None))
validator._restore_property = MagicMock(
return_value=ValidationStatus.BLOCKED)
validator._patch_property = MagicMock(
return_value=(True, True, ValidationStatus.BLOCKED))
with StdoutCapture() as out:
self.assertEqual(ValidationStatus.PASSED_WITH_WARNINGS,
validator.validate(self.discovery_container))
self.assertIn('WARNING::Skipping non-trivial property Name;',
out.raw)
def test_should_fail_bacause_of_unknown_entity_type(self):
metadata_manager = MetadataManager(["qualifier"])
self.metadata_container = metadata_manager.read_metadata_from_strings("Unknown", METADATA)
self.discovery_container = DiscoveryContainer()
self.discovery_container.add_resource(ApiResource("/redfish/resource1",
'netloc', RESOURCE_WITH_UNKNOWN_ENTITY_TYPE,
"#N.R"))
requirements = [
]
validator = MetadataGetValidator(self.metadata_container, requirements)
with StdoutCapture() as output:
self.assertEqual(ValidationStatus.FAILED, validator.validate(self.discovery_container))
self.assertIn("ERROR::Unknown entity type 'unknown.entity.type'", output.raw)
def test_should_fail_if_property_of_incorrect_type(self):
metadata_manager = MetadataManager(["qualifier"])
self.metadata_container = metadata_manager.read_metadata_from_strings("Unknown", METADATA)
self.discovery_container = DiscoveryContainer()
self.discovery_container.add_resource(ApiResource("/redfish/resource1",
'netloc', RESOURCE_WITH_INVALID_PROPERTY_VALUE,
"#N.R"))
requirements = [
]
validator = MetadataGetValidator(self.metadata_container, requirements)
with StdoutCapture() as output:
self.assertEqual(ValidationStatus.FAILED, validator.validate(self.discovery_container))
self.assertIn('Property resource.id->ObjectWithNumber is expected to be json object', '\n'.join(output))
def test_discovery_error_if_unexpected_additional_properties(self):
"""
Entity type used in this test does not accept additional properties. As a result, ApiExplorer is expected
to raise an error about unexpected 'additional_property' property.
ApiExplorer validate
"""
metadata = """
<Schema xmlns="http://docs.oasis-open.org/odata/ns/edm" Namespace="N">
<EntityType Name="Outer" Abstract="false">
<Property Name="@odata.id" Type="Edm.String"/>
<Property Name="@odata.type" Type="Edm.String"/>
<Property Name="expected" Type="Edm.Int64"/>
<Annotation Term="OData.AdditionalProperties" Bool="false"/>
</EntityType>
</Schema>
"""
resource = \
{
"@odata.id": "id",
"@odata.type": "N.Outer",
"expected": 10,
"additional_property": 1
}
metadata_manager = MetadataManager(["qualifier"])
metadata_container = metadata_manager.read_metadata_from_strings(
"Unknown", metadata)
discovery_container = DiscoveryContainer()
configuration = Configuration(
**dict(UseSSL='True', ApiEndpoint=API_ENDPOINT))
api_explorer = ApiExplorer(metadata_container, configuration)
with mock.patch(
'cts_core.discovery.api_explorer.ApiExplorer._get_resource'
) as get_resource:
get_resource.side_effect = [
(Link('link', 'netloc'), RequestStatus.SUCCESS, resource, None)
]
with StdoutCapture() as output:
api_explorer.discover("/outer", "N.Outer", discovery_container)
self.assertEqual(1, get_resource.call_count)
self.assertIn("unexpected properties: [additional_property]",
'\n'.join(output))
def test_should_fail_if_non_nullable_property_is_null(self):
metadata_manager = MetadataManager(["qualifier"])
self.metadata_container = metadata_manager.read_metadata_from_strings("Unknown", METADATA)
self.discovery_container = DiscoveryContainer()
self.discovery_container.add_resource(ApiResource("/redfish/resource1",
'netloc', RESOURCE_WITH_NULL_ON_NON_NULLABLE,
"#N.R"))
requirements = [
]
validator = MetadataGetValidator(self.metadata_container, requirements)
with StdoutCapture() as output:
self.assertEqual(ValidationStatus.FAILED, validator.validate(self.discovery_container))
self.assertIn('ERROR::Property resource.id->CapacityGiB cannot be null', '\n'.join(output))
self.assertIn('ERROR::Property resource.id->ObjectWithNumber->Number cannot be null', '\n'.join(output))
def test_should_validate_dynamic_properties_at_entity_level(self):
metadata_manager = MetadataManager(["qualifier"])
self.metadata_container = metadata_manager.read_metadata_from_strings("Unknown", METADATA)
self.discovery_container = DiscoveryContainer()
self.discovery_container.add_resource(ApiResource("/redfish/resource1",
'netloc', RESOURCE_WITH_INCOMPLETE_DYNAMIC_PROPERTY,
"#N.R"))
requirements = [
]
validator = MetadataGetValidator(self.metadata_container, requirements)
with StdoutCapture() as output:
self.assertEqual(ValidationStatus.FAILED, validator.validate(self.discovery_container))
self.assertIn('ERROR::Required property resource.id->aaaaaaaa->Obligatory not present in the resource',
'\n'.join(output))
def test_follow_references_when_loading_local_matadata(self):
MetadataManager.SERVICE_TO_DIR = {
"SERVICE_A": "a"
}
os.path.isdir = MagicMock(return_value=True)
manager = MetadataManager([])
with StdoutCapture() as output:
with patch("__builtin__.open", mock_open(read_data=METADATA_ROOT)) as mock_file:
with patch("cts_framework.commons.digest.DirDigest.__init__") as init:
init.return_value = None
with patch("cts_framework.commons.digest.DirDigest.is_valid") as is_valid:
is_valid.return_value = True
manager.read_metadata_for_services("SERVICE_A")
arguments = [arg[0][0] for arg in mock_file.call_args_list]
self.assertGreater(len([a for a in arguments if "Org.OData.Core.V1.xml" in a]), 0)
def test_follow_references_when_loading_remote_matadata(self):
configuration = Configuration(
**dict(UseSSL='True', ApiEndpoint=API_ENDPOINT))
manager = MetadataManager([])
with StdoutCapture() as output:
with patch("cts_core.commons.api_caller.ApiCaller.get_xml"
) as get_xml:
get_xml.side_effect = [
(None, RequestStatus.SUCCESS, 200, METADATA_ROOT, None),
(None, RequestStatus.SUCCESS, 200, METADATA_ROOT, None)
]
manager.download_metadata(configuration)
arguments = [arg[0][0] for arg in get_xml.call_args_list]
self.assertGreater(
len([a for a in arguments if "Org.OData.Core.V1.xml" in a]), 0)
self.assertEqual(-1, output.raw.find("ERROR::"))
def run(self):
metadata_manager = MetadataManager(self.configuration)
metadata_manager.load_files()
metadata_container = metadata_manager.load_metadata_properties()
api_explorer = ApiExplorer("/redfish/v1/", "ServiceRoot.ServiceRoot",
metadata_container, self.configuration)
discovery_container = api_explorer.process_with_resource(
DiscoveryContainer())
status = MetadataGetValidator(metadata_container).validate(
discovery_container)
if status:
self.set_status_passed()
else:
self.set_status_failed()
def test_should_pass_when_unknown_entity_type_mapped_to_known_one(self):
metadata_manager = MetadataManager(["qualifier"],
map_types={
"A": "B",
"unknown.entity.type": "N.R"
})
self.metadata_container = metadata_manager.read_metadata_from_strings(
"Unknown", METADATA)
self.discovery_container = DiscoveryContainer()
self.discovery_container.add_resource(
ApiResource("/redfish/resource1", 'netloc',
RESOURCE_WITH_UNKNOWN_ENTITY_TYPE, "#N.R"))
requirements = []
validator = MetadataGetValidator(self.metadata_container, requirements)
self.assertEqual(ValidationStatus.PASSED,
validator.validate(self.discovery_container))
def test_should_fail_bacause_of_unknown_complex_type(self):
metadata_manager = MetadataManager(["qualifier"])
self.metadata_container = metadata_manager.read_metadata_from_strings(
"Unknown", METADATA)
self.discovery_container = DiscoveryContainer()
self.discovery_container.add_resource(
ApiResource("/redfish/resource1", 'netloc',
RESOURCE_WITH_UNKNOWN_COMPLEX_TYPE, "#N.R"))
requirements = []
validator = MetadataGetValidator(self.metadata_container, requirements)
with StdoutCapture() as output:
self.assertEqual(ValidationStatus.FAILED,
validator.validate(self.discovery_container))
self.assertIn('Reference to unknown type unknown.complex.type',
'\n'.join(output))
def test_should_fail_bacause_of_unknown_entity_type(self):
metadata_manager = MetadataManager(["qualifier"])
self.metadata_container = metadata_manager.read_metadata_from_strings(
"Unknown", METADATA)
self.discovery_container = DiscoveryContainer()
self.discovery_container.add_resource(
ApiResource("/redfish/resource1", 'netloc',
RESOURCE_WITH_UNKNOWN_ENTITY_TYPE, "#N.R"))
requirements = []
validator = MetadataGetValidator(self.metadata_container, requirements)
with StdoutCapture() as output:
self.assertEqual(ValidationStatus.FAILED,
validator.validate(self.discovery_container))
self.assertIn("ERROR::Unknown entity type 'unknown.entity.type'",
output.raw)
def test_property_invalid_collection(self):
METADATA = """
<Schema xmlns="http://docs.oasis-open.org/odata/ns/edm" Namespace="MyNamespace.v1_0_0">
<EntityType Name="MyEntity">
<Property name="property_name" type="Collection(MyComplexType)">
</Property>
</EntityType>
<ComplexType Name="MyComplexType">
<Property Name="Name" Nullable="false" Type="Edm.String"/>
</ComplexType>
</Schema>
"""
discovery_container = DiscoveryContainer()
metadata_manager = MetadataManager(["qualifier"])
metadata_container = metadata_manager.read_metadata_from_strings(
"Unknown", METADATA)
EntityJson = {
"@odata.type": "MyNamespace.v1_0_0.MyEntity",
"property_name": {
'a': {
'x': 1
},
'b': {
'y': 2
}
}
}
entity_type = EntityJson["@odata.type"]
with StdoutCapture() as output:
self.assertEqual(
ValidationStatus.FAILED,
metadata_container.entities[entity_type].validate(
EntityJson, ''))
self.assertIn(
'ERROR::Property ->property_name is expected to be collection, but it is not'
'', output.raw)
def test_should_fail_if_property_of_incorrect_type(self):
metadata_manager = MetadataManager(["qualifier"])
self.metadata_container = metadata_manager.read_metadata_from_strings(
"Unknown", METADATA)
self.discovery_container = DiscoveryContainer()
self.discovery_container.add_resource(
ApiResource("/redfish/resource1", 'netloc',
RESOURCE_WITH_INVALID_PROPERTY_VALUE, "#N.R"))
requirements = []
validator = MetadataGetValidator(self.metadata_container, requirements)
with StdoutCapture() as output:
self.assertEqual(ValidationStatus.FAILED,
validator.validate(self.discovery_container))
self.assertIn(
'Property resource.id->ObjectWithNumber is expected to be json object',
'\n'.join(output))
def test_should_suggest_other_names_for_additionals(self):
metadata_manager = MetadataManager(["qualifier"])
self.metadata_container = metadata_manager.read_metadata_from_strings("Unknown", METADATA)
self.discovery_container = DiscoveryContainer()
self.discovery_container.add_resource(ApiResource("/redfish/resource1",
'netloc', RESOURCE_CORRECT,
"#N.R"))
requirements = []
validator = MetadataGetValidator(self.metadata_container, requirements)
with StdoutCapture() as output:
self.assertEqual(ValidationStatus.PASSED, validator.validate(self.discovery_container))
self.assertIn('Schema defines other, not used, but similar properties: [OptionalProperty1, OptionalProperty3]',
'\n'.join(output))
self.assertIn(
'Schema defines other, not used, but similar properties: [OptionalPropertyInComplex1, OptionalPropertyInComplex3]',
'\n'.join(output))
def test_should_validate_dynamic_properties_at_entity_level(self):
metadata_manager = MetadataManager(["qualifier"])
self.metadata_container = metadata_manager.read_metadata_from_strings(
"Unknown", METADATA)
self.discovery_container = DiscoveryContainer()
self.discovery_container.add_resource(
ApiResource("/redfish/resource1", 'netloc',
RESOURCE_WITH_INCOMPLETE_DYNAMIC_PROPERTY, "#N.R"))
requirements = []
validator = MetadataGetValidator(self.metadata_container, requirements)
with StdoutCapture() as output:
self.assertEqual(ValidationStatus.FAILED,
validator.validate(self.discovery_container))
self.assertIn(
'ERROR::Required property resource.id->aaaaaaaa->Obligatory not present in the resource',
'\n'.join(output))
def test_discovery_can_handle_null_navigation_property(self):
metadata = """
<Schema xmlns="http://docs.oasis-open.org/odata/ns/edm" Namespace="N">
<EntityType Name="Outer" Abstract="false">
<NavigationProperty Name="Link" Type="N.Referenced" ContainsTarget="true">
</NavigationProperty>
</EntityType>
<EntityType Name="Referenced" Abstract="false">
</EntityType>
</Schema>
"""
resource = \
{
"@odata.id": "resource.id",
"@odata.type": "#N.Outer",
"Link": {
"@odata.id": None
},
}
metadata_manager = MetadataManager(["qualifier"])
metadata_container = metadata_manager.read_metadata_from_strings(
"Unknown", metadata)
discovery_container = DiscoveryContainer()
configuration = Configuration(
**dict(UseSSL='True', ApiEndpoint=API_ENDPOINT))
api_explorer = ApiExplorer(metadata_container, configuration)
with mock.patch(
'cts_core.discovery.api_explorer.ApiExplorer._get_resource'
) as get_resource:
get_resource.side_effect = [
(Link('link', 'netloc'), RequestStatus.SUCCESS, resource, None)
]
with StdoutCapture() as output:
api_explorer.discover("/outer", "N.Outer", discovery_container)
self.assertEqual(1, get_resource.call_count)
self.assertNotIn("ERROR::", '\n'.join(output))
def test_should_pass_when_unknown_complex_type_mapped_on_known_type(self):
metadata_manager = MetadataManager(["qualifier"],
map_types={
"A":
"B",
"unknown.complex.type":
"N.ObjectWithNumericProperty"
})
self.metadata_container = metadata_manager.read_metadata_from_strings(
METADATA)
self.discovery_container = DiscoveryContainer()
self.discovery_container.add_resource(
ApiResource("/redfish/resource1", 'netloc',
RESOURCE_WITH_UNKNOWN_COMPLEX_TYPE, "#N.R"))
requirements = []
validator = MetadataGetValidator(self.metadata_container, requirements)
self.assertEqual(ValidationStatus.PASSED,
validator.validate(self.discovery_container))
def test_follow_references_when_loading_local_matadata(self):
MetadataManager.SERVICE_TO_DIR = {"SERVICE_A": "a"}
os.path.isdir = MagicMock(return_value=True)
manager = MetadataManager([])
with StdoutCapture() as output:
with patch("__builtin__.open",
mock_open(read_data=METADATA_ROOT)) as mock_file:
with patch("cts_framework.commons.digest.DirDigest.__init__"
) as init:
init.return_value = None
with patch(
"cts_framework.commons.digest.DirDigest.is_valid"
) as is_valid:
is_valid.return_value = True
manager.read_metadata_for_services("SERVICE_A")
arguments = [arg[0][0] for arg in mock_file.call_args_list]
self.assertGreater(
len([a for a in arguments if "Org.OData.Core.V1.xml" in a]), 0)
def test_discovery_error_if_unexpected_additional_properties(self):
"""
Entity type used in this test does not accept additional properties. As a result, ApiExplorer is expected
to raise an error about unexpected 'additional_property' property.
ApiExplorer validate
"""
metadata = """
<Schema xmlns="http://docs.oasis-open.org/odata/ns/edm" Namespace="N">
<EntityType Name="Outer" Abstract="false">
<Property Name="@odata.id" Type="Edm.String"/>
<Property Name="@odata.type" Type="Edm.String"/>
<Property Name="expected" Type="Edm.Int64"/>
<Annotation Term="OData.AdditionalProperties" Bool="false"/>
</EntityType>
</Schema>
"""
resource = \
{
"@odata.id": "id",
"@odata.type": "N.Outer",
"expected": 10,
"additional_property": 1
}
metadata_manager = MetadataManager(["qualifier"])
metadata_container = metadata_manager.read_metadata_from_strings("Unknown", metadata)
discovery_container = DiscoveryContainer()
configuration = Configuration(
**dict(UseSSL='True', ApiEndpoint=API_ENDPOINT))
api_explorer = ApiExplorer(metadata_container, configuration)
with mock.patch(
'cts_core.discovery.api_explorer.ApiExplorer._get_resource') as get_resource:
get_resource.side_effect = [(Link('link', 'netloc'), RequestStatus.SUCCESS, resource, None)]
with StdoutCapture() as output:
api_explorer.discover("/outer", "N.Outer", discovery_container)
self.assertEqual(1, get_resource.call_count)
self.assertIn("unexpected properties: [additional_property]", '\n'.join(output))
def test_should_suggest_other_names_for_additionals(self):
metadata_manager = MetadataManager(["qualifier"])
self.metadata_container = metadata_manager.read_metadata_from_strings(
"Unknown", METADATA)
self.discovery_container = DiscoveryContainer()
self.discovery_container.add_resource(
ApiResource("/redfish/resource1", 'netloc', RESOURCE_CORRECT,
"#N.R"))
requirements = []
validator = MetadataGetValidator(self.metadata_container, requirements)
with StdoutCapture() as output:
self.assertEqual(ValidationStatus.PASSED,
validator.validate(self.discovery_container))
self.assertIn(
'Schema defines other, not used, but similar properties: [OptionalProperty1, OptionalProperty3]',
'\n'.join(output))
self.assertIn(
'Schema defines other, not used, but similar properties: [OptionalPropertyInComplex1, OptionalPropertyInComplex3]',
'\n'.join(output))
def test_entity_sees_inherited_properties(self):
metadata = """
<Schemas>
<Schema xmlns="http://docs.oasis-open.org/odata/ns/edm" Namespace="A">
<EntityType Name="Resource" Abstract="false">
<Property Name="GrandpaProperty" Type="Resource.Description">
<Annotation Term="OData.Permissions" EnumMember="OData.Permission/Read"/>
</Property>
</EntityType>
</Schema>
<Schema xmlns="http://docs.oasis-open.org/odata/ns/edm" Namespace="B">
<EntityType Name="Resource" BaseType="A.Resource" Abstract="false">
<Property Name="DaddyProperty" Type="Resource.Id" Nullable="false">
<Annotation Term="OData.Permissions" EnumMember="OData.Permission/Read"/>
</Property>
</EntityType>
</Schema>
<Schema xmlns="http://docs.oasis-open.org/odata/ns/edm" Namespace="C">
<EntityType Name="Resource" BaseType="B.Resource" Abstract="false">
<Property Name="KidProperty" Type="Resource.Id" Nullable="false">
<Annotation Term="OData.Permissions" EnumMember="OData.Permission/Read"/>
</Property>
</EntityType>
</Schema>
</Schemas>
"""
metadata_manager = MetadataManager(["qualifier"])
metadata_container = metadata_manager.read_metadata_from_strings("Unknown", metadata)
resource_definition = metadata_container.entities['C.Resource']
properties = resource_definition.properties
self.assertIn('KidProperty', properties)
self.assertIn('DaddyProperty', properties)
self.assertIn('GrandpaProperty', properties)
def test_discovery_can_handle_null_navigation_property(self):
metadata = """
<Schema xmlns="http://docs.oasis-open.org/odata/ns/edm" Namespace="N">
<EntityType Name="Outer" Abstract="false">
<NavigationProperty Name="Link" Type="N.Referenced" ContainsTarget="true">
</NavigationProperty>
</EntityType>
<EntityType Name="Referenced" Abstract="false">
</EntityType>
</Schema>
"""
resource = \
{
"@odata.id": "resource.id",
"@odata.type": "#N.Outer",
"Link": {
"@odata.id": None
},
}
metadata_manager = MetadataManager(["qualifier"])
metadata_container = metadata_manager.read_metadata_from_strings("Unknown", metadata)
discovery_container = DiscoveryContainer()
configuration = Configuration(
**dict(UseSSL='True', ApiEndpoint=API_ENDPOINT))
api_explorer = ApiExplorer(metadata_container, configuration)
with mock.patch(
'cts_core.discovery.api_explorer.ApiExplorer._get_resource') as get_resource:
get_resource.side_effect = [(Link('link', 'netloc'), RequestStatus.SUCCESS, resource, None)]
with StdoutCapture() as output:
api_explorer.discover("/outer", "N.Outer", discovery_container)
self.assertEqual(1, get_resource.call_count)
self.assertNotIn("ERROR::", '\n'.join(output))
def test_should_not_patch_if_property_annotation_is_non_trivial_and_alternative_implementation_not_known(self):
"""
when additional property of type 'ComplexType' does have annotation Term Nontriavial should not be patched
"""
metadata_manager = MetadataManager(["qualifier"])
metadata_container = metadata_manager.read_metadata_from_strings(AdditionalPropertiesPatchTest.METADATA)
entity_json = {
"@odata.type": "MyNamespace.v1_0_0.MyEntity",
"Outer": {
"@odata.type": "MyNamespace.v1_0_0.OuterComplexType",
"Name": "OuterName",
"InnerToValidate": {
"@odata.type": "MyNamespace.v1_0_0.InnerComplexType",
"Name": "This name property is required"
}
}
}
self.discovery_container.add_resource(ApiResource("/redfish/v1/Managers/RMC", "netloc",
entity_json, "#MyNamespace.v1_0_0.MyEntity"))
with mock.patch('cts_core.commons.api_caller.ApiCaller.__init__') as api_caller_init_mock:
api_caller_init_mock.return_value = None
validator = MetadataPatchValidator(metadata_container, None, PatchingStrategy2_2())
# this ValidationStatus.BLOCKED should be not affect final ValidationStatus
validator._verify_property = MagicMock(return_value=(ValidationStatus.BLOCKED, None))
validator._restore_property = MagicMock(return_value=ValidationStatus.BLOCKED)
validator._patch_property = MagicMock(return_value=(True, True, ValidationStatus.BLOCKED))
with StdoutCapture() as out:
self.assertEqual(ValidationStatus.PASSED_WITH_WARNINGS, validator.validate(self.discovery_container))
self.assertIn('WARNING::Skipping non-trivial property Name;', out.raw)
def test_patch_nontrivial_boot_property(self):
metadata_manager = MetadataManager(["qualifier"])
this_dir = os.path.dirname(os.path.realpath(__file__))
metadata_dir = os.path.join(this_dir, 'metadata')
self.assertTrue(metadata_manager.read_metadata_from_dir(metadata_dir))
metadata_container = metadata_manager.metadata_container
entity_json ={
"@odata.context": "/redfish/v1/$metadata#ComputerSystem.ComputerSystem",
"@odata.id": "/redfish/v1/Systems/34",
"@odata.type": "#ComputerSystem.v1_3_0.ComputerSystem",
"Id": "34",
"Name": "Computer System",
"Description": "Computer System description",
"SystemType": "Physical",
"AssetTag": "AZaz09[]!@#$%^&*()_+",
"Manufacturer": None,
"Model": None,
"SKU": None,
"SerialNumber": None,
"PartNumber": None,
"UUID": "1d7a1040-05e4-11e6-a108-54ab3a8ec80f",
"HostName": None,
"Status": {
"State": "Enabled",
"Health": "OK",
"HealthRollup": "OK"
},
"IndicatorLED": None,
"PowerState": "Off",
"BiosVersion": "F20A3A03",
"Boot": {
"@odata.type": "#ComputerSystem.v1_1_0.Boot",
"BootSourceOverrideEnabled": "Disabled",
"BootSourceOverrideTarget": "None",
"*****@*****.**": [
"Hdd",
"Pxe",
"None",
"RemoteDrive"
],
"BootSourceOverrideMode": "Legacy",
"*****@*****.**": [
"Legacy",
"UEFI"
]
},
"ProcessorSummary": {
"Count": 2,
"Model": "Intel(R) Xeon(R)",
"Status": {
"State": "Enabled",
"Health": "OK",
"HealthRollup": "OK"
}
},
"MemorySummary": {
"TotalSystemMemoryGiB": 30.52,
"Status": {
"State": "Enabled",
"Health": "OK",
"HealthRollup": "OK"
}
},
"Processors": {
"@odata.id": "/redfish/v1/Systems/34/Processors"
},
"EthernetInterfaces": {
"@odata.id": "/redfish/v1/Systems/34/EthernetInterfaces"
},
"NetworkInterfaces": {
"@odata.id": "/redfish/v1/Systems/34/NetworkInterfaces"
},
"Storage": {
"@odata.id": "/redfish/v1/Systems/34/Storage"
},
"Memory": {
"@odata.id": "/redfish/v1/Systems/34/Memory"
},
"PCIeDevices": [],
"PCIeFunctions": [],
"TrustedModules": [],
"Links": {
"@odata.type": "#ComputerSystem.v1_2_0.Links",
"Chassis": [
{
"@odata.id": "/redfish/v1/Chassis/38"
}
],
"Endpoints": [],
"ManagedBy": [
{
"@odata.id": "/redfish/v1/Managers/38"
}
],
"Oem": {}
},
"Actions": {
"#ComputerSystem.Reset": {
"target": "/redfish/v1/Systems/34/Actions/ComputerSystem.Reset",
"*****@*****.**": [
"On",
"ForceOff",
"GracefulShutdown",
"GracefulRestart",
"ForceRestart"
]
},
"Oem": {
"#Intel.Oem.ChangeTPMState": {
"target": "/redfish/v1/Systems/34/Actions/Oem/Intel.Oem.ChangeTPMState",
"*****@*****.**": []
}
}
},
"Oem": {
"Intel_RackScale": {
"@odata.type": "#Intel.Oem.ComputerSystem",
"PciDevices": [],
"PCIeConnectionId": [],
"ProcessorSockets": 2,
"MemorySockets": 16,
"DiscoveryState": "Basic",
"UserModeEnabled": None,
"TrustedExecutionTechnologyEnabled": None,
"Metrics": {
"@odata.id": "/redfish/v1/Systems/34/Metrics"
}
}
}
}
self.discovery_container.add_resource(ApiResource("/redfish/v1/Systems/34", "https://localhost:8443",
entity_json, "#ComputerSystem.v1_3_0.ComputerSystem"))
with mock.patch('cts_core.commons.api_caller.ApiCaller.__init__') as api_caller_init_mock:
api_caller_init_mock.return_value = None
validator = MetadataPatchValidator(metadata_container, None, PatchingStrategy2_2())
# this ValidationStatus.BLOCKED should be not affect final ValidationStatus
validator._verify_property = MagicMock(return_value=(ValidationStatus.PASSED, None))
validator._restore_property = MagicMock(return_value=ValidationStatus.PASSED)
validator._patch_property = MagicMock(return_value=(True, True, ValidationStatus.PASSED))
with mock.patch('cts_core.commons.api_caller.ApiCaller.patch_resource') as api_caller_patch_resource:
api_caller_patch_resource.return_value = (RequestStatus.SUCCESS, 200, None, None)
with mock.patch('cts_core.commons.api_caller.ApiCaller.get_resource') as api_caller_get_resource:
api_caller_get_resource.return_value = (Link("/redfish/v1/Systems/34", "https://localhost:8443"),
RequestStatus.SUCCESS,
200,
entity_json,
None)
with StdoutCapture() as out:
self.assertEqual(ValidationStatus.PASSED, validator.validate(self.discovery_container))
self.assertNotIn('WARNING::Skipping non-trivial property', out.raw)
def test_patch_nontrivial_roles(self):
metadata_manager = MetadataManager(["qualifier"])
this_dir = os.path.dirname(os.path.realpath(__file__))
metadata_dir = os.path.join(this_dir, 'metadata')
self.assertTrue(metadata_manager.read_metadata_from_dir(metadata_dir))
metadata_container = metadata_manager.metadata_container
role_administrator_json = {
"@odata.type": "#Role.v1_0_0.Role",
"Description": "Administrator User Role",
"OemPrivileges": [
"OemClearLog",
"OemPowerControl"
],
"@odata.id": "/redfish/v1/AccountService/Roles/Administrator",
"@odata.context": "/redfish/v1/$metadata#AccountService/Roles/Administrator/$entity",
"AssignedPrivileges": [
"Login",
"ConfigureManager",
"ConfigureUsers",
"ConfigureSelf",
"ConfigureComponents"
],
"Id": "Administrator",
"IsPredefined": True,
"Name": "User Role"
}
role_operator_json = {
"@odata.type": "#Role.v1_0_0.Role",
"Description": "Operator User Role",
"OemPrivileges": [],
"@odata.id": "/redfish/v1/AccountService/Roles/Operator",
"@odata.context": "/redfish/v1/$metadata#AccountService/Roles/Operator/$entity",
"AssignedPrivileges": [
"Login",
"ConfigureSelf",
"ConfigureComponents"
],
"Id": "Operator",
"IsPredefined": True,
"Name": "User Role"
}
role_readonly_json = {
"@odata.type": "#Role.v1_0_0.Role",
"Description": "ReadOnly User Role",
"OemPrivileges": [],
"@odata.id": "/redfish/v1/AccountService/Roles/ReadOnly",
"@odata.context": "/redfish/v1/$metadata#AccountService/Roles/ReadOnly/$entity",
"AssignedPrivileges": [
"Login",
"ConfigureSelf"
],
"Id": "ReadOnly",
"IsPredefined": True,
"Name": "User Role"
}
role_custom_json = {
"@odata.type": "#Role.v1_0_0.Role",
"Description": "Custom User Role",
"OemPrivileges": [],
"@odata.id": "/redfish/v1/AccountService/Roles/Custom",
"@odata.context": "/redfish/v1/$metadata#AccountService/Roles/ReadOnly/$entity",
"AssignedPrivileges": [
"Login",
"ConfigureSelf"
],
"Id": "ReadOnly",
"IsPredefined": False,
"Name": "Custom Role"
}
self.discovery_container.add_resource(ApiResource("/redfish/v1/AccountService/Roles/Administrator",
"https://localhost:8443",
role_administrator_json, "#Role.v1_0_0.Role"))
self.discovery_container.add_resource(ApiResource("/redfish/v1/AccountService/Roles/Operator",
"https://localhost:8443",
role_operator_json, "#Role.v1_0_0.Role"))
self.discovery_container.add_resource(ApiResource("/redfish/v1/AccountService/Roles/ReadOnly",
"https://localhost:8443",
role_readonly_json, "#Role.v1_0_0.Role"))
self.discovery_container.add_resource(ApiResource("/redfish/v1/AccountService/Roles/Custom",
"https://localhost:8443",
role_custom_json, "#Role.v1_0_0.Custom"))
with mock.patch('cts_core.commons.api_caller.ApiCaller.__init__') as api_caller_init_mock:
api_caller_init_mock.return_value = None
validator = MetadataPatchValidator(metadata_container, None, PatchingStrategy2_2())
# this ValidationStatus.BLOCKED should be not affect final ValidationStatus
validator._verify_property = MagicMock(return_value=(ValidationStatus.PASSED, None))
validator._restore_property = MagicMock(return_value=ValidationStatus.PASSED)
validator._patch_property = MagicMock(return_value=(True, True, ValidationStatus.PASSED))
with mock.patch('cts_core.validation.patch.metadata_patch_validator.MetadataPatchValidator'
'._validate_resource') as validate_resource:
with StdoutCapture() as out:
self.assertEqual(ValidationStatus.PASSED, validator.validate(self.discovery_container))
self.assertEquals(1, validate_resource.call_count) # only for 'custom' role
def setUp(self):
metadata_manager = MetadataManager(["qualifier"])
self.metadata_container = metadata_manager.read_metadata_from_strings("Unknown", METADATA)
self.discovery_container = DiscoveryContainer(metadata_container=self.metadata_container)
self.validator = HierarchyValidator(self.discovery_container, self.metadata_container, MetadataConstants2_1)
self.builder = ResourceBuilder(self.discovery_container)
