IOEventSubscriberTest - Code Metrics - Inspection of "Update readme, fix scrutinizer path" - mediamonks/php-rest-api - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 8796f9...232efd )

unknown

created 2017-01-30 11:48 UTC

IOEventSubscriberTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	290
Duplicated Lines	30.34 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

Metric	Value
dl	88
loc	290
rs	9.2
c	0
b	0
f	0
wmc	34
lcom	1
cbo	5

How to fix Duplicated Code

<?php

namespace tests\MediaMonks\RestApi\EventSubscriber;

use MediaMonks\RestApi\EventSubscriber\IOEventSubscriber;
use MediaMonks\RestApi\Response\Response;
use \Mockery as m;
use Symfony\Component\HttpKernel\KernelEvents;

class IOEventSubscriberTest extends \PHPUnit_Framework_TestCase
{
    protected function getSubject($mocks = null)
    {
        list($matcher, $requestTransformer, $responseTransformer) = $mocks ?: $this->getMocks();
        return new IOEventSubscriber($matcher, $requestTransformer, $responseTransformer);
    }

    protected function getMocks()
    {
        $matcher             = m::mock('MediaMonks\RestApi\Request\RequestMatcherInterface');
        $requestTransformer  = m::mock('MediaMonks\RestApi\Request\RequestTransformerInterface');
        $responseTransformer = m::mock('MediaMonks\RestApi\Response\ResponseTransformerInterface');
        $responseTransformer->shouldReceive('createResponseFromContent')->andReturn(new Response());

        return [$matcher, $requestTransformer, $responseTransformer];
    }

    public function testGetSubscribedEvents()
    {
        $subscribedEvents = IOEventSubscriber::getSubscribedEvents();

        $this->assertArrayHasKey(KernelEvents::REQUEST, $subscribedEvents);
        $this->assertArrayHasKey(KernelEvents::EXCEPTION, $subscribedEvents);
        $this->assertArrayHasKey(KernelEvents::VIEW, $subscribedEvents);
        $this->assertArrayHasKey(KernelEvents::RESPONSE, $subscribedEvents);
    }

    public function testOnRequestIsBound()
    {
        $this->methodIsBound('onRequest', KernelEvents::REQUEST);
    }

    public function testOnRequestNoMatch()
    {
        list($matcher, $requestTransformer, $responseTransformer) = $this->getMocks();
        $matcher->shouldReceive('matches')->andReturn(false);
        $requestTransformer->shouldReceive('transform');

        $subject = $this->getSubject([$matcher, $requestTransformer, $responseTransformer]);

        $mockEvent = m::mock('Symfony\Component\HttpKernel\Event\GetResponseEvent');
        $mockEvent->shouldReceive('getRequest')->andReturn(m::mock('Symfony\Component\HttpFoundation\Request'));
        $mockEvent->shouldReceive('getRequestType');

        $subject->onRequest($mockEvent);

        try {
            $requestTransformer->shouldNotHaveReceived('transform');
            $this->assertTrue(true);
        } catch (\Exception $e) {
            $this->assertTrue(false, $e->getMessage());
        }
    }

    public function testOnRequest()
    {
        list($matcher, $requestTransformer, $responseTransformer) = $this->getMocks();
        $matcher->shouldReceive('matches')->andReturn(true);
        $requestTransformer->shouldReceive('transform');

        $subject = $this->getSubject([$matcher, $requestTransformer, $responseTransformer]);

        $mockEvent = m::mock('Symfony\Component\HttpKernel\Event\GetResponseEvent');
        $mockEvent->shouldReceive('getRequest')->andReturn(m::mock('Symfony\Component\HttpFoundation\Request'));
        $mockEvent->shouldReceive('getRequestType');

        $subject->onRequest($mockEvent);

        try {
            $requestTransformer->shouldHaveReceived('transform')->between(1, 1);
            $this->assertTrue(true);
        } catch (\Exception $e) {
            $this->assertTrue(false, $e->getMessage());
        }
    }

    public function testOnExceptionIsBound()
    {
        $this->methodIsBound('onException', KernelEvents::EXCEPTION);
    }

