Code Duplication - Maltzur/injectify - Measure and Improve Code Quality continuously with Scrutinizer

Code Duplication Length = 14-19 lines in 13 locations

tests/test_injectors/test_inject_decorated_method.py 2 locations


    assert target.target(101) == 202


def test_field_injector_correctly_injects_decorated_method_after_ordinal_field():
    class Target:
        @decorate
        def target(self, x):
            if x > 100:
                y = x * 2
            else:
                y = x + 2
            return y

    @inject(
        target=Target.target, injector=FieldInjector('y', ordinal=0, insert='after')
    )
    def handler():
        y -= 1

    target = Target()
    assert target.target(13) == 15
    assert target.target(101) == 201


def test_nested_injector_correctly_injects_decorated_method():

    assert target.target(101) == 201


def test_field_injector_correctly_injects_decorated_method_before_ordinal_field():
    class Target:
        @decorate
        def target(self, x):
            if x > 100:
                y = x * 2
            else:
                y = x + 2
            return y

    @inject(
        target=Target.target, injector=FieldInjector('y', ordinal=1, insert='before'),
    )
    def handler():
        x += 1

    target = Target()
    assert target.target(13) == 16
    assert target.target(101) == 202


def test_field_injector_correctly_injects_decorated_method_after_ordinal_field():

tests/test_injectors/test_inject_static_method.py 4 locations


    assert target.target(101) == 202


def test_field_injector_correctly_injects_static_method_after_ordinal_field():
    class Target:
        @staticmethod
        def target(x):
            if x > 100:
                y = x * 2
            else:
                y = x + 2
            return y

    @inject(
        target=Target.target, injector=FieldInjector('y', ordinal=0, insert='after')
    )
    def handler():
        y -= 1

    target = Target()
    assert target.target(13) == 15
    assert target.target(101) == 201


def test_nested_injector_correctly_injects_static_method():

    assert target.target(101) == 201


def test_field_injector_correctly_injects_static_method_before_ordinal_field():
    class Target:
        @staticmethod
        def target(x):
            if x > 100:
                y = x * 2
            else:
                y = x + 2
            return y

    @inject(
        target=Target.target, injector=FieldInjector('y', ordinal=1, insert='before'),
    )
    def handler():
        x += 1

    target = Target()
    assert target.target(13) == 16
    assert target.target(101) == 202


def test_field_injector_correctly_injects_static_method_after_ordinal_field():

    assert target.target(101) == 204


def test_field_injector_correctly_injects_static_method_after_all_fields():
    class Target:
        @staticmethod
        def target(x):
            if x > 100:
                y = x * 2
            else:
                y = x + 2
            return y

    @inject(target=Target.target, injector=FieldInjector('y', insert='after'))
    def handler():
        y -= 1

    target = Target()
    assert target.target(13) == 14
    assert target.target(101) == 201


def test_field_injector_correctly_injects_static_method_before_ordinal_field():

    assert target.target(101) == 202


def test_field_injector_correctly_injects_static_method_before_all_fields():
    class Target:
        @staticmethod
        def target(x):
            if x > 100:
                y = x * 2
            else:
                y = x + 2
            return y

    @inject(target=Target.target, injector=FieldInjector('y', insert='before'))
    def handler():
        x += 1

    target = Target()
    assert target.target(13) == 16
    assert target.target(101) == 204


def test_field_injector_correctly_injects_static_method_after_all_fields():

tests/test_injectors/test_inject_method.py 4 locations


    assert target.target(101) == 202


def test_field_injector_correctly_injects_method_after_ordinal_field():
    class Target:
        def target(self, x):
            if x > 100:
                y = x * 2
            else:
                y = x + 2
            return y

    @inject(
        target=Target.target, injector=FieldInjector('y', ordinal=0, insert='after')
    )
    def handler():
        y -= 1

    target = Target()
    assert target.target(13) == 15
    assert target.target(101) == 201


def test_nested_injector_correctly_injects_method():

    assert target.target(101) == 201


def test_field_injector_correctly_injects_method_before_ordinal_field():
    class Target:
        def target(self, x):
            if x > 100:
                y = x * 2
            else:
                y = x + 2
            return y

    @inject(
        target=Target.target, injector=FieldInjector('y', ordinal=1, insert='before'),
    )
    def handler():
        x += 1

    target = Target()
    assert target.target(13) == 16
    assert target.target(101) == 202


def test_field_injector_correctly_injects_method_after_ordinal_field():

    assert target.target(101) == 204


def test_field_injector_correctly_injects_method_after_all_fields():
    class Target:
        def target(self, x):
            if x > 100:
                y = x * 2
            else:
                y = x + 2
            return y

    @inject(target=Target.target, injector=FieldInjector('y', insert='after'))
    def handler():
        y -= 1

    target = Target()
    assert target.target(13) == 14
    assert target.target(101) == 201


def test_field_injector_correctly_injects_method_before_ordinal_field():

    assert target.target(101) == 202


