MysqlActivityRepositoryTest::tearDownAfterClass() - Code Metrics - Inspection of "Adds more strict checking of returned interface" - jacobemerick/web - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 4c6be8...89e88a )

by Jacob

created 2016-02-21 04:39 UTC

MysqlActivityRepositoryTest::tearDownAfterClass() A

↳ Parent: MysqlActivityRepositoryTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	5
rs	9.4285
cc	1
eloc	3
nc	1
nop	0

<?php

namespace Jacobemerick\Web\Domain\Stream\Activity;

use Aura\Sql\ConnectionLocator;
use Aura\Sql\ExtendedPdo;
use PHPUnit_Framework_TestCase;

class MysqlActivityRepositoryTest extends PHPUnit_Framework_TestCase
{

    protected static $connection;

    public static function setUpBeforeClass()

    {
        $extendedPdo = new ExtendedPdo('sqlite::memory:');
        $extendedPdo->exec("ATTACH DATABASE `jpemeric_stream.db` AS `jpemeric_stream`");
        $extendedPdo->exec("
            CREATE TABLE IF NOT EXISTS `jpemeric_stream`.`activity` (
              `id` integer PRIMARY KEY AUTOINCREMENT,
              `message` text NOT NULL,
              `message_long` text NOT NULL,
              `datetime` datetime NOT NULL,
              `metadata` text NOT NULL,
              `type` varchar(10) NOT NULL,
              `type_id` integer NOT NULL,
              `created_at` datetime,
              `updated_at` datetime
            )"
        );

        self::$connection = new ConnectionLocator(function () use ($extendedPdo) {
            return $extendedPdo;
        });
    }

    public function testIsInstanceOfActivityRepository()
    {
        $repository = new MysqlActivityRepository(self::$connection);

        $this->assertInstanceOf(
            'Jacobemerick\Web\Domain\Stream\Activity\MysqlActivityRepository',
            $repository
        );
    }

    public function testImplementsActivityInterface()
    {
        $repository = new MysqlActivityRepository(self::$connection);

        $this->assertInstanceOf(
            'Jacobemerick\Web\Domain\Stream\Activity\ActivityRepositoryInterface',
            $repository
        );
    }

    public function testConstructSetsConnections()
    {
        $respository = new MysqlActivityRepository(self::$connection);

        $this->assertAttributeSame(
            self::$connection,
            'connections',
            $respository
        );
    }

    public function testGetActivityById()
    {
        $testData = [
            'id' => rand(1, 100),
            'message' => 'test data',
        ];

        $this->insertData($testData);

        $repository = new MysqlActivityRepository(self::$connection);
        $data = $repository->getActivityById($testData['id']);

        $this->assertNotFalse($data);
        $this->assertInternalType('array', $data);
        $this->assertArraySubset($testData, $data);
    }

    public function testGetActivityByIdFailure()
    {
        $testData = [
            'id' => rand(1, 100),
            'message' => 'test data',
        ];

        $this->insertData($testData);

        $repository = new MysqlActivityRepository(self::$connection);
        $data = $repository->getActivityById($testData['id'] + 1);

        $this->assertFalse($data);
    }

    public function testGetActivities()
    {
        $testData = [
            [
                'id' => rand(1, 100),
                'message' => 'test one',
            ],
            [
                'id' => rand(101, 200),
                'message' => 'test two',
            ],
        ];

        array_walk($testData, [$this, 'insertData']);

        $repository = new MysqlActivityRepository(self::$connection);
        $data = $repository->getActivities();

        $this->assertNotFalse($data);
        $this->assertInternalType('array', $data);
        foreach ($testData as $key => $testRow) {
            $this->assertInternalType('array', $testRow);
            $this->assertArraySubset($testRow, $data[$key]);
        }
    }

    public function testGetActivitiesFailure()
    {
        $repository = new MysqlActivityRepository(self::$connection);
        $data = $repository->getActivities();

        $this->assertEmpty($data);
        $this->assertInternalType('array', $data);
    }

    public function testGetActivitiesRange()

