Issues in MinifineTest.php (master) - Issues in master - PeeHaa/Minifine - Measure and Improve Code Quality continuously with Scrutinizer

Issues (3)

Security Analysis no request data

Cross-Site Scripting

Cross-Site Scripting enables an attacker to inject code into the response of a web-request that is viewed by other users. It can for example be used to bypass access controls, or even to take over other users' accounts.

File Exposure

File Exposure allows an attacker to gain access to local files that he should not be able to access. These files can for example include database credentials, or other configuration files.

File Manipulation

File Manipulation enables an attacker to write custom data to files. This potentially leads to injection of arbitrary code on the server.

Object Injection

Object Injection enables an attacker to inject an object into PHP code, and can lead to arbitrary code execution, file exposure, or file manipulation attacks.

Code Injection

Code Injection enables an attacker to execute arbitrary code on the server.

Response Splitting

Response Splitting can be used to send arbitrary responses.

File Inclusion

File Inclusion enables an attacker to inject custom files into PHP's file loading mechanism, either explicitly passed to include, or for example via PHP's auto-loading mechanism.

Command Injection

Command Injection enables an attacker to inject a shell command that is execute with the privileges of the web-server. This can be used to expose sensitive data, or gain access of your server.

SQL Injection

SQL Injection enables an attacker to execute arbitrary SQL code on your database server gaining access to user data, or manipulating user data.

XPath Injection

XPath Injection enables an attacker to modify the parts of XML document that are read. If that XML document is for example used for authentication, this can lead to further vulnerabilities similar to SQL Injection.

LDAP Injection

LDAP Injection enables an attacker to inject LDAP statements potentially granting permission to run unauthorized queries, or modify content inside the LDAP tree.

Header Injection

Other Vulnerability

This category comprises other attack vectors such as manipulating the PHP runtime, loading custom extensions, freezing the runtime, or similar.

Regex Injection

Regex Injection enables an attacker to execute arbitrary code in your PHP process.

XML Injection

XML Injection enables an attacker to read files on your local filesystem including configuration files, or can be abused to freeze your web-server process.

Variable Injection

Variable Injection enables an attacker to overwrite program variables with custom data, and can lead to further vulnerabilities.

Unfortunately, the security analysis is currently not available for your project. If you are a non-commercial open-source project, please contact support to gain access.

test/Unit/MinifineTest.php (2 issues)

Labels

Severity

Major 2

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php

namespace MinifineTest;

use Minifine\Minifine;

class MinifineTest extends \PHPUnit_Framework_TestCase
{
    public function tearDown()
    {
        @unlink(TEST_DATA_DIR . '/css/test.css');
// For example instead of
@mkdir($dir);

// Better use
if (@mkdir($dir) === false) {
    throw new \RuntimeException('The directory '.$dir.' could not be created.');
}
        @unlink(TEST_DATA_DIR . '/js/test.js');
// For example instead of
@mkdir($dir);

// Better use
if (@mkdir($dir) === false) {
    throw new \RuntimeException('The directory '.$dir.' could not be created.');
}
    }

    /**
     * @covers Minifine\Minifine::__construct
     */
    public function testConstructorDevelopment()
    {
        $this->assertInstanceOf('Minifine\\Minifine', new Minifine(TEST_DATA_DIR));
    }

    /**
     * @covers Minifine\Minifine::__construct
     */
    public function testConstructorProduction()
    {
        $this->assertInstanceOf('Minifine\\Minifine', new Minifine(TEST_DATA_DIR, true));
    }

    /**
     * @covers Minifine\Minifine::__construct
     * @covers Minifine\Minifine::appendJsMinifier
     * @covers Minifine\Minifine::append
     */
    public function testAppendJsMinifier()
    {
        $minifier = new Minifine(TEST_DATA_DIR);

        $this->assertNull($minifier->appendJsMinifier($this->getMock('Minifine\\Minifier\\Minifier')));
    }

