[github/shaarli/Shaarli.git] / tests / front / controller / admin / ManageShaareControllerTest / DeleteBookmarkTest.php

<?php

declare(strict_types=1);

namespace Shaarli\Front\Controller\Admin\ManageShaareControllerTest;

use Shaarli\Bookmark\Bookmark;
use Shaarli\Bookmark\Exception\BookmarkNotFoundException;
use Shaarli\Formatter\BookmarkFormatter;
use Shaarli\Formatter\FormatterFactory;
use Shaarli\Front\Controller\Admin\FrontAdminControllerMockHelper;
use Shaarli\Front\Controller\Admin\ManageShaareController;
use Shaarli\Http\HttpAccess;
use Shaarli\Security\SessionManager;
use Shaarli\TestCase;
use Slim\Http\Request;
use Slim\Http\Response;

class DeleteBookmarkTest extends TestCase
{
    use FrontAdminControllerMockHelper;

    /** @var ManageShaareController */
    protected $controller;

    public function setUp(): void
    {
        $this->createContainer();

        $this->container->httpAccess = $this->createMock(HttpAccess::class);
        $this->controller = new ManageShaareController($this->container);
    }

    /**
     * Delete bookmark - Single bookmark with valid parameters
     */
    public function testDeleteSingleBookmark(): void
    {
        $parameters = ['id' => '123'];

        $request = $this->createMock(Request::class);
        $request
            ->method('getParam')
            ->willReturnCallback(function (string $key) use ($parameters): ?string {
                return $parameters[$key] ?? null;
            })
        ;
        $response = new Response();

        $bookmark = (new Bookmark())->setId(123)->setUrl('http://domain.tld')->setTitle('Title 123');

        $this->container->bookmarkService->expects(static::once())->method('get')->with(123)->willReturn($bookmark);
        $this->container->bookmarkService->expects(static::once())->method('remove')->with($bookmark, false);
        $this->container->bookmarkService->expects(static::once())->method('save');
        $this->container->formatterFactory = $this->createMock(FormatterFactory::class);
        $this->container->formatterFactory
            ->expects(static::once())
            ->method('getFormatter')
            ->with('raw')
            ->willReturnCallback(function () use ($bookmark): BookmarkFormatter {
                $formatter = $this->createMock(BookmarkFormatter::class);
                $formatter
                    ->expects(static::once())
                    ->method('format')
                    ->with($bookmark)
                    ->willReturn(['formatted' => $bookmark])
                ;

                return $formatter;
            })
        ;

        // Make sure that PluginManager hook is triggered
        $this->container->pluginManager
            ->expects(static::once())
            ->method('executeHooks')
            ->with('delete_link', ['formatted' => $bookmark])
        ;

        $result = $this->controller->deleteBookmark($request, $response);

        static::assertSame(302, $result->getStatusCode());
        static::assertSame(['/subfolder/'], $result->getHeader('location'));
    }

    /**
     * Delete bookmark - Multiple bookmarks with valid parameters
     */
    public function testDeleteMultipleBookmarks(): void
    {
        $parameters = ['id' => '123 456 789'];

        $request = $this->createMock(Request::class);
        $request
            ->method('getParam')
            ->willReturnCallback(function (string $key) use ($parameters): ?string {
                return $parameters[$key] ?? null;
            })
        ;
        $response = new Response();

        $bookmarks = [
            (new Bookmark())->setId(123)->setUrl('http://domain.tld')->setTitle('Title 123'),
            (new Bookmark())->setId(456)->setUrl('http://domain.tld')->setTitle('Title 456'),
            (new Bookmark())->setId(789)->setUrl('http://domain.tld')->setTitle('Title 789'),
        ];

        $this->container->bookmarkService
            ->expects(static::exactly(3))
            ->method('get')
            ->withConsecutive([123], [456], [789])
            ->willReturnOnConsecutiveCalls(...$bookmarks)
        ;
        $this->container->bookmarkService
            ->expects(static::exactly(3))
            ->method('remove')
            ->withConsecutive(...array_map(function (Bookmark $bookmark): array {
                return [$bookmark, false];
            }, $bookmarks))
        ;
        $this->container->bookmarkService->expects(static::once())->method('save');
        $this->container->formatterFactory = $this->createMock(FormatterFactory::class);
        $this->container->formatterFactory
            ->expects(static::once())
            ->method('getFormatter')
            ->with('raw')
            ->willReturnCallback(function () use ($bookmarks): BookmarkFormatter {
                $formatter = $this->createMock(BookmarkFormatter::class);

                $formatter
                    ->expects(static::exactly(3))
                    ->method('format')
                    ->withConsecutive(...array_map(function (Bookmark $bookmark): array {
                        return [$bookmark];
                    }, $bookmarks))
                    ->willReturnOnConsecutiveCalls(...array_map(function (Bookmark $bookmark): array {
                        return ['formatted' => $bookmark];
                    }, $bookmarks))
                ;

                return $formatter;
            })
        ;

        // Make sure that PluginManager hook is triggered
        $this->container->pluginManager
            ->expects(static::exactly(3))
            ->method('executeHooks')
            ->with('delete_link')
        ;

        $result = $this->controller->deleteBookmark($request, $response);

        static::assertSame(302, $result->getStatusCode());
        static::assertSame(['/subfolder/'], $result->getHeader('location'));
    }

