New unit tests for cached category resources

oneview_redfish_toolkit/tests/blueprints/test_chassis.py

@@ -19,13 +19,15 @@
 import copy
 import json
 from unittest import mock
+from unittest.mock import call
 
 # 3rd party libs
 from flask_api import status
 from hpOneView.exceptions import HPOneViewException
 
 # Module libs
 from oneview_redfish_toolkit.blueprints import chassis
+from oneview_redfish_toolkit import category_resource
 from oneview_redfish_toolkit import multiple_oneview
 from oneview_redfish_toolkit.tests.base_flask_test import BaseFlaskTest
 
@@ -230,6 +232,56 @@ def test_enclosure_env_config_unexpected_error(self):
             response.status_code)
         self.assertEqual("application/json", response.mimetype)
 
+    @mock.patch.object(multiple_oneview, 'get_map_resources')
+    @mock.patch.object(multiple_oneview, 'get_map_appliances')
+    def test_get_enclosure_chassis_cached(self, get_map_appliances,
+                                          get_map_resources):
+        """"Tests EnclosureChassis with a known Enclosure"""
+
+        get_map_resources.return_value = OrderedDict({
+            "0000000000A66101": "10.0.0.1",
+        })
+        get_map_appliances.return_value = self.map_appliance
+        self.oneview_client.index_resources.get_all.return_value = \
+            [{"category": "enclosures"}]
+        self.oneview_client.enclosures.get.return_value = self.enclosure
+        self.oneview_client.enclosures.get_environmental_configuration.\
+            return_value = self.enclosure_environment_configuration_mockup
+        self.oneview_client.appliance_node_information.get_version.return_value = \
+            self.appliance_info
+
+        uri = "/redfish/v1/Chassis/0000000000A66101"
+        uuid = uri.split('/')[-1]
+
+        # Get EnclosureChassis
+        response = self.client.get(uri)
+
+        result = json.loads(response.data.decode("utf-8"))
+
+        # Tests response
+        self.assertEqual(status.HTTP_200_OK, response.status_code)
+
+        # Get cached EnclosureChassis
+        response = self.client.get(uri)
+
+        # Tests cached response
+        self.assertEqual(status.HTTP_200_OK, response.status_code)
+        self.assertEqual("application/json", response.mimetype)
+        self.assertEqualMockup(self.enclosure_chassis_mockup, result)
+        self.assertEqual(
+            "{}{}".format("W/", self.enclosure["eTag"]),
+            response.headers["ETag"])
+
+        # Check for cached calls
+        self.oneview_client.index_resources.get_all.assert_called_once_with(
+            filter='uuid=' + uuid
+        )
+        assert self.oneview_client.enclosures.get.has_calls(
+            [call(uuid),
+             call(uuid)]
+        )
+        self.assertTrue(category_resource.get_category_by_resource_id(uuid))
+
     #############
     # Blade     #
     #############
@@ -359,6 +411,59 @@ def test_server_hardware_unexpected_error(self):
             response.status_code)
         self.assertEqual("application/json", response.mimetype)
 
+    @mock.patch.object(multiple_oneview, 'get_map_resources')
+    @mock.patch.object(multiple_oneview, 'get_map_appliances')
+    def test_get_blade_chassis_with_computer_system_cached(self,
+                                                           get_map_appliances,
+                                                           get_map_resources):
+        """"Tests BladeChassis with a known Server Hardware"""
+
+        get_map_resources.return_value = OrderedDict({
+            "30303437-3034-4D32-3230-313133364752": "10.0.0.1",
+        })
+        get_map_appliances.return_value = self.map_appliance
+        self.oneview_client.index_resources.get_all.return_value = \
+            [{"category": "server-hardware"}]
+        self.oneview_client.server_hardware.get.return_value = \
+            self.server_hardware
+        self.oneview_client.appliance_node_information.get_version.return_value = \
+            self.appliance_info
+
+        uri = "/redfish/v1/Chassis/30303437-3034-4D32-3230-313133364752"
+        uuid = uri.split('/')[-1]
+
+        # Get BladeChassis
+        response = self.client.get(uri)
+
+        result = json.loads(response.data.decode("utf-8"))
+
+        # Tests response
+        self.assertEqual(status.HTTP_200_OK, response.status_code)
+
+        # Get cached BladeChassis
+        response = self.client.get(uri)
+
+        result = json.loads(response.data.decode("utf-8"))
+
+        # Tests response
+        self.assertEqual(status.HTTP_200_OK, response.status_code)
+        self.assertEqual("application/json", response.mimetype)
+        self.assertEqual("application/json", response.mimetype)
+        self.assertEqualMockup(self.blade_chassis_mockup, result)
+        self.assertEqual(
+            "{}{}".format("W/", self.server_hardware["eTag"]),
+            response.headers["ETag"])
+
+        # Check for cached calls
+        self.oneview_client.index_resources.get_all.assert_called_once_with(
+            filter='uuid=' + uuid
+        )
+        assert self.oneview_client.server_hardware.get.has_calls(
+            [call(uuid),
+             call(uuid)]
+        )
+        self.assertTrue(category_resource.get_category_by_resource_id(uuid))
+
     ########
     # Rack #
     ########