def test_field_injector_correctly_injects_method_before_all_fields():
    class Target:
        def target(self, x):
            if x > 100:
                y = x * 2
            else:
                y = x + 2
            return y

    @inject(target=Target.target, injector=FieldInjector('y', insert='before'))
    def handler():
        x += 1

    target = Target()
    assert target.target(13) == 16
    assert target.target(101) == 204


def test_field_injector_correctly_injects_method_after_all_fields():

tests/test_injectors/test_inject_async_function.py 1 location


    assert run(target(101)) == 201


def test_field_injector_correctly_injects_async_function_before_ordinal_field():
    async def target(x):
        if x > 100:
            y = x * 2
        else:
            y = x + 2
        return y

    @inject(
        target=target, injector=FieldInjector('y', ordinal=1, insert='before'),
    )
    def handler():
        x += 1

    assert run(target(13)) == 16
    assert run(target(101)) == 202


def test_field_injector_correctly_injects_async_function_after_ordinal_field():

tests/test_injectors/test_inject_function.py 2 locations


    assert target(101) == 201


def test_field_injector_correctly_injects_function_before_ordinal_field():
    def target(x):
        if x > 100:
            y = x * 2
        else:
            y = x + 2
        return y

    @inject(
        target=target, injector=FieldInjector('y', ordinal=1, insert='before'),
    )
    def handler():
        x += 1

    assert target(13) == 16
    assert target(101) == 202


def test_field_injector_correctly_injects_function_after_ordinal_field():

    assert target(101) == 202


def test_field_injector_correctly_injects_function_after_ordinal_field():
    def target(x):
        if x > 100:
            y = x * 2
        else:
            y = x + 2
        return y

    @inject(target=target, injector=FieldInjector('y', ordinal=0, insert='after'))
    def handler():
        y -= 1

    assert target(13) == 15
    assert target(101) == 201


def test_nested_injector_correctly_injects_function():

		@@ 152-170 (lines=19) @@
149		assert target.target(101) == 202
150
151
152		def test_field_injector_correctly_injects_decorated_method_after_ordinal_field():
153		class Target:
154		@decorate
155		def target(self, x):
156		if x > 100:
157		y = x * 2
158		else:
159		y = x + 2
160		return y
161
162		@inject(
163		target=Target.target, injector=FieldInjector('y', ordinal=0, insert='after')
164		)
165		def handler():
166		y -= 1
167
168		target = Target()
169		assert target.target(13) == 15
170		assert target.target(101) == 201
171
172
173		def test_nested_injector_correctly_injects_decorated_method():
		@@ 131-149 (lines=19) @@
128		assert target.target(101) == 201
129
130
131		def test_field_injector_correctly_injects_decorated_method_before_ordinal_field():
132		class Target:
133		@decorate
134		def target(self, x):
135		if x > 100:
136		y = x * 2
137		else:
138		y = x + 2
139		return y
140
141		@inject(
142		target=Target.target, injector=FieldInjector('y', ordinal=1, insert='before'),
143		)
144		def handler():
145		x += 1
146
147		target = Target()
148		assert target.target(13) == 16
149		assert target.target(101) == 202
150
151
152		def test_field_injector_correctly_injects_decorated_method_after_ordinal_field():

		@@ 145-163 (lines=19) @@
142		assert target.target(101) == 202
143
144
145		def test_field_injector_correctly_injects_static_method_after_ordinal_field():
146		class Target:
147		@staticmethod
148		def target(x):
149		if x > 100:
150		y = x * 2
151		else:
152		y = x + 2
153		return y
154
155		@inject(
156		target=Target.target, injector=FieldInjector('y', ordinal=0, insert='after')
157		)
158		def handler():
159		y -= 1
160
161		target = Target()
162		assert target.target(13) == 15
163		assert target.target(101) == 201
164
165
166		def test_nested_injector_correctly_injects_static_method():
		@@ 124-142 (lines=19) @@
121		assert target.target(101) == 201
122
123
124		def test_field_injector_correctly_injects_static_method_before_ordinal_field():
125		class Target:
126		@staticmethod
127		def target(x):
128		if x > 100:
129		y = x * 2
130		else:
131		y = x + 2
132		return y
133
134		@inject(
135		target=Target.target, injector=FieldInjector('y', ordinal=1, insert='before'),
136		)
137		def handler():
138		x += 1
139
140		target = Target()
141		assert target.target(13) == 16
142		assert target.target(101) == 202
143
144
145		def test_field_injector_correctly_injects_static_method_after_ordinal_field():
		@@ 105-121 (lines=17) @@
102		assert target.target(101) == 204
103
104
105		def test_field_injector_correctly_injects_static_method_after_all_fields():
106		class Target:
107		@staticmethod
108		def target(x):
109		if x > 100:
110		y = x * 2
111		else:
112		y = x + 2
113		return y
114
115		@inject(target=Target.target, injector=FieldInjector('y', insert='after'))
116		def handler():
117		y -= 1
118
119		target = Target()
120		assert target.target(13) == 14
121		assert target.target(101) == 201
122
123
124		def test_field_injector_correctly_injects_static_method_before_ordinal_field():
		@@ 86-102 (lines=17) @@
