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

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

↳ Parent: ArrayMergerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	18
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	12
nc	1
nop	0
dl	0
loc	18
rs	9.8666
c	0
b	0
f	0

<?php

namespace Graze\ArrayMerger\Test\Unit;

use Graze\ArrayMerger\ArrayMerger;
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 ArrayMergerTest extends TestCase
{
    public function testSingleArrayReturnsTheArray()
    {
        $merger = new ArrayMerger();

        $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 ArrayMerger();

        $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 ArrayMerger();

        $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 ArrayMerger(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 ArrayMerger(new FirstValue());

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

        $this->assertEquals(
            ['first', 'second'],
            $merger->merge($a, $b),
            "Expected a non appended array when the flag is not set"
        );
    }

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

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

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

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

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

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

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

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

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

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

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

        $merger = new ArrayMerger();

        $this->assertEquals(['first' => 'b', 'second' => ['a' => 'cake']], $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 ArrayMerger(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 ArrayMerger(new LastNonNullValue());

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

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

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

        $this->assertEquals(
            ['first' => 'a', 'second' => 'b'],
            ArrayMerger::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'],
            ArrayMerger::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],
            ArrayMerger::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'],
            ArrayMerger::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'],
            ArrayMerger::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'],
            ArrayMerger::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'],
            ArrayMerger::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']],
            ArrayMerger::both($a, $b),
            "Expected both results from merge"
        );
    }

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

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


1			<?php
2
3			namespace Graze\ArrayMerger\Test\Unit;
4
5			use Graze\ArrayMerger\ArrayMerger;
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 ArrayMergerTest extends TestCase
13			{
14			public function testSingleArrayReturnsTheArray()
15			{
16			$merger = new ArrayMerger();
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 ArrayMerger();
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 ArrayMerger();
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 ArrayMerger(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 ArrayMerger(new FirstValue());
76
77			$this->assertEquals(
78			['first', 'second', 'third', 'fourth'],
79			$merger->merge($a, $b),
80			"Expected appended array"
81			);
82			$merger = new ArrayMerger(new FirstValue(), ArrayMerger::FLAG_MERGE_VALUE_ARRAY);
83
84			$this->assertEquals(
85			['first', 'second'],
86			$merger->merge($a, $b),
87			"Expected a non appended array when the flag is not set"
88			);
89			}
90
91			public function testSequentialChildArraysAreNotAppendedBecauseThisIsNotRecursive()
92			{
93			$a = ['first' => ['a', 'c', 'd'], 'second' => 2];
94			$b = ['first' => ['b', 'e'], 'second' => null];
95
96			$merger = new ArrayMerger(new LastValue());
97
98			$this->assertEquals(
99			['first' => ['b', 'e'], 'second' => null],
100			$merger->merge($a, $b),
101			"Expected appended child array"
102			);
103
104			$merger = new ArrayMerger(new LastValue(), ArrayMerger::FLAG_MERGE_VALUE_ARRAY);
105
106			$this->assertEquals(
107			['first' => ['b', 'e'], '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 ArrayMerger(new FirstValue());
119
120			$this->assertEquals(
121			['first', 'second', 'second', 'third'],
122			$merger->merge($a, $b),
123			"Expected duplicated second value"
124			);
125
126			$merger = new ArrayMerger(new FirstValue(), ArrayMerger::FLAG_UNIQUE_VALUE_ARRAY);
127
128			$this->assertEquals(
129			['first', 'second', 'third'],
130			$merger->merge($a, $b),
131			"Expected unique output"
132			);
133			}
134
135			public function testNonRecursiveFunctionality()
136			{
137			$a = ['first' => 1, 'second' => ['a' => 2, 'b' => 3]];
138			$b = ['first' => 'b', 'second' => ['a' => 'cake']];
139
140			$merger = new ArrayMerger();
141
142			$this->assertEquals(['first' => 'b', 'second' => ['a' => 'cake']], $merger->merge($a, $b));
143
144			$c = ['third' => ['stuff' => 'beep']];
145
146			$this->assertEquals(
147			['first' => 1, 'second' => ['a' => 2, 'b' => 3], 'third' => ['stuff' => 'beep']],
148			$merger->merge($a, $c)
149			);
150			}
151
152			public function testInjectingDifferentValueMerger()
153			{
154			$merger = new ArrayMerger(new FirstNonNullValue());
155
156			$a = ['first' => 1, 'second' => null];
157			$b = ['first' => 2, 'second' => 'pants'];
158
159			$this->assertEquals(['first' => 1, 'second' => 'pants'], $merger->merge($a, $b));
160			}
161
162			public function testMergingMoreThanTwoArrays()
163			{
164			$merger = new ArrayMerger(new LastNonNullValue());
165
166			$a = ['first' => 1, 'second' => null];
167			$b = ['first' => 2, 'second' => 'pants'];
168			$c = ['first' => null, 'second' => null, 'third' => 3];
169
170			$this->assertEquals(
171			['first' => 2, 'second' => 'pants', 'third' => 3],
172			$merger->merge($a, $b, $c)
173			);
174			}
175
176			public function testStaticCalling()
177			{
178			$a = ['first' => 1, 'second' => 2];
179			$b = ['first' => 'a', 'second' => 'b'];
180
181			$this->assertEquals(
182			['first' => 'a', 'second' => 'b'],
183			ArrayMerger::mergeUsing(new LastValue(), $a, $b),
184			"Expected second result from merge"
185			);
186			}
187
188			public function testStaticFirstNonNull()
189			{
190			$a = ['first' => 1, 'second' => null];
191			$b = ['first' => null, 'second' => 'b'];
192
193			$this->assertEquals(
194			['first' => 1, 'second' => 'b'],
195			ArrayMerger::firstNonNull($a, $b),
196			"Expected first non null result from merge"
197			);
198			}
199
200			public function testStaticFirst()
201			{
202			$a = ['first' => 1, 'second' => null];
203			$b = ['first' => null, 'second' => 'b'];
204
205			$this->assertEquals(
206			['first' => 1, 'second' => null],
207			ArrayMerger::first($a, $b),
208			"Expected first result from merge"
209			);
210			}
211
212			public function testStaticLastNonNull()
213			{
214			$a = ['first' => 1, 'second' => null];
215			$b = ['first' => null, 'second' => 'b'];
216
217			$this->assertEquals(
218			['first' => 1, 'second' => 'b'],
219			ArrayMerger::lastNonNull($a, $b),
220			"Expected last non null result from merge"
221			);
222			}
223
224			public function testStaticLast()
225			{
226			$a = ['first' => 1, 'second' => null];
227			$b = ['first' => null, 'second' => 'b'];
228
229			$this->assertEquals(
230			['first' => null, 'second' => 'b'],
231			ArrayMerger::last($a, $b),
232			"Expected second result from merge"
233			);
234			}
235
236			public function testStaticProduct()
237			{
238			$a = ['first' => 1, 'second' => null];
239			$b = ['first' => 2, 'second' => 'b'];
240
241			$this->assertEquals(
242			['first' => 2, 'second' => 'b'],
243			ArrayMerger::product($a, $b),
244			"Expected product result from merge"
245			);
246			}
247
248			public function testStaticSum()
249			{
250			$a = ['first' => 1, 'second' => null];
251			$b = ['first' => 2, 'second' => 'b'];
252
253			$this->assertEquals(
254			['first' => 3, 'second' => 'b'],
255			ArrayMerger::sum($a, $b),
256			"Expected summed result from merge"
257			);
258			}
259
260			public function testStaticBoth()
261			{
262			$a = ['first' => 1, 'second' => null];
263			$b = ['first' => null, 'second' => 'b'];
264
265			$this->assertEquals(
266			['first' => [1, null], 'second' => [null, 'b']],
267			ArrayMerger::both($a, $b),
268			"Expected both results from merge"
269			);
270			}
271
272			public function testStaticRandom()
273			{
274			$a = ['first' => 1, 'second' => null];
275			$b = ['first' => null, 'second' => 'b'];
276
277			$this->assertArrayHasKey(
278			'first',
279			ArrayMerger::random($a, $b),
280			"Expected a random result from merge"
281			);
282			}
283			}
284

graze / array-merger

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

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

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