@@ -433,6 +538,55 @@ def test_rack_unexpected_error(self):
             response.status_code)
         self.assertEqual("application/json", response.mimetype)
 
+    @mock.patch.object(multiple_oneview, 'get_map_resources')
+    @mock.patch.object(multiple_oneview, 'get_map_appliances')
+    def test_get_rack_chassis_cached(self, get_map_appliances,
+                                     get_map_resources):
+        """"Tests RackChassis with a known Rack"""
+
+        get_map_resources.return_value = OrderedDict({
+            "2AB100LMNB": "10.0.0.1",
+        })
+        get_map_appliances.return_value = self.map_appliance
+        self.oneview_client.index_resources.get_all.return_value = \
+            [{"category": "racks"}]
+        self.oneview_client.racks.get.return_value = self.rack
+
+        uri = "/redfish/v1/Chassis/2AB100LMNB"
+        uuid = uri.split('/')[-1]
+
+        # Get RackChassis
+        response = self.client.get(uri)
+
+        result = json.loads(response.data.decode("utf-8"))
+
+        # Tests response
+        self.assertEqual(status.HTTP_200_OK, response.status_code)
+        self.assertEqual("application/json", response.mimetype)
+
+        # Get cached RackChassis
+        response = self.client.get(uri)
+
+        result = json.loads(response.data.decode("utf-8"))
+
+        # Tests response
+        self.assertEqual(status.HTTP_200_OK, response.status_code)
+        self.assertEqual("application/json", response.mimetype)
+        self.assertEqualMockup(self.rack_chassis_mockup, result)
+        self.assertEqual(
+            "{}{}".format("W/", self.rack["eTag"]),
+            response.headers["ETag"])
+
+        # Check for cached calls
+        self.oneview_client.index_resources.get_all.assert_called_once_with(
+            filter='uuid=' + uuid
+        )
+        assert self.oneview_client.racks.get.has_calls(
+            [call(uuid),
+             call(uuid)]
+        )
+        self.assertTrue(category_resource.get_category_by_resource_id(uuid))
+
     def test_change_power_state(self):
         """Tests changes a SH chassi type with valid reset options
 

oneview_redfish_toolkit/tests/blueprints/test_computer_system.py

@@ -29,6 +29,7 @@
 # Module libs
 import oneview_redfish_toolkit.api.status_mapping as status_mapping
 from oneview_redfish_toolkit.blueprints import computer_system
+from oneview_redfish_toolkit import category_resource
 from oneview_redfish_toolkit import multiple_oneview
 from oneview_redfish_toolkit.services import computer_system_service
 from oneview_redfish_toolkit.tests.base_flask_test import BaseFlaskTest
@@ -365,6 +366,59 @@ def test_get_computer_system_spt(self):
         self.oneview_client.server_profile_templates.get \
             .assert_called_with("1f0ca9ef-7f81-45e3-9d64-341b46cf87e0")
 
+    def test_get_computer_system_spt_cached(self):
+        """Tests ComputerSystem with a known Server Profile Templates"""
+
+        with open(
+            'oneview_redfish_toolkit/mockups/oneview/'
+            'ServerProfileTemplate.json'
+        ) as f:
+            server_profile_template = json.load(f)
+
+        with open(
+            'oneview_redfish_toolkit/mockups/redfish/CapabilitiesObject.json'
+        ) as f:
+            capabilities_obj_mockup = json.load(f)
+
+        # Create mock response
+        self.oneview_client.\
+            server_profiles.get.side_effect = self.not_found_error
+        self.oneview_client.server_profile_templates.get.return_value = \
+            server_profile_template
+
+        uri = "/redfish/v1/Systems/1f0ca9ef-7f81-45e3-9d64-341b46cf87e0"
+        uuid = uri.split('/')[-1]
+
+        # Get ComputerSystem
+        response = self.client.get(uri)
+
+        # Gets json from response
+        result = json.loads(response.data.decode("utf-8"))
+
+        # Tests response
+        self.assertEqual(status.HTTP_200_OK, response.status_code)
+        self.assertEqual("application/json", response.mimetype)
+        self.assertEqualMockup(capabilities_obj_mockup, result)
+
+        # Get cached ComputerSystem
+        response = self.client.get(uri)
+
+        # Gets json from response
+        result = json.loads(response.data.decode("utf-8"))
+
+        # Tests response
+        self.assertEqual(status.HTTP_200_OK, response.status_code)
+        self.assertEqual("application/json", response.mimetype)
+        self.assertEqualMockup(capabilities_obj_mockup, result)
+        self.oneview_client.server_profiles.get \
+            .assert_called_once_with(uuid)
+        self.oneview_client.server_profile_templates.get \
+            .assert_has_calls(
+                [call(uuid),
+                 call(uuid)]
+                )
+        self.assertTrue(category_resource.get_category_by_resource_id(uuid))
+
     def test_change_power_state(self):
         """Tests change SH power state with valid power values
 

oneview_redfish_toolkit/tests/blueprints/test_resource_block.py