    {
        $testData = [
            [
                'id' => rand(1, 100),
                'message' => 'test one',
            ],
            [
                'id' => rand(101, 200),
                'message' => 'test two',
            ],
            [
                'id' => rand(201, 300),
                'message' => 'test three',
            ],
        ];

        array_walk($testData, [$this, 'insertData']);

        $repository = new MysqlActivityRepository(self::$connection);
        $data = $repository->getActivities(2, 1);

        $this->assertNotFalse($data);
        $this->assertInternalType('array', $data);
        $this->assertCount(2, $data);

        $testData = array_slice($testData, 1, 2);

        foreach ($testData as $key => $testRow) {
            $this->assertInternalType('array', $testRow);
            $this->assertArraySubset($testRow, $data[$key]);
        }
    }

    public function testGetActivitiesRangeFailure()

    {
        $testData = [
            [
                'id' => rand(1, 100),
                'message' => 'test one',
            ],
            [
                'id' => rand(101, 200),
                'message' => 'test two',
            ],
        ];

        array_walk($testData, [$this, 'insertData']);

        $repository = new MysqlActivityRepository(self::$connection);
        $data = $repository->getActivities(1, 3);

        $this->assertEmpty($data);
        $this->assertInternalType('array', $data);
    }

    public function testGetActivitiesCount()
    {
        $testData = [
            [
                'id' => rand(1, 100),
                'message' => 'test one',
            ],
            [
                'id' => rand(101, 200),
                'message' => 'test two',
            ],
        ];

        array_walk($testData, [$this, 'insertData']);

        $repository = new MysqlActivityRepository(self::$connection);
        $data = $repository->getActivitiesCount();

        $this->assertNotFalse($data);
        $this->assertStringMatchesFormat('%d', $data);
        $this->assertEquals(count($testData), $data);
    }

    public function testGetActivitiesCountEmpty()
    {
        $repository = new MysqlActivityRepository(self::$connection);
        $data = $repository->getActivitiesCount();

        $this->assertNotFalse($data);
        $this->assertStringMatchesFormat('%d', $data);
        $this->assertEquals('0', $data);
    }

    public function testGetActivitiesByType()
    {
        $testData = [
            [
                'id' => rand(1, 100),
                'message' => 'test one',
                'type' => 'type one',
            ],
            [
                'id' => rand(101, 200),
                'message' => 'test two',
                'type' => 'type two',
            ],
            [
                'id' => rand(201, 300),
                'message' => 'test three',
                'type' => 'type one',
            ],
        ];

        array_walk($testData, [$this, 'insertData']);

        $repository = new MysqlActivityRepository(self::$connection);
        $data = $repository->getActivitiesByType('type one');

        $this->assertNotFalse($data);
        $this->assertInternalType('array', $data);

        $testData = array_filter($testData, function ($row) {
            return ($row['type'] == 'type one');
        });
        $testData = array_values($testData);

        foreach ($testData as $key => $testRow) {
            $this->assertInternalType('array', $testRow);
            $this->assertArraySubset($testRow, $data[$key]);
        }
    }

    public function testGetActivitiesByTypeFailure()

    {
        $testData = [
            [
                'id' => rand(1, 100),
                'message' => 'test one',
                'type' => 'type one',
            ],
            [
                'id' => rand(101, 200),
                'message' => 'test two',
                'type' => 'type one',
            ],
        ];

        array_walk($testData, [$this, 'insertData']);

        $repository = new MysqlActivityRepository(self::$connection);
        $data = $repository->getActivitiesByType('type two');

        $this->assertEmpty($data);
        $this->assertInternalType('array', $data);
    }

    public function testGetActivitiesByTypeRange()
    {
        $testData = [
            [
                'id' => rand(1, 100),
                'message' => 'test one',
                'type' => 'type one',
            ],
            [
                'id' => rand(101, 200),
                'message' => 'test two',
                'type' => 'type two',
            ],
            [
                'id' => rand(201, 300),
                'message' => 'test three',
                'type' => 'type one',
            ],
            [
                'id' => rand(301, 400),
                'message' => 'test four',
                'type' => 'type one',
            ],
        ];

        array_walk($testData, [$this, 'insertData']);

        $repository = new MysqlActivityRepository(self::$connection);
        $data = $repository->getActivitiesByType('type one', 2, 1);

        $this->assertNotFalse($data);
        $this->assertInternalType('array', $data);
        $this->assertCount(2, $data);

        $testData = array_filter($testData, function ($row) {
            return ($row['type'] == 'type one');
        });
        $testData = array_values($testData);
        $testData = array_slice($testData, 1, 2);

        foreach ($testData as $key => $testRow) {
            $this->assertInternalType('array', $testRow);
            $this->assertArraySubset($testRow, $data[$key]);
        }
    }