    /**
     * @covers Minifine\Minifine::__construct
     * @covers Minifine\Minifine::prependJsMinifier
     * @covers Minifine\Minifine::prepend
     */
    public function testPrependJsMinifier()
    {
        $minifier = new Minifine(TEST_DATA_DIR);

        $this->assertNull($minifier->prependJsMinifier($this->getMock('Minifine\\Minifier\\Minifier')));
    }

    /**
     * @covers Minifine\Minifine::__construct
     * @covers Minifine\Minifine::appendCssMinifier
     * @covers Minifine\Minifine::append
     */
    public function testAppendCssMinifier()
    {
        $minifier = new Minifine(TEST_DATA_DIR);

        $this->assertNull($minifier->appendCssMinifier($this->getMock('Minifine\\Minifier\\Minifier')));
    }

    /**
     * @covers Minifine\Minifine::__construct
     * @covers Minifine\Minifine::prependCssMinifier
     * @covers Minifine\Minifine::prepend
     */
    public function testPrependCssMinifier()
    {
        $minifier = new Minifine(TEST_DATA_DIR);

        $this->assertNull($minifier->prependCssMinifier($this->getMock('Minifine\\Minifier\\Minifier')));
    }

    /**
     * @covers Minifine\Minifine::__construct
     * @covers Minifine\Minifine::appendCssMinifier
     * @covers Minifine\Minifine::append
     * @covers Minifine\Minifine::css
     */
    public function testCssProduction()
    {
        $minifier = new Minifine(TEST_DATA_DIR, true);

        $this->assertSame(
            '<link rel="stylesheet" href="/css/test.css">',
            $minifier->css(['/css/bootstrap.min.css', '/css/jquery.min.css', '/css/custom.css'], '/css/test.css')
        );
    }

    /**
     * @covers Minifine\Minifine::__construct
     * @covers Minifine\Minifine::appendCssMinifier
     * @covers Minifine\Minifine::append
     * @covers Minifine\Minifine::css
     * @covers Minifine\Minifine::minify
     * @covers Minifine\Minifine::merge
     */
    public function testCssDevelopment()
    {
        $minifierMock = $this->getMock('Minifine\\Minifier\\Minifier');

        $minifierMock
            ->expects($this->once())
            ->method('minify')
            ->willReturn('minifiedcontent')
        ;

        $minifier = new Minifine(TEST_DATA_DIR);
        $minifier->appendCssMinifier($minifierMock);

        $this->assertSame(
            '<link rel="stylesheet" href="/css/bootstrap.min.css">'
            . "\n" . '<link rel="stylesheet" href="/css/jquery.min.css">'
            . "\n" . '<link rel="stylesheet" href="/css/custom.css">',
            $minifier->css(['/css/bootstrap.min.css', '/css/jquery.min.css', '/css/custom.css'], '/css/test.css')
        );

        $this->assertSame('minifiedcontent', file_get_contents(TEST_DATA_DIR . '/css/test.css'));
    }

    /**
     * @covers Minifine\Minifine::__construct
     * @covers Minifine\Minifine::appendCssMinifier
     * @covers Minifine\Minifine::append
     * @covers Minifine\Minifine::css
     * @covers Minifine\Minifine::minify
     * @covers Minifine\Minifine::merge
     */
    public function testCssDevelopmentAppendedMinifier()
    {
        $minifierMock = $this->getMock('Minifine\\Minifier\\Minifier');

        $minifierMock
            ->expects($this->once())
            ->method('minify')
            ->willReturn('minifiedcontent')
        ;

        $appendedMock = $this->getMock('Minifine\\Minifier\\Minifier');

        $appendedMock
            ->expects($this->once())
            ->method('minify')
            ->willReturn('appendedcontent')
        ;

        $minifier = new Minifine(TEST_DATA_DIR);
        $minifier->appendCssMinifier($minifierMock);
        $minifier->appendCssMinifier($appendedMock);

        $minifier->css(['/css/bootstrap.min.css', '/css/jquery.min.css', '/css/custom.css'], '/css/test.css');

        $this->assertSame('appendedcontent', file_get_contents(TEST_DATA_DIR . '/css/test.css'));
    }

