TemplateServiceTest::testRenderWillMergePredefinedParametersWithParameters() - Code Metrics - Inspection of "Allow to set predefined template parameters availa..." - Roave/EmailTemplates - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#10)

by Jonas

created 2017-01-18 16:35 UTC

testRenderWillMergePredefinedParametersWithParameters() A

↳ Parent: TemplateServiceTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	55
Code Lines	40

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	55
rs	9.7692
cc	1
eloc	40
nc	1
nop	0

How to fix Long Method

<?php
/**
 * Copyright (c) 2014 Roave, LLC.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   * Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in
 *     the documentation and/or other materials provided with the
 *     distribution.
 *
 *   * Neither the names of the copyright holders nor the names of the
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * @author    Antoine Hedgecock
 *
 * @copyright 2014 Roave, LLC
 * @license   http://www.opensource.org/licenses/bsd-license.php  BSD License
 */

namespace EmailTemplatesTest\Service;

use DateTime;
use Doctrine\Common\Persistence\ObjectManager;
use PHPUnit_Framework_MockObject_MockObject;
use PHPUnit_Framework_TestCase;
use Roave\EmailTemplates\Entity\TemplateEntity;
use Roave\EmailTemplates\Hydrator\TemplateHydrator;
use Roave\EmailTemplates\InputFilter\TemplateInputFilter;
use Roave\EmailTemplates\Options\TemplateServiceOptions;
use Roave\EmailTemplates\Repository\TemplateRepositoryInterface;
use Roave\EmailTemplates\Service\Exception\FailedDataValidationException;
use Roave\EmailTemplates\Service\Template\Engine\EngineInterface;
use Roave\EmailTemplates\Service\Template\EnginePluginManager;
use Roave\EmailTemplates\Service\TemplateService;
use Zend\EventManager\EventManagerInterface;

/**
 * Class TemplateServiceTest
 *
 * @coversDefaultClass \Roave\EmailTemplates\Service\TemplateService
 * @covers ::<!public>
 *
 * @group service
 */
class TemplateServiceTest extends PHPUnit_Framework_TestCase
{
    /**
     * @var PHPUnit_Framework_MockObject_MockObject
     */
    protected $objectManager;

    /**
     * @var PHPUnit_Framework_MockObject_MockObject
     */
    protected $repository;

    /**
     * @var PHPUnit_Framework_MockObject_MockObject
     */
    protected $inputFilter;

    /**
     * @var PHPUnit_Framework_MockObject_MockObject
     */
    protected $hydrator;

    /**
     * @var PHPUnit_Framework_MockObject_MockObject
     */
    protected $engineManager;

    /**
     * @var PHPUnit_Framework_MockObject_MockObject
     */
    protected $eventManager;

    /**
     * @var TemplateServiceOptions
     */
    protected $options;

    /**
     * @var TemplateService
     */
    protected $templateService;

    /**
     * @covers ::__construct
     */
    protected function setUp()
    {
        $this->objectManager = $this->getMock(ObjectManager::class);
        $this->repository    = $this->getMock(TemplateRepositoryInterface::class);
        $this->inputFilter   = $this->getMock(TemplateInputFilter::class);
        $this->hydrator      = $this->getMock(TemplateHydrator::class);
        $this->engineManager = $this->getMock(EnginePluginManager::class);
        $this->eventManager  = $this->getMock(EventManagerInterface::class);
        $this->options       = new TemplateServiceOptions();

        $this->templateService = new TemplateService(
            $this->objectManager,
            $this->repository,
            $this->inputFilter,
            $this->hydrator,
            $this->engineManager,
            $this->options
        );

        $this->templateService->setEventManager($this->eventManager);
    }

    /**
     * @covers ::render
     */
    public function testRender()
    {
        $locale     = 'sv_SE';
        $templateId = 'test:template:id';
        $parameters = ['company' => 'Roave'];

        $template = new TemplateEntity();
        $template->setSubject('subject');
        $template->setTextBody('text');
        $template->setHtmlBody('html');

        $engine = $this->getMock(EngineInterface::class);

        // First run is the subject
        $engine
            ->expects($this->at(0))
            ->method('render')
            ->with($template->getSubject(), $parameters)
            ->will($this->returnValue($template->getSubject()));

        // Second run is the html body
        $engine
            ->expects($this->at(1))
            ->method('render')
            ->with($template->getHtmlBody(), $parameters)
            ->will($this->returnValue($template->getHtmlBody()));

        // Third run is the text body
        $engine
            ->expects($this->at(2))
            ->method('render')
            ->with($template->getTextBody(), $parameters)
            ->will($this->returnValue($template->getTextBody()));

        $this->repository
            ->expects($this->once())
            ->method('getByIdAndLocale')
            ->with($templateId, $locale)
            ->will($this->returnValue($template));

        $this->eventManager
            ->expects($this->once())
            ->method('trigger')
            ->with(
                TemplateService::EVENT_RENDER,
                $this->templateService,
                [
                    'template'   => $template,
                    'parameters' => $parameters
                ]
            );

        $this->engineManager
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue($engine));