    public function testOnExceptionNoMatch()
    {
        list($matcher, $requestTransformer, $responseTransformer) = $this->getMocks();
        $matcher->shouldReceive('matches')->andReturn(false);

        $subject = $this->getSubject([$matcher, $requestTransformer, $responseTransformer]);

        $mockEvent = m::mock('Symfony\Component\HttpKernel\Event\GetResponseForExceptionEvent');
        $mockEvent->shouldReceive('getRequest')->andReturn(m::mock('Symfony\Component\HttpFoundation\Request'));
        $mockEvent->shouldReceive('getRequestType');

        $subject->onException($mockEvent);

        try {
            $mockEvent->shouldNotHaveReceived('setResponse');
            $this->assertTrue(true);
        } catch (\Exception $e) {
            $this->assertTrue(false, $e->getMessage());
        }
    }

    public function testOnException()
    {
        list($matcher, $requestTransformer, $responseTransformer) = $this->getMocks();
        $matcher->shouldReceive('matches')->andReturn(true);

        $subject = $this->getSubject([$matcher, $requestTransformer, $responseTransformer]);

        $mockEvent = m::mock('Symfony\Component\HttpKernel\Event\GetResponseForExceptionEvent');
        $mockEvent->shouldReceive('getRequest')->andReturn(m::mock('Symfony\Component\HttpFoundation\Request'));
        $mockEvent->shouldReceive('getRequestType');
        $mockEvent->shouldReceive('setResponse');
        $mockEvent->shouldReceive('getException');

        $subject->onException($mockEvent);

        try {
            $mockEvent->shouldHaveReceived('setResponse')->between(1, 1);
            $this->assertTrue(true);
        } catch (\Exception $e) {
            $this->assertTrue(false, $e->getMessage());
        }
    }

    public function testOnViewIsBould()
    {
        $this->methodIsBound('onView', KernelEvents::VIEW);
    }

    public function testOnViewNoMatch()
    {
        list($matcher, $requestTransformer, $responseTransformer) = $this->getMocks();
        $matcher->shouldReceive('matches')->andReturn(false);

        $subject = $this->getSubject([$matcher, $requestTransformer, $responseTransformer]);

        $mockEvent = m::mock('Symfony\Component\HttpKernel\Event\GetResponseForControllerResultEvent');
        $mockEvent->shouldReceive('getRequest')->andReturn(m::mock('Symfony\Component\HttpFoundation\Request'));
        $mockEvent->shouldReceive('getRequestType');

        $subject->onView($mockEvent);

        try {
            $mockEvent->shouldNotHaveReceived('setResponse');
            $this->assertTrue(true);
        } catch (\Exception $e) {
            $this->assertTrue(false, $e->getMessage());
        }
    }

    public function testOnView()
    {
        list($matcher, $requestTransformer, $responseTransformer) = $this->getMocks();
        $matcher->shouldReceive('matches')->andReturn(true);

        $subject = $this->getSubject([$matcher, $requestTransformer, $responseTransformer]);

        $mockEvent = m::mock('Symfony\Component\HttpKernel\Event\GetResponseForControllerResultEvent');
        $mockEvent->shouldReceive('getRequest')->andReturn(m::mock('Symfony\Component\HttpFoundation\Request'));
        $mockEvent->shouldReceive('getRequestType');
        $mockEvent->shouldReceive('getControllerResult');
        $mockEvent->shouldReceive('setResponse');

        $subject->onView($mockEvent);

        try {
            $mockEvent->shouldHaveReceived('setResponse')->between(1, 1);
            $this->assertTrue(true);
        } catch (\Exception $e) {
            $this->assertTrue(false, $e->getMessage());
        }
    }

    public function testOnResponseEarlyIsBound()
    {
        $this->methodIsBound('onResponseEarly', KernelEvents::RESPONSE);
    }

    public function testOnResponseEarlyNoMatch()
    {
        list($matcher, $requestTransformer, $responseTransformer) = $this->getMocks();
        $matcher->shouldReceive('matches')->andReturn(false);

        $subject = $this->getSubject([$matcher, $requestTransformer, $responseTransformer]);

        $mockEvent = m::mock('Symfony\Component\HttpKernel\Event\FilterResponseEvent');
        $mockEvent->shouldReceive('getRequest')->andReturn(m::mock('Symfony\Component\HttpFoundation\Request'));
        $mockEvent->shouldReceive('getRequestType');

        $subject->onResponseEarly($mockEvent);

        try {
            $mockEvent->shouldNotHaveReceived('setResponse');
            $this->assertTrue(true);
        } catch (\Exception $e) {
            $this->assertTrue(false, $e->getMessage());
        }
    }