    /**
     * @covers Minifine\Minifine::__construct
     * @covers Minifine\Minifine::appendCssMinifier
     * @covers Minifine\Minifine::append
     * @covers Minifine\Minifine::prependCssMinifier
     * @covers Minifine\Minifine::prepend
     * @covers Minifine\Minifine::css
     * @covers Minifine\Minifine::minify
     * @covers Minifine\Minifine::merge
     */
    public function testCssDevelopmentPrependedMinifier()
    {
        $minifierMock = $this->getMock('Minifine\\Minifier\\Minifier');

        $minifierMock
            ->expects($this->once())
            ->method('minify')
            ->willReturn('minifiedcontent')
        ;

        $prependedMock = $this->getMock('Minifine\\Minifier\\Minifier');

        $prependedMock
            ->expects($this->once())
            ->method('minify')
            ->willReturn('prependedcontent')
        ;

        $minifier = new Minifine(TEST_DATA_DIR);
        $minifier->appendCssMinifier($minifierMock);
        $minifier->prependCssMinifier($prependedMock);

        $minifier->css(['/css/bootstrap.min.css', '/css/jquery.min.css', '/css/custom.css'], '/css/test.css');

        $this->assertSame('minifiedcontent', file_get_contents(TEST_DATA_DIR . '/css/test.css'));
    }

    /**
     * @covers Minifine\Minifine::__construct
     * @covers Minifine\Minifine::appendJsMinifier
     * @covers Minifine\Minifine::append
     * @covers Minifine\Minifine::js
     */
    public function testJsProduction()
    {
        $this->assertSame(
            '<script src="/js/test.js"></script>',
            (new Minifine(TEST_DATA_DIR, true))->js(['/js/boostrap.min.js', '/js/jquery.min.js', '/js/main.js'], '/js/test.js')
        );
    }

    /**
     * @covers Minifine\Minifine::__construct
     * @covers Minifine\Minifine::appendJsMinifier
     * @covers Minifine\Minifine::append
     * @covers Minifine\Minifine::css
     * @covers Minifine\Minifine::minify
     * @covers Minifine\Minifine::merge
     */
    public function testJsDevelopment()
    {
        $minifierMock = $this->getMock('Minifine\\Minifier\\Minifier');

        $minifierMock
            ->expects($this->once())
            ->method('minify')
            ->willReturn('minifiedcontent')
        ;

        $minifier = new Minifine(TEST_DATA_DIR);
        $minifier->appendJsMinifier($minifierMock);

        $this->assertSame(
            '<script src="/js/bootstrap.min.js"></script>'
            . "\n" . '<script src="/js/jquery.min.js"></script>'
            . "\n" . '<script src="/js/main.js"></script>',
            $minifier->js(['/js/bootstrap.min.js', '/js/jquery.min.js', '/js/main.js'], '/js/test.js')
        );

        $this->assertSame('minifiedcontent', file_get_contents(TEST_DATA_DIR . '/js/test.js'));
    }

    /**
     * @covers Minifine\Minifine::__construct
     * @covers Minifine\Minifine::appendJsMinifier
     * @covers Minifine\Minifine::append
     * @covers Minifine\Minifine::css
     * @covers Minifine\Minifine::minify
     * @covers Minifine\Minifine::merge
     */
    public function testJsDevelopmentAppendedMinifier()
    {
        $minifierMock = $this->getMock('Minifine\\Minifier\\Minifier');

        $minifierMock
            ->expects($this->once())
            ->method('minify')
            ->willReturn('minifiedcontent')
        ;

        $appendedMock = $this->getMock('Minifine\\Minifier\\Minifier');

        $appendedMock
            ->expects($this->once())
            ->method('minify')
            ->willReturn('appendedcontent')
        ;

        $minifier = new Minifine(TEST_DATA_DIR);
        $minifier->appendJsMinifier($minifierMock);
        $minifier->appendJsMinifier($appendedMock);

        $minifier->js(['/js/bootstrap.min.js', '/js/jquery.min.js', '/js/main.js'], '/js/test.js');

        $this->assertSame('appendedcontent', file_get_contents(TEST_DATA_DIR . '/js/test.js'));
    }