    public function testGetActivitiesByTypeRangeFailure()
    {
        $testData = [
            [
                'id' => rand(1, 100),
                'message' => 'test one',
                'type' => 'type one',
            ],
            [
                'id' => rand(101, 200),
                'message' => 'test two',
                'type' => 'type one',
            ],
            [
                'id' => rand(201, 300),
                'message' => 'test three',
                'type' => 'type one',
            ],
        ];

        array_walk($testData, [$this, 'insertData']);

        $repository = new MysqlActivityRepository(self::$connection);
        $data = $repository->getActivitiesByType('type two', 2, 1);

        $this->assertEmpty($data);
        $this->assertInternalType('array', $data);
    }

    public function testGetActivitiesByTypeCount()
    {
        $testData = [
            [
                'id' => rand(1, 100),
                'message' => 'test one',
                'type' => 'type one',
            ],
            [
                'id' => rand(101, 200),
                'message' => 'test two',
                'type' => 'type two',
            ],
            [
                'id' => rand(201, 300),
                'message' => 'test three',
                'type' => 'type one',
            ],
        ];

        array_walk($testData, [$this, 'insertData']);

        $repository = new MysqlActivityRepository(self::$connection);
        $data = $repository->getActivitiesByTypeCount('type one');

        $testData = array_filter($testData, function ($row) {
            return ($row['type'] == 'type one');
        });

        $this->assertNotFalse($data);
        $this->assertStringMatchesFormat('%d', $data);
        $this->assertEquals(count($testData), $data);
    }

    public function testGetActivitiesByTypeCountEmpty()

    {
        $testData = [
            [
                'id' => rand(1, 100),
                'message' => 'test one',
                'type' => 'type one',
            ],
            [
                'id' => rand(101, 200),
                'message' => 'test two',
                'type' => 'type one',
            ],
        ];

        array_walk($testData, [$this, 'insertData']);

        $repository = new MysqlActivityRepository(self::$connection);
        $data = $repository->getActivitiesByTypeCount('type two');

        $this->assertNotFalse($data);
        $this->assertStringMatchesFormat('%d', $data);
        $this->assertEquals('0', $data);
    }

    protected function tearDown()
    {
        self::$connection->getDefault()->perform("DELETE FROM `jpemeric_stream`.`activity`");
    }

    public static function tearDownAfterClass()
    {
        self::$connection->getDefault()->disconnect();

        unlink('jpemeric_stream.db');
    }

    protected function insertData(array $data)
    {
        $defaultData = [
            'id' => null,
            'message' => '',
            'message_long' => '',
            'datetime' => '',
            'metadata' => '',
            'type' => '',
            'type_id' => '',
        ];

        $data = array_merge($defaultData, $data);

        return self::$connection->getDefault()->perform("
            INSERT INTO `jpemeric_stream`.`activity`
                (id, message, message_long, datetime, metadata, type, type_id)
            VALUES
                (:id, :message, :message_long, :datetime, :metadata, :type, :type_id)",
            $data
        );
    }
}