    public function testOnResponseEarly()
    {
        list($matcher, $requestTransformer, $responseTransformer) = $this->getMocks();
        $matcher->shouldReceive('matches')->andReturn(true);
        $responseTransformer->shouldReceive('transformEarly')->andReturn(m::mock('Symfony\Component\HttpFoundation\Response'));

        $subject = $this->getSubject([$matcher, $requestTransformer, $responseTransformer]);

        $mockEvent = m::mock('Symfony\Component\HttpKernel\Event\FilterResponseEvent');
        $mockEvent->shouldReceive('getRequest')->andReturn(m::mock('Symfony\Component\HttpFoundation\Request'));
        $mockEvent->shouldReceive('getRequestType');
        $mockEvent->shouldReceive('getResponse')->andReturn(m::mock('Symfony\Component\HttpFoundation\Response'));
        $mockEvent->shouldReceive('setResponse');

        $subject->onResponseEarly($mockEvent);

        try {
            $mockEvent->shouldHaveReceived('setResponse')->between(1, 1);
            $this->assertTrue(true);
        } catch (\Exception $e) {
            $this->assertTrue(false, $e->getMessage());
        }
    }

    public function testOnResponseLateIsBound()
    {
        $this->methodIsBound('onResponseLate', KernelEvents::RESPONSE);
    }

    public function testOnResponseLateNoMatch()
    {
        list($matcher, $requestTransformer, $responseTransformer) = $this->getMocks();
        $matcher->shouldReceive('matches')->andReturn(false);

        $subject = $this->getSubject([$matcher, $requestTransformer, $responseTransformer]);

        $mockEvent = m::mock('Symfony\Component\HttpKernel\Event\FilterResponseEvent');
        $mockEvent->shouldReceive('getRequest')->andReturn(m::mock('Symfony\Component\HttpFoundation\Request'));
        $mockEvent->shouldReceive('getRequestType');

        $subject->onResponseLate($mockEvent);

        try {
            $requestTransformer->shouldNotHaveReceived('transformLate');
            $this->assertTrue(true);
        } catch (\Exception $e) {
            $this->assertTrue(false, $e->getMessage());
        }
    }

    public function testOnResponseLate()
    {
        list($matcher, $requestTransformer, $responseTransformer) = $this->getMocks();
        $matcher->shouldReceive('matches')->andReturn(true);
        $responseTransformer->shouldReceive('transformLate');

        $subject = $this->getSubject([$matcher, $requestTransformer, $responseTransformer]);

        $mockEvent = m::mock('Symfony\Component\HttpKernel\Event\FilterResponseEvent');
        $mockEvent->shouldReceive('getRequest')->andReturn(m::mock('Symfony\Component\HttpFoundation\Request'));
        $mockEvent->shouldReceive('getRequestType');
        $mockEvent->shouldReceive('getResponse')->andReturn(m::mock('Symfony\Component\HttpFoundation\Response'));
//        $mockEvent->shouldReceive('setResponse');

        $subject->onResponseLate($mockEvent);

        try {
            $responseTransformer->shouldHaveReceived('transformLate')->between(1, 1);
            $this->assertTrue(true);
        } catch (\Exception $e) {
            $this->assertTrue(false, $e->getMessage());
        }
    }

    protected function methodIsBound($method, $testEvent)
    {
        foreach (IOEventSubscriber::getSubscribedEvents() as $event => $listeners) {
            foreach ($listeners as $listener) {
                list ($listener) = $listener;
                if ($listener == $method && $event == $testEvent) {
                    $this->assertTrue(true);
                    return;
                }
            }
        }

        $this->assertTrue(false, $method . ' is not bound to event ' . $testEvent);
    }
}


