github.com/muhammedhassanm/blockchain@v0.0.0-20200120143007-697261defd4d/sawtooth-core-master/validator/tests/test_setting_cache/tests.py (about)

     1  # Copyright 2017 Intel Corporation
     2  #
     3  # Licensed under the Apache License, Version 2.0 (the "License");
     4  # you may not use this file except in compliance with the License.
     5  # You may obtain a copy of the License at
     6  #
     7  #     http://www.apache.org/licenses/LICENSE-2.0
     8  #
     9  # Unless required by applicable law or agreed to in writing, software
    10  # distributed under the License is distributed on an "AS IS" BASIS,
    11  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  # See the License for the specific language governing permissions and
    13  # limitations under the License.
    14  # ----------------------------------------------------------------------------
    15  import unittest
    16  
    17  from sawtooth_validator.protobuf.block_pb2 import BlockHeader
    18  from sawtooth_validator.protobuf.block_pb2 import Block
    19  from sawtooth_validator.protobuf.events_pb2 import Event
    20  from sawtooth_validator.protobuf.transaction_receipt_pb2 import \
    21      TransactionReceipt
    22  from sawtooth_validator.journal.block_wrapper import BlockWrapper
    23  from sawtooth_validator.state.settings_cache import SettingsCache
    24  from sawtooth_validator.state.settings_cache import SettingsObserver
    25  from test_setting_cache.mocks import MockSettingsViewFactory
    26  
    27  
    28  class TestSettingsObserver(unittest.TestCase):
    29      def setUp(self):
    30          self._settings_view_factory = MockSettingsViewFactory()
    31          self._settings_cache = SettingsCache(
    32              self._settings_view_factory,
    33          )
    34          self._settings_obsever = SettingsObserver(
    35              to_update=self._settings_cache.invalidate,
    36              forked=self._settings_cache.forked
    37          )
    38  
    39          # Make sure SettingsCache has populated settings
    40          self._settings_view_factory.add_setting("setting1", "test")
    41  
    42      def create_block(self, previous_block_id="0000000000000000"):
    43          block_header = BlockHeader(
    44              block_num=85,
    45              state_root_hash="0987654321fedcba",
    46              previous_block_id=previous_block_id)
    47          block = BlockWrapper(
    48              Block(
    49                  header_signature="abcdef1234567890",
    50                  header=block_header.SerializeToString()))
    51          return block
    52  
    53      def test_chain_update(self):
    54          """
    55          Test that if there is no fork and only one value is updated, only
    56          that value is in validated in the catch.
    57          """
    58          # Set up cache so it does not fork
    59          block1 = self.create_block()
    60          self._settings_obsever.chain_update(block1, [])
    61          self._settings_cache.get_setting("setting1", "state_root")
    62          self.assertNotEqual(self._settings_cache["setting1"], None)
    63  
    64          # Add next block and event that says network was updated.
    65          block2 = self.create_block("abcdef1234567890")
    66          event = Event(
    67              event_type="settings/update",
    68              attributes=[Event.Attribute(key="updated", value="setting1")])
    69          receipts = TransactionReceipt(events=[event])
    70          self._settings_obsever.chain_update(block2, [receipts])
    71          # Check that only "network" was invalidated
    72          self.assertEqual(self._settings_cache["setting"], None)
    73  
    74          # check that the correct values can be fetched from state.
    75          settings_view = \
    76              self._settings_view_factory.create_settings_view("state_root")
    77  
    78          self.assertEqual(
    79              self._settings_cache.get_setting("setting1", "state_root"),
    80              settings_view.get_setting("setting1"))
    81  
    82      def test_fork(self):
    83          """
    84          Test that if there is a fork, all values in the cache will be
    85          invalidated and fetched from state.
    86          """
    87          block = self.create_block()
    88          self._settings_obsever.chain_update(block, [])
    89          # Check that all items are invalid
    90          for key in self._settings_cache:
    91              self.assertEqual(self._settings_cache[key], None)
    92  
    93          # Check that the items can be fetched from state.
    94          settings_view = \
    95              self._settings_view_factory.create_settings_view("state_root")
    96  
    97          self.assertEqual(
    98              self._settings_cache.get_setting("setting1", "state_root"),
    99              settings_view.get_setting("setting1"))
   100  
   101  
   102  class TestSettingsCache(unittest.TestCase):
   103      def setUp(self):
   104          self._settings_view_factory = MockSettingsViewFactory()
   105          self._settings_cache = SettingsCache(
   106              self._settings_view_factory,
   107          )
   108  
   109      def test_get_settings(self):
   110          """
   111          Test that a setting can be fetched from the state.
   112          """
   113          self._settings_view_factory.add_setting("setting1", "test")
   114          self.assertIsNone(self._settings_cache["setting1"])
   115  
   116          settings_view = \
   117              self._settings_view_factory.create_settings_view("state_root")
   118          self.assertEqual(
   119              self._settings_cache.get_setting("setting1", "state_root"),
   120              settings_view.get_setting("setting1"))
   121  
   122      def test_setting_invalidate(self):
   123          """
   124          Test that a setting can be invalidated.
   125          """
   126          self._settings_view_factory.add_setting("setting1", "test")
   127          self._settings_cache.invalidate("setting1")
   128  
   129          self.assertEqual(self._settings_cache["setting2"], None)
   130  
   131          settings_view = \
   132              self._settings_view_factory.create_settings_view("state_root")
   133          self.assertEqual(
   134              self._settings_cache.get_setting("setting1", "state_root"),
   135              settings_view.get_setting("setting1"))
   136  
   137      def test_forked(self):
   138          """
   139          Test that forked() invalidates all items in the cache, and they can
   140          be fetched from state.
   141          """
   142          self._settings_view_factory.add_setting("setting1", "test1")
   143          self._settings_view_factory.add_setting("setting2", "test2")
   144  
   145          settings_view = \
   146              self._settings_view_factory.create_settings_view("state_root")
   147  
   148          self._settings_cache.get_setting("setting1", "test1")
   149          self._settings_cache.get_setting("setting2", "test2")
   150  
   151          self.assertEqual(len(self._settings_cache), 2)
   152          self._settings_cache.forked()
   153  
   154          self.assertEqual(self._settings_cache["setting1"], None)
   155          self.assertEqual(self._settings_cache["setting2"], None)
   156  
   157          self.assertEqual(
   158              self._settings_cache.get_setting("setting1", "state_root"),
   159              settings_view.get_setting("setting1"))
   160  
   161          self.assertEqual(
   162              self._settings_cache.get_setting("setting2", "state_root"),
   163              settings_view.get_setting("setting2"))