@@ -29,6 +29,7 @@
 # Module libs
 import oneview_redfish_toolkit.api.status_mapping as status_mapping
 from oneview_redfish_toolkit.blueprints import resource_block
+from oneview_redfish_toolkit import category_resource
 from oneview_redfish_toolkit import multiple_oneview
 from oneview_redfish_toolkit.tests.base_flask_test import BaseFlaskTest
 
@@ -155,6 +156,60 @@ def test_get_storage_resource_block(self):
         self.oneview_client.logical_enclosures.get_all.assert_called_with()
         self.oneview_client.drive_enclosures.get_all.assert_called_with()
 
+    def test_get_storage_resource_block_cached(self):
+        with open(
+            'oneview_redfish_toolkit/mockups/redfish/StorageResourceBlock.json'
+        ) as f:
+            expected_resource_block = json.load(f)
+
+        self.oneview_client.server_hardware.get.side_effect = \
+            self.resource_not_found
+        self.oneview_client.server_profile_templates.get.side_effect = \
+            self.resource_not_found
+        self.oneview_client.index_resources.get.return_value = self.drive
+        self.oneview_client.connection.get.side_effect = [
+            self.drive_index_tree, self.drive_index_tree,
+        ]
+        self.oneview_client.server_profile_templates.get_all.return_value = \
+            self.server_profile_templates
+        self.oneview_client.\
+            logical_enclosures.get_all.return_value = self.log_encl_list
+        self.oneview_client.drive_enclosures.get_all.return_value = \
+            self.drive_enclosure_list
+
+        uri = "/redfish/v1/CompositionService/ResourceBlocks/"\
+              "c4f0392d-fae9-4c2e-a2e6-b22e6bb7533e"
+        uuid = uri.split('/')[-1]
+
+        response = self.client.get(uri)
+
+        result = json.loads(response.data.decode("utf-8"))
+
+        self.assertEqual(status.HTTP_200_OK, response.status_code)
+        self.assertEqual("application/json", response.mimetype)
+        self.assertEqualMockup(expected_resource_block, result)
+
+        # Get cached storage resource block
+        response = self.client.get(uri)
+
+        result = json.loads(response.data.decode("utf-8"))
+
+        self.assertEqual(status.HTTP_200_OK, response.status_code)
+        self.assertEqual("application/json", response.mimetype)
+        self.assertEqualMockup(expected_resource_block, result)
+
+        self.oneview_client.server_profile_templates.get_all.has_calls(
+            [call(uri),
+             call(uri)]
+        )
+        self.oneview_client.server_hardware.get.assert_called_once_with(uuid)
+        self.oneview_client.index_resources.get.assert_has_calls(
+            [call('/rest/drives/' + uuid),
+             call('/rest/drives/' + uuid)]
+        )
+        self.assertTrue(category_resource.get_category_by_resource_id(
+            ('/rest/drives/' + uuid)))
+
     def test_get_storage_resource_block_when_drive_is_composed(self):
         with open(
             'oneview_redfish_toolkit/mockups/redfish/'
@@ -372,6 +427,50 @@ def test_get_spt_resource_block(self):
         self.oneview_client.logical_enclosures.get_all.assert_called_with()
         self.oneview_client.drive_enclosures.get_all.assert_called_with()
 
+    def test_get_spt_resource_block_cached(self):
+        with open(
+            'oneview_redfish_toolkit/mockups/redfish'
+            '/ServerProfileTemplateResourceBlock.json'
+        ) as f:
+            expected_resource_block = json.load(f)
+
+        self.oneview_client.server_hardware.get.side_effect = \
+            self.resource_not_found
+        self.oneview_client.server_profile_templates.get.return_value = \
+            self.server_profile_template
+        self.oneview_client.logical_enclosures.get_all.return_value = \
+            self.log_encl_list
+        self.oneview_client.drive_enclosures.get_all.return_value = \
+            self.drive_enclosure_list
+
+        uri = "/redfish/v1/CompositionService/ResourceBlocks"\
+              "/1f0ca9ef-7f81-45e3-9d64-341b46cf87e0"
+        uuid = uri.split('/')[-1]
+
+        response = self.client.get(uri)
+
+        result = json.loads(response.data.decode("utf-8"))
+
+        self.assertEqual(status.HTTP_200_OK, response.status_code)
+        self.assertEqual("application/json", response.mimetype)
+        self.assertEqualMockup(expected_resource_block, result)
+
+        # Get cached spt resource block
+        response = self.client.get(uri)
+
+        result = json.loads(response.data.decode("utf-8"))
+
+        self.assertEqual(status.HTTP_200_OK, response.status_code)
+        self.assertEqual("application/json", response.mimetype)
+        self.assertEqualMockup(expected_resource_block, result)
+
+        self.oneview_client.server_hardware.get.assert_called_once_with(uuid)
+        self.oneview_client.server_profile_templates.get.assert_has_calls(
+            [call(uuid),
+             call(uuid)]
+        )
+        self.assertTrue(category_resource.get_category_by_resource_id(uuid))
+
     def test_get_spt_resource_when_template_has_not_valid_controller(self):
         with open(
             'oneview_redfish_toolkit/mockups/redfish'