Python get_default_registry示例

示例#1

def test_on_create_minimal(
        cause_factory):

    registry = kopf.get_default_registry()
    resource = Resource('group', 'version', 'plural')
    cause = cause_factory(resource=resource, reason=Reason.CREATE)

    @kopf.on.create('group', 'version', 'plural')
    def fn(**_):
        pass

    with pytest.deprecated_call(match=r"use registry.resource_changing_handlers"):
        handlers = registry.get_resource_changing_handlers(cause)

    assert len(handlers) == 1
    assert handlers[0].fn is fn
    assert handlers[0].reason == Reason.CREATE
    assert handlers[0].field is None
    assert handlers[0].errors is None
    assert handlers[0].timeout is None
    assert handlers[0].retries is None
    assert handlers[0].backoff is None
    assert handlers[0].labels is None
    assert handlers[0].annotations is None
    assert handlers[0].when is None

示例#2

def test_on_field_minimal(cause_factory):
    registry = kopf.get_default_registry()
    resource = Resource('group', 'version', 'plural')
    old = {'field': {'subfield': 'old'}}
    new = {'field': {'subfield': 'new'}}
    cause = cause_factory(resource=resource,
                          reason=Reason.UPDATE,
                          old=old,
                          new=new,
                          body=new)

    @kopf.on.field('group', 'version', 'plural', field='field.subfield')
    def fn(**_):
        pass

    with pytest.deprecated_call(match=r"cease using the internal registries"):
        handlers = registry.get_cause_handlers(cause)

    assert len(handlers) == 1
    assert handlers[0].fn is fn
    assert handlers[0].reason is None
    assert handlers[0].field == ('field', 'subfield')
    assert handlers[0].timeout is None
    assert handlers[0].labels is None
    assert handlers[0].annotations is None
    assert handlers[0].when is None

示例#3

def test_nothing(invoke, real_run):
    result = invoke(['run'])
    assert result.exit_code == 0

    registry = kopf.get_default_registry()
    handlers = registry.resource_changing_handlers.get_all_handlers()
    assert len(handlers) == 0

示例#4

文件： test_decorators_deprecated_cooldown.py 项目： ztaylor54/kopf

def test_on_field_with_cooldown(mocker, cause_factory):
    registry = kopf.get_default_registry()
    resource = Resource('group', 'version', 'plural')
    diff = [('op', ('field', 'subfield'), 'old', 'new')]
    cause = cause_factory(resource=resource, reason=Reason.UPDATE, diff=diff)
    mocker.patch('kopf.reactor.registries.match', return_value=True)

    with pytest.deprecated_call(match=r"use backoff="):

        @kopf.on.field('group',
                       'version',
                       'plural',
                       field='field.subfield',
                       cooldown=78)
        def fn(**_):
            pass

    handlers = registry.resource_changing_handlers[resource].get_handlers(
        cause)
    assert len(handlers) == 1
    assert handlers[0].fn is fn
    assert handlers[0].backoff == 78

    with pytest.deprecated_call(match=r"use handler.backoff"):
        assert handlers[0].cooldown == 78

示例#5

文件： conftest.py 项目： tomasfarias/kopf

def clean_default_registry():
    registry = kopf.get_default_registry()
    kopf.set_default_registry(kopf.GlobalRegistry())
    try:
        yield
    finally:
        kopf.set_default_registry(registry)

示例#6

def test_on_field_minimal(
        cause_factory):

    registry = kopf.get_default_registry()
    resource = Resource('group', 'version', 'plural')
    diff = [('op', ('field', 'subfield'), 'old', 'new')]
    cause = cause_factory(resource=resource, reason=Reason.UPDATE, diff=diff)

    @kopf.on.field('group', 'version', 'plural', 'field.subfield')
    def fn(**_):
        pass

    with pytest.deprecated_call(match=r"use registry.resource_changing_handlers"):
        handlers = registry.get_resource_changing_handlers(cause)

    assert len(handlers) == 1
    assert handlers[0].fn is fn
    assert handlers[0].reason is None
    assert handlers[0].field == ('field', 'subfield')
    assert handlers[0].errors is None
    assert handlers[0].timeout is None
    assert handlers[0].retries is None
    assert handlers[0].backoff is None
    assert handlers[0].labels is None
    assert handlers[0].annotations is None
    assert handlers[0].when is None

示例#7