        list ($subject, $html, $text) = $this->templateService->render($templateId, $locale, $parameters);

        $this->assertEquals($template->getSubject(), $subject);
        $this->assertEquals($template->getHtmlBody(), $html);
        $this->assertEquals($template->getTextBody(), $text);
    }

    /**
     * @covers ::render
     * @covers ::create
     */
    public function testRenderWithMissingTemplate()
    {
        $locale     = 'sv_SE';
        $templateId = 'test:template:id';
        $parameters = ['company' => 'Roave'];

        $template = new TemplateEntity();
        $template->setSubject($this->options->getDefaultSubject());
        $template->setTextBody(sprintf($this->options->getDefaultBody(), $templateId, $locale));
        $template->setHtmlBody(sprintf($this->options->getDefaultBody(), $templateId, $locale));

        $engine = $this->getMock(EngineInterface::class);

        // First run is the subject
        $engine
            ->expects($this->at(0))
            ->method('render')
            ->with($template->getSubject(), $parameters)
            ->will($this->returnValue($template->getSubject()));

        // Second run is the html body
        $engine
            ->expects($this->at(1))
            ->method('render')
            ->with($template->getHtmlBody(), $parameters)
            ->will($this->returnValue($template->getHtmlBody()));

        // Third run is the text body
        $engine
            ->expects($this->at(2))
            ->method('render')
            ->with($template->getTextBody(), $parameters)
            ->will($this->returnValue($template->getTextBody()));

        $this->repository
            ->expects($this->once())
            ->method('getByIdAndLocale')
            ->with($templateId, $locale)
            ->will($this->returnValue(null));

        $this->eventManager
            ->expects($this->at(0))
            ->method('trigger')
            ->with(TemplateService::EVENT_CREATE, $this->templateService, $this->callback(function ($parameters) {
                return ($parameters['template'] instanceof TemplateEntity);
            }));

        $this->eventManager
            ->expects($this->at(1))
            ->method('trigger')
            ->with(TemplateService::EVENT_RENDER);

        $this->engineManager
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue($engine));

        list ($subject, $html, $text) = $this->templateService->render($templateId, $locale, $parameters);

        $this->assertEquals($template->getSubject(), $subject);
        $this->assertEquals($template->getHtmlBody(), $html);
        $this->assertEquals($template->getTextBody(), $text);
    }

    /**
     * @covers ::update
     */
    public function testUpdateWithIncorrectData()
    {
        $this->setExpectedException(FailedDataValidationException::class);

        $this->hydrator
            ->expects($this->once())
            ->method('extract')
            ->will($this->returnValue([]));

        $this->inputFilter
            ->expects($this->once())
            ->method('getMessages')
            ->will($this->returnValue([]));

        $this->templateService->update([], new TemplateEntity());
    }

    /**
     * @covers ::update
     */
    public function testUpdate()
    {
        $data     = ['foo' => 'bar'];
        $template = $this->getMock(TemplateEntity::class);
        $template
            ->expects($this->once())
            ->method('setUpdatedAt')
            ->with($this->isInstanceOf(DateTime::class));

        $this->hydrator
            ->expects($this->once())
            ->method('extract')
            ->will($this->returnValue([]));

        $this->inputFilter
            ->expects($this->once())
            ->method('isValid')
            ->will($this->returnValue(true));

        $this->inputFilter
            ->expects($this->once())
            ->method('getValues')
            ->will($this->returnValue($data));

        $this->hydrator
            ->expects($this->once())
            ->method('hydrate')
            ->with($data, $template);

        $this->objectManager
            ->expects($this->once())
            ->method('flush');

        $this->templateService->update($data, $template);
    }

    /**
     * @covers ::render
     */
    public function testRenderWillMergePredefinedParametersWithParameters()
    {
        $locale               = 'sv_SE';
        $templateId           = 'test:template:id';
        $parameters           = ['company' => 'Roave'];
        $predefinedParameters = ['company' => 'ShouldNotBeThisOne', 'anotherOneThatShouldBeIncluded' => 'value'];
        $expectedParameters   = ['company' => 'Roave', 'anotherOneThatShouldBeIncluded' => 'value'];

        $this->options->setPredefinedParams($predefinedParameters);

        $template = new TemplateEntity();
        $template->setSubject($this->options->getDefaultSubject());
        $template->setTextBody(sprintf($this->options->getDefaultBody(), $templateId, $locale));
        $template->setHtmlBody(sprintf($this->options->getDefaultBody(), $templateId, $locale));

        $engine = $this->getMock(EngineInterface::class);

        // First run is the subject
        $engine
            ->expects($this->at(0))
            ->method('render')
            ->with($template->getSubject(), $expectedParameters)
            ->will($this->returnValue($template->getSubject()));

        // Second run is the html body
        $engine
            ->expects($this->at(1))
            ->method('render')
            ->with($template->getHtmlBody(), $expectedParameters)
            ->will($this->returnValue($template->getHtmlBody()));

        // Third run is the text body
        $engine
            ->expects($this->at(2))
            ->method('render')
            ->with($template->getTextBody(), $expectedParameters)
            ->will($this->returnValue($template->getTextBody()));

        $this->repository
            ->expects($this->once())
            ->method('getByIdAndLocale')
            ->with($templateId, $locale)
            ->will($this->returnValue($template));

        $this->engineManager
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue($engine));

        list ($subject, $html, $text) = $this->templateService->render($templateId, $locale, $parameters);

        $this->assertEquals($template->getSubject(), $subject);
        $this->assertEquals($template->getHtmlBody(), $html);
        $this->assertEquals($template->getTextBody(), $text);
    }
}


