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"))