tests.test_magic_partial_functions_scoped_singletons.MyDepOne.__init__() - Code Metrics - meadsteve/lagom - Measure and Improve Code Quality continuously with Scrutinizer

MyDepOne.init() A
last analyzed 2024-11-22 07:23 UTC

↳ Parent: tests.test_magic_partial_functions_scoped_singletons

Complexity

Conditions

Size

Total Lines	2
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	2
nop	2
dl	0
loc	2
rs	10
c	0
b	0
f	0

import inspect
from random import random
from typing import Any, ClassVar

from lagom import Container, magic_bind_to_container, Singleton


class SomeCache:
    loaded: ClassVar[bool] = False

    def __init__(self):
        SomeCache.loaded = True
        self._init_random = random()

    def value(self):
        return self._init_random


class MyDepOne:
    value: Any

    def __init__(self, cache: SomeCache):
        self.value = cache.value()


class MyDepTwo:
    other_value: Any

    def __init__(self, cache: SomeCache):
        self.other_value = cache.value()


def test_by_default_all_resources_are_reconstructed(container: Container):
    @magic_bind_to_container(container)
    def example_function(dep_one: MyDepOne, dep_two: MyDepTwo):
        return {"a": dep_one.value, "b": dep_two.other_value}

    result = example_function()
    assert result["a"] != result["b"]


def test_invocation_level_singletons_can_be_defined(container: Container):
    @magic_bind_to_container(container, shared=[SomeCache])
    def example_function_with_invocation_level_sharing(
        dep_one: MyDepOne, dep_two: MyDepTwo
    ):
        return {"a": dep_one.value, "b": dep_two.other_value}

    result = example_function_with_invocation_level_sharing()
    assert result["a"] == result["b"]


def test_invocation_level_singletons_dont_affect_the_base_container(
    container: Container,
):
    @magic_bind_to_container(container, shared=[SomeCache])
    def example_function_with_invocation_level_sharing(
        cache_one: SomeCache, cache_two: SomeCache
    ):
        # This is what we expect with invocation level singleton
        assert cache_one == cache_two

    example_function_with_invocation_level_sharing()

    # Check that each invocation gets a new one - this is the normal behaviour
    assert container[SomeCache] != container[SomeCache]


def test_invocation_level_singletons_are_not_shared_across_calls(container: Container):
    @magic_bind_to_container(container, shared=[SomeCache])
    def example_function_with_invocation_level_sharing(
        dep_one: MyDepOne, dep_two: MyDepTwo
    ):
        return {"a": dep_one.value, "b": dep_two.other_value}

    call_one = example_function_with_invocation_level_sharing()
    call_two = example_function_with_invocation_level_sharing()

    assert call_one["a"] != call_two["a"]


def test_that_shared_types_are_lazy_loaded(container: Container):
    SomeCache.loaded = False

    @magic_bind_to_container(container, shared=[SomeCache])
    def example_function_that_defines_but_doesnt_use_sharing():
        return "ok"

    example_function_that_defines_but_doesnt_use_sharing()
    assert not SomeCache.loaded


def test_partial_application_returns_something_that_is_considered_a_function(
    container: Container,
):
    @magic_bind_to_container(container, shared=[SomeCache])
    def example_function_with_shared():
        return "ok"

    inspect.isfunction(example_function_with_shared)


def test_invocation_level_singletons_respect_container_singletons(container: Container):
    container[SomeCache] = Singleton(SomeCache)


    @magic_bind_to_container(container, shared=[SomeCache])

    def example_function_with_invocation_level_sharing(
        dep_one: MyDepOne, dep_two: MyDepTwo
    ):
        return {"a": dep_one.value, "b": dep_two.other_value}

    result_one = example_function_with_invocation_level_sharing()
    result_two = example_function_with_invocation_level_sharing()

    assert result_one["a"] == result_one["b"]
    assert result_one["a"] == result_two["a"]