1			<?php
2			/**
3			* Copyright (c) 2014 Roave, LLC.
4			* All rights reserved.
5			*
6			* Redistribution and use in source and binary forms, with or without
7			* modification, are permitted provided that the following conditions
8			* are met:
9			*
10			* * Redistributions of source code must retain the above copyright
11			* notice, this list of conditions and the following disclaimer.
12			*
13			* * Redistributions in binary form must reproduce the above copyright
14			* notice, this list of conditions and the following disclaimer in
15			* the documentation and/or other materials provided with the
16			* distribution.
17			*
18			* * Neither the names of the copyright holders nor the names of the
19			* contributors may be used to endorse or promote products derived
20			* from this software without specific prior written permission.
21			*
22			* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23			* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24			* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
25			* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
26			* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
27			* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
28			* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
29			* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
30			* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
32			* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33			* POSSIBILITY OF SUCH DAMAGE.
34			*
35			* @author Antoine Hedgecock
36			*
37			* @copyright 2014 Roave, LLC
38			* @license http://www.opensource.org/licenses/bsd-license.php BSD License
39			*/
40
41			namespace EmailTemplatesTest\Service;
42
43			use DateTime;
44			use Doctrine\Common\Persistence\ObjectManager;
45			use PHPUnit_Framework_MockObject_MockObject;
46			use PHPUnit_Framework_TestCase;
47			use Roave\EmailTemplates\Entity\TemplateEntity;
48			use Roave\EmailTemplates\Hydrator\TemplateHydrator;
49			use Roave\EmailTemplates\InputFilter\TemplateInputFilter;
50			use Roave\EmailTemplates\Options\TemplateServiceOptions;
51			use Roave\EmailTemplates\Repository\TemplateRepositoryInterface;
52			use Roave\EmailTemplates\Service\Exception\FailedDataValidationException;
53			use Roave\EmailTemplates\Service\Template\Engine\EngineInterface;
54			use Roave\EmailTemplates\Service\Template\EnginePluginManager;
55			use Roave\EmailTemplates\Service\TemplateService;
56			use Zend\EventManager\EventManagerInterface;
57
58			/**
59			* Class TemplateServiceTest
60			*
61			* @coversDefaultClass \Roave\EmailTemplates\Service\TemplateService
62			* @covers ::<!public>
63			*
64			* @group service
65			*/
66			class TemplateServiceTest extends PHPUnit_Framework_TestCase
67			{
68			/**
69			* @var PHPUnit_Framework_MockObject_MockObject
70			*/
71			protected $objectManager;
72
73			/**
74			* @var PHPUnit_Framework_MockObject_MockObject
75			*/
76			protected $repository;
77
78			/**
79			* @var PHPUnit_Framework_MockObject_MockObject
80			*/
81			protected $inputFilter;
82
83			/**
84			* @var PHPUnit_Framework_MockObject_MockObject
85			*/
86			protected $hydrator;
87
88			/**
89			* @var PHPUnit_Framework_MockObject_MockObject
90			*/
91			protected $engineManager;
92
93			/**
94			* @var PHPUnit_Framework_MockObject_MockObject
95			*/
96			protected $eventManager;
97
98			/**
99			* @var TemplateServiceOptions
100			*/
101			protected $options;
102
103			/**
104			* @var TemplateService
105			*/
106			protected $templateService;
107
108			/**
109			* @covers ::__construct
110			*/
111			protected function setUp()
112			{
113			$this->objectManager = $this->getMock(ObjectManager::class);
114			$this->repository = $this->getMock(TemplateRepositoryInterface::class);
115			$this->inputFilter = $this->getMock(TemplateInputFilter::class);
116			$this->hydrator = $this->getMock(TemplateHydrator::class);
117			$this->engineManager = $this->getMock(EnginePluginManager::class);
118			$this->eventManager = $this->getMock(EventManagerInterface::class);
119			$this->options = new TemplateServiceOptions();
120
121			$this->templateService = new TemplateService(
122			$this->objectManager,
123			$this->repository,
124			$this->inputFilter,
125			$this->hydrator,
126			$this->engineManager,
127			$this->options
128			);
129
130			$this->templateService->setEventManager($this->eventManager);
131			}
132
133			/**
134			* @covers ::render
135			*/
136			public function testRender()
137			{
138			$locale = 'sv_SE';
139			$templateId = 'test:template:id';
140			$parameters = ['company' => 'Roave'];
141
142			$template = new TemplateEntity();
143			$template->setSubject('subject');
144			$template->setTextBody('text');
145			$template->setHtmlBody('html');
146
147			$engine = $this->getMock(EngineInterface::class);
148
149			// First run is the subject
150			$engine
151			->expects($this->at(0))
152			->method('render')
153			->with($template->getSubject(), $parameters)
154			->will($this->returnValue($template->getSubject()));
155
156			// Second run is the html body
157			$engine
158			->expects($this->at(1))
159			->method('render')
160			->with($template->getHtmlBody(), $parameters)
161			->will($this->returnValue($template->getHtmlBody()));
162
163			// Third run is the text body
164			$engine
165			->expects($this->at(2))
166			->method('render')
167			->with($template->getTextBody(), $parameters)
168			->will($this->returnValue($template->getTextBody()));
169
170			$this->repository
171			->expects($this->once())
172			->method('getByIdAndLocale')
173			->with($templateId, $locale)
174			->will($this->returnValue($template));
175
176			$this->eventManager
177			->expects($this->once())
178			->method('trigger')
179			->with(
180			TemplateService::EVENT_RENDER,
181			$this->templateService,
182			[
183			'template' => $template,
184			'parameters' => $parameters
185			]
186			);
187
188			$this->engineManager
189			->expects($this->once())
190			->method('get')
191			->will($this->returnValue($engine));
192
193			list ($subject, $html, $text) = $this->templateService->render($templateId, $locale, $parameters);
194
195			$this->assertEquals($template->getSubject(), $subject);
196			$this->assertEquals($template->getHtmlBody(), $html);
197			$this->assertEquals($template->getTextBody(), $text);
198			}
199
200			/**
201			* @covers ::render
202			* @covers ::create
203			*/
204			public function testRenderWithMissingTemplate()
205			{
206			$locale = 'sv_SE';
207			$templateId = 'test:template:id';
208			$parameters = ['company' => 'Roave'];
209
210			$template = new TemplateEntity();
211			$template->setSubject($this->options->getDefaultSubject());
212			$template->setTextBody(sprintf($this->options->getDefaultBody(), $templateId, $locale));
213			$template->setHtmlBody(sprintf($this->options->getDefaultBody(), $templateId, $locale));
214
215			$engine = $this->getMock(EngineInterface::class);
216
217			// First run is the subject
218			$engine
219			->expects($this->at(0))
220			->method('render')
221			->with($template->getSubject(), $parameters)
222			->will($this->returnValue($template->getSubject()));
223
224			// Second run is the html body
225			$engine
226			->expects($this->at(1))
227			->method('render')
228			->with($template->getHtmlBody(), $parameters)
229			->will($this->returnValue($template->getHtmlBody()));
230
231			// Third run is the text body
232			$engine
233			->expects($this->at(2))
234			->method('render')
235			->with($template->getTextBody(), $parameters)
236			->will($this->returnValue($template->getTextBody()));
237
238			$this->repository
239			->expects($this->once())
240			->method('getByIdAndLocale')
241			->with($templateId, $locale)
242			->will($this->returnValue(null));
243
244			$this->eventManager
245			->expects($this->at(0))
246			->method('trigger')
247			->with(TemplateService::EVENT_CREATE, $this->templateService, $this->callback(function ($parameters) {
248			return ($parameters['template'] instanceof TemplateEntity);
249			}));
250
251			$this->eventManager
252			->expects($this->at(1))
253			->method('trigger')
254			->with(TemplateService::EVENT_RENDER);
255
256			$this->engineManager
257			->expects($this->once())
258			->method('get')
259			->will($this->returnValue($engine));
260
261			list ($subject, $html, $text) = $this->templateService->render($templateId, $locale, $parameters);
262
263			$this->assertEquals($template->getSubject(), $subject);
264			$this->assertEquals($template->getHtmlBody(), $html);
265			$this->assertEquals($template->getTextBody(), $text);
266			}
267
268			/**
269			* @covers ::update
270			*/
271			public function testUpdateWithIncorrectData()
272			{
273			$this->setExpectedException(FailedDataValidationException::class);
274
275			$this->hydrator
276			->expects($this->once())
277			->method('extract')
278			->will($this->returnValue([]));
279
280			$this->inputFilter
281			->expects($this->once())
282			->method('getMessages')
283			->will($this->returnValue([]));
284
285			$this->templateService->update([], new TemplateEntity());
286			}
287
288			/**
289			* @covers ::update
290			*/
291			public function testUpdate()
292			{
293			$data = ['foo' => 'bar'];
294			$template = $this->getMock(TemplateEntity::class);
295			$template
296			->expects($this->once())
297			->method('setUpdatedAt')
298			->with($this->isInstanceOf(DateTime::class));
299
300			$this->hydrator
301			->expects($this->once())
302			->method('extract')
303			->will($this->returnValue([]));
304
305			$this->inputFilter
306			->expects($this->once())
307			->method('isValid')
308			->will($this->returnValue(true));
309
310			$this->inputFilter
311			->expects($this->once())
312			->method('getValues')
313			->will($this->returnValue($data));
314
315			$this->hydrator
316			->expects($this->once())
317			->method('hydrate')
318			->with($data, $template);
319
320			$this->objectManager
321			->expects($this->once())
322			->method('flush');
323
324			$this->templateService->update($data, $template);
325			}
326
327			/**
328			* @covers ::render
329			*/
330			public function testRenderWillMergePredefinedParametersWithParameters()
331			{
332			$locale = 'sv_SE';
333			$templateId = 'test:template:id';
334			$parameters = ['company' => 'Roave'];
335			$predefinedParameters = ['company' => 'ShouldNotBeThisOne', 'anotherOneThatShouldBeIncluded' => 'value'];
336			$expectedParameters = ['company' => 'Roave', 'anotherOneThatShouldBeIncluded' => 'value'];
337
338			$this->options->setPredefinedParams($predefinedParameters);
339
340			$template = new TemplateEntity();
341			$template->setSubject($this->options->getDefaultSubject());
342			$template->setTextBody(sprintf($this->options->getDefaultBody(), $templateId, $locale));
343			$template->setHtmlBody(sprintf($this->options->getDefaultBody(), $templateId, $locale));
344
345			$engine = $this->getMock(EngineInterface::class);
346
347			// First run is the subject
348			$engine
349			->expects($this->at(0))
350			->method('render')
351			->with($template->getSubject(), $expectedParameters)
352			->will($this->returnValue($template->getSubject()));
353
354			// Second run is the html body
355			$engine
356			->expects($this->at(1))
357			->method('render')
358			->with($template->getHtmlBody(), $expectedParameters)
359			->will($this->returnValue($template->getHtmlBody()));
360
361			// Third run is the text body
362			$engine
363			->expects($this->at(2))
364			->method('render')
365			->with($template->getTextBody(), $expectedParameters)
366			->will($this->returnValue($template->getTextBody()));
367
368			$this->repository
369			->expects($this->once())
370			->method('getByIdAndLocale')
371			->with($templateId, $locale)
372			->will($this->returnValue($template));
373
374			$this->engineManager
375			->expects($this->once())
376			->method('get')
377			->will($this->returnValue($engine));
378
379			list ($subject, $html, $text) = $this->templateService->render($templateId, $locale, $parameters);
380
381			$this->assertEquals($template->getSubject(), $subject);
382			$this->assertEquals($template->getHtmlBody(), $html);
383			$this->assertEquals($template->getTextBody(), $text);
384			}
385			}
386

Roave / EmailTemplates

Pull Request — master (#10)

testRenderWillMergePredefinedParametersWithParameters() A

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like