RecursiveArrayMergerTest::testDefaultFunctionality() - Code Metrics - graze/array-merger - Measure and Improve Code Quality continuously with Scrutinizer

testDefaultFunctionality() A
last analyzed 2018-09-13 12:33 UTC

↳ Parent: RecursiveArrayMergerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	16
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	9
dl	0
loc	16
rs	9.9666
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

namespace Graze\ArrayMerger\Test\Unit;

use Graze\ArrayMerger\RecursiveArrayMerger;
use Graze\ArrayMerger\Test\TestCase;
use Graze\ArrayMerger\ValueMerger\FirstNonNullValue;
use Graze\ArrayMerger\ValueMerger\FirstValue;
use Graze\ArrayMerger\ValueMerger\LastNonNullValue;
use Graze\ArrayMerger\ValueMerger\LastValue;

class RecursiveArrayMergerTest extends TestCase
{
    public function testSingleArrayReturnsTheArray()
    {
        $merger = new RecursiveArrayMerger();

        $this->assertEquals(
            ['a' => 1, 'b' => 2],
            $merger->merge(['a' => 1, 'b' => 2])
        );
    }

    public function testDefaultFunctionality()
    {
        $a = ['first' => 1, 'second' => 2];
        $b = ['first' => 'a', 'second' => 'b'];

        $merger = new RecursiveArrayMerger();

        $this->assertEquals(
            ['first' => 'a', 'second' => 'b'],
            $merger->merge($a, $b),
            "Expected second result from merge"
        );

        $c = ['first' => 'c'];

        $this->assertEquals(['first' => 'c', 'second' => 2], $merger->merge($a, $c), "Expected Merge of 'a' and 'c'");
    }

    public function testNullsAreValuesWhenSecond()
    {
        $a = ['first' => 1, 'second' => 2];
        $b = ['first' => 'a', 'second' => null];

        $merger = new RecursiveArrayMerger();

        $this->assertEquals(
            ['first' => 'a', 'second' => null],
            $merger->merge($a, $b),
            "Expected second result from merge"
        );
    }

    public function testNullsAreValuesWhenFirst()
    {
        $a = ['first' => null, 'second' => 2];
        $b = ['first' => 'a', 'second' => null];

        $merger = new RecursiveArrayMerger(new FirstValue());

        $this->assertEquals(
            ['first' => null, 'second' => 2],
            $merger->merge($a, $b),
            "Expected first result from merge"
        );
    }

    public function testSequentialTopLevelArraysAreAppended()
    {
        $a = ['first', 'second'];
        $b = ['third', 'fourth'];

        $merger = new RecursiveArrayMerger(new FirstValue());

        $this->assertEquals(
            ['first', 'second', 'third', 'fourth'],
            $merger->merge($a, $b),
            "Expected appended array"
        );
        $merger = new RecursiveArrayMerger(new FirstValue(), RecursiveArrayMerger::FLAG_MERGE_VALUE_ARRAY);

        $this->assertEquals(
            ['first', 'second'],
            $merger->merge($a, $b),
            "Expected merged array"
        );
    }

    public function testSequentialChildArraysAreAppended()
    {
        $a = ['first' => ['child' => ['a', 'c', 'd']], 'second' => 2];
        $b = ['first' => ['child' => ['b', 'e']], 'second' => null];

        $merger = new RecursiveArrayMerger(new LastValue());

        $this->assertEquals(
            ['first' => ['child' => ['a', 'c', 'd', 'b', 'e']], 'second' => null],
            $merger->merge($a, $b),
            "Expected appended child array"
        );

        $merger = new RecursiveArrayMerger(new LastValue(), RecursiveArrayMerger::FLAG_MERGE_VALUE_ARRAY);

        $this->assertEquals(
            ['first' => ['child' => ['b', 'e', 'd']], 'second' => null],
            $merger->merge($a, $b),
            "Expected merged child array"
        );
    }

    public function testSequentialTopLevelArraysCanBeUnique()
    {
        $a = ['first', 'second'];
        $b = ['second', 'third'];

        $merger = new RecursiveArrayMerger(new LastValue());

        $this->assertEquals(
            ['first', 'second', 'second', 'third'],
            $merger->merge($a, $b),
            "Expected duplicated array"
        );

        $merger = new RecursiveArrayMerger(new LastValue(), RecursiveArrayMerger::FLAG_UNIQUE_VALUE_ARRAY);

        $this->assertEquals(
            ['first', 'second', 'third'],
            $merger->merge($a, $b),
            "Expected unique array"
        );
    }

