<?php
/**
* Copyright © Magento, Inc. All rights reserved.
* See COPYING.txt for license details.
*/
declare(strict_types=1);

namespace Magento\Framework\RequireJs\Test\Unit;

use Magento\Framework\Code\Minifier\AdapterInterface;
use Magento\Framework\Filesystem\File\Read;
use Magento\Framework\Filesystem\File\ReadFactory;
use Magento\Framework\RequireJs\Config;
use Magento\Framework\RequireJs\Config\File\Collector\Aggregated;
use Magento\Framework\View\Asset\ContextInterface;
use Magento\Framework\View\Asset\Minification;
use Magento\Framework\View\Asset\Repository;
use Magento\Framework\View\Asset\RepositoryMap;
use Magento\Framework\View\Design\ThemeInterface;
use Magento\Framework\View\DesignInterface;
use Magento\Framework\View\File;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
* @SuppressWarnings(PHPMD.CouplingBetweenObjects)
*/
class ConfigTest extends TestCase
{
/**
* @var Aggregated|MockObject
*/
private $fileSource;

/**
* @var DesignInterface|MockObject
*/
private $design;

/**
* @var Read|MockObject
*/
private $fileReader;

/**
* @var ContextInterface|MockObject
*/
private $context;

/**
* @var Config
*/
private $object;

/**
* @var Minification|MockObject
*/
private $minificationMock;

/**
* @var AdapterInterface|MockObject
*/
private $minifyAdapterMock;

/**
* @var RepositoryMap|MockObject
*/
private $repositoryMapMock;

protected function setUp(): void
{
$this->fileSource = $this->createMock(Aggregated::class);
$this->design = $this->getMockForAbstractClass(DesignInterface::class);

$readFactory = $this->createMock(ReadFactory::class);
$this->fileReader = $this->createMock(Read::class);
$readFactory->method('create')
->willReturn($this->fileReader);
$repo = $this->createMock(Repository::class);
$this->context = $this->getMockBuilder(ContextInterface::class)
->setMethods(
[
'getConfigPath',
'getPath',
'getBaseUrl',
'getAreaCode',
'getThemePath',
'getLocale'
]
)
->getMockForAbstractClass();
$repo->expects($this->once())->method('getStaticViewFileContext')->willReturn($this->context);
$this->minificationMock = $this->getMockBuilder(Minification::class)
->disableOriginalConstructor()
->getMock();

$this->minifyAdapterMock = $this->getMockBuilder(AdapterInterface::class)
->getMockForAbstractClass();

$this->repositoryMapMock = $this->getMockBuilder(RepositoryMap::class)
->disableOriginalConstructor()
->getMock();

$this->object = new Config(
$this->fileSource,
$this->design,
$readFactory,
$repo,
$this->minifyAdapterMock,
$this->minificationMock,
$this->repositoryMapMock
);
}

public function testGetConfig()
{
$this->fileReader->expects($this->any())
->method('readAll')
->willReturnCallback(
function ($file) {
return $file . ' content';
}
);
$fileOne = $this->createMock(File::class);
$fileOne->expects($this->once())
->method('getFilename')
->willReturn('some/full/relative/path/file_one.js');
$fileOne->expects($this->once())
->method('getName')
->willReturn('file_one.js');
$fileTwo = $this->createMock(File::class);
$fileTwo->expects($this->once())
->method('getFilename')
->willReturn('some/full/relative/path/file_two.js');
$fileTwo->expects($this->once())
->method('getName')
->willReturn('file_two.js');
$theme = $this->getMockForAbstractClass(ThemeInterface::class);
$this->design->expects($this->once())
->method('getDesignTheme')
->willReturn($theme);
$this->fileSource->expects($this->once())
->method('getFiles')
->with($theme, Config::CONFIG_FILE_NAME)
->willReturn([$fileOne, $fileTwo]);
$this->minificationMock
->expects($this->atLeastOnce())
->method('isEnabled')
->with('js')
->willReturn(true);

$expected = <<<expected
(function(require){
(function() {
file_one.js content
require.config(config);
})();
(function() {
file_two.js content
require.config(config);
})();



})(require);
expected;

$this->minifyAdapterMock
->expects($this->once())
->method('minify')
->with($expected)
->willReturnArgument(0);

$actual = $this->object->getConfig();
$this->assertEquals($actual, $expected);
}

public function testGetMinResolverCode()
{
$this->minificationMock
->expects($this->once())
->method('getExcludes')
->with('js')
->willReturn(['\.min\.']);
$this->minificationMock
->expects($this->once())
->method('isEnabled')
->with('js')
->willReturn(true);
$this->minifyAdapterMock
->expects($this->once())
->method('minify')
->willReturnArgument(0);

$expected = <<<code
(function () {
var ctx = require.s.contexts._,
origNameToUrl = ctx.nameToUrl,
baseUrl = ctx.config.baseUrl;

ctx.nameToUrl = function() {
var url = origNameToUrl.apply(ctx, arguments);
if (url.indexOf(baseUrl)===0&&!url.match(/\.min\./)) {
url = url.replace(/(\.min)?\.js$/, '.min.js');
}
return url;
};
})();
code;
$this->assertEquals($expected, $this->object->getMinResolverCode());
}

public function testGetConfigFileRelativePath()
{
$this->minificationMock
->expects($this->any())
->method('addMinifiedSign')
->willReturnArgument(0);
$this->context->expects($this->once())->method('getConfigPath')->willReturn('path');
$actual = $this->object->getConfigFileRelativePath();
$this->assertSame('path/requirejs-config.js', $actual);
}

public function testGetMixinsFileRelativePath()
{
$this->minificationMock
->expects($this->any())
->method('addMinifiedSign')
->willReturnArgument(0);
$this->context->expects($this->once())->method('getPath')->willReturn('path');
$actual = $this->object->getMixinsFileRelativePath();
$this->assertSame('path/mage/requirejs/mixins.js', $actual);
}

public function testGetMinResolverRelativePath()
{
$this->minificationMock
->expects($this->any())
->method('addMinifiedSign')
->willReturnArgument(0);
$this->context->expects($this->once())->method('getConfigPath')->willReturn('path');
$actual = $this->object->getMinResolverRelativePath();
$this->assertSame('path/requirejs-min-resolver.js', $actual);
}

public function testGetBaseConfig()
{
$this->context->expects($this->once())->method('getPath')->willReturn('area/theme/locale');
$this->context->expects($this->once())
->method('getBaseUrl')
->willReturn('http://base.url/');
$expected = <<<expected
require.config({"baseUrl":"http://base.url/area/theme/locale"});
expected;
$actual = $this->object->getBaseConfig();
$this->assertSame($expected, $actual);
}
}