def test_on_field_minimal(mocker):
    registry = kopf.get_default_registry()
    resource = Resource('group', 'version', 'plural')
    diff = [('op', ('field', 'subfield'), 'old', 'new')]
    cause = mocker.MagicMock(resource=resource,
                             reason=Reason.UPDATE,
                             diff=diff)

    @kopf.on.field('group', 'version', 'plural', 'field.subfield')
    def fn(**_):
        pass

    handlers = registry.resource_changing_handlers[resource].get_handlers(
        cause)
    assert len(handlers) == 1
    assert handlers[0].fn is fn
    assert handlers[0].reason is None
    assert handlers[0].field == ('field', 'subfield')
    assert handlers[0].errors is None
    assert handlers[0].timeout is None
    assert handlers[0].retries is None
    assert handlers[0].backoff is None
    assert handlers[0].labels is None
    assert handlers[0].annotations is None
    assert handlers[0].when is None

示例#8

def test_on_resume_minimal(mocker, reason):
    registry = kopf.get_default_registry()
    resource = Resource('group', 'version', 'plural')
    cause = mocker.MagicMock(resource=resource,
                             reason=reason,
                             initial=True,
                             deleted=False)

    @kopf.on.resume('group', 'version', 'plural')
    def fn(**_):
        pass

    handlers = registry.resource_changing_handlers[resource].get_handlers(
        cause)
    assert len(handlers) == 1
    assert handlers[0].fn is fn
    assert handlers[0].reason is None
    assert handlers[0].field is None
    assert handlers[0].errors is None
    assert handlers[0].timeout is None
    assert handlers[0].retries is None
    assert handlers[0].backoff is None
    assert handlers[0].labels is None
    assert handlers[0].annotations is None
    assert handlers[0].when is None

示例#9

文件： test_decorators.py 项目： zer0n1/kopf

def test_on_field_minimal(cause_factory):
    registry = kopf.get_default_registry()
    resource = Resource('group', 'version', 'plural')
    old = {'field': {'subfield': 'old'}}
    new = {'field': {'subfield': 'new'}}
    cause = cause_factory(resource=resource, reason=Reason.UPDATE, old=old, new=new, body=new)

    @kopf.on.field('group', 'version', 'plural', field='field.subfield')
    def fn(**_):
        pass

    handlers = registry.resource_changing_handlers.get_handlers(cause)
    assert len(handlers) == 1
    assert handlers[0].fn is fn
    assert handlers[0].reason is None
    assert handlers[0].errors is None
    assert handlers[0].timeout is None
    assert handlers[0].retries is None
    assert handlers[0].backoff is None
    assert handlers[0].labels is None
    assert handlers[0].annotations is None
    assert handlers[0].when is None
    assert handlers[0].field == ('field', 'subfield')
    assert handlers[0].value is None
    assert handlers[0].old is None
    assert handlers[0].new is None

示例#10

文件： test_decorators.py 项目： ztaylor54/kopf

def test_on_delete_minimal(cause_factory):
    registry = kopf.get_default_registry()
    resource = Resource('group', 'version', 'plural')
    cause = cause_factory(resource=resource, reason=Reason.DELETE)

    @kopf.on.delete('group', 'version', 'plural')
    def fn(**_):
        pass

    handlers = registry.resource_changing_handlers[resource].get_handlers(
        cause)
    assert len(handlers) == 1
    assert handlers[0].fn is fn
    assert handlers[0].reason == Reason.DELETE
    assert handlers[0].field is None
    assert handlers[0].errors is None
    assert handlers[0].timeout is None
    assert handlers[0].retries is None
    assert handlers[0].backoff is None
    assert handlers[0].labels is None
    assert handlers[0].annotations is None
    assert handlers[0].when is None
    assert handlers[0].field is None
    assert handlers[0].old is None
    assert handlers[0].new is None

示例#11

def clear_default_registry():
    old_registry = kopf.get_default_registry()
    new_registry = kopf.GlobalRegistry()
    kopf.set_default_registry(new_registry)
    try:
        yield new_registry
    finally:
        kopf.set_default_registry(old_registry)

示例#12

def test_one_module(invoke, real_run):
    result = invoke(['run', '-m', 'package.module_1'])
    assert result.exit_code == 0

    registry = kopf.get_default_registry()
    handlers = registry.resource_changing_handlers.get_all_handlers()
    assert len(handlers) == 1
    assert handlers[0].id == 'create_fn'

