def test_memorydatabase(): subject_storage_factory.override( providers.Factory(lambda x: SQLLiteSubjectStorage(x, ":memory:")) ) assert not subject_storage_factory("test-subject").is_persistent() assert not subject_storage_factory("test-subject").is_concurrency_safe()
def init(): # This is an inmemory database and it is not persistent # you probably want to comment out this configuration and enable a more appropriate one from krules_core.tests.subject.sqlite_storage import SQLLiteSubjectStorage subject_storage_factory.override( providers.Factory( lambda x, **kwargs: SQLLiteSubjectStorage(x, ":memory:")))
def setup_module(_): extra_kwargs = {} if os.environ.get("API_URL", False): extra_kwargs.update({ "override_api_url": os.environ.get("API_URL") }) def _raise(): raise Exception("No subject storage provider overridden") subject_storage_factory.override( providers.Factory(lambda name, event_info, event_data: name.startswith("k8s:") and k8s_storage_impl.SubjectsK8sStorage( resource_path=name[4:], resource_body=event_data ) or _raise()) ) global POD_NAME, NAMESPACE POD_NAME = "pytest-temp-{0}".format( ''.join(random.choice(string.ascii_lowercase) for i in range(8)) ) if os.environ.get("API_URL", False): config = pykube.KubeConfig.from_url(os.environ.get("API_URL")) else: config = pykube.KubeConfig.from_env() if os.environ.get("NAMESPACE", False): NAMESPACE = os.environ.get("NAMESPACE") else: NAMESPACE = config.namespace # create a test pod obj = { "apiVersion": "v1", "kind": "Pod", "metadata": { "name": POD_NAME, "namespace": NAMESPACE, "labels": { "app": "pytest-temp" } }, "spec": { "containers": [{ "name": "hello", "image": "karthequian/helloworld" }] } } api = pykube.HTTPClient(config) pykube.Pod(api, obj).create()
def test_memorydatabase(): if os.path.exists(TEST_FNAME): os.unlink(TEST_FNAME) subject_storage_factory.override( providers.Factory( lambda x, **kwargs: SQLLiteSubjectStorage(x, TEST_FNAME))) assert subject_storage_factory("test-subject").is_persistent() assert subject_storage_factory("test-subject").is_concurrency_safe()
def init(): # This is an inmemory database and it is not persistent # you probably want to comment out this configuration and enable a more appropriate one # Redis subjects storage support subjects_redis_storage_settings = settings_factory() \ .get("subjects-backends") \ .get("redis") from redis_subjects_storage import storage_impl as redis_storage_impl subject_storage_factory.override( providers.Factory(lambda x: redis_storage_impl.SubjectsRedisStorage( x, subjects_redis_storage_settings.get("url"))))
def setup_module(_): extra_kwargs = {} if os.environ.get("API_URL", False): extra_kwargs.update({"override_api_url": os.environ.get("API_URL")}) subject_storage_factory.override( providers.Factory(lambda name, event_info, event_data: ( name.startswith("k8s:") and k8s_storage_impl.SubjectsK8sStorage( resource_path=name[4:], resource_body=event_data.get("k8s_object")) or providers. Factory(lambda *args, **kwargs: SQLLiteSubjectStorage( args[0], ":memory:"))))) proc_events_rx_factory.override( providers.Singleton(rx.subjects.ReplaySubject))
def init(): # Redis subjects storage support from redis_subjects_storage import storage_impl as redis_storage_impl subjects_redis_storage_settings = configs_factory() \ .get("subjects-backends") \ .get("redis") subject_storage_factory.override( providers.Factory(lambda name, **kwargs: redis_storage_impl.SubjectsRedisStorage( name, subjects_redis_storage_settings.get("url"), key_prefix=subjects_redis_storage_settings.get("key_prefix") ) ) )
def init(): # This is an inmemory database and it is not persistent # you probably want to comment out this configuration and enable a more appropriate one from krules_core.tests.subject.sqlite_storage import SQLLiteSubjectStorage from k8s_subjects_storage import storage_impl as k8s_storage_impl from redis_subjects_storage import storage_impl as redis_storage_impl subjects_redis_storage_settings = configs_factory() \ .get("subjects-backends") \ .get("redis") subject_storage_factory.override( providers.Factory(lambda name, event_info, event_data: name.startswith("k8s:") and k8s_storage_impl.SubjectsK8sStorage( resource_path=name[4:], resource_body=event_data ) or redis_storage_impl.SubjectsRedisStorage(name, subjects_redis_storage_settings.get("url")) ) ) from krules_cloudevents.route.dispatcher import CloudEventsDispatcher from krules_core.providers import event_dispatcher_factory import os, socket event_dispatcher_factory.override( providers.Singleton(lambda: CloudEventsDispatcher(os.environ["K_SINK"], os.environ.get("K_SERVICE", socket.gethostname()))) ) class CallableWithCtxArgProcessor(BaseArgProcessor): @staticmethod def interested_in(arg): try: sig = inspect.signature(arg) return len(sig.parameters) == 1 and "ctx" in sig.parameters or "_" in sig.parameters except TypeError: return False def process(self, instance): return self._arg(instance) processors.append(CallableWithCtxArgProcessor)
def init(): # This is an inmemory database and it is not persistent # you probably want to comment out this configuration and enable a more appropriate one # from krules_core.tests.subject.sqlite_storage import SQLLiteSubjectStorage # subject_storage_factory.override( # providers.Factory(lambda x: SQLLiteSubjectStorage(x, ":memory:")) # ) #Redis subjects storage support subjects_redis_storage_settings = configs_factory() \ .get("subjects-backends") \ .get("redis") from redis_subjects_storage import storage_impl as redis_storage_impl subject_storage_factory.override( providers.Factory(lambda name, event_info, event_data: name.startswith("k8s:") and k8s_storage_impl.SubjectsK8sStorage( resource_path=name[4:], resource_body=event_data ) or redis_storage_impl.SubjectsRedisStorage(name, subjects_redis_storage_settings.get("url")) ) )
event_dispatcher_factory, subject_storage_factory, subject_factory) from krules_core.route.router import EventRouter from .route.dispatcher import CloudEventsDispatcher from krules_core.tests.subject.sqlite_storage import SQLLiteSubjectStorage from pytest_localserver.http import WSGIServer from werkzeug.wrappers import Request httpserver = plugin.httpserver configs_factory.override(providers.Singleton(lambda: {})) event_router_factory.override(providers.Singleton(EventRouter)) subject_storage_factory.override( providers.Factory( lambda x, **kwargs: SQLLiteSubjectStorage(x, ":memory:"))) def fake_receiver_app(environ, start_response): """Simplest possible WSGI application""" request = Request(environ) m = marshaller.NewDefaultHTTPMarshaller() event = m.FromRequest(v1.Event(), request.headers, io.BytesIO(request.data), lambda x: json.load(x)) event_info = event.Properties() event_info.update(event_info.pop("extensions")) subject = subject_factory(event_info.get("subject", "sys-0")) assert "originid" in event_info assert "subject" in event_info
def setup_module(_): subject_storage_factory.override( providers.Factory(lambda *args, **kwargs: EmptySubjectStorage()))
def setup_module(_): redis_url = os.environ.get("TEST_REDIS_SUBJECTS_STORAGE_URL", "redis://localhost/0") subject_storage_factory.override( providers.Factory(lambda x: subject_storage(x, redis_url, "myapp")) )