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