1			<?php
2
3			namespace tests\MediaMonks\RestApi\EventSubscriber;
4
5			use MediaMonks\RestApi\EventSubscriber\IOEventSubscriber;
6			use MediaMonks\RestApi\Response\Response;
7			use \Mockery as m;
8			use Symfony\Component\HttpKernel\KernelEvents;
9
10			class IOEventSubscriberTest extends \PHPUnit_Framework_TestCase
11			{
12			protected function getSubject($mocks = null)
13			{
14			list($matcher, $requestTransformer, $responseTransformer) = $mocks ?: $this->getMocks();
15			return new IOEventSubscriber($matcher, $requestTransformer, $responseTransformer);
16			}
17
18			protected function getMocks()
19			{
20			$matcher = m::mock('MediaMonks\RestApi\Request\RequestMatcherInterface');
21			$requestTransformer = m::mock('MediaMonks\RestApi\Request\RequestTransformerInterface');
22			$responseTransformer = m::mock('MediaMonks\RestApi\Response\ResponseTransformerInterface');
23			$responseTransformer->shouldReceive('createResponseFromContent')->andReturn(new Response());
24
25			return [$matcher, $requestTransformer, $responseTransformer];
26			}
27
28			public function testGetSubscribedEvents()
29			{
30			$subscribedEvents = IOEventSubscriber::getSubscribedEvents();
31
32			$this->assertArrayHasKey(KernelEvents::REQUEST, $subscribedEvents);
33			$this->assertArrayHasKey(KernelEvents::EXCEPTION, $subscribedEvents);
34			$this->assertArrayHasKey(KernelEvents::VIEW, $subscribedEvents);
35			$this->assertArrayHasKey(KernelEvents::RESPONSE, $subscribedEvents);
36			}
37
38			public function testOnRequestIsBound()
39			{
40			$this->methodIsBound('onRequest', KernelEvents::REQUEST);
41			}
42
43			public function testOnRequestNoMatch()
44			{
45			list($matcher, $requestTransformer, $responseTransformer) = $this->getMocks();
46			$matcher->shouldReceive('matches')->andReturn(false);
47			$requestTransformer->shouldReceive('transform');
48
49			$subject = $this->getSubject([$matcher, $requestTransformer, $responseTransformer]);
50
51			$mockEvent = m::mock('Symfony\Component\HttpKernel\Event\GetResponseEvent');
52			$mockEvent->shouldReceive('getRequest')->andReturn(m::mock('Symfony\Component\HttpFoundation\Request'));
53			$mockEvent->shouldReceive('getRequestType');
54
55			$subject->onRequest($mockEvent);
56
57			try {
58			$requestTransformer->shouldNotHaveReceived('transform');
59			$this->assertTrue(true);
60			} catch (\Exception $e) {
61			$this->assertTrue(false, $e->getMessage());
62			}
63			}
64
65			public function testOnRequest()
66			{
67			list($matcher, $requestTransformer, $responseTransformer) = $this->getMocks();
68			$matcher->shouldReceive('matches')->andReturn(true);
69			$requestTransformer->shouldReceive('transform');
70
71			$subject = $this->getSubject([$matcher, $requestTransformer, $responseTransformer]);
72
73			$mockEvent = m::mock('Symfony\Component\HttpKernel\Event\GetResponseEvent');
74			$mockEvent->shouldReceive('getRequest')->andReturn(m::mock('Symfony\Component\HttpFoundation\Request'));
75			$mockEvent->shouldReceive('getRequestType');
76
77			$subject->onRequest($mockEvent);
78
79			try {
80			$requestTransformer->shouldHaveReceived('transform')->between(1, 1);
81			$this->assertTrue(true);
82			} catch (\Exception $e) {
83			$this->assertTrue(false, $e->getMessage());
84			}
85			}
86
87			public function testOnExceptionIsBound()
88			{
89			$this->methodIsBound('onException', KernelEvents::EXCEPTION);
90			}
91
92			public function testOnExceptionNoMatch()
93			{
94			list($matcher, $requestTransformer, $responseTransformer) = $this->getMocks();
95			$matcher->shouldReceive('matches')->andReturn(false);
96
97			$subject = $this->getSubject([$matcher, $requestTransformer, $responseTransformer]);
98
99			$mockEvent = m::mock('Symfony\Component\HttpKernel\Event\GetResponseForExceptionEvent');
100			$mockEvent->shouldReceive('getRequest')->andReturn(m::mock('Symfony\Component\HttpFoundation\Request'));
101			$mockEvent->shouldReceive('getRequestType');
102
103			$subject->onException($mockEvent);
104
105			try {
106			$mockEvent->shouldNotHaveReceived('setResponse');
107			$this->assertTrue(true);
108			} catch (\Exception $e) {
109			$this->assertTrue(false, $e->getMessage());
110			}
111			}
112
113			public function testOnException()
114			{
115			list($matcher, $requestTransformer, $responseTransformer) = $this->getMocks();
116			$matcher->shouldReceive('matches')->andReturn(true);
117
118			$subject = $this->getSubject([$matcher, $requestTransformer, $responseTransformer]);
119
120			$mockEvent = m::mock('Symfony\Component\HttpKernel\Event\GetResponseForExceptionEvent');
121			$mockEvent->shouldReceive('getRequest')->andReturn(m::mock('Symfony\Component\HttpFoundation\Request'));
122			$mockEvent->shouldReceive('getRequestType');
123			$mockEvent->shouldReceive('setResponse');
124			$mockEvent->shouldReceive('getException');
125
126			$subject->onException($mockEvent);
127
128			try {
129			$mockEvent->shouldHaveReceived('setResponse')->between(1, 1);
130			$this->assertTrue(true);
131			} catch (\Exception $e) {
132			$this->assertTrue(false, $e->getMessage());
133			}
134			}
135
136			public function testOnViewIsBould()
137			{
138			$this->methodIsBound('onView', KernelEvents::VIEW);
139			}
140
141			public function testOnViewNoMatch()
142			{
143			list($matcher, $requestTransformer, $responseTransformer) = $this->getMocks();
144			$matcher->shouldReceive('matches')->andReturn(false);
145
146			$subject = $this->getSubject([$matcher, $requestTransformer, $responseTransformer]);
147
148			$mockEvent = m::mock('Symfony\Component\HttpKernel\Event\GetResponseForControllerResultEvent');
149			$mockEvent->shouldReceive('getRequest')->andReturn(m::mock('Symfony\Component\HttpFoundation\Request'));
150			$mockEvent->shouldReceive('getRequestType');
151
152			$subject->onView($mockEvent);
153
154			try {
155			$mockEvent->shouldNotHaveReceived('setResponse');
156			$this->assertTrue(true);
157			} catch (\Exception $e) {
158			$this->assertTrue(false, $e->getMessage());
159			}
160			}
161
162			public function testOnView()
163			{
164			list($matcher, $requestTransformer, $responseTransformer) = $this->getMocks();
165			$matcher->shouldReceive('matches')->andReturn(true);
166
167			$subject = $this->getSubject([$matcher, $requestTransformer, $responseTransformer]);
168
169			$mockEvent = m::mock('Symfony\Component\HttpKernel\Event\GetResponseForControllerResultEvent');
170			$mockEvent->shouldReceive('getRequest')->andReturn(m::mock('Symfony\Component\HttpFoundation\Request'));
171			$mockEvent->shouldReceive('getRequestType');
172			$mockEvent->shouldReceive('getControllerResult');
173			$mockEvent->shouldReceive('setResponse');
174
175			$subject->onView($mockEvent);
176
177			try {
178			$mockEvent->shouldHaveReceived('setResponse')->between(1, 1);
179			$this->assertTrue(true);
180			} catch (\Exception $e) {
181			$this->assertTrue(false, $e->getMessage());
182			}
183			}
184
185			public function testOnResponseEarlyIsBound()
186			{
187			$this->methodIsBound('onResponseEarly', KernelEvents::RESPONSE);
188			}
189
190			public function testOnResponseEarlyNoMatch()
191			{
192			list($matcher, $requestTransformer, $responseTransformer) = $this->getMocks();
193			$matcher->shouldReceive('matches')->andReturn(false);
194
195			$subject = $this->getSubject([$matcher, $requestTransformer, $responseTransformer]);
196
197			$mockEvent = m::mock('Symfony\Component\HttpKernel\Event\FilterResponseEvent');
198			$mockEvent->shouldReceive('getRequest')->andReturn(m::mock('Symfony\Component\HttpFoundation\Request'));
199			$mockEvent->shouldReceive('getRequestType');
200
201			$subject->onResponseEarly($mockEvent);
202
203			try {
204			$mockEvent->shouldNotHaveReceived('setResponse');
205			$this->assertTrue(true);
206			} catch (\Exception $e) {
207			$this->assertTrue(false, $e->getMessage());
208			}
209			}
210
211			public function testOnResponseEarly()
212			{
213			list($matcher, $requestTransformer, $responseTransformer) = $this->getMocks();
214			$matcher->shouldReceive('matches')->andReturn(true);
215			$responseTransformer->shouldReceive('transformEarly')->andReturn(m::mock('Symfony\Component\HttpFoundation\Response'));
216
217			$subject = $this->getSubject([$matcher, $requestTransformer, $responseTransformer]);
218
219			$mockEvent = m::mock('Symfony\Component\HttpKernel\Event\FilterResponseEvent');
220			$mockEvent->shouldReceive('getRequest')->andReturn(m::mock('Symfony\Component\HttpFoundation\Request'));
221			$mockEvent->shouldReceive('getRequestType');
222			$mockEvent->shouldReceive('getResponse')->andReturn(m::mock('Symfony\Component\HttpFoundation\Response'));
223			$mockEvent->shouldReceive('setResponse');
224
225			$subject->onResponseEarly($mockEvent);
226
227			try {
228			$mockEvent->shouldHaveReceived('setResponse')->between(1, 1);
229			$this->assertTrue(true);
230			} catch (\Exception $e) {
231			$this->assertTrue(false, $e->getMessage());
232			}
233			}
234
235			public function testOnResponseLateIsBound()
236			{
237			$this->methodIsBound('onResponseLate', KernelEvents::RESPONSE);
238			}
239
240			public function testOnResponseLateNoMatch()
241			{
242			list($matcher, $requestTransformer, $responseTransformer) = $this->getMocks();
243			$matcher->shouldReceive('matches')->andReturn(false);
244
245			$subject = $this->getSubject([$matcher, $requestTransformer, $responseTransformer]);
246
247			$mockEvent = m::mock('Symfony\Component\HttpKernel\Event\FilterResponseEvent');
248			$mockEvent->shouldReceive('getRequest')->andReturn(m::mock('Symfony\Component\HttpFoundation\Request'));
249			$mockEvent->shouldReceive('getRequestType');
250
251			$subject->onResponseLate($mockEvent);
252
253			try {
254			$requestTransformer->shouldNotHaveReceived('transformLate');
255			$this->assertTrue(true);
256			} catch (\Exception $e) {
257			$this->assertTrue(false, $e->getMessage());
258			}
259			}
260
261			public function testOnResponseLate()
262			{
263			list($matcher, $requestTransformer, $responseTransformer) = $this->getMocks();
264			$matcher->shouldReceive('matches')->andReturn(true);
265			$responseTransformer->shouldReceive('transformLate');
266
267			$subject = $this->getSubject([$matcher, $requestTransformer, $responseTransformer]);
268
269			$mockEvent = m::mock('Symfony\Component\HttpKernel\Event\FilterResponseEvent');
270			$mockEvent->shouldReceive('getRequest')->andReturn(m::mock('Symfony\Component\HttpFoundation\Request'));
271			$mockEvent->shouldReceive('getRequestType');
272			$mockEvent->shouldReceive('getResponse')->andReturn(m::mock('Symfony\Component\HttpFoundation\Response'));
273			// $mockEvent->shouldReceive('setResponse');
274
275			$subject->onResponseLate($mockEvent);
276
277			try {
278			$responseTransformer->shouldHaveReceived('transformLate')->between(1, 1);
279			$this->assertTrue(true);
280			} catch (\Exception $e) {
281			$this->assertTrue(false, $e->getMessage());
282			}
283			}
284
285			protected function methodIsBound($method, $testEvent)
286			{
287			foreach (IOEventSubscriber::getSubscribedEvents() as $event => $listeners) {
288			foreach ($listeners as $listener) {
289			list ($listener) = $listener;
290			if ($listener == $method && $event == $testEvent) {
291			$this->assertTrue(true);
292			return;
293			}
294			}
295			}
296
297			$this->assertTrue(false, $method . ' is not bound to event ' . $testEvent);
298			}
299			}
300

mediamonks / php-rest-api

Push — master ( 8796f9...232efd )

IOEventSubscriberTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like