    /**
     * @covers Minifine\Minifine::__construct
     * @covers Minifine\Minifine::appendJsMinifier
     * @covers Minifine\Minifine::append
     * @covers Minifine\Minifine::prependJsMinifier
     * @covers Minifine\Minifine::prepend
     * @covers Minifine\Minifine::css
     * @covers Minifine\Minifine::minify
     * @covers Minifine\Minifine::merge
     */
    public function testJsDevelopmentPrependedMinifier()
    {
        $minifierMock = $this->getMock('Minifine\\Minifier\\Minifier');

        $minifierMock
            ->expects($this->once())
            ->method('minify')
            ->willReturn('minifiedcontent')
        ;

        $prependedMock = $this->getMock('Minifine\\Minifier\\Minifier');

        $prependedMock
            ->expects($this->once())
            ->method('minify')
            ->willReturn('prependedcontent')
        ;

        $minifier = new Minifine(TEST_DATA_DIR);
        $minifier->appendJsMinifier($minifierMock);
        $minifier->prependJsMinifier($prependedMock);

        $minifier->js(['/js/bootstrap.min.js', '/js/jquery.min.js', '/js/main.js'], '/js/test.js');

        $this->assertSame('minifiedcontent', file_get_contents(TEST_DATA_DIR . '/js/test.js'));
    }

    /**
     * @covers Minifine\Minifine::__construct
     * @covers Minifine\Minifine::js
     * @covers Minifine\Minifine::minify
     * @covers Minifine\Minifine::merge
     */
    public function testMerge()
    {
        $minifier = new Minifine(TEST_DATA_DIR);

        $minifier->js(['/js/bootstrap.min.js', '/js/jquery.min.js', '/js/main.js'], '/js/test.js');

        $this->assertSame('|bootstrap||jquery||main|', file_get_contents(TEST_DATA_DIR . '/js/test.js'));
    }
}