示例#13

文件： test_preloading.py 项目： nnazeer/kopf

def test_one_file(invoke, real_run):
    result = invoke(['run', 'handler1.py'])
    assert result.exit_code == 0

    registry = kopf.get_default_registry()
    handlers = registry._resource_changing.get_all_handlers()
    assert len(handlers) == 1
    assert handlers[0].id == 'create_fn'

示例#14

def registry(registry_factory):
    """
    Ensure that the tests have a fresh new global (not re-used) registry.
    """
    old_registry = kopf.get_default_registry()
    new_registry = registry_factory()
    kopf.set_default_registry(new_registry)
    yield new_registry
    kopf.set_default_registry(old_registry)

示例#15

def test_two_files(invoke, real_run):
    result = invoke(['run', 'handler1.py', 'handler2.py'])
    assert result.exit_code == 0

    registry = kopf.get_default_registry()
    handlers = registry._changing.get_all_handlers()
    assert len(handlers) == 2
    assert handlers[0].id == 'create_fn'
    assert handlers[1].id == 'update_fn'

示例#16

def test_mixed_sources(invoke, real_run):
    result = invoke(['run', 'handler1.py', '-m', 'package.module_2'])
    assert result.exit_code == 0

    registry = kopf.get_default_registry()
    handlers = registry.resource_changing_handlers.get_all_handlers()
    assert len(handlers) == 2
    assert handlers[0].id == 'create_fn'
    assert handlers[1].id == 'update_fn'

示例#17

def test_one_module(invoke, login, real_run):
    result = invoke(['run', '-m', 'package.module_1'])
    assert result.exit_code == 0

    registry = kopf.get_default_registry()
    assert len(registry.resources) == 1
    resource = list(registry.resources)[0]
    handlers = registry._cause_handlers[resource]._handlers
    assert len(handlers) == 1
    assert handlers[0].id == 'create_fn'

示例#18

文件： test_preloading.py 项目： hariprasathcse/kopf

def test_one_file(invoke, login, real_run):
    result = invoke(['run', 'handler1.py'])
    assert result.exit_code == 0

    registry = kopf.get_default_registry()
    assert len(registry.resources) == 1
    resource = list(registry.resources)[0]
    handlers = registry._resource_changing_handlers[resource]._handlers
    assert len(handlers) == 1
    assert handlers[0].id == 'create_fn'

示例#19

def test_two_files(invoke, login, real_run):
    result = invoke(['run', 'handler1.py', 'handler2.py'])
    assert result.exit_code == 0

    registry = kopf.get_default_registry()
    assert len(registry.resources) == 1
    resource = list(registry.resources)[0]
    handlers = registry._cause_handlers[resource]._handlers
    assert len(handlers) == 2
    assert handlers[0].id == 'create_fn'
    assert handlers[1].id == 'update_fn'

示例#20

文件： test_resumes_mixed_in.py 项目： zhutony/kopf

def test_resumes_ignored_for_non_initial_causes(mocker, reason, deleted):
    registry = kopf.get_default_registry()
    resource = Resource('group', 'version', 'plural')
    cause = mocker.MagicMock(resource=resource, reason=reason, initial=False, deleted=deleted)

    @kopf.on.resume('group', 'version', 'plural')
    def fn(**_):
        pass

    handlers = registry.resource_changing_handlers[resource].get_handlers(cause)
    assert len(handlers) == 0

示例#21

def clear_default_registry():
    """
    Ensure that the tests have a fresh new global (not re-used) registry.
    """
    old_registry = kopf.get_default_registry()
    new_registry = type(old_registry)()  # i.e. OperatorRegistry/GlobalRegistry
    kopf.set_default_registry(new_registry)
    try:
        yield new_registry
    finally:
        kopf.set_default_registry(old_registry)

示例#22

文件： test_preloading.py 项目： prakashkl88/kopf

def test_two_modules(invoke, real_run):
    result = invoke(['run', '-m', 'package.module_1', '-m', 'package.module_2'])
    assert result.exit_code == 0

    registry = kopf.get_default_registry()
    assert len(registry.resources) == 1
    resource = list(registry.resources)[0]
    handlers = registry._resource_changing_handlers[resource]._handlers
    assert len(handlers) == 2
    assert handlers[0].id == 'create_fn'
    assert handlers[1].id == 'update_fn'

示例#23