    public function testSequentialChildArraysCanBeUnique()
    {
        $a = ['first' => ['child' => ['a', 'c', 'd']], 'second' => 2];
        $b = ['first' => ['child' => ['d', 'e']], 'second' => null];

        $merger = new RecursiveArrayMerger(new FirstValue());

        $this->assertEquals(
            ['first' => ['child' => ['a', 'c', 'd', 'd', 'e']], 'second' => 2],
            $merger->merge($a, $b),
            "Expected merged child array"
        );

        $merger = new RecursiveArrayMerger(new FirstValue(), RecursiveArrayMerger::FLAG_UNIQUE_VALUE_ARRAY);

        $this->assertEquals(
            ['first' => ['child' => ['a', 'c', 'd', 'e']], 'second' => 2],
            $merger->merge($a, $b),
            "Expected appended child array"
        );
    }

    public function testRecursiveFunctionality()
    {
        $a = ['first' => 1, 'second' => ['a' => 2, 'b' => 3]];
        $b = ['first' => 'b', 'second' => ['a' => 'cake']];

        $merger = new RecursiveArrayMerger();

        $this->assertEquals(['first' => 'b', 'second' => ['a' => 'cake', 'b' => 3]], $merger->merge($a, $b));

        $c = ['third' => ['stuff' => 'beep']];

        $this->assertEquals(
            ['first' => 1, 'second' => ['a' => 2, 'b' => 3], 'third' => ['stuff' => 'beep']],
            $merger->merge($a, $c)
        );
    }

    public function testInjectingDifferentValueMerger()
    {
        $merger = new RecursiveArrayMerger(new FirstNonNullValue());

        $a = ['first' => 1, 'second' => null];
        $b = ['first' => 2, 'second' => 'pants'];

        $this->assertEquals(['first' => 1, 'second' => 'pants'], $merger->merge($a, $b));
    }

    public function testMergingMoreThanTwoArrays()
    {
        $merger = new RecursiveArrayMerger(new LastNonNullValue());

        $a = ['first' => 1, 'second' => ['a' => 2, 'b' => 3]];
        $b = ['first' => 'b', 'second' => ['a' => 'cake']];
        $c = ['first' => null, 'second' => ['a' => null, 'c ' => null]];

        $this->assertEquals(
            ['first' => 'b', 'second' => ['a' => 'cake', 'b' => 3, 'c ' => null]],
            $merger->merge($a, $b, $c)
        );
    }

    public function testCallable()
    {
        $merger = new RecursiveArrayMerger('max');

        $a = ['first' => 1, 'second' => 5];
        $b = ['first' => 2, 'second' => 2];

        $this->assertEquals(['first' => 2, 'second' => 5], $merger->merge($a, $b));
    }

    public function testStaticCalling()
    {
        $a = ['first' => 1, 'second' => 2];
        $b = ['first' => 'a', 'second' => 'b'];

        $this->assertEquals(
            ['first' => 'a', 'second' => 'b'],
            RecursiveArrayMerger::mergeUsing(new LastValue(), $a, $b),
            "Expected second result from merge"
        );
    }

    public function testStaticFirstNonNull()
    {
        $a = ['first' => 1, 'second' => null];
        $b = ['first' => null, 'second' => 'b'];

        $this->assertEquals(
            ['first' => 1, 'second' => 'b'],
            RecursiveArrayMerger::firstNonNull($a, $b),
            "Expected first non null result from merge"
        );
    }

    public function testStaticFirst()
    {
        $a = ['first' => 1, 'second' => null];
        $b = ['first' => null, 'second' => 'b'];

        $this->assertEquals(
            ['first' => 1, 'second' => null],
            RecursiveArrayMerger::first($a, $b),
            "Expected first result from merge"
        );
    }

    public function testStaticLastNonNull()
    {
        $a = ['first' => 1, 'second' => null];
        $b = ['first' => null, 'second' => 'b'];

        $this->assertEquals(
            ['first' => 1, 'second' => 'b'],
            RecursiveArrayMerger::lastNonNull($a, $b),
            "Expected last non null result from merge"
        );
    }

