def test_get_score_api(self,
                           mocked_icon_score_engine_validate_score_blacklist,
                           mocked_score_context_util_get_icon_score):
        context = IconScoreContext(IconScoreContextType.INVOKE)
        context.new_icon_score_mapper = IconScoreMapper()

        # failure case: should raise error if there is no SCORE
        score_address = create_address(AddressPrefix.CONTRACT)
        mocked_score_context_util_get_icon_score.return_value = None
        self.assertRaises(ScoreNotFoundException,
                          IconScoreEngine.get_score_api, context,
                          score_address)
        mocked_icon_score_engine_validate_score_blacklist.assert_called_with(
            context, score_address)

        # reset mock
        mocked_icon_score_engine_validate_score_blacklist.reset_mock(
            return_value=None)

        # success case: if SCORE exists, getattr(score, "__get_api") method should be called

        score_object = Mock(spec=IconScoreBase)
        mocked_score_context_util_get_icon_score.return_value = score_object

        IconScoreEngine.get_score_api(context, score_address)
        mocked_icon_score_engine_validate_score_blacklist.assert_called_with(
            context, score_address)
        get_api = getattr(score_object, ATTR_SCORE_GET_API)
        get_api.assert_called()
Example #2
0
    def test_call(self,
                  mocked_score_engine_get_icon_score,
                  mocked_score_engine_convert_score_params_by_annotations):
        context = IconScoreContext(IconScoreContextType.INVOKE)
        context.new_icon_score_mapper = IconScoreMapper()

        def intercept_score_base_call(func_name: str, kw_params: dict):
            self.assertEqual(func_name, 'score_method')
            # should be equal to converted_params
            self.assertEqual(kw_params, converted_params)
            return "__call method called"

        score_address = Mock(spec=Address)
        score_object = Mock(spec=IconScoreBase)
        mocked_score_engine_get_icon_score.return_value = score_object

        primitive_params = {"address": str(create_address(AddressPrefix.EOA)),
                            "integer": "0x10"}
        converted_params = {"address": create_address(AddressPrefix.EOA),
                            "integer": 10}
        mocked_score_engine_convert_score_params_by_annotations.return_value = converted_params
        context.set_func_type_by_icon_score = Mock()
        setattr(score_object, ATTR_SCORE_CALL, Mock(side_effect=intercept_score_base_call))

        # set method, and params, method cannot be None as pre-validate it
        data = {'method': 'score_method',
                'params': primitive_params}
        result = IconScoreEngine._call(context, score_address, data)

        self.assertEqual(result, "__call method called")
        IconScoreEngine._get_icon_score.assert_called()
        IconScoreEngine._convert_score_params_by_annotations.assert_called()
        context.set_func_type_by_icon_score.assert_called()
        call = getattr(score_object, ATTR_SCORE_CALL)
        call.assert_called()
def context():
    ctx = IconScoreContext(IconScoreContextType.DIRECT)
    ctx.tx = Transaction(tx_hash=create_tx_hash(), origin=EOA1)
    ctx.block = Block(block_height=0, block_hash=create_block_hash(), timestamp=0, prev_hash=None)
    ctx.msg = Message(sender=EOA1, value=0)
    ctx.icon_score_mapper = IconScoreMapper()
    ctx.new_icon_score_mapper = {}
    ctx.step_counter = IconScoreStepCounter(1, {}, 1000, False)
    ctx.event_logs = []
    ctx.traces = []
    ctx.current_address = EOA1
    IconScoreContext.storage = ContextStorage(deploy=Mock(spec=Storage), fee=None, icx=None, iiss=None, prep=None,
                                              issue=None, meta=None, rc=None, inv=None)

    ContextContainer._push_context(ctx)
    yield ctx
    ContextContainer._pop_context()