def test_on_startup_with_cooldown():
    registry = kopf.get_default_registry()

    @kopf.on.startup(cooldown=78)
    def fn(**_):
        pass

    handlers = registry.get_activity_handlers(activity=Activity.STARTUP)
    assert len(handlers) == 1
    assert handlers[0].fn is fn
    assert handlers[0].backoff == 78
    assert handlers[0].cooldown == 78  # deprecated alias

示例#24

文件： test_resumes_mixed_in.py 项目： zhutony/kopf

def test_resumes_selected_for_initial_deletions_when_explicitly_marked(mocker, reason):
    registry = kopf.get_default_registry()
    resource = Resource('group', 'version', 'plural')
    cause = mocker.MagicMock(resource=resource, reason=reason, initial=True, deleted=True)

    @kopf.on.resume('group', 'version', 'plural', deleted=True)
    def fn(**_):
        pass

    handlers = registry.resource_changing_handlers[resource].get_handlers(cause)
    assert len(handlers) == 1
    assert handlers[0].fn is fn

示例#25

文件： test_legacy2_resumes_mixed_in.py 项目： tinyzimmer/kopf

def test_resumes_ignored_for_initial_deletions_by_default(reason, cause_factory):
    registry = kopf.get_default_registry()
    resource = Resource('group', 'version', 'plural')
    cause = cause_factory(resource=resource, reason=reason, initial=True,
                          body={'metadata': {'deletionTimestamp': '...'}})

    @kopf.on.resume('group', 'version', 'plural')
    def fn(**_):
        pass

    with pytest.deprecated_call(match=r"use registry.resource_changing_handlers"):
        handlers = registry.get_resource_changing_handlers(cause)
    assert len(handlers) == 0

示例#26

def test_resumes_selected_for_initial_non_deletions(reason, cause_factory):
    registry = kopf.get_default_registry()
    resource = Resource('group', 'version', 'plural')
    cause = cause_factory(resource=resource, reason=reason, initial=True)

    @kopf.on.resume('group', 'version', 'plural')
    def fn(**_):
        pass

    with pytest.deprecated_call(match=r"cease using the internal registries"):
        handlers = registry.get_resource_changing_handlers(cause)
    assert len(handlers) == 1
    assert handlers[0].fn is fn

示例#27

def test_resumes_ignored_for_non_initial_causes(reason, deleted, cause_factory):
    registry = kopf.get_default_registry()
    resource = Resource('group', 'version', 'plural')
    cause = cause_factory(resource=resource, reason=reason, initial=False,
                          body={'metadata': {'deletionTimestamp': '...'} if deleted else {}})

    @kopf.on.resume('group', 'version', 'plural')
    def fn(**_):
        pass

    with pytest.deprecated_call(match=r"cease using the internal registries"):
        handlers = registry.get_resource_changing_handlers(cause)
    assert len(handlers) == 0

示例#28

def test_resumes_selected_for_initial_non_deletions(reason, cause_factory):

    registry = kopf.get_default_registry()
    resource = Resource('group', 'version', 'plural')
    cause = cause_factory(resource=resource, reason=reason, initial=True)

    @kopf.on.resume('group', 'version', 'plural')
    def fn(**_):
        pass

    handlers = registry.resource_changing_handlers.get_handlers(cause)
    assert len(handlers) == 1
    assert handlers[0].fn is fn

示例#29

def test_resumes_selected_for_initial_non_deletions(reason, cause_factory,
                                                    resource):

    registry = kopf.get_default_registry()
    cause = cause_factory(resource=resource, reason=reason, initial=True)

    @kopf.on.resume(*resource)
    def fn(**_):
        pass

    handlers = registry._changing.get_handlers(cause)
    assert len(handlers) == 1
    assert handlers[0].fn is fn

示例#30

def test_resumes_selected_for_initial_deletions_when_explicitly_marked(reason, cause_factory):
    registry = kopf.get_default_registry()
    resource = Resource('group', 'version', 'plural')
    cause = cause_factory(resource=resource, reason=reason, initial=True,
                          body={'metadata': {'deletionTimestamp': '...'}})

    @kopf.on.resume('group', 'version', 'plural', deleted=True)
    def fn(**_):
        pass

    with pytest.deprecated_call(match=r"cease using the internal registries"):
        handlers = registry.get_resource_changing_handlers(cause)
    assert len(handlers) == 1
    assert handlers[0].fn is fn