def run(self):
if self.metadata_container is None:
return
test_name = "Storage Services CRUD test"
print "MESSAGE::%s starting" % test_name
print "TEST_CASE::API crawling"
api_explorer = ApiExplorer(self.metadata_container, self.configuration)
self.discovery_container, status = api_explorer.discover(MetadataConstants.SERVICE_ROOT_URI,
MetadataConstants.SERVICE_ROOT)
print "STATUS::{status}".format(status=status)
requirements = [
Requirement(MetadataConstants.SERVICE_ROOT, min=1, max=1),
Requirement(MetadataConstants.STORAGE_SERVICE, min=1),
Requirement(MetadataConstants.LOGICAL_DRIVE_COLLECTION, min=1),
Requirement(MetadataConstants.REMOTE_TARGET_COLLECTION, min=1),
Requirement(MetadataConstants.LOGICAL_DRIVE, min=2)
]
preconditions = Preconditions(self.metadata_container, requirements)
status = preconditions.validate(self.discovery_container)
if status == ValidationStatus.FAILED:
self.set_status_blocked()
return
self.api_caller = ApiCaller(self.configuration)
status = ValidationStatus.join_statuses(status, self.crud_logical_drive())
status = ValidationStatus.join_statuses(status, self.crud_remote_target())
print "MESSAGE::%s overall status: %s" % (test_name, ColorPrinter.format_status(status))
def run(self):
print "TEST_CASE::API crawling"
api_explorer = ApiExplorer(self.metadata_container, self.configuration)
discovery_container, status = api_explorer.discover(
MetadataConstants.SERVICE_ROOT_URI, MetadataConstants.SERVICE_ROOT)
print "STATUS::{status}".format(status=status)
print "TEST_CASE::Checking for mandatory entities"
requirements = [
Requirement(MetadataConstants.SERVICE_ROOT, min=1, max=1)
]
preconditions = Preconditions(self.metadata_container, requirements)
self.set_validation_status(preconditions.validate(discovery_container))
validation_functions = [
self.at_least_one_compute_module_in_pod,
self.at_least_one_ethernet_switch_in_the_pod,
self.ethernet_based_fabric_for_network_connectivity,
self.secure_communication_channel, self.node_reset_support,
self.manual_tests, self.validate_all_or_none_chassis_have_location,
self.validate_path_using_contains_property,
self.power_monitoring_support
]
for validation_function in validation_functions:
try:
validation_function(discovery_container)
except Exception as err:
print "ERROR::Exception %s" % err
self.set_validation_status(ValidationStatus.FAILED)
print "SCREEN::Overall status: %s" % self.validation_status
def test_not_found_in_empty_discovery_container(self):
discovery_container = DiscoveryContainer(metadata_container=self.metadata_container)
requirements = [
Requirement("Chassis.Chassis", min=1, max=1)
]
preconditions = Preconditions(self.metadata_container, requirements)
self.assertEqual(ValidationStatus.FAILED, preconditions.validate(discovery_container))
def run(self):
print "TEST_CASE::API crawling"
api_explorer = ApiExplorer(self.metadata_container, self.configuration)
discovery_container, status = api_explorer.discover(
MetadataConstants.SERVICE_ROOT_URI, MetadataConstants.SERVICE_ROOT)
print "STATUS::{status}".format(status=status)
requirements = [
Requirement(MetadataConstants.SERVICE_ROOT, min=1, max=1),
Requirement(MetadataConstants.ETHERNET_SWITCH, min=1),
Requirement(MetadataConstants.ETHERNET_SWITCH_PORT, min=1)
]
preconditions = Preconditions(self.metadata_container, requirements)
status = preconditions.validate(discovery_container)
self.api_caller = ApiCaller(self.configuration)
self.crud_vlan(discovery_container)
def run(self):
if self.metadata_container is None:
return
self.chosen_endpoint, self.chosen_zone, self.chosen_volume, self.chosen_volume_collection = (
None, ) * 4
self.initiator_endpoint, self.target_endpoint, self.zone_endpoint, self.created_volume = (
None, ) * 4
self.initiator_unique_name = self.generate_unique_names() if self.configuration.UniqueInitiatorName \
!= "generate" else self.configuration.UniqueInitiatorName
self.target_unique_name = self.generate_unique_names() if self.configuration.UniqueTargetName \
!= "generate" else self.configuration.UniqueTargetName
test_name = "Storage Services CRUD test with NVM Express (NVMe) Support"
print "MESSAGE::%s starting" % test_name
print "TEST_CASE::API crawling"
api_explorer = ApiExplorer(self.metadata_container, self.configuration)
self.discovery_container, status = api_explorer.discover(
MetadataConstants.SERVICE_ROOT_URI, MetadataConstants.SERVICE_ROOT)
print "STATUS::{status}".format(status=status)
requirements = [
Requirement(MetadataConstants.SERVICE_ROOT, min=1, max=1),
Requirement(MetadataConstants.STORAGE_SERVICE, min=1),
Requirement(MetadataConstants.VOLUME, min=1),
Requirement(MetadataConstants.VOLUME_COLLECTION, min=1)
]
preconditions = Preconditions(self.metadata_container, requirements)
status = preconditions.validate(self.discovery_container)
if status == ValidationStatus.FAILED:
self.set_status_failed()
return
self.api_caller = ApiCaller(self.configuration)
status = ValidationStatus.join_statuses(status, self.crud_nvme())
print "MESSAGE::%s overall status: %s" % (
test_name, ColorPrinter.format_status(status))
def run(self):
print "TEST_CASE::API crawling"
api_explorer = ApiExplorer(self.metadata_container, self.configuration)
discovery_container, status = api_explorer.discover(MetadataConstants.SERVICE_ROOT_URI,
MetadataConstants.SERVICE_ROOT)
print "STATUS::{status}".format(status=status)
requirements = [
Requirement(MetadataConstants.SERVICE_ROOT, min=1, max=1)
]
MetadataGetValidator(self.metadata_container, requirements).validate(discovery_container)
def test_not_found_in_non_empty_discovery_container(self):
discovery_container = DiscoveryContainer(metadata_container=self.metadata_container)
discovery_container.add_resource(ApiResource("id_1", 'netloc', {'@odata.id': '123',
'Oem':
{'Intel_RackScale':
{'Location':
{'Id': 1, 'ParentId': None}
}
}
}, None))
requirements = [
Requirement("Chassis.Chassis", min=1, max=1)
]
preconditions = Preconditions(self.metadata_container, requirements)
self.assertEqual(ValidationStatus.FAILED, preconditions.validate(discovery_container))
def test_fail_when_more_than_max(self):
discovery_container = DiscoveryContainer(metadata_container=self.metadata_container)
discovery_container.add_resource(ApiResource("id_1", 'netloc', {'@odata.id': '123',
'@odata.type' : '#Chassis.v1_0_0.Chassis',
'Oem':
{'Intel_RackScale':
{'Location':
{'Id': 1, 'ParentId': None}
}
}
}, None))
requirements = [
Requirement("Chassis.Chassis", min=0, max=0)
]
preconditions = Preconditions(self.metadata_container, requirements)
self.assertEqual(ValidationStatus.FAILED, preconditions.validate(discovery_container))
def run(self):
if self.metadata_container is None:
return
print "TEST_CASE::API crawling"
api_explorer = ApiExplorer(self.metadata_container, self.configuration)
discovery_container, status = api_explorer.discover(MetadataConstants.SERVICE_ROOT_URI,
MetadataConstants.SERVICE_ROOT)
print "STATUS::{status}".format(status=status)
requirements = [
Requirement(MetadataConstants.SERVICE_ROOT, min=1, max=1)
]
MetadataGetValidator(self.metadata_container, requirements).validate(discovery_container)
performance_status = self._measuring_request_responses(api_explorer)
print("STATUS::{status}".format(status=performance_status))
def run(self):
if self.metadata_container is None:
return
print "TEST_CASE::API crawling"
api_explorer = ApiExplorer(self.metadata_container, self.configuration)
discovery_container, status = api_explorer.discover(
MetadataConstants.SERVICE_ROOT_URI, MetadataConstants.SERVICE_ROOT)
print "STATUS::{status}".format(status=status)
requirements = [
Requirement(MetadataConstants.SERVICE_ROOT, min=1, max=1)
]
validator = MetadataPatchValidator(self.metadata_container,
self.configuration,
PatchingStrategy2_1(), requirements)
validator.validate(discovery_container)
def crud_vlan(self):
"""
Test is trying to perform CRUD (create, read, update, delete) operations on a VLAN Network Interface resource
"""
requirements = [
Requirement(MetadataConstants.SERVICE_ROOT, min=1, max=1),
Requirement(MetadataConstants.VLAN_NETWORK_INTERFACE_COLLECTION,
min=1),
]
preconditions = Preconditions(self.metadata_container, requirements)
status = preconditions.validate(self.discovery_container)
if status is ValidationStatus.PASSED_WITH_WARNINGS:
cts_warning(
"Without some components it is not possible to perform tests.")
print "STATUS::{status}".format(status=status)
return ValidationStatus.PASSED_WITH_WARNINGS
if status is ValidationStatus.FAILED:
return ValidationStatus.BLOCKED
vlan_network_interface_collections = \
dict(self.discovery_container.get_resources(MetadataConstants.VLAN_NETWORK_INTERFACE_COLLECTION,
any_child_version=True))
chosen_vlan_network_interface_collection = None
new_vlan_id = 0
for vlan_network_interface_collection in vlan_network_interface_collections:
present_vlan_ids = []
vlan_network_interfaces = \
dict(self.discovery_container.
get_resources(MetadataConstants.VLAN_NETWORK_INTERFACE,
constraints=[from_collection(vlan_network_interface_collection)],
any_child_version=True))
if len(vlan_network_interfaces) > MAX_VLAN_ID - MIN_VLAN_ID:
continue
for resource_link, resource in vlan_network_interfaces.iteritems():
try:
present_vlan_ids.append(resource.body["VLANId"])
except:
cts_error("Inorrect resource {resource_link:id} structure",
**locals())
for possible_id in range(MIN_VLAN_ID, MAX_VLAN_ID + 1):
if possible_id not in present_vlan_ids:
chosen_vlan_network_interface_collection = vlan_network_interface_collection
new_vlan_id = possible_id
break
if chosen_vlan_network_interface_collection:
break
if chosen_vlan_network_interface_collection:
print "MESSAGE::CRUD test will be performed on vlan network interface collection %s" % \
chosen_vlan_network_interface_collection
else:
cts_warning('No free VLAN id available')
return ValidationStatus.BLOCKED
self.post_vlan_payload = dict(
VLANId=new_vlan_id,
VLANEnable=True,
Oem=dict(Intel_RackScale=dict(Tagged=True)))
if self._test_case_create_vlan(
chosen_vlan_network_interface_collection):
self._test_case_get_created_vlan()
self._test_case_delete_created_vlan()
self._test_case_get_deleted_vlan()
def crud_static_mac(self):
"""
Test is trying to perform CRUD (create, read, update, delete) operations on a Static MAC resource
"""
def _find_unique_mac_address_vlan_id_pair(present_pairs):
MAX_ADDRESS = 281474976710656 - 1 # 16^12 - 1
def address_to_string(address):
parts = []
for _ in range(6):
parts.append(address % 256)
address = address / 256
return ":".join("{0:02x}".format(part)
for part in parts).upper()
address = 0
vlan_id = MIN_VLAN_ID
while (address_to_string(address), vlan_id) in present_pairs:
address = address + 1
if address > MAX_ADDRESS:
address = 0
vlan_id = vlan_id + 1
if vlan_id > MAX_VLAN_ID:
return None
return (address_to_string(address), vlan_id)
requirements = [
Requirement(MetadataConstants.SERVICE_ROOT, min=1, max=1),
Requirement(MetadataConstants.ETHERNET_SWITCH, min=1),
Requirement(MetadataConstants.ETHERNET_SWITCH_PORT, min=1),
Requirement(MetadataConstants.STATIC_MAC_COLLECTION, min=1),
]
preconditions = Preconditions(self.metadata_container, requirements)
if preconditions.validate(
self.discovery_container) == ValidationStatus.FAILED:
return ValidationStatus.BLOCKED
static_mac_collections = \
dict(self.discovery_container.get_resources(MetadataConstants.STATIC_MAC_COLLECTION,
any_child_version=True))
chosen_static_mac_collection = static_mac_collections.keys()[0]
print "MESSAGE::\nMESSAGE::Static MAC CRUD test will be performed on collection: {}"\
.format(chosen_static_mac_collection)
present_vlan_id_mac_address_pairs = []
for resource_link, resource in self.discovery_container.get_resources(
MetadataConstants.STATIC_MAC,
any_child_version=True,
constraints=[from_collection(chosen_static_mac_collection)]):
try:
present_vlan_id_mac_address_pairs.append(
(resource.body["MACAddress"], resource.body["VLANId"]))
except Exception as err:
cts_warning(
"{link:id} Incorrect resource structure; err={err:exception}",
link=resource_link,
err=err)
initial_values = _find_unique_mac_address_vlan_id_pair(
present_vlan_id_mac_address_pairs)
if not initial_values:
cts_error("Cannot create a Static MAC on the chosen collection - "
"all MAC addresses and VLAN ids already occupied")
return ValidationStatus.BLOCKED
self.post_static_mac_payload = dict(MACAddress=initial_values[0],
VLANId=initial_values[1])
# PSME does not support patching Static MAC
if self._test_case_create_static_mac(chosen_static_mac_collection):
self._test_case_get_created_static_mac()
self._test_case_delete_created_static_mac()
self._test_case_get_deleted_static_mac()
* http://www.apache.org/licenses/LICENSE-2.0
*
* @copyright
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* @section DESCRIPTION
"""
from cts_core.commons.preconditions import Requirement
from cts_core.metadata.metadata_constants import MetadataConstants2_1, MetadataConstants2_2
RequiredTypes_PSME_2_1 = [
Requirement(MetadataConstants2_1.CHASSIS, min=1),
Requirement(MetadataConstants2_1.CHASSIS_COLLECTION, min=1),
Requirement(MetadataConstants2_1.COMPUTER_SYSTEM, min=1),
Requirement(MetadataConstants2_1.COMPOSED_SYSTEM_COLLECTION, min=1),
Requirement(MetadataConstants2_1.ETHERNET_INTERFACE, min=1),
Requirement(MetadataConstants2_1.EVENT_DESTINATION_COLLECTION, min=1),
Requirement(MetadataConstants2_1.EVENT_SERVICE, min=1),
Requirement(MetadataConstants2_1.MANAGER, min=1),
Requirement(MetadataConstants2_1.MANAGER_COLLECTION, min=1),
Requirement(MetadataConstants2_1.MEMORY, min=1),
Requirement(MetadataConstants2_1.MEMORY_COLLECTION, min=1),
Requirement(MetadataConstants2_1.PROCESSOR, min=1),
Requirement(MetadataConstants2_1.PROCESSOR_COLLECTION, min=1),
Requirement(MetadataConstants2_1.SERVICE_ROOT, min=1, max=1),
Requirement(MetadataConstants2_1.TASK_COLLECTION, min=1),
Requirement(MetadataConstants2_1.TASK_SERVICE, min=1),