83		assert target.target(101) == 202
84
85
86		def test_field_injector_correctly_injects_static_method_before_all_fields():
87		class Target:
88		@staticmethod
89		def target(x):
90		if x > 100:
91		y = x * 2
92		else:
93		y = x + 2
94		return y
95
96		@inject(target=Target.target, injector=FieldInjector('y', insert='before'))
97		def handler():
98		x += 1
99
100		target = Target()
101		assert target.target(13) == 16
102		assert target.target(101) == 204
103
104
105		def test_field_injector_correctly_injects_static_method_after_all_fields():

		@@ 138-155 (lines=18) @@
135		assert target.target(101) == 202
136
137
138		def test_field_injector_correctly_injects_method_after_ordinal_field():
139		class Target:
140		def target(self, x):
141		if x > 100:
142		y = x * 2
143		else:
144		y = x + 2
145		return y
146
147		@inject(
148		target=Target.target, injector=FieldInjector('y', ordinal=0, insert='after')
149		)
150		def handler():
151		y -= 1
152
153		target = Target()
154		assert target.target(13) == 15
155		assert target.target(101) == 201
156
157
158		def test_nested_injector_correctly_injects_method():
		@@ 118-135 (lines=18) @@
115		assert target.target(101) == 201
116
117
118		def test_field_injector_correctly_injects_method_before_ordinal_field():
119		class Target:
120		def target(self, x):
121		if x > 100:
122		y = x * 2
123		else:
124		y = x + 2
125		return y
126
127		@inject(
128		target=Target.target, injector=FieldInjector('y', ordinal=1, insert='before'),
129		)
130		def handler():
131		x += 1
132
133		target = Target()
134		assert target.target(13) == 16
135		assert target.target(101) == 202
136
137
138		def test_field_injector_correctly_injects_method_after_ordinal_field():
		@@ 100-115 (lines=16) @@
97		assert target.target(101) == 204
98
99
100		def test_field_injector_correctly_injects_method_after_all_fields():
101		class Target:
102		def target(self, x):
103		if x > 100:
104		y = x * 2
105		else:
106		y = x + 2
107		return y
108
109		@inject(target=Target.target, injector=FieldInjector('y', insert='after'))
110		def handler():
111		y -= 1
112
113		target = Target()
114		assert target.target(13) == 14
115		assert target.target(101) == 201
116
117
118		def test_field_injector_correctly_injects_method_before_ordinal_field():
		@@ 82-97 (lines=16) @@
79		assert target.target(101) == 202
80
81
82		def test_field_injector_correctly_injects_method_before_all_fields():
83		class Target:
84		def target(self, x):
85		if x > 100:
86		y = x * 2
87		else:
88		y = x + 2
89		return y
90
91		@inject(target=Target.target, injector=FieldInjector('y', insert='before'))
92		def handler():
93		x += 1
94
95		target = Target()
96		assert target.target(13) == 16
97		assert target.target(101) == 204
98
99
100		def test_field_injector_correctly_injects_method_after_all_fields():

		@@ 115-130 (lines=16) @@
112		assert run(target(101)) == 201
113
114
115		def test_field_injector_correctly_injects_async_function_before_ordinal_field():
116		async def target(x):
117		if x > 100:
118		y = x * 2
119		else:
120		y = x + 2
121		return y
122
123		@inject(
124		target=target, injector=FieldInjector('y', ordinal=1, insert='before'),
125		)
126		def handler():
127		x += 1
128
129		assert run(target(13)) == 16
130		assert run(target(101)) == 202
131
132
133		def test_field_injector_correctly_injects_async_function_after_ordinal_field():

		@@ 106-121 (lines=16) @@
103		assert target(101) == 201
104
105
106		def test_field_injector_correctly_injects_function_before_ordinal_field():
107		def target(x):
108		if x > 100:
109		y = x * 2
110		else:
111		y = x + 2
112		return y
113
114		@inject(
115		target=target, injector=FieldInjector('y', ordinal=1, insert='before'),
116		)
117		def handler():
118		x += 1
119
120		assert target(13) == 16
121		assert target(101) == 202
122
123
124		def test_field_injector_correctly_injects_function_after_ordinal_field():
		@@ 124-137 (lines=14) @@
121		assert target(101) == 202
122
123
124		def test_field_injector_correctly_injects_function_after_ordinal_field():
125		def target(x):
126		if x > 100:
127		y = x * 2
128		else:
129		y = x + 2
130		return y
131
132		@inject(target=target, injector=FieldInjector('y', ordinal=0, insert='after'))
133		def handler():
134		y -= 1
135
136		assert target(13) == 15
137		assert target(101) == 201
138
139
140		def test_nested_injector_correctly_injects_function():

Maltzur / injectify

Code Duplication Length = 14-19 lines in 13 locations

tests/test_injectors/test_inject_decorated_method.py 2 locations

tests/test_injectors/test_inject_static_method.py 4 locations

tests/test_injectors/test_inject_method.py 4 locations

tests/test_injectors/test_inject_async_function.py 1 location

tests/test_injectors/test_inject_function.py 2 locations