1		<?php
2
3		namespace Jacobemerick\Web\Domain\Stream\Activity;
4
5		use Aura\Sql\ConnectionLocator;
6		use Aura\Sql\ExtendedPdo;
7		use PHPUnit_Framework_TestCase;
8
9		class MysqlActivityRepositoryTest extends PHPUnit_Framework_TestCase
10		{
11
12		protected static $connection;
13
14	View Code Duplication	public static function setUpBeforeClass()
		0 ignored issues – show Duplication introduced 2016-02-21 04:42 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
15		{
16		$extendedPdo = new ExtendedPdo('sqlite::memory:');
17		$extendedPdo->exec("ATTACH DATABASE `jpemeric_stream.db` AS `jpemeric_stream`");
18		$extendedPdo->exec("
19		CREATE TABLE IF NOT EXISTS `jpemeric_stream`.`activity` (
20		`id` integer PRIMARY KEY AUTOINCREMENT,
21		`message` text NOT NULL,
22		`message_long` text NOT NULL,
23		`datetime` datetime NOT NULL,
24		`metadata` text NOT NULL,
25		`type` varchar(10) NOT NULL,
26		`type_id` integer NOT NULL,
27		`created_at` datetime,
28		`updated_at` datetime
29		)"
30		);
31
32		self::$connection = new ConnectionLocator(function () use ($extendedPdo) {
33		return $extendedPdo;
34		});
35		}
36
37		public function testIsInstanceOfActivityRepository()
38		{
39		$repository = new MysqlActivityRepository(self::$connection);
40
41		$this->assertInstanceOf(
42		'Jacobemerick\Web\Domain\Stream\Activity\MysqlActivityRepository',
43		$repository
44		);
45		}
46
47		public function testImplementsActivityInterface()
48		{
49		$repository = new MysqlActivityRepository(self::$connection);
50
51		$this->assertInstanceOf(
52		'Jacobemerick\Web\Domain\Stream\Activity\ActivityRepositoryInterface',
53		$repository
54		);
55		}
56
57		public function testConstructSetsConnections()
58		{
59		$respository = new MysqlActivityRepository(self::$connection);
60
61		$this->assertAttributeSame(
62		self::$connection,
63		'connections',
64		$respository
65		);
66		}
67
68		public function testGetActivityById()
69		{
70		$testData = [
71		'id' => rand(1, 100),
72		'message' => 'test data',
73		];
74
75		$this->insertData($testData);
76
77		$repository = new MysqlActivityRepository(self::$connection);
78		$data = $repository->getActivityById($testData['id']);
79
80		$this->assertNotFalse($data);
81		$this->assertInternalType('array', $data);
82		$this->assertArraySubset($testData, $data);
83		}
84
85		public function testGetActivityByIdFailure()
86		{
87		$testData = [
88		'id' => rand(1, 100),
89		'message' => 'test data',
90		];
91
92		$this->insertData($testData);
93
94		$repository = new MysqlActivityRepository(self::$connection);
95		$data = $repository->getActivityById($testData['id'] + 1);
96
97		$this->assertFalse($data);
98		}
99
100		public function testGetActivities()
101		{
102		$testData = [
103		[
104		'id' => rand(1, 100),
105		'message' => 'test one',
106		],
107		[
108		'id' => rand(101, 200),
109		'message' => 'test two',
110		],
111		];
112
113		array_walk($testData, [$this, 'insertData']);
114
115		$repository = new MysqlActivityRepository(self::$connection);
116		$data = $repository->getActivities();
117
118		$this->assertNotFalse($data);
119		$this->assertInternalType('array', $data);
120		foreach ($testData as $key => $testRow) {
121		$this->assertInternalType('array', $testRow);
122		$this->assertArraySubset($testRow, $data[$key]);
123		}
124		}
125
126		public function testGetActivitiesFailure()
127		{
128		$repository = new MysqlActivityRepository(self::$connection);
129		$data = $repository->getActivities();
130
131		$this->assertEmpty($data);
132		$this->assertInternalType('array', $data);
133		}
134
135	View Code Duplication	public function testGetActivitiesRange()
		0 ignored issues – show Duplication introduced 2016-02-21 04:42 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
136		{
137		$testData = [
138		[
139		'id' => rand(1, 100),
140		'message' => 'test one',
141		],
142		[
143		'id' => rand(101, 200),
144		'message' => 'test two',
145		],
146		[
147		'id' => rand(201, 300),
148		'message' => 'test three',
149		],
150		];
151
152		array_walk($testData, [$this, 'insertData']);
153
154		$repository = new MysqlActivityRepository(self::$connection);
155		$data = $repository->getActivities(2, 1);
156
157		$this->assertNotFalse($data);
158		$this->assertInternalType('array', $data);
159		$this->assertCount(2, $data);
160
161		$testData = array_slice($testData, 1, 2);
162
163		foreach ($testData as $key => $testRow) {
164		$this->assertInternalType('array', $testRow);
165		$this->assertArraySubset($testRow, $data[$key]);
166		}
167		}
168
169	View Code Duplication	public function testGetActivitiesRangeFailure()
		0 ignored issues – show Duplication introduced 2016-02-21 04:42 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
170		{
171		$testData = [
172		[
173		'id' => rand(1, 100),
174		'message' => 'test one',
175		],
176		[
177		'id' => rand(101, 200),
178		'message' => 'test two',
179		],
180		];
181
182		array_walk($testData, [$this, 'insertData']);
183
184		$repository = new MysqlActivityRepository(self::$connection);
185		$data = $repository->getActivities(1, 3);
186
187		$this->assertEmpty($data);
188		$this->assertInternalType('array', $data);
189		}
190
191		public function testGetActivitiesCount()
192		{
193		$testData = [
194		[
195		'id' => rand(1, 100),
196		'message' => 'test one',
197		],
198		[
199		'id' => rand(101, 200),
200		'message' => 'test two',
201		],
202		];
203
204		array_walk($testData, [$this, 'insertData']);
205
206		$repository = new MysqlActivityRepository(self::$connection);
207		$data = $repository->getActivitiesCount();
208
209		$this->assertNotFalse($data);
210		$this->assertStringMatchesFormat('%d', $data);
211		$this->assertEquals(count($testData), $data);
212		}
213
214		public function testGetActivitiesCountEmpty()
215		{
216		$repository = new MysqlActivityRepository(self::$connection);
217		$data = $repository->getActivitiesCount();
218
219		$this->assertNotFalse($data);
220		$this->assertStringMatchesFormat('%d', $data);
221		$this->assertEquals('0', $data);
222		}
223
224		public function testGetActivitiesByType()
225		{
226		$testData = [
227		[
228		'id' => rand(1, 100),
229		'message' => 'test one',
230		'type' => 'type one',
231		],
232		[
233		'id' => rand(101, 200),
234		'message' => 'test two',
235		'type' => 'type two',
236		],
237		[
238		'id' => rand(201, 300),
239		'message' => 'test three',
240		'type' => 'type one',
241		],
242		];
243
244		array_walk($testData, [$this, 'insertData']);
245
246		$repository = new MysqlActivityRepository(self::$connection);
247		$data = $repository->getActivitiesByType('type one');
248
249		$this->assertNotFalse($data);
250		$this->assertInternalType('array', $data);
251
252		$testData = array_filter($testData, function ($row) {
253		return ($row['type'] == 'type one');
254		});
255		$testData = array_values($testData);
256
257		foreach ($testData as $key => $testRow) {
258		$this->assertInternalType('array', $testRow);
259		$this->assertArraySubset($testRow, $data[$key]);
260		}
261		}
262
263	View Code Duplication	public function testGetActivitiesByTypeFailure()
		0 ignored issues – show Duplication introduced 2016-02-21 04:42 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
264		{
265		$testData = [
266		[
267		'id' => rand(1, 100),
268		'message' => 'test one',
269		'type' => 'type one',
270		],
271		[
272		'id' => rand(101, 200),
273		'message' => 'test two',
274		'type' => 'type one',
275		],
276		];
277
278		array_walk($testData, [$this, 'insertData']);
279
280		$repository = new MysqlActivityRepository(self::$connection);
281		$data = $repository->getActivitiesByType('type two');
282
283		$this->assertEmpty($data);
284		$this->assertInternalType('array', $data);
285		}
286
287		public function testGetActivitiesByTypeRange()
288		{
289		$testData = [
290		[
291		'id' => rand(1, 100),
292		'message' => 'test one',
293		'type' => 'type one',
294		],
295		[
296		'id' => rand(101, 200),
297		'message' => 'test two',
298		'type' => 'type two',
299		],
300		[
301		'id' => rand(201, 300),
302		'message' => 'test three',
303		'type' => 'type one',
304		],
305		[
306		'id' => rand(301, 400),
307		'message' => 'test four',
308		'type' => 'type one',
309		],
310		];
311
312		array_walk($testData, [$this, 'insertData']);
313
314		$repository = new MysqlActivityRepository(self::$connection);
315		$data = $repository->getActivitiesByType('type one', 2, 1);
316
317		$this->assertNotFalse($data);
318		$this->assertInternalType('array', $data);
319		$this->assertCount(2, $data);
320
321		$testData = array_filter($testData, function ($row) {
322		return ($row['type'] == 'type one');
323		});
324		$testData = array_values($testData);
325		$testData = array_slice($testData, 1, 2);
326
327		foreach ($testData as $key => $testRow) {
328		$this->assertInternalType('array', $testRow);
329		$this->assertArraySubset($testRow, $data[$key]);
330		}
331		}
332
333		public function testGetActivitiesByTypeRangeFailure()
334		{
335		$testData = [
336		[
337		'id' => rand(1, 100),
338		'message' => 'test one',
339		'type' => 'type one',
340		],
341		[
342		'id' => rand(101, 200),
343		'message' => 'test two',
344		'type' => 'type one',
345		],
346		[
347		'id' => rand(201, 300),
348		'message' => 'test three',
349		'type' => 'type one',
350		],
351		];
352
353		array_walk($testData, [$this, 'insertData']);
354
355		$repository = new MysqlActivityRepository(self::$connection);
356		$data = $repository->getActivitiesByType('type two', 2, 1);
357
358		$this->assertEmpty($data);
359		$this->assertInternalType('array', $data);
360		}
361
362		public function testGetActivitiesByTypeCount()
363		{
364		$testData = [
365		[
366		'id' => rand(1, 100),
367		'message' => 'test one',
368		'type' => 'type one',
369		],
370		[
371		'id' => rand(101, 200),
372		'message' => 'test two',
373		'type' => 'type two',
374		],
375		[
376		'id' => rand(201, 300),
377		'message' => 'test three',
378		'type' => 'type one',
379		],
380		];
381
382		array_walk($testData, [$this, 'insertData']);
383
384		$repository = new MysqlActivityRepository(self::$connection);
385		$data = $repository->getActivitiesByTypeCount('type one');
386
387		$testData = array_filter($testData, function ($row) {
388		return ($row['type'] == 'type one');
389		});
390
391		$this->assertNotFalse($data);
392		$this->assertStringMatchesFormat('%d', $data);
393		$this->assertEquals(count($testData), $data);
394		}
395
396	View Code Duplication	public function testGetActivitiesByTypeCountEmpty()
		0 ignored issues – show Duplication introduced 2016-02-21 04:42 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
397		{
398		$testData = [
399		[
400		'id' => rand(1, 100),
401		'message' => 'test one',
402		'type' => 'type one',
403		],
404		[
405		'id' => rand(101, 200),
406		'message' => 'test two',
407		'type' => 'type one',
408		],
409		];
410
411		array_walk($testData, [$this, 'insertData']);
412
413		$repository = new MysqlActivityRepository(self::$connection);
414		$data = $repository->getActivitiesByTypeCount('type two');
415
416		$this->assertNotFalse($data);
417		$this->assertStringMatchesFormat('%d', $data);
418		$this->assertEquals('0', $data);
419		}
420
421		protected function tearDown()
422		{
423		self::$connection->getDefault()->perform("DELETE FROM `jpemeric_stream`.`activity`");
424		}
425
426		public static function tearDownAfterClass()
427		{
428		self::$connection->getDefault()->disconnect();
		0 ignored issues – show Bug introduced 2016-02-20 23:05 UTC by Report Bug Copy Issue Report The method `disconnect()` does not exist on `Aura\Sql\ExtendedPdoInterface`. Did you maybe mean `connect()`? This check marks calls to methods that do not seem to exist on an object. This is most likely the result of a method being renamed without all references to it being renamed likewise. Loading history...
429		unlink('jpemeric_stream.db');
430		}
431
432		protected function insertData(array $data)
433		{
434		$defaultData = [
435		'id' => null,
436		'message' => '',
437		'message_long' => '',
438		'datetime' => '',
439		'metadata' => '',
440		'type' => '',
441		'type_id' => '',
442		];
443
444		$data = array_merge($defaultData, $data);
445
446		return self::$connection->getDefault()->perform("
447		INSERT INTO `jpemeric_stream`.`activity`
448		(id, message, message_long, datetime, metadata, type, type_id)
449		VALUES
450		(:id, :message, :message_long, :datetime, :metadata, :type, :type_id)",
451		$data
452		);
453		}
454		}
455

jacobemerick / web

Push — master ( 4c6be8...89e88a )

MysqlActivityRepositoryTest::tearDownAfterClass() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like