    /**
     * Delete bookmark - Single bookmark not found in the data store
     */
    public function testDeleteSingleBookmarkNotFound(): void
    {
        $parameters = ['id' => '123'];

        $request = $this->createMock(Request::class);
        $request
            ->method('getParam')
            ->willReturnCallback(function (string $key) use ($parameters): ?string {
                return $parameters[$key] ?? null;
            })
        ;
        $response = new Response();

        $this->container->bookmarkService
            ->expects(static::once())
            ->method('get')
            ->willThrowException(new BookmarkNotFoundException())
        ;
        $this->container->bookmarkService->expects(static::never())->method('remove');
        $this->container->bookmarkService->expects(static::never())->method('save');
        $this->container->formatterFactory = $this->createMock(FormatterFactory::class);
        $this->container->formatterFactory
            ->expects(static::once())
            ->method('getFormatter')
            ->with('raw')
            ->willReturnCallback(function (): BookmarkFormatter {
                $formatter = $this->createMock(BookmarkFormatter::class);

                $formatter->expects(static::never())->method('format');

                return $formatter;
            })
        ;
        // Make sure that PluginManager hook is not triggered
        $this->container->pluginManager
            ->expects(static::never())
            ->method('executeHooks')
            ->with('delete_link')
        ;

        $result = $this->controller->deleteBookmark($request, $response);

        static::assertSame(302, $result->getStatusCode());
        static::assertSame(['/subfolder/'], $result->getHeader('location'));
    }

    /**
     * Delete bookmark - Multiple bookmarks with one not found in the data store
     */
    public function testDeleteMultipleBookmarksOneNotFound(): void
    {
        $parameters = ['id' => '123 456 789'];

        $request = $this->createMock(Request::class);
        $request
            ->method('getParam')
            ->willReturnCallback(function (string $key) use ($parameters): ?string {
                return $parameters[$key] ?? null;
            })
        ;
        $response = new Response();

        $bookmarks = [
            (new Bookmark())->setId(123)->setUrl('http://domain.tld')->setTitle('Title 123'),
            (new Bookmark())->setId(789)->setUrl('http://domain.tld')->setTitle('Title 789'),
        ];

        $this->container->bookmarkService
            ->expects(static::exactly(3))
            ->method('get')
            ->withConsecutive([123], [456], [789])
            ->willReturnCallback(function (int $id) use ($bookmarks): Bookmark {
                if ($id === 123) {
                    return $bookmarks[0];
                }
                if ($id === 789) {
                    return $bookmarks[1];
                }
                throw new BookmarkNotFoundException();
            })
        ;
        $this->container->bookmarkService
            ->expects(static::exactly(2))
            ->method('remove')
            ->withConsecutive(...array_map(function (Bookmark $bookmark): array {
                return [$bookmark, false];
            }, $bookmarks))
        ;
        $this->container->bookmarkService->expects(static::once())->method('save');
        $this->container->formatterFactory = $this->createMock(FormatterFactory::class);
        $this->container->formatterFactory
            ->expects(static::once())
            ->method('getFormatter')
            ->with('raw')
            ->willReturnCallback(function () use ($bookmarks): BookmarkFormatter {
                $formatter = $this->createMock(BookmarkFormatter::class);

                $formatter
                    ->expects(static::exactly(2))
                    ->method('format')
                    ->withConsecutive(...array_map(function (Bookmark $bookmark): array {
                        return [$bookmark];
                    }, $bookmarks))
                    ->willReturnOnConsecutiveCalls(...array_map(function (Bookmark $bookmark): array {
                        return ['formatted' => $bookmark];
                    }, $bookmarks))
                ;

                return $formatter;
            })
        ;

        // Make sure that PluginManager hook is not triggered
        $this->container->pluginManager
            ->expects(static::exactly(2))
            ->method('executeHooks')
            ->with('delete_link')
        ;

        $this->container->sessionManager
            ->expects(static::once())
            ->method('setSessionParameter')
            ->with(SessionManager::KEY_ERROR_MESSAGES, ['Bookmark with identifier 456 could not be found.'])
        ;

        $result = $this->controller->deleteBookmark($request, $response);

        static::assertSame(302, $result->getStatusCode());
        static::assertSame(['/subfolder/'], $result->getHeader('location'));
    }

