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_acl_rule(self):
"""
Test is trying to perform CRUD (create, read, update, delete) as well as binding operations on an ACL and ACL
Rule resource
"""
switches = \
dict(self.discovery_container.get_resources(MetadataConstants.ETHERNET_SWITCH, any_child_version=True))
all_ports = []
if not switches:
cts_error(
"Could not find any Ethernet Switch to perform the test on, aborting"
)
return ValidationStatus.BLOCKED
chosen_switch, chosen_acl_collection, chosen_port, mirrored_port = None, None, None, None
for switch in switches.keys():
acl_collections = dict(
self.discovery_container.get_resources(
MetadataConstants.ETHERNET_SWITCH_ACL_COLLECTION,
any_child_version=True,
constraints=[from_collection(switch)]))
if acl_collections:
chosen_switch = switch
chosen_acl_collection = choice(acl_collections.keys())
all_ports = [
port[1].odata_id
for port in self.discovery_container.get_resources(
MetadataConstants.ETHERNET_SWITCH_PORT,
any_child_version=True,
constraints=[from_collection(chosen_switch)])
]
try:
chosen_port = choice(all_ports)
all_ports.remove(chosen_port)
mirrored_port = choice(all_ports)
except IndexError:
if not chosen_port:
print "MESSAGE::Could not find a proper port for ACL binding on the switch"
continue
else:
print "WARNING::Only one proper port found, unable to create a Mirror rule"
break
if not chosen_acl_collection:
cts_error(
"Could not find any ACL collection on any of the present Ethernet Switches, aborting"
)
return ValidationStatus.BLOCKED
if not chosen_port:
cts_error(
"Could not find any proper port for ACL binding on any of the present Ethernet Switches, aborting"
)
return ValidationStatus.BLOCKED
print "MESSAGE:CRUD test will be performed on ACL collection: {collection}, the test will attempt to bind and "\
"unbind the ACL from the port: {port}".format(collection=chosen_acl_collection, port=chosen_port)
self.post_acl_payload = dict()
self.rules_payloads = dict()
self.rules_payloads["Deny"] = dict(
Action="Deny",
Condition=dict(MACSource=dict(MACAddress="AA:BB:CC:DD:EE:FF",
Mask="FF:FF:FF:00:00:00")))
self.rules_payloads["Permit"] = dict(
Action="Permit",
Condition=dict(IPSource=dict(IPv4Address="192.168.0.1",
Mask="255.255.255.0")))
self.rules_payloads["Forward"] = dict(
Action="Forward",
ForwardMirrorInterface={"@odata.id": chosen_port},
Condition=dict(IPDestination=dict(IPv4Address="1.1.1.1")))
if mirrored_port:
self.rules_payloads["Mirror"] = dict(
RuleId=1111,
Action="Mirror",
ForwardMirrorInterface={"@odata.id": chosen_port},
MirrorPortRegion=[{
"@odata.id": mirrored_port
}],
MirrorType="Egress",
Condition=dict(VLANId=dict(Id=1, Mask=None)))
# basic rules (Deny and Permit actions) should be supported by any PSME service; therefore failure in adding
# them triggers FAILED status for the test. If the mandatory rules are added successfully, but there is an
# error while adding the optional (Forward and Mirror actions) rules, the test's result is PASSED WITH WARNINGS
self.mandatory_rules = ["Deny", "Permit"]
if self._test_case_create_acl(chosen_acl_collection):
self._test_case_get_created_acl()
if self._test_case_add_rules_to_acl(
): # Rules need to be added before binding
if self._test_case_bind_acl_to_port(chosen_port):
if self._test_case_bound_acl_and_port_are_linked(
chosen_port, True):
if self._test_case_unbind_acl_from_port(chosen_port):
self._test_case_bound_acl_and_port_are_linked(
chosen_port, False)
self._test_case_delete_rules_from_acl()
self._test_case_delete_created_acl()
self._test_case_get_deleted_acl()
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()
def test_dataframes(self):
metadata_container = MetadataManager(["qualifier"]).\
read_metadata_from_strings("Unknown", self.TEST_METADATA)
dc = DiscoveryContainer(service_root="/redfish/v1",
metadata_container=metadata_container)
chassis1_2_1 = {
"@odata.context": "/redfish/v1/$metadata#Chassis/Members/$entity",
"@odata.id": "/redfish/v1/Chassis/Rack1",
"@odata.type": "#Chassis.v1_2_0.Chassis",
"ChassisType": "Rack",
"SomeValue": 1,
}
chassis1_2_2 = {
"@odata.context": "/redfish/v1/$metadata#Chassis/Members/$entity",
"@odata.id": "/redfish/v1/Chassis/Rack2",
"@odata.type": "#Chassis.v1_2_0.Chassis",
"ChassisType": "Rack",
"SomeValue": 3,
}
chassis1_0_1 = {
"@odata.context": "/redfish/v1/$metadata#Chassis/Members/$entity",
"@odata.id": "/redfish/v1/Chassis/Module1",
"@odata.type": "#Chassis.v1_0_0.Chassis",
"ChassisType": "Module",
"SomeValue": 2,
}
chassis1_0_2 = {
"@odata.context": "/redfish/v1/$metadata#Chassis/Members/$entity",
"@odata.id": "/redfish/v1/Chassis/Module2",
"@odata.type": "#Chassis.v1_0_0.Chassis",
"ChassisType": "Module",
"SomeValue": 4,
}
dc.add_resource(
ApiResource("/redfish/v1/Chassis/Rack1", 'netloc', chassis1_2_1,
"Chassis.v1_2_0.Chassis"))
dc.add_resource(
ApiResource("/redfish/v1/Chassis/Rack2", 'netloc', chassis1_2_2,
"Chassis.v1_2_0.Chassis"))
dc.add_resource(
ApiResource("/redfish/v1/Chassis/Module1", 'netloc', chassis1_0_1,
"Chassis.v1_0_0.Chassis"))
dc.add_resource(
ApiResource("/redfish/v1/Chassis/Module2", 'netloc', chassis1_0_2,
"Chassis.v1_0_0.Chassis"))
def _some_values(resource_list):
return [
resource.body["SomeValue"] for _, resource in resource_list
]
self.assertEqual(2, dc.count_resources("Chassis.v1_2_0.Chassis"))
self.assertEqual(
2,
dc.count_resources("Chassis.v1_2_0.Chassis",
any_child_version=True))
self.assertEqual(2, dc.count_resources("Chassis.v1_0_0.Chassis"))
self.assertEqual(
4,
dc.count_resources("Chassis.v1_0_0.Chassis",
any_child_version=True))
self.assertEqual(0, dc.count_resources("Chassis.Chassis"))
self.assertEqual(
4, dc.count_resources("Chassis.Chassis", any_child_version=True))
self.assertEqual([1, 2, 3, 4],
_some_values(
dc.get_resources(
"Chassis.Chassis",
any_child_version=True,
constraints=[order_by("SomeValue")])))
self.assertEqual(2, len(dc.get_resources("Chassis.v1_2_0.Chassis")))
self.assertEqual(
4, len(dc.get_resources("Chassis.Chassis",
any_child_version=True)))
self.assertEqual([1, 2, 3],
_some_values(
dc.get_resources(
"Chassis.Chassis",
any_child_version=True,
constraints=[order_by("SomeValue"),
first(3)])))
self.assertEqual([2, 1],
_some_values(
dc.get_resources("Chassis.Chassis",
any_child_version=True,
constraints=[
order_by("SomeValue",
ascending=False),
last(2)
])))
self.assertEqual([3, 4],
_some_values(
dc.get_resources(
"Chassis.Chassis",
any_child_version=True,
constraints=[order_by("SomeValue"),
last(2)])))
self.assertEqual(
2,
len(
dc.get_resources("Chassis.Chassis",
any_child_version=True,
constraints=[less("SomeValue", 3)])))
self.assertEqual(
3,
len(
dc.get_resources("Chassis.Chassis",
any_child_version=True,
constraints=[less_or_equal("SomeValue", 3)])))
self.assertEqual(
1,
len(
dc.get_resources("Chassis.Chassis",
any_child_version=True,
constraints=[equal("SomeValue", 3)])))
self.assertEqual(
3,
len(
dc.get_resources("Chassis.Chassis",
any_child_version=True,
constraints=[not_equal("SomeValue", 3)])))
self.assertEqual(
0,
len(
dc.get_resources("Chassis.Chassis",
any_child_version=False,
constraints=[order_by("SomeValue")])))
self.assertEqual(
0,
len(
dc.get_resources("Chassis.v1_2_0.Chassis",
any_child_version=False,
constraints=[greater("SomeValue", 3)])))
self.assertEqual(
1,
len(
dc.get_resources("Chassis.v1_0_0.Chassis",
any_child_version=True,
constraints=[greater("SomeValue", 3)])))
self.assertEqual(
2,
len(
dc.get_resources(
"Chassis.v1_0_0.Chassis",
any_child_version=True,
constraints=[greater_or_equal("SomeValue", 3)])))
self.assertEqual(
4,
len(
dc.get_resources(
"Chassis.v1_0_0.Chassis",
any_child_version=True,
constraints=[from_collection("/redfish/v1/Chassis")])))
chassis1_0_2["@odata.id"] = "/redfish/v1/Chassis2/Module2"
dc.add_resource(
ApiResource("/redfish/v1/Chassis2/Module2", 'netloc', chassis1_0_2,
"Chassis.v1_0_0.Chassis"))
self.assertEqual(
4,
len(
dc.get_resources(
"Chassis.v1_0_0.Chassis",
any_child_version=True,
constraints=[from_collection("/redfish/v1/Chassis")])))
self.assertEqual(
1,
len(
dc.get_resources(
"Chassis.v1_0_0.Chassis",
any_child_version=True,
constraints=[from_collection("/redfish/v1/Chassis2")])))
self.assertEqual(
2,
len(
dc.get_resources("Chassis.v1_0_0.Chassis",
any_child_version=True,
constraints=[
urls([
"/redfish/v1/Chassis/Rack1",
"/redfish/v1/Chassis/Module1"
])
])))
def crud_remote_target(self):
"""
Test is checking for rsa compute blade presence
"""
ld_created_for_crud = False
target_iqn = "cts.target:cts_test_target"
target_iqns = set()
chosen_logical_drive, chosen_remote_target_collection = None, None
if not self.discovery_container.count_resources(MetadataConstants.LOGICAL_DRIVE, any_child_version=True):
cts_error("Insufficient resources for API test. No logical drives found.")
return ValidationStatus.BLOCKED
logical_drives = dict(self.discovery_container.get_resources(MetadataConstants.LOGICAL_DRIVE,
any_child_version=True,
constraints=[equal("Mode", "LV"),
equal("Protected", False)]))
if not logical_drives:
logical_drives = dict(self.discovery_container.get_resources(MetadataConstants.LOGICAL_DRIVE,
any_child_version=True,
constraints=[equal("Mode", "RBD"),
equal("Protected", False)]))
try:
chosen_remote_target_collection = self.discovery_container.get_resources(
MetadataConstants.REMOTE_TARGET_COLLECTION,
any_child_version=True)[0][0]
chosen_logical_drive = [link for link, resource in logical_drives.iteritems() if not
len(resource.body["Links"]["Targets"])][0]
except (KeyError, IndexError):
pass
if not chosen_remote_target_collection:
cts_error("Insufficient resources available on API for test. Could not find any remote target collection")
return ValidationStatus.BLOCKED
if not chosen_logical_drive:
cts_warning("Insufficient resources available on API for test. Could not find an unprotected logical drive "
"with no targets attached")
print "MESSAGE::Trying to create a new logical volume for the target, then proceeding with remote target "\
"CRUD test"
if self.crud_logical_drive(create_logical_drive_for_target_crud=True) == ValidationStatus.PASSED:
chosen_logical_drive = self.created_logical_drive
ld_created_for_crud = True
else:
cts_error("Creating a new logical volume for the target failed, skipping remote target tests")
return ValidationStatus.BLOCKED
targets = [link for link, resource in
self.discovery_container.get_resources(MetadataConstants.REMOTE_TARGET,
any_child_version=True,
constraints=[
from_collection(chosen_remote_target_collection)
])]
for target in targets:
addresses = self.discovery_container[target].body["Addresses"]
for address in addresses:
try:
target_iqns.add(address["iSCSI"]["TargetIQN"])
except KeyError:
pass
if target_iqn in target_iqns:
iqn_number = 0
while target_iqn + str(iqn_number) in target_iqns:
iqn_number += 1
target_iqn = target_iqn + str(iqn_number)
print "MESSAGE::Remote Target CRUD test will be performed on remote target collection %s, creating remote "\
"target based on %s with first lowest consecutive \'cts.target:cts_test_target<number>\' target IQN "\
"available: %s" % (chosen_remote_target_collection, chosen_logical_drive, target_iqn)
self.post_remote_target_payload = dict(
Addresses=[dict(
iSCSI=dict(
TargetIQN=target_iqn,
TargetLUN=[dict(
LUN=1,
LogicalDrive={"@odata.id": urlparse(chosen_logical_drive).path}
)],
)
)],
Initiator=[dict(
iSCSI=dict(
InitiatorIQN="cts.initiator:initiator_cts_test"
)
)]
)
status = self._test_case_create_remote_target(chosen_remote_target_collection)
if status == ValidationStatus.PASSED: # only perform other tests if creation was successful
status = ValidationStatus.join_statuses(status, self._test_case_get_created_remote_target())
status = ValidationStatus.join_statuses(status, self._test_case_logical_drive_has_link_to_created_target(
chosen_logical_drive))
status = ValidationStatus.join_statuses(status, self._test_case_update_created_remote_target())
status = ValidationStatus.join_statuses(status, self._test_case_delete_created_remote_target())
status = ValidationStatus.join_statuses(status, self._test_case_get_deleted_remote_target())
if ld_created_for_crud:
ld = self.created_logical_drive
del_status = self._test_case_delete_created_logical_drive(ld)
del_status = ValidationStatus.join_statuses(del_status, self._test_case_get_deleted_logical_drive(ld))
if status == ValidationStatus.PASSED and del_status != status:
cts_error("Remote target CRUD test passed, but the logical drive it created failed to delete properly")
status = ValidationStatus.PASSED_WITH_WARNINGS
return status
def crud_logical_drive(self, create_logical_drive_for_target_crud=None):
"""
Test is trying to perform CRUD (create, read, update, delete) operations on a logical drive
:type create_logical_drive_for_target_crud: Boolean
"""
status = ValidationStatus.BLOCKED
lvm_found = False
chosen_logical_drive_type, chosen_logical_drive_mode = None, None
chosen_logical_drive_collection, chosen_logical_drive, chosen_logical_drive_group = None, None, None
inherited_bootable = None
# to speed things up, always look for the lowest capacity logical drive
LVM_LV_SPECIFIC_CONSTRAINTS = [equal("Mode", "LV"), greater("CapacityGiB", 0), not_equal("Snapshot", True),
order_by("CapacityGiB")]
CEPH_RBD_SPECIFIC_CONSTRAINTS = [equal("Mode", "RBD"), greater("CapacityGiB", 0), order_by("CapacityGiB")]
logical_drive_collections = dict(self.discovery_container.get_resources(
MetadataConstants.LOGICAL_DRIVE_COLLECTION,
any_child_version=True))
for collection in logical_drive_collections.keys():
chosen_logical_drive_collection = collection
logical_drive_groups = dict(self.discovery_container.get_resources(MetadataConstants.LOGICAL_DRIVE,
any_child_version=True,
constraints=[equal("Mode", "LVG"),
from_collection(collection)]))
if logical_drive_groups:
lvm_found = True
else:
logical_drive_groups = dict(self.discovery_container.get_resources(MetadataConstants.LOGICAL_DRIVE,
any_child_version=True,
constraints=[equal("Mode", "Pool"),
from_collection(
collection)]))
if logical_drive_groups:
specific_constraints = LVM_LV_SPECIFIC_CONSTRAINTS if lvm_found else CEPH_RBD_SPECIFIC_CONSTRAINTS
for lvg_link, lvg in logical_drive_groups.iteritems():
chosen_logical_drive_group = lvg.odata_id
try:
child_lvs = [lv["@odata.id"] for lv in lvg.body["Links"]["LogicalDrives"]]
chosen_logical_drive, _ = self.discovery_container.get_resources(
MetadataConstants.LOGICAL_DRIVE,
any_child_version=True,
constraints=specific_constraints
+ [odata_ids(child_lvs)])[0]
lv = self.discovery_container[chosen_logical_drive]
inherited_bootable = lv.body["Bootable"]
chosen_logical_drive_type = lv.body["Type"]
chosen_logical_drive_mode = lv.body["Mode"]
except (KeyError,IndexError) as error:
cts_error("Exception while parsing {id:id}: {error:exception}", id=chosen_logical_drive,
error=error)
chosen_logical_drive = None
pass
else:
break
if not chosen_logical_drive_group:
resource = "logical drive group" if lvm_found else "Pool"
cts_warning("Could not find a {resource} resource in collection {collection}", **locals())
if lvm_found and not chosen_logical_drive:
cts_warning("Could not find a logical volume in collection {collection}", **locals())
if lvm_found and not chosen_logical_drive:
cts_error("Could not find any logical volume")
return status
if not chosen_logical_drive_group:
cts_error("Could not find any logical drive group, aborting")
return status
self.post_logical_drive_payload = dict(
Name="LVM Logical Drive created by CTS",
Type=chosen_logical_drive_type,
Mode=chosen_logical_drive_mode,
Protected=False,
CapacityGiB=self.discovery_container[chosen_logical_drive].body["CapacityGiB"],
Image="CTS test image",
Bootable=inherited_bootable if inherited_bootable else False,
Snapshot=True,
Links=dict(
LogicalDrives=[{"@odata.id": chosen_logical_drive_group}],
MasterDrive={"@odata.id": urlparse(chosen_logical_drive).path}
)
)
# Creating the first RBD if no other was found
if not chosen_logical_drive:
if lvm_found:
print "ERROR::Could not find a logical drive suitable for snapshot"
return status
cts_warning("Could not find any logical drive suitable for snapshot. Since CEPH was detected, CTS will "\
"try to create the first RBD")
self.post_logical_drive_payload = dict(
Name="CEPH Logical Drive created by CTS",
Type="CEPH",
Mode="RBD",
Protected=False,
CapacityGiB=self.discovery_container[chosen_logical_drive_group].body["CapacityGiB"]/2,
Bootable=False,
Snapshot=False,
Links=dict(
LogicalDrives=[{"@odata.id": urlparse(chosen_logical_drive_group).path}],
MasterDrive=None
)
)
print "MESSAGE::Logical drive CRUD test will be performed on logical drive collection %s, creating logical " \
"drive based on %s on group %s" % (chosen_logical_drive_collection, chosen_logical_drive,
chosen_logical_drive_group)
self.expected_created_logical_drive_body = deepcopy(self.post_logical_drive_payload)
# The logical drive in LogicalDrives link is really the volume group and is going to be seen under
# UsedBy on REST
self.expected_created_logical_drive_body["Links"]["UsedBy"] = \
self.expected_created_logical_drive_body["Links"]["LogicalDrives"]
self.expected_created_logical_drive_body["Links"]["LogicalDrives"] = []
status = self._test_case_create_logical_drive(chosen_logical_drive_collection)
if status == ValidationStatus.PASSED: # only perform other tests if creation was successful
ld = self.created_logical_drive
status = ValidationStatus.join_statuses(status, self._test_case_get_created_logical_drive(ld))
if create_logical_drive_for_target_crud:
return status
if status == ValidationStatus.PASSED:
status = ValidationStatus.join_statuses(status, self._test_case_update_created_logical_drive())
status = ValidationStatus.join_statuses(status, self._test_case_delete_created_logical_drive(ld))
status = ValidationStatus.join_statuses(status, self._test_case_get_deleted_logical_drive(ld))
return status
def test_dataframes(self):
metadata_container = MetadataManager(["qualifier"]).\
read_metadata_from_strings("Unknown", self.TEST_METADATA)
dc = DiscoveryContainer(service_root="/redfish/v1", metadata_container=metadata_container)
chassis1_2_1 = {
"@odata.context": "/redfish/v1/$metadata#Chassis/Members/$entity",
"@odata.id": "/redfish/v1/Chassis/Rack1",
"@odata.type": "#Chassis.v1_2_0.Chassis",
"ChassisType": "Rack",
"SomeValue": 1,
}
chassis1_2_2 = {
"@odata.context": "/redfish/v1/$metadata#Chassis/Members/$entity",
"@odata.id": "/redfish/v1/Chassis/Rack2",
"@odata.type": "#Chassis.v1_2_0.Chassis",
"ChassisType": "Rack",
"SomeValue": 3,
}
chassis1_0_1 = {
"@odata.context": "/redfish/v1/$metadata#Chassis/Members/$entity",
"@odata.id": "/redfish/v1/Chassis/Module1",
"@odata.type": "#Chassis.v1_0_0.Chassis",
"ChassisType": "Module",
"SomeValue": 2,
}
chassis1_0_2 = {
"@odata.context": "/redfish/v1/$metadata#Chassis/Members/$entity",
"@odata.id": "/redfish/v1/Chassis/Module2",
"@odata.type": "#Chassis.v1_0_0.Chassis",
"ChassisType": "Module",
"SomeValue": 4,
}
dc.add_resource(ApiResource("/redfish/v1/Chassis/Rack1", 'netloc', chassis1_2_1,
"Chassis.v1_2_0.Chassis"))
dc.add_resource(ApiResource("/redfish/v1/Chassis/Rack2", 'netloc',chassis1_2_2, "Chassis.v1_2_0.Chassis"))
dc.add_resource(ApiResource("/redfish/v1/Chassis/Module1", 'netloc',chassis1_0_1, "Chassis.v1_0_0.Chassis"))
dc.add_resource(ApiResource("/redfish/v1/Chassis/Module2", 'netloc',chassis1_0_2, "Chassis.v1_0_0.Chassis"))
def _some_values(resource_list):
return [resource.body["SomeValue"] for _, resource in resource_list]
self.assertEqual(2, dc.count_resources("Chassis.v1_2_0.Chassis"))
self.assertEqual(2, dc.count_resources("Chassis.v1_2_0.Chassis", any_child_version=True))
self.assertEqual(2, dc.count_resources("Chassis.v1_0_0.Chassis"))
self.assertEqual(4, dc.count_resources("Chassis.v1_0_0.Chassis", any_child_version=True))
self.assertEqual(0, dc.count_resources("Chassis.Chassis"))
self.assertEqual(4, dc.count_resources("Chassis.Chassis", any_child_version=True))
self.assertEqual([1,2,3,4], _some_values(dc.get_resources("Chassis.Chassis", any_child_version=True,
constraints=[order_by("SomeValue")])))
self.assertEqual(2, len(dc.get_resources("Chassis.v1_2_0.Chassis")))
self.assertEqual(4, len(dc.get_resources("Chassis.Chassis", any_child_version=True)))
self.assertEqual([1,2,3], _some_values(dc.get_resources("Chassis.Chassis", any_child_version=True,
constraints=[order_by("SomeValue"),
first(3)])))
self.assertEqual([2,1], _some_values(dc.get_resources("Chassis.Chassis", any_child_version=True,
constraints=[order_by("SomeValue", ascending=False),
last(2)])))
self.assertEqual([3,4], _some_values(dc.get_resources("Chassis.Chassis", any_child_version=True,
constraints=[order_by("SomeValue"), last(2)])))
self.assertEqual(2, len(dc.get_resources("Chassis.Chassis", any_child_version=True,
constraints=[less("SomeValue", 3)])))
self.assertEqual(3, len(dc.get_resources("Chassis.Chassis", any_child_version=True,
constraints=[less_or_equal("SomeValue", 3)])))
self.assertEqual(1, len(dc.get_resources("Chassis.Chassis", any_child_version=True,
constraints=[equal("SomeValue", 3)])))
self.assertEqual(3, len(dc.get_resources("Chassis.Chassis", any_child_version=True,
constraints=[not_equal("SomeValue", 3)])))
self.assertEqual(0, len(dc.get_resources("Chassis.Chassis", any_child_version=False,
constraints=[order_by("SomeValue")])))
self.assertEqual(0, len(dc.get_resources("Chassis.v1_2_0.Chassis", any_child_version=False,
constraints=[greater("SomeValue", 3)])))
self.assertEqual(1, len(dc.get_resources("Chassis.v1_0_0.Chassis", any_child_version=True,
constraints=[greater("SomeValue", 3)])))
self.assertEqual(2, len(dc.get_resources("Chassis.v1_0_0.Chassis", any_child_version=True,
constraints=[greater_or_equal("SomeValue", 3)])))
self.assertEqual(4, len(dc.get_resources("Chassis.v1_0_0.Chassis", any_child_version=True,
constraints=[from_collection("/redfish/v1/Chassis")])))
chassis1_0_2["@odata.id"] = "/redfish/v1/Chassis2/Module2"
dc.add_resource(ApiResource("/redfish/v1/Chassis2/Module2", 'netloc', chassis1_0_2,
"Chassis.v1_0_0.Chassis"))
self.assertEqual(4, len(dc.get_resources("Chassis.v1_0_0.Chassis", any_child_version=True,
constraints=[from_collection("/redfish/v1/Chassis")])))
self.assertEqual(1, len(dc.get_resources("Chassis.v1_0_0.Chassis", any_child_version=True,
constraints=[from_collection("/redfish/v1/Chassis2")])))
self.assertEqual(2, len(dc.get_resources("Chassis.v1_0_0.Chassis", any_child_version=True,
constraints=[urls(["/redfish/v1/Chassis/Rack1",
"/redfish/v1/Chassis/Module1"])])))
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:
try:
parent_port = get_parent_odata_id(vlan_network_interface_collection)
parent_port_id = self.discovery_container[parent_port].body["PortId"]
except:
continue
# For arista setup, only ever try adding VLANs on the main /1 port
if parent_port_id.endswith("/2") or parent_port_id.endswith("/3") or parent_port_id.endswith("/4"):
continue
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:
print "MESSAGE::No free VLAN id available on collection {}".format(vlan_network_interface_collection)
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 on any of the suitable ports (perhaps there are no suitable ports)')
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()