1			import inspect
2			from random import random
3			from typing import Any, ClassVar
4
5			from lagom import Container, magic_bind_to_container, Singleton
6
7
8			class SomeCache:
9			loaded: ClassVar[bool] = False
10
11			def __init__(self):
12			SomeCache.loaded = True
13			self._init_random = random()
14
15			def value(self):
16			return self._init_random
17
18
19			class MyDepOne:
20			value: Any
21
22			def __init__(self, cache: SomeCache):
23			self.value = cache.value()
24
25
26			class MyDepTwo:
27			other_value: Any
28
29			def __init__(self, cache: SomeCache):
30			self.other_value = cache.value()
31
32
33			def test_by_default_all_resources_are_reconstructed(container: Container):
34			@magic_bind_to_container(container)
35			def example_function(dep_one: MyDepOne, dep_two: MyDepTwo):
36			return {"a": dep_one.value, "b": dep_two.other_value}
37
38			result = example_function()
39			assert result["a"] != result["b"]
40
41
42			def test_invocation_level_singletons_can_be_defined(container: Container):
43			@magic_bind_to_container(container, shared=[SomeCache])
44			def example_function_with_invocation_level_sharing(
45			dep_one: MyDepOne, dep_two: MyDepTwo
46			):
47			return {"a": dep_one.value, "b": dep_two.other_value}
48
49			result = example_function_with_invocation_level_sharing()
50			assert result["a"] == result["b"]
51
52
53			def test_invocation_level_singletons_dont_affect_the_base_container(
54			container: Container,
55			):
56			@magic_bind_to_container(container, shared=[SomeCache])
57			def example_function_with_invocation_level_sharing(
58			cache_one: SomeCache, cache_two: SomeCache
59			):
60			# This is what we expect with invocation level singleton
61			assert cache_one == cache_two
62
63			example_function_with_invocation_level_sharing()
64
65			# Check that each invocation gets a new one - this is the normal behaviour
66			assert container[SomeCache] != container[SomeCache]
67
68
69			def test_invocation_level_singletons_are_not_shared_across_calls(container: Container):
70			@magic_bind_to_container(container, shared=[SomeCache])
71			def example_function_with_invocation_level_sharing(
72			dep_one: MyDepOne, dep_two: MyDepTwo
73			):
74			return {"a": dep_one.value, "b": dep_two.other_value}
75
76			call_one = example_function_with_invocation_level_sharing()
77			call_two = example_function_with_invocation_level_sharing()
78
79			assert call_one["a"] != call_two["a"]
80
81
82			def test_that_shared_types_are_lazy_loaded(container: Container):
83			SomeCache.loaded = False
84
85			@magic_bind_to_container(container, shared=[SomeCache])
86			def example_function_that_defines_but_doesnt_use_sharing():
87			return "ok"
88
89			example_function_that_defines_but_doesnt_use_sharing()
90			assert not SomeCache.loaded
91
92
93			def test_partial_application_returns_something_that_is_considered_a_function(
94			container: Container,
95			):
96			@magic_bind_to_container(container, shared=[SomeCache])
97			def example_function_with_shared():
98			return "ok"
99
100			inspect.isfunction(example_function_with_shared)
101
102
103			def test_invocation_level_singletons_respect_container_singletons(container: Container):
104			container[SomeCache] = Singleton(SomeCache)
			0 ignored issues – show Comprehensibility Best Practice introduced 2020-06-04 18:49 UTC by Report Bug Copy Issue Report The variable `SomeCache` does not seem to be defined. Loading history...
105
106			@magic_bind_to_container(container, shared=[SomeCache])
			0 ignored issues – show Comprehensibility Best Practice introduced 2020-06-04 18:49 UTC by Report Bug Copy Issue Report The variable `SomeCache` does not seem to be defined. Loading history...
107			def example_function_with_invocation_level_sharing(
108			dep_one: MyDepOne, dep_two: MyDepTwo
109			):
110			return {"a": dep_one.value, "b": dep_two.other_value}
111
112			result_one = example_function_with_invocation_level_sharing()
113			result_two = example_function_with_invocation_level_sharing()
114
115			assert result_one["a"] == result_one["b"]
116			assert result_one["a"] == result_two["a"]
117

meadsteve / lagom

MyDepOne.__init__() A last analyzed 2024-11-22 07:23 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

MyDepOne.init() A
last analyzed 2024-11-22 07:23 UTC