    /**
     * Delete bookmark - Invalid ID
     */
    public function testDeleteInvalidId(): void
    {
        $parameters = ['id' => 'nope not an ID'];

        $request = $this->createMock(Request::class);
        $request
            ->method('getParam')
            ->willReturnCallback(function (string $key) use ($parameters): ?string {
                return $parameters[$key] ?? null;
            })
        ;
        $response = new Response();

        $this->container->sessionManager
            ->expects(static::once())
            ->method('setSessionParameter')
            ->with(SessionManager::KEY_ERROR_MESSAGES, ['Invalid bookmark ID provided.'])
        ;

        $result = $this->controller->deleteBookmark($request, $response);

        static::assertSame(302, $result->getStatusCode());
        static::assertSame(['/subfolder/'], $result->getHeader('location'));
    }

    /**
     * Delete bookmark - Empty ID
     */
    public function testDeleteEmptyId(): void
    {
        $request = $this->createMock(Request::class);
        $response = new Response();

        $this->container->sessionManager
            ->expects(static::once())
            ->method('setSessionParameter')
            ->with(SessionManager::KEY_ERROR_MESSAGES, ['Invalid bookmark ID provided.'])
        ;

        $result = $this->controller->deleteBookmark($request, $response);

        static::assertSame(302, $result->getStatusCode());
        static::assertSame(['/subfolder/'], $result->getHeader('location'));
    }

    /**
     * Delete bookmark - from bookmarklet
     */
    public function testDeleteBookmarkFromBookmarklet(): void
    {
        $parameters = [
            'id' => '123',
            'source' => 'bookmarklet',
        ];

        $request = $this->createMock(Request::class);
        $request
            ->method('getParam')
            ->willReturnCallback(function (string $key) use ($parameters): ?string {
                return $parameters[$key] ?? null;
            })
        ;
        $response = new Response();

        $this->container->formatterFactory = $this->createMock(FormatterFactory::class);
        $this->container->formatterFactory
            ->expects(static::once())
            ->method('getFormatter')
            ->willReturnCallback(function (): BookmarkFormatter {
                $formatter = $this->createMock(BookmarkFormatter::class);
                $formatter->method('format')->willReturn(['formatted']);

                return $formatter;
            })
        ;

        $result = $this->controller->deleteBookmark($request, $response);

        static::assertSame(200, $result->getStatusCode());
        static::assertSame('<script>self.close();</script>', (string) $result->getBody('location'));
    }
}
Commit	Line	Data
baa69791 A	1	<?php
	2
	3	declare(strict_types=1);
	4
	5	namespace Shaarli\Front\Controller\Admin\ManageShaareControllerTest;
	6
baa69791 A	7	use Shaarli\Bookmark\Bookmark;
	8	use Shaarli\Bookmark\Exception\BookmarkNotFoundException;
	9	use Shaarli\Formatter\BookmarkFormatter;
	10	use Shaarli\Formatter\FormatterFactory;
	11	use Shaarli\Front\Controller\Admin\FrontAdminControllerMockHelper;
	12	use Shaarli\Front\Controller\Admin\ManageShaareController;
	13	use Shaarli\Http\HttpAccess;
	14	use Shaarli\Security\SessionManager;