    public function testStaticLast()
    {
        $a = ['first' => 1, 'second' => null];
        $b = ['first' => null, 'second' => 'b'];

        $this->assertEquals(
            ['first' => null, 'second' => 'b'],
            RecursiveArrayMerger::last($a, $b),
            "Expected second result from merge"
        );
    }

    public function testStaticProduct()
    {
        $a = ['first' => 1, 'second' => null];
        $b = ['first' => 2, 'second' => 'b'];

        $this->assertEquals(
            ['first' => 2, 'second' => 'b'],
            RecursiveArrayMerger::product($a, $b),
            "Expected product result from merge"
        );
    }

    public function testStaticSum()
    {
        $a = ['first' => 1, 'second' => null];
        $b = ['first' => 2, 'second' => 'b'];

        $this->assertEquals(
            ['first' => 3, 'second' => 'b'],
            RecursiveArrayMerger::sum($a, $b),
            "Expected summed result from merge"
        );
    }

    public function testStaticBoth()
    {
        $a = ['first' => 1, 'second' => null];
        $b = ['first' => null, 'second' => 'b'];

        $this->assertEquals(
            ['first' => [1, null], 'second' => [null, 'b']],
            RecursiveArrayMerger::both($a, $b),
            "Expected both results from merge"
        );
    }

    public function testStaticRandom()
    {
        $a = ['first' => 1, 'second' => null];
        $b = ['first' => null, 'second' => 'b'];

        $this->assertArrayHasKey(
            'first',
            RecursiveArrayMerger::random($a, $b),
            "Expected a random result from merge"
        );
    }
}