1			<?php
2
3			namespace MinifineTest;
4
5			use Minifine\Minifine;
6
7			class MinifineTest extends \PHPUnit_Framework_TestCase
8			{
9			public function tearDown()
10			{
11			@unlink(TEST_DATA_DIR . '/css/test.css');
			0 ignored issues – show Security Best Practice introduced 2015-11-23 21:45 UTC by Report Bug Copy Issue Report Show Similar Issues like this It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended. If you suppress an error, we recommend checking for the error condition explicitly: // For example instead of @mkdir($dir); // Better use if (@mkdir($dir) === false) { throw new \RuntimeException('The directory '.$dir.' could not be created.'); } Loading history...
12			@unlink(TEST_DATA_DIR . '/js/test.js');
			0 ignored issues – show Security Best Practice introduced 2015-11-23 21:45 UTC by Report Bug Copy Issue Report Show Similar Issues like this It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended. If you suppress an error, we recommend checking for the error condition explicitly: // For example instead of @mkdir($dir); // Better use if (@mkdir($dir) === false) { throw new \RuntimeException('The directory '.$dir.' could not be created.'); } Loading history...
13			}
14
15			/**
16			* @covers Minifine\Minifine::__construct
17			*/
18			public function testConstructorDevelopment()
19			{
20			$this->assertInstanceOf('Minifine\\Minifine', new Minifine(TEST_DATA_DIR));
21			}
22
23			/**
24			* @covers Minifine\Minifine::__construct
25			*/
26			public function testConstructorProduction()
27			{
28			$this->assertInstanceOf('Minifine\\Minifine', new Minifine(TEST_DATA_DIR, true));
29			}
30
31			/**
32			* @covers Minifine\Minifine::__construct
33			* @covers Minifine\Minifine::appendJsMinifier
34			* @covers Minifine\Minifine::append
35			*/
36			public function testAppendJsMinifier()
37			{
38			$minifier = new Minifine(TEST_DATA_DIR);
39
40			$this->assertNull($minifier->appendJsMinifier($this->getMock('Minifine\\Minifier\\Minifier')));
41			}
42
43			/**
44			* @covers Minifine\Minifine::__construct
45			* @covers Minifine\Minifine::prependJsMinifier
46			* @covers Minifine\Minifine::prepend
47			*/
48			public function testPrependJsMinifier()
49			{
50			$minifier = new Minifine(TEST_DATA_DIR);
51
52			$this->assertNull($minifier->prependJsMinifier($this->getMock('Minifine\\Minifier\\Minifier')));
53			}
54
55			/**
56			* @covers Minifine\Minifine::__construct
57			* @covers Minifine\Minifine::appendCssMinifier
58			* @covers Minifine\Minifine::append
59			*/
60			public function testAppendCssMinifier()
61			{
62			$minifier = new Minifine(TEST_DATA_DIR);
63
64			$this->assertNull($minifier->appendCssMinifier($this->getMock('Minifine\\Minifier\\Minifier')));
65			}
66
67			/**
68			* @covers Minifine\Minifine::__construct
69			* @covers Minifine\Minifine::prependCssMinifier
70			* @covers Minifine\Minifine::prepend
71			*/
72			public function testPrependCssMinifier()
73			{
74			$minifier = new Minifine(TEST_DATA_DIR);
75
76			$this->assertNull($minifier->prependCssMinifier($this->getMock('Minifine\\Minifier\\Minifier')));
77			}
78
79			/**
80			* @covers Minifine\Minifine::__construct
81			* @covers Minifine\Minifine::appendCssMinifier
82			* @covers Minifine\Minifine::append
83			* @covers Minifine\Minifine::css
84			*/
85			public function testCssProduction()
86			{
87			$minifier = new Minifine(TEST_DATA_DIR, true);
88
89			$this->assertSame(
90			'<link rel="stylesheet" href="/css/test.css">',
91			$minifier->css(['/css/bootstrap.min.css', '/css/jquery.min.css', '/css/custom.css'], '/css/test.css')
92			);
93			}
94
95			/**
96			* @covers Minifine\Minifine::__construct
97			* @covers Minifine\Minifine::appendCssMinifier
98			* @covers Minifine\Minifine::append
99			* @covers Minifine\Minifine::css
100			* @covers Minifine\Minifine::minify
101			* @covers Minifine\Minifine::merge
102			*/
103			public function testCssDevelopment()
104			{
105			$minifierMock = $this->getMock('Minifine\\Minifier\\Minifier');
106
107			$minifierMock
108			->expects($this->once())
109			->method('minify')
110			->willReturn('minifiedcontent')
111			;
112
113			$minifier = new Minifine(TEST_DATA_DIR);
114			$minifier->appendCssMinifier($minifierMock);
115
116			$this->assertSame(
117			'<link rel="stylesheet" href="/css/bootstrap.min.css">'
118			. "\n" . '<link rel="stylesheet" href="/css/jquery.min.css">'
119			. "\n" . '<link rel="stylesheet" href="/css/custom.css">',
120			$minifier->css(['/css/bootstrap.min.css', '/css/jquery.min.css', '/css/custom.css'], '/css/test.css')
121			);
122
123			$this->assertSame('minifiedcontent', file_get_contents(TEST_DATA_DIR . '/css/test.css'));
124			}
125
126			/**
127			* @covers Minifine\Minifine::__construct
128			* @covers Minifine\Minifine::appendCssMinifier
129			* @covers Minifine\Minifine::append
130			* @covers Minifine\Minifine::css
131			* @covers Minifine\Minifine::minify
132			* @covers Minifine\Minifine::merge
133			*/
134			public function testCssDevelopmentAppendedMinifier()
135			{
136			$minifierMock = $this->getMock('Minifine\\Minifier\\Minifier');
137
138			$minifierMock
139			->expects($this->once())
140			->method('minify')
141			->willReturn('minifiedcontent')
142			;
143
144			$appendedMock = $this->getMock('Minifine\\Minifier\\Minifier');
145
146			$appendedMock
147			->expects($this->once())
148			->method('minify')
149			->willReturn('appendedcontent')
150			;
151
152			$minifier = new Minifine(TEST_DATA_DIR);
153			$minifier->appendCssMinifier($minifierMock);
154			$minifier->appendCssMinifier($appendedMock);
155
156			$minifier->css(['/css/bootstrap.min.css', '/css/jquery.min.css', '/css/custom.css'], '/css/test.css');
157
158			$this->assertSame('appendedcontent', file_get_contents(TEST_DATA_DIR . '/css/test.css'));
159			}
160
161			/**
162			* @covers Minifine\Minifine::__construct
163			* @covers Minifine\Minifine::appendCssMinifier
164			* @covers Minifine\Minifine::append
165			* @covers Minifine\Minifine::prependCssMinifier
166			* @covers Minifine\Minifine::prepend
167			* @covers Minifine\Minifine::css
168			* @covers Minifine\Minifine::minify
169			* @covers Minifine\Minifine::merge
170			*/
171			public function testCssDevelopmentPrependedMinifier()
172			{
173			$minifierMock = $this->getMock('Minifine\\Minifier\\Minifier');
174
175			$minifierMock
176			->expects($this->once())
177			->method('minify')
178			->willReturn('minifiedcontent')
179			;
180
181			$prependedMock = $this->getMock('Minifine\\Minifier\\Minifier');
182
183			$prependedMock
184			->expects($this->once())
185			->method('minify')
186			->willReturn('prependedcontent')
187			;
188
189			$minifier = new Minifine(TEST_DATA_DIR);
190			$minifier->appendCssMinifier($minifierMock);
191			$minifier->prependCssMinifier($prependedMock);
192
193			$minifier->css(['/css/bootstrap.min.css', '/css/jquery.min.css', '/css/custom.css'], '/css/test.css');
194
195			$this->assertSame('minifiedcontent', file_get_contents(TEST_DATA_DIR . '/css/test.css'));
196			}
197
198			/**
199			* @covers Minifine\Minifine::__construct
200			* @covers Minifine\Minifine::appendJsMinifier
201			* @covers Minifine\Minifine::append
202			* @covers Minifine\Minifine::js
203			*/
204			public function testJsProduction()
205			{
206			$this->assertSame(
207			'<script src="/js/test.js"></script>',
208			(new Minifine(TEST_DATA_DIR, true))->js(['/js/boostrap.min.js', '/js/jquery.min.js', '/js/main.js'], '/js/test.js')
209			);
210			}
211
212			/**
213			* @covers Minifine\Minifine::__construct
214			* @covers Minifine\Minifine::appendJsMinifier
215			* @covers Minifine\Minifine::append
216			* @covers Minifine\Minifine::css
217			* @covers Minifine\Minifine::minify
218			* @covers Minifine\Minifine::merge
219			*/
220			public function testJsDevelopment()
221			{
222			$minifierMock = $this->getMock('Minifine\\Minifier\\Minifier');
223
224			$minifierMock
225			->expects($this->once())
226			->method('minify')
227			->willReturn('minifiedcontent')
228			;
229
230			$minifier = new Minifine(TEST_DATA_DIR);
231			$minifier->appendJsMinifier($minifierMock);
232
233			$this->assertSame(
234			'<script src="/js/bootstrap.min.js"></script>'
235			. "\n" . '<script src="/js/jquery.min.js"></script>'
236			. "\n" . '<script src="/js/main.js"></script>',
237			$minifier->js(['/js/bootstrap.min.js', '/js/jquery.min.js', '/js/main.js'], '/js/test.js')
238			);
239
240			$this->assertSame('minifiedcontent', file_get_contents(TEST_DATA_DIR . '/js/test.js'));
241			}
242
243			/**
244			* @covers Minifine\Minifine::__construct
245			* @covers Minifine\Minifine::appendJsMinifier
246			* @covers Minifine\Minifine::append
247			* @covers Minifine\Minifine::css
248			* @covers Minifine\Minifine::minify
249			* @covers Minifine\Minifine::merge
250			*/
251			public function testJsDevelopmentAppendedMinifier()
252			{
253			$minifierMock = $this->getMock('Minifine\\Minifier\\Minifier');
254
255			$minifierMock
256			->expects($this->once())
257			->method('minify')
258			->willReturn('minifiedcontent')
259			;
260
261			$appendedMock = $this->getMock('Minifine\\Minifier\\Minifier');
262
263			$appendedMock
264			->expects($this->once())
265			->method('minify')
266			->willReturn('appendedcontent')
267			;
268
269			$minifier = new Minifine(TEST_DATA_DIR);
270			$minifier->appendJsMinifier($minifierMock);
271			$minifier->appendJsMinifier($appendedMock);
272
273			$minifier->js(['/js/bootstrap.min.js', '/js/jquery.min.js', '/js/main.js'], '/js/test.js');
274
275			$this->assertSame('appendedcontent', file_get_contents(TEST_DATA_DIR . '/js/test.js'));
276			}
277
278			/**
279			* @covers Minifine\Minifine::__construct
280			* @covers Minifine\Minifine::appendJsMinifier
281			* @covers Minifine\Minifine::append
282			* @covers Minifine\Minifine::prependJsMinifier
283			* @covers Minifine\Minifine::prepend
284			* @covers Minifine\Minifine::css
285			* @covers Minifine\Minifine::minify
286			* @covers Minifine\Minifine::merge
287			*/
288			public function testJsDevelopmentPrependedMinifier()
289			{
290			$minifierMock = $this->getMock('Minifine\\Minifier\\Minifier');
291
292			$minifierMock
293			->expects($this->once())
294			->method('minify')
295			->willReturn('minifiedcontent')
296			;
297
298			$prependedMock = $this->getMock('Minifine\\Minifier\\Minifier');
299
300			$prependedMock
301			->expects($this->once())
302			->method('minify')
303			->willReturn('prependedcontent')
304			;
305
306			$minifier = new Minifine(TEST_DATA_DIR);
307			$minifier->appendJsMinifier($minifierMock);
308			$minifier->prependJsMinifier($prependedMock);
309
310			$minifier->js(['/js/bootstrap.min.js', '/js/jquery.min.js', '/js/main.js'], '/js/test.js');
311
312			$this->assertSame('minifiedcontent', file_get_contents(TEST_DATA_DIR . '/js/test.js'));
313			}
314
315			/**
316			* @covers Minifine\Minifine::__construct
317			* @covers Minifine\Minifine::js
318			* @covers Minifine\Minifine::minify
319			* @covers Minifine\Minifine::merge
320			*/
321			public function testMerge()
322			{
323			$minifier = new Minifine(TEST_DATA_DIR);
324
325			$minifier->js(['/js/bootstrap.min.js', '/js/jquery.min.js', '/js/main.js'], '/js/test.js');
326
327			$this->assertSame('\|bootstrap\|\|jquery\|\|main\|', file_get_contents(TEST_DATA_DIR . '/js/test.js'));
328			}
329			}
330

PeeHaa / Minifine

Issues (3)

Security Analysis no request data

test/Unit/MinifineTest.php (2 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like