a5a9cf23	15	use Shaarli\TestCase;
baa69791 A	16	use Slim\Http\Request;
	17	use Slim\Http\Response;
	18
	19	class DeleteBookmarkTest extends TestCase
	20	{
	21	use FrontAdminControllerMockHelper;
	22
	23	/** @var ManageShaareController */
	24	protected $controller;
	25
	26	public function setUp(): void
	27	{
	28	$this->createContainer();
	29
	30	$this->container->httpAccess = $this->createMock(HttpAccess::class);
	31	$this->controller = new ManageShaareController($this->container);
	32	}
	33
	34	/**
	35	* Delete bookmark - Single bookmark with valid parameters
	36	*/
	37	public function testDeleteSingleBookmark(): void
	38	{
	39	$parameters = ['id' => '123'];
	40
	41	$request = $this->createMock(Request::class);
	42	$request
	43	->method('getParam')
	44	->willReturnCallback(function (string $key) use ($parameters): ?string {
	45	return $parameters[$key] ?? null;
	46	})
	47	;
	48	$response = new Response();
	49
	50	$bookmark = (new Bookmark())->setId(123)->setUrl('http://domain.tld')->setTitle('Title 123');
	51
	52	$this->container->bookmarkService->expects(static::once())->method('get')->with(123)->willReturn($bookmark);
	53	$this->container->bookmarkService->expects(static::once())->method('remove')->with($bookmark, false);
	54	$this->container->bookmarkService->expects(static::once())->method('save');
	55	$this->container->formatterFactory = $this->createMock(FormatterFactory::class);
	56	$this->container->formatterFactory
	57	->expects(static::once())
	58	->method('getFormatter')
	59	->with('raw')
	60	->willReturnCallback(function () use ($bookmark): BookmarkFormatter {
	61	$formatter = $this->createMock(BookmarkFormatter::class);
9fbc4229 A	62	$formatter
	63	->expects(static::once())
	64	->method('format')
	65	->with($bookmark)
	66	->willReturn(['formatted' => $bookmark])
	67	;
baa69791 A	68
	69	return $formatter;
	70	})
	71	;
	72
	73	// Make sure that PluginManager hook is triggered
	74	$this->container->pluginManager
	75	->expects(static::once())
	76	->method('executeHooks')
9fbc4229	77	->with('delete_link', ['formatted' => $bookmark])
baa69791 A	78	;
	79
	80	$result = $this->controller->deleteBookmark($request, $response);
	81
	82	static::assertSame(302, $result->getStatusCode());
	83	static::assertSame(['/subfolder/'], $result->getHeader('location'));
	84	}
	85
	86	/**
	87	* Delete bookmark - Multiple bookmarks with valid parameters
	88	*/
	89	public function testDeleteMultipleBookmarks(): void
	90	{
	91	$parameters = ['id' => '123 456 789'];
	92
	93	$request = $this->createMock(Request::class);
	94	$request
	95	->method('getParam')
	96	->willReturnCallback(function (string $key) use ($parameters): ?string {
	97	return $parameters[$key] ?? null;
	98	})
	99	;
	100	$response = new Response();
	101
	102	$bookmarks = [
	103	(new Bookmark())->setId(123)->setUrl('http://domain.tld')->setTitle('Title 123'),
	104	(new Bookmark())->setId(456)->setUrl('http://domain.tld')->setTitle('Title 456'),
	105	(new Bookmark())->setId(789)->setUrl('http://domain.tld')->setTitle('Title 789'),
	106	];
	107
	108	$this->container->bookmarkService
	109	->expects(static::exactly(3))
	110	->method('get')
	111	->withConsecutive([123], [456], [789])
	112	->willReturnOnConsecutiveCalls(...$bookmarks)
	113	;
	114	$this->container->bookmarkService
	115	->expects(static::exactly(3))
	116	->method('remove')
	117	->withConsecutive(...array_map(function (Bookmark $bookmark): array {
	118	return [$bookmark, false];
	119	}, $bookmarks))
	120	;
	121	$this->container->bookmarkService->expects(static::once())->method('save');
	122	$this->container->formatterFactory = $this->createMock(FormatterFactory::class);
	123	$this->container->formatterFactory
	124	->expects(static::once())
	125	->method('getFormatter')
	126	->with('raw')
	127	->willReturnCallback(function () use ($bookmarks): BookmarkFormatter {
	128	$formatter = $this->createMock(BookmarkFormatter::class);
	129
	130	$formatter
	131	->expects(static::exactly(3))
	132	->method('format')
	133	->withConsecutive(...array_map(function (Bookmark $bookmark): array {
	134	return [$bookmark];
	135	}, $bookmarks))
9fbc4229 A	136	->willReturnOnConsecutiveCalls(...array_map(function (Bookmark $bookmark): array {
	137	return ['formatted' => $bookmark];
	138	}, $bookmarks))
baa69791 A	139	;
	140
	141	return $formatter;
	142	})
	143	;
	144
	145	// Make sure that PluginManager hook is triggered
	146	$this->container->pluginManager
	147	->expects(static::exactly(3))
	148	->method('executeHooks')
	149	->with('delete_link')
	150	;
	151
	152	$result = $this->controller->deleteBookmark($request, $response);
	153
	154	static::assertSame(302, $result->getStatusCode());
	155	static::assertSame(['/subfolder/'], $result->getHeader('location'));
	156	}
	157
	158	/**
	159	* Delete bookmark - Single bookmark not found in the data store
	160	*/
	161	public function testDeleteSingleBookmarkNotFound(): void
	162	{
	163	$parameters = ['id' => '123'];
	164
	165	$request = $this->createMock(Request::class);
	166	$request
	167	->method('getParam')
	168	->willReturnCallback(function (string $key) use ($parameters): ?string {
	169	return $parameters[$key] ?? null;
	170	})
	171	;
	172	$response = new Response();
	173
	174	$this->container->bookmarkService
	175	->expects(static::once())
	176	->method('get')
	177	->willThrowException(new BookmarkNotFoundException())
	178	;
	179	$this->container->bookmarkService->expects(static::never())->method('remove');
	180	$this->container->bookmarkService->expects(static::never())->method('save');
	181	$this->container->formatterFactory = $this->createMock(FormatterFactory::class);
	182	$this->container->formatterFactory
	183	->expects(static::once())
	184	->method('getFormatter')
	185	->with('raw')
	186	->willReturnCallback(function (): BookmarkFormatter {
	187	$formatter = $this->createMock(BookmarkFormatter::class);
	188
	189	$formatter->expects(static::never())->method('format');
	190
	191	return $formatter;
	192	})
	193	;
	194	// Make sure that PluginManager hook is not triggered
	195	$this->container->pluginManager
	196	->expects(static::never())
	197	->method('executeHooks')
	198	->with('delete_link')
	199	;
	200
	201	$result = $this->controller->deleteBookmark($request, $response);
	202
203	static::assertSame(302, $result->getStatusCode());
204	static::assertSame(['/subfolder/'], $result->getHeader('location'));
205	}
206
207	/**
208	* Delete bookmark - Multiple bookmarks with one not found in the data store
209	*/
210	public function testDeleteMultipleBookmarksOneNotFound(): void
211	{
212	$parameters = ['id' => '123 456 789'];
213
214	$request = $this->createMock(Request::class);
215	$request
216	->method('getParam')
217	->willReturnCallback(function (string $key) use ($parameters): ?string {
218	return $parameters[$key] ?? null;
219	})
220	;
221	$response = new Response();
222
223	$bookmarks = [
224	(new Bookmark())->setId(123)->setUrl('http://domain.tld')->setTitle('Title 123'),
225	(new Bookmark())->setId(789)->setUrl('http://domain.tld')->setTitle('Title 789'),
226	];
227
228	$this->container->bookmarkService
229	->expects(static::exactly(3))
230	->method('get')
231	->withConsecutive([123], [456], [789])
232	->willReturnCallback(function (int $id) use ($bookmarks): Bookmark {
233	if ($id === 123) {
234	return $bookmarks[0];
235	}
236	if ($id === 789) {
237	return $bookmarks[1];
238	}
239	throw new BookmarkNotFoundException();
240	})
241	;
242	$this->container->bookmarkService
243	->expects(static::exactly(2))
244	->method('remove')
245	->withConsecutive(...array_map(function (Bookmark $bookmark): array {
246	return [$bookmark, false];
247	}, $bookmarks))
248	;
249	$this->container->bookmarkService->expects(static::once())->method('save');
250	$this->container->formatterFactory = $this->createMock(FormatterFactory::class);
251	$this->container->formatterFactory
252	->expects(static::once())
253	->method('getFormatter')
254	->with('raw')
255	->willReturnCallback(function () use ($bookmarks): BookmarkFormatter {
256	$formatter = $this->createMock(BookmarkFormatter::class);
257
258	$formatter
259	->expects(static::exactly(2))
260	->method('format')
261	->withConsecutive(...array_map(function (Bookmark $bookmark): array {
262	return [$bookmark];
263	}, $bookmarks))
9fbc4229 A	264	->willReturnOnConsecutiveCalls(...array_map(function (Bookmark $bookmark): array {
	265	return ['formatted' => $bookmark];
	266	}, $bookmarks))
baa69791 A	267	;
	268
	269	return $formatter;
	270	})
	271	;
	272
	273	// Make sure that PluginManager hook is not triggered
	274	$this->container->pluginManager
	275	->expects(static::exactly(2))
	276	->method('executeHooks')
	277	->with('delete_link')
	278	;
	279
	280	$this->container->sessionManager
	281	->expects(static::once())
	282	->method('setSessionParameter')
	283	->with(SessionManager::KEY_ERROR_MESSAGES, ['Bookmark with identifier 456 could not be found.'])
	284	;
	285
	286	$result = $this->controller->deleteBookmark($request, $response);
	287
	288	static::assertSame(302, $result->getStatusCode());
	289	static::assertSame(['/subfolder/'], $result->getHeader('location'));
	290	}
	291
	292	/**
	293	* Delete bookmark - Invalid ID
	294	*/
	295	public function testDeleteInvalidId(): void
	296	{
	297	$parameters = ['id' => 'nope not an ID'];
	298
	299	$request = $this->createMock(Request::class);
	300	$request
	301	->method('getParam')
	302	->willReturnCallback(function (string $key) use ($parameters): ?string {
	303	return $parameters[$key] ?? null;
	304	})
	305	;
	306	$response = new Response();
	307
	308	$this->container->sessionManager
	309	->expects(static::once())
	310	->method('setSessionParameter')
	311	->with(SessionManager::KEY_ERROR_MESSAGES, ['Invalid bookmark ID provided.'])
	312	;
	313
	314	$result = $this->controller->deleteBookmark($request, $response);
	315
	316	static::assertSame(302, $result->getStatusCode());
	317	static::assertSame(['/subfolder/'], $result->getHeader('location'));
	318	}
	319
	320	/**
	321	* Delete bookmark - Empty ID
	322	*/
	323	public function testDeleteEmptyId(): void
	324	{
	325	$request = $this->createMock(Request::class);
	326	$response = new Response();
	327
	328	$this->container->sessionManager
	329	->expects(static::once())
	330	->method('setSessionParameter')
331	->with(SessionManager::KEY_ERROR_MESSAGES, ['Invalid bookmark ID provided.'])
332	;
333
334	$result = $this->controller->deleteBookmark($request, $response);
335
336	static::assertSame(302, $result->getStatusCode());
337	static::assertSame(['/subfolder/'], $result->getHeader('location'));
338	}
339
340	/**
341	* Delete bookmark - from bookmarklet
342	*/
343	public function testDeleteBookmarkFromBookmarklet(): void
344	{
345	$parameters = [
346	'id' => '123',
347	'source' => 'bookmarklet',
348	];
349
350	$request = $this->createMock(Request::class);
351	$request
352	->method('getParam')
353	->willReturnCallback(function (string $key) use ($parameters): ?string {
354	return $parameters[$key] ?? null;
355	})
356	;
357	$response = new Response();
358
359	$this->container->formatterFactory = $this->createMock(FormatterFactory::class);
360	$this->container->formatterFactory
361	->expects(static::once())
362	->method('getFormatter')
9fbc4229 A	363	->willReturnCallback(function (): BookmarkFormatter {
	364	$formatter = $this->createMock(BookmarkFormatter::class);
	365	$formatter->method('format')->willReturn(['formatted']);
	366
	367	return $formatter;
	368	})
baa69791 A	369	;
	370
	371	$result = $this->controller->deleteBookmark($request, $response);
	372
	373	static::assertSame(200, $result->getStatusCode());
	374	static::assertSame('<script>self.close();</script>', (string) $result->getBody('location'));
	375	}
	376	}