1			<?php
2
3			namespace Graze\ArrayMerger\Test\Unit;
4
5			use Graze\ArrayMerger\RecursiveArrayMerger;
6			use Graze\ArrayMerger\Test\TestCase;
7			use Graze\ArrayMerger\ValueMerger\FirstNonNullValue;
8			use Graze\ArrayMerger\ValueMerger\FirstValue;
9			use Graze\ArrayMerger\ValueMerger\LastNonNullValue;
10			use Graze\ArrayMerger\ValueMerger\LastValue;
11
12			class RecursiveArrayMergerTest extends TestCase
13			{
14			public function testSingleArrayReturnsTheArray()
15			{
16			$merger = new RecursiveArrayMerger();
17
18			$this->assertEquals(
19			['a' => 1, 'b' => 2],
20			$merger->merge(['a' => 1, 'b' => 2])
21			);
22			}
23
24			public function testDefaultFunctionality()
25			{
26			$a = ['first' => 1, 'second' => 2];
27			$b = ['first' => 'a', 'second' => 'b'];
28
29			$merger = new RecursiveArrayMerger();
30
31			$this->assertEquals(
32			['first' => 'a', 'second' => 'b'],
33			$merger->merge($a, $b),
34			"Expected second result from merge"
35			);
36
37			$c = ['first' => 'c'];
38
39			$this->assertEquals(['first' => 'c', 'second' => 2], $merger->merge($a, $c), "Expected Merge of 'a' and 'c'");
40			}
41
42			public function testNullsAreValuesWhenSecond()
43			{
44			$a = ['first' => 1, 'second' => 2];
45			$b = ['first' => 'a', 'second' => null];
46
47			$merger = new RecursiveArrayMerger();
48
49			$this->assertEquals(
50			['first' => 'a', 'second' => null],
51			$merger->merge($a, $b),
52			"Expected second result from merge"
53			);
54			}
55
56			public function testNullsAreValuesWhenFirst()
57			{
58			$a = ['first' => null, 'second' => 2];
59			$b = ['first' => 'a', 'second' => null];
60
61			$merger = new RecursiveArrayMerger(new FirstValue());
62
63			$this->assertEquals(
64			['first' => null, 'second' => 2],
65			$merger->merge($a, $b),
66			"Expected first result from merge"
67			);
68			}
69
70			public function testSequentialTopLevelArraysAreAppended()
71			{
72			$a = ['first', 'second'];
73			$b = ['third', 'fourth'];
74
75			$merger = new RecursiveArrayMerger(new FirstValue());
76
77			$this->assertEquals(
78			['first', 'second', 'third', 'fourth'],
79			$merger->merge($a, $b),
80			"Expected appended array"
81			);
82			$merger = new RecursiveArrayMerger(new FirstValue(), RecursiveArrayMerger::FLAG_MERGE_VALUE_ARRAY);
83
84			$this->assertEquals(
85			['first', 'second'],
86			$merger->merge($a, $b),
87			"Expected merged array"
88			);
89			}
90
91			public function testSequentialChildArraysAreAppended()
92			{
93			$a = ['first' => ['child' => ['a', 'c', 'd']], 'second' => 2];
94			$b = ['first' => ['child' => ['b', 'e']], 'second' => null];
95
96			$merger = new RecursiveArrayMerger(new LastValue());
97
98			$this->assertEquals(
99			['first' => ['child' => ['a', 'c', 'd', 'b', 'e']], 'second' => null],
100			$merger->merge($a, $b),
101			"Expected appended child array"
102			);
103
104			$merger = new RecursiveArrayMerger(new LastValue(), RecursiveArrayMerger::FLAG_MERGE_VALUE_ARRAY);
105
106			$this->assertEquals(
107			['first' => ['child' => ['b', 'e', 'd']], 'second' => null],
108			$merger->merge($a, $b),
109			"Expected merged child array"
110			);
111			}
112
113			public function testSequentialTopLevelArraysCanBeUnique()
114			{
115			$a = ['first', 'second'];
116			$b = ['second', 'third'];
117
118			$merger = new RecursiveArrayMerger(new LastValue());
119
120			$this->assertEquals(
121			['first', 'second', 'second', 'third'],
122			$merger->merge($a, $b),
123			"Expected duplicated array"
124			);
125
126			$merger = new RecursiveArrayMerger(new LastValue(), RecursiveArrayMerger::FLAG_UNIQUE_VALUE_ARRAY);
127
128			$this->assertEquals(
129			['first', 'second', 'third'],
130			$merger->merge($a, $b),
131			"Expected unique array"
132			);
133			}
134
135			public function testSequentialChildArraysCanBeUnique()
136			{
137			$a = ['first' => ['child' => ['a', 'c', 'd']], 'second' => 2];
138			$b = ['first' => ['child' => ['d', 'e']], 'second' => null];
139
140			$merger = new RecursiveArrayMerger(new FirstValue());
141
142			$this->assertEquals(
143			['first' => ['child' => ['a', 'c', 'd', 'd', 'e']], 'second' => 2],
144			$merger->merge($a, $b),
145			"Expected merged child array"
146			);
147
148			$merger = new RecursiveArrayMerger(new FirstValue(), RecursiveArrayMerger::FLAG_UNIQUE_VALUE_ARRAY);
149
150			$this->assertEquals(
151			['first' => ['child' => ['a', 'c', 'd', 'e']], 'second' => 2],
152			$merger->merge($a, $b),
153			"Expected appended child array"
154			);
155			}
156
157			public function testRecursiveFunctionality()
158			{
159			$a = ['first' => 1, 'second' => ['a' => 2, 'b' => 3]];
160			$b = ['first' => 'b', 'second' => ['a' => 'cake']];
161
162			$merger = new RecursiveArrayMerger();
163
164			$this->assertEquals(['first' => 'b', 'second' => ['a' => 'cake', 'b' => 3]], $merger->merge($a, $b));
165
166			$c = ['third' => ['stuff' => 'beep']];
167
168			$this->assertEquals(
169			['first' => 1, 'second' => ['a' => 2, 'b' => 3], 'third' => ['stuff' => 'beep']],
170			$merger->merge($a, $c)
171			);
172			}
173
174			public function testInjectingDifferentValueMerger()
175			{
176			$merger = new RecursiveArrayMerger(new FirstNonNullValue());
177
178			$a = ['first' => 1, 'second' => null];
179			$b = ['first' => 2, 'second' => 'pants'];
180
181			$this->assertEquals(['first' => 1, 'second' => 'pants'], $merger->merge($a, $b));
182			}
183
184			public function testMergingMoreThanTwoArrays()
185			{
186			$merger = new RecursiveArrayMerger(new LastNonNullValue());
187
188			$a = ['first' => 1, 'second' => ['a' => 2, 'b' => 3]];
189			$b = ['first' => 'b', 'second' => ['a' => 'cake']];
190			$c = ['first' => null, 'second' => ['a' => null, 'c ' => null]];
191
192			$this->assertEquals(
193			['first' => 'b', 'second' => ['a' => 'cake', 'b' => 3, 'c ' => null]],
194			$merger->merge($a, $b, $c)
195			);
196			}
197
198			public function testCallable()
199			{
200			$merger = new RecursiveArrayMerger('max');
201
202			$a = ['first' => 1, 'second' => 5];
203			$b = ['first' => 2, 'second' => 2];
204
205			$this->assertEquals(['first' => 2, 'second' => 5], $merger->merge($a, $b));
206			}
207
208			public function testStaticCalling()
209			{
210			$a = ['first' => 1, 'second' => 2];
211			$b = ['first' => 'a', 'second' => 'b'];
212
213			$this->assertEquals(
214			['first' => 'a', 'second' => 'b'],
215			RecursiveArrayMerger::mergeUsing(new LastValue(), $a, $b),
216			"Expected second result from merge"
217			);
218			}
219
220			public function testStaticFirstNonNull()
221			{
222			$a = ['first' => 1, 'second' => null];
223			$b = ['first' => null, 'second' => 'b'];
224
225			$this->assertEquals(
226			['first' => 1, 'second' => 'b'],
227			RecursiveArrayMerger::firstNonNull($a, $b),
228			"Expected first non null result from merge"
229			);
230			}
231
232			public function testStaticFirst()
233			{
234			$a = ['first' => 1, 'second' => null];
235			$b = ['first' => null, 'second' => 'b'];
236
237			$this->assertEquals(
238			['first' => 1, 'second' => null],
239			RecursiveArrayMerger::first($a, $b),
240			"Expected first result from merge"
241			);
242			}
243
244			public function testStaticLastNonNull()
245			{
246			$a = ['first' => 1, 'second' => null];
247			$b = ['first' => null, 'second' => 'b'];
248
249			$this->assertEquals(
250			['first' => 1, 'second' => 'b'],
251			RecursiveArrayMerger::lastNonNull($a, $b),
252			"Expected last non null result from merge"
253			);
254			}
255
256			public function testStaticLast()
257			{
258			$a = ['first' => 1, 'second' => null];
259			$b = ['first' => null, 'second' => 'b'];
260
261			$this->assertEquals(
262			['first' => null, 'second' => 'b'],
263			RecursiveArrayMerger::last($a, $b),
264			"Expected second result from merge"
265			);
266			}
267
268			public function testStaticProduct()
269			{
270			$a = ['first' => 1, 'second' => null];
271			$b = ['first' => 2, 'second' => 'b'];
272
273			$this->assertEquals(
274			['first' => 2, 'second' => 'b'],
275			RecursiveArrayMerger::product($a, $b),
276			"Expected product result from merge"
277			);
278			}
279
280			public function testStaticSum()
281			{
282			$a = ['first' => 1, 'second' => null];
283			$b = ['first' => 2, 'second' => 'b'];
284
285			$this->assertEquals(
286			['first' => 3, 'second' => 'b'],
287			RecursiveArrayMerger::sum($a, $b),
288			"Expected summed result from merge"
289			);
290			}
291
292			public function testStaticBoth()
293			{
294			$a = ['first' => 1, 'second' => null];
295			$b = ['first' => null, 'second' => 'b'];
296
297			$this->assertEquals(
298			['first' => [1, null], 'second' => [null, 'b']],
299			RecursiveArrayMerger::both($a, $b),
300			"Expected both results from merge"
301			);
302			}
303
304			public function testStaticRandom()
305			{
306			$a = ['first' => 1, 'second' => null];
307			$b = ['first' => null, 'second' => 'b'];
308
309			$this->assertArrayHasKey(
310			'first',
311			RecursiveArrayMerger::random($a, $b),
312			"Expected a random result from merge"
313			);
314			}
315			}
316

graze / array-merger

testDefaultFunctionality() A last analyzed 2018-09-13 12:33 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

testDefaultFunctionality() A
last analyzed 2018-09-13 12:33 UTC