class DiffOpOutputBuilderTest

class DiffOpOutputBuilderTest extends TestCase {
    
    /**
     * @return array
     *   - Expected output in terms of return class. A list of class names
     *     expected to be returned by DiffEngine::diff().
     *   - An array of strings to change from.
     *   - An array of strings to change to.
     */
    public static function provideTestDiff() : array {
        return [
            'empty' => [
                [],
                [],
                [],
            ],
            'add' => [
                [
                    new DiffOpAdd([
                        'a',
                    ]),
                ],
                [],
                [
                    'a',
                ],
            ],
            'copy' => [
                [
                    new DiffOpCopy([
                        'a',
                    ]),
                ],
                [
                    'a',
                ],
                [
                    'a',
                ],
            ],
            'change' => [
                [
                    new DiffOpChange([
                        'a',
                    ], [
                        'b',
                    ]),
                ],
                [
                    'a',
                ],
                [
                    'b',
                ],
            ],
            'copy-and-change' => [
                [
                    new DiffOpCopy([
                        'a',
                    ]),
                    new DiffOpChange([
                        'b',
                    ], [
                        'c',
                    ]),
                ],
                [
                    'a',
                    'b',
                ],
                [
                    'a',
                    'c',
                ],
            ],
            'copy-change-copy' => [
                [
                    new DiffOpCopy([
                        'a',
                    ]),
                    new DiffOpChange([
                        'b',
                    ], [
                        'c',
                    ]),
                    new DiffOpCopy([
                        'd',
                    ]),
                ],
                [
                    'a',
                    'b',
                    'd',
                ],
                [
                    'a',
                    'c',
                    'd',
                ],
            ],
            'copy-change-copy-add' => [
                [
                    new DiffOpCopy([
                        'a',
                    ]),
                    new DiffOpChange([
                        'b',
                    ], [
                        'c',
                    ]),
                    new DiffOpCopy([
                        'd',
                    ]),
                    new DiffOpAdd([
                        'e',
                    ]),
                ],
                [
                    'a',
                    'b',
                    'd',
                ],
                [
                    'a',
                    'c',
                    'd',
                    'e',
                ],
            ],
            'copy-delete' => [
                [
                    new DiffOpCopy([
                        'a',
                    ]),
                    new DiffOpDelete([
                        'b',
                        'd',
                    ]),
                ],
                [
                    'a',
                    'b',
                    'd',
                ],
                [
                    'a',
                ],
            ],
            'change-copy' => [
                [
                    new DiffOpChange([
                        'aa',
                        'bb',
                        'cc',
                    ], [
                        'a',
                        'c',
                    ]),
                    new DiffOpCopy([
                        'd',
                    ]),
                ],
                [
                    'aa',
                    'bb',
                    'cc',
                    'd',
                ],
                [
                    'a',
                    'c',
                    'd',
                ],
            ],
            'copy-change-copy-change' => [
                [
                    new DiffOpCopy([
                        'a',
                    ]),
                    new DiffOpChange([
                        'bb',
                    ], [
                        'b',
                        'c',
                    ]),
                    new DiffOpCopy([
                        'd',
                    ]),
                    new DiffOpChange([
                        'ee',
                    ], [
                        'e',
                    ]),
                ],
                [
                    'a',
                    'bb',
                    'd',
                    'ee',
                ],
                [
                    'a',
                    'b',
                    'c',
                    'd',
                    'e',
                ],
            ],
        ];
    }
    
    /**
     * Tests whether op classes returned match expectations.
     *
     * @covers ::toOpsArray
     * @dataProvider provideTestDiff
     */
    public function testToOpsArray(array $expected, array $from, array $to) : void {
        $diffOpBuilder = new DiffOpOutputBuilder();
        $differ = new Differ($diffOpBuilder);
        $diff = $differ->diffToArray($from, $to);
        $this->assertEquals($expected, $diffOpBuilder->toOpsArray($diff));
    }
    
    /**
     * @covers ::getDiff
     * @dataProvider provideTestDiff
     */
    public function testGetDiff(array $expected, array $from, array $to) : void {
        $differ = new Differ(new DiffOpOutputBuilder());
        $diff = $differ->diff($from, $to);
        $this->assertEquals($expected, unserialize($diff));
    }
    
    /**
     * Tests that two files can be successfully diffed.
     *
     * @covers ::toOpsArray
     */
    public function testDiffInfiniteLoop() : void {
        $from = explode("\n", file_get_contents(__DIR__ . '/Engine/fixtures/file1.txt'));
        $to = explode("\n", file_get_contents(__DIR__ . '/Engine/fixtures/file2.txt'));
        $diffOpBuilder = new DiffOpOutputBuilder();
        $differ = new Differ($diffOpBuilder);
        $diff = $differ->diffToArray($from, $to);
        $diffOps = $diffOpBuilder->toOpsArray($diff);
        $this->assertCount(4, $diffOps);
        $this->assertEquals($diffOps[0], new DiffOpAdd([
            '    - image.style.max_325x325',
        ]));
        $this->assertEquals($diffOps[1], new DiffOpCopy([
            '    - image.style.max_650x650',
        ]));
        $this->assertEquals($diffOps[2], new DiffOpChange([
            '    - image.style.max_325x325',
        ], [
            '_core:',
            '  default_config_hash: random_hash_string_here',
        ]));
        $this->assertEquals($diffOps[3], new DiffOpCopy([
            'fallback_image_style: max_325x325',
            '',
        ]));
    }

}