ContentTest::parseContentInfoFromResponse() - Code Metrics - Inspection of "[TMP] broken commit on ContentTypeTest" - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — ezp26297-rest_embedding_http_c... ( 6dcd26...7b4207 )

unknown

created 2016-10-04 15:13 UTC

ContentTest::parseContentInfoFromResponse() A

↳ Parent: ContentTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	12
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	6
nc	1
nop	1
dl	0
loc	12
rs	9.4285
c	0
b	0
f	0

<?php

/**
 * File containing the Functional\ContentTest class.
 *
 * @copyright Copyright (C) eZ Systems AS. All rights reserved.
 * @license For full copyright and license information view LICENSE file distributed with this source code.
 *
 * @version //autogentag//
 */
namespace eZ\Bundle\EzPublishRestBundle\Tests\Functional;

use Buzz\Message\Response;
use eZ\Bundle\EzPublishRestBundle\Tests\Functional\TestCase as RESTFunctionalTestCase;
use eZ\Publish\API\Repository\Values\Content\ContentInfo;
use eZ\Publish\Core\Repository\Values\Content\Content;
use eZ\Publish\Core\Repository\Values\Content\VersionInfo;
use eZ\Publish\Core\Repository\Values\ContentType\ContentType;
use eZ\Publish\Core\REST\Server\Values\Version;

class ContentTest extends RESTFunctionalTestCase
{
    private $createdContentTypeId = 1;

    /**
     * @covers POST /content/objects
     *
     * @return string REST content ID
     */
    public function testCreateContent()
    {
        $request = $this->createHttpRequest('POST', '/api/ezp/v2/content/objects', 'ContentCreate+xml', 'ContentInfo+json');
        $string = $this->addTestSuffix(__FUNCTION__);
        $body = <<< XML
<?xml version="1.0" encoding="UTF-8"?>
<ContentCreate>
  <ContentType href="/api/ezp/v2/content/types/{$this->createdContentTypeId}" />
  <mainLanguageCode>eng-GB</mainLanguageCode>
  <LocationCreate>
    <ParentLocation href="/api/ezp/v2/content/locations/1/2" />
    <priority>0</priority>
    <hidden>false</hidden>
    <sortField>PATH</sortField>
    <sortOrder>ASC</sortOrder>
  </LocationCreate>
  <Section href="/api/ezp/v2/content/sections/1" />
  <alwaysAvailable>true</alwaysAvailable>
  <remoteId>{$string}</remoteId>
  <User href="/api/ezp/v2/user/users/14" />
  <modificationDate>2012-09-30T12:30:00</modificationDate>
  <fields>
    <field>
      <fieldDefinitionIdentifier>name</fieldDefinitionIdentifier>
      <languageCode>eng-GB</languageCode>
      <fieldValue>{$string}</fieldValue>
    </field>
  </fields>
</ContentCreate>
XML;
        $request->setContent($body);

        $response = $this->sendHttpRequest($request);

        self::assertHttpResponseCodeEquals($response, 201);
        self::assertHttpResponseHasHeader($response, 'Location');

        $href = $response->getHeader('Location');
        $this->addCreatedElement($href);

        return $href;
    }

    /**
     * @depends testCreateContent
     * @covers PUBLISH /content/objects/<contentId>/versions/<versionNumber>
     *
     * @return string REST content ID
     */
    public function testPublishContent($restContentHref)
    {
        $response = $this->sendHttpRequest(
            $this->createHttpRequest('PUBLISH', "$restContentHref/versions/1")
        );
        self::assertHttpResponseCodeEquals($response, 204);

        return $restContentHref;
    }

    /**
     * @depends testPublishContent
     * @covers GET /content/objects?remoteId=<remoteId>
     */
    public function testRedirectContent($restContentHref)
    {
        $response = $this->sendHttpRequest(
            $this->createHttpRequest('GET', '/api/ezp/v2/content/objects?remoteId=' . $this->addTestSuffix('testCreateContent'))
        );

        self::assertHttpResponseCodeEquals($response, 307);
        self::assertEquals($response->getHeader('Location'), $restContentHref);
    }

    /**
     * @depends testPublishContent
     */
    public function testLoadContent($restContentHref)
    {
        $response = $this->sendHttpRequest(
            $this->createHttpRequest('GET', $restContentHref, '', 'ContentInfo+json')
        );

        self::assertHttpResponseCodeEquals($response, 200);

        return $response;
    }

    /**
     * @depends testLoadContent
     */
    public function testLoadContentCacheTags(Response $response)
    {
        $contentInfo = $this->parseContentInfoFromResponse($response);

        $this->assertHttpResponseHasCacheTags(
            $response,
            [
                'location-' . $contentInfo->mainLocationId,
                'content-' . $contentInfo->id,
                'content-type-' . $contentInfo->contentTypeId,
            ]
        );
    }

    /**
     * @depends testPublishContent
     */
    public function testUpdateContentMetadata($restContentHref)
    {
        $string = $this->addTestSuffix(__FUNCTION__);
        $content = <<< XML
<?xml version="1.0" encoding="UTF-8"?>
<ContentUpdate>
  <Owner href="/api/ezp/v2/user/users/10"/>
  <remoteId>{$string}</remoteId>
</ContentUpdate>
XML;
        $request = $this->createHttpRequest('PATCH', $restContentHref, 'ContentUpdate+xml', 'ContentInfo+json');
        $request->setContent($content);
        $response = $this->sendHttpRequest($request);
        self::assertHttpResponseCodeEquals($response, 200);

        // @todo test data
    }

    /**
     * @depends testPublishContent
     *
     * @return string ContentVersion REST ID
     */
    public function testCreateDraftFromVersion($restContentHref)
    {
        $response = $this->sendHttpRequest(
            $this->createHttpRequest('COPY', "{$restContentHref}/versions/1")
        );

        self::assertHttpResponseCodeEquals($response, 201);
        self::assertEquals($response->getHeader('Location'), "{$restContentHref}/versions/2");

        return $response->getHeader('Location');
    }

    /**
     * @depends testPublishContent
     * @covers GET /content/objects/<contentId>/currentversion
     * @covers \eZ\Publish\Core\REST\Server\Controller\Content::redirectCurrentVersion
     */
    public function testRedirectCurrentVersion($restContentHref)
    {
        $response = $this->sendHttpRequest(
            $this->createHttpRequest('GET', "$restContentHref/currentversion")
        );

        self::assertHttpResponseCodeEquals($response, 307);
        self::assertHttpResponseHasHeader($response, 'Location', "$restContentHref/versions/1");

        $this->assertHttpResponseHasCacheTags(
            $response,
            [
                'content-' . $this->extractLastIdFromHref($restContentHref),
            ]
        );
    }

    /**
     * @depends testCreateDraftFromVersion
     * @covers GET /content/objects/<contentId>/versions/<versionNumber>
     *
     * @param string $restContentVersionHref
     */
    public function testLoadContentVersion($restContentVersionHref)
    {
        $response = $this->sendHttpRequest(
            $this->createHttpRequest('GET', $restContentVersionHref, '', 'Version+json')
        );

        self::assertHttpResponseCodeEquals($response, 200);
        // @todo test data
        // @todo test filtering (language, fields, etc)

        return $response;
    }

    /**
     * @depends testLoadContentVersion
     */
    public function testLoadContentVersionCacheTags(Response $response)
    {
        $version = $this->parseVersionFromResponse($response);

        $this->assertHttpResponseHasCacheTags(
            $response,
            [
                'content-' . $version->content->contentInfo->id,
                'content-type-' . $version->contentType->id,
            ]
        );
    }

    /**
     * @covers COPY /content/objects/<contentId>
     * @depends testPublishContent
     *
     * @return string the copied content href
     */
    public function testCopyContent($restContentHref)
    {
        $testContent = $this->loadContent($restContentHref);

        $request = $this->createHttpRequest('COPY', $restContentHref);
        $request->addHeader('Destination: ' . $testContent['MainLocation']['_href']);

        $response = $this->sendHttpRequest($request);

        self::assertHttpResponseCodeEquals($response, 201);
        self::assertStringStartsWith('/api/ezp/v2/content/objects/', $response->getHeader('Location'));

        $this->addCreatedElement($response->getHeader('Location'));

        return $response->getHeader('Location');
    }

    /**
     * @covers DELETE /content/objects/<versionNumber>
     * @depends testCopyContent
     */
    public function testDeleteContent($restContentHref)
    {
        self::markTestSkipped("Fails as the content created by copyContent isn't found");
        $response = $this->sendHttpRequest(
            $this->createHttpRequest('DELETE', $restContentHref)
        );

        self::assertHttpResponseCodeEquals($response, 204);
    }

    /**
     * @depends testPublishContent
     * @covers GET /content/objects/<contentId>/versions
     */
    public function testLoadContentVersions($restContentHref)
    {
        $response = $this->sendHttpRequest(
            $this->createHttpRequest('GET', "$restContentHref/versions", '', 'VersionList')
        );

        self::assertHttpResponseCodeEquals($response, 200);

        $this->assertHttpResponseHasCacheTags(
            $response,
            ['content-' . $this->extractContentIdFromHref($restContentHref)]
        );
    }

    /**
     * @depends testPublishContent
     *
     * @param string $restContentHref /content/objects/<contentId>
     * @covers COPY /content/objects/<contentId>/currentversion
     *
     * @return string the ID of the created version (/content/objects/<contentId>/versions/<versionNumber>
     */
    public function testCreateDraftFromCurrentVersion($restContentHref)
    {
        $response = $this->sendHttpRequest(
            $this->createHttpRequest('COPY', "$restContentHref/currentversion")
        );

        self::assertHttpResponseCodeEquals($response, 201);
        self::assertHttpResponseHasHeader($response, 'Location');

        return $response->getHeader('Location');
    }

    /**
     * @depends testCreateDraftFromCurrentVersion
     *
     * @param string $restContentVersionHref /api/ezp/v2/content/objects/<contentId>/versions>/<versionNumber>
     * @covers DELETE /api/ezp/v2/content/objects/<contentId>/versions>/<versionNumber>
     */
    public function testDeleteContentVersion($restContentVersionHref)
    {
        $response = $this->sendHttpRequest(
            $this->createHttpRequest('DELETE', $restContentVersionHref)
        );

        self::assertHttpResponseCodeEquals($response, 204);
    }

    /**
     * @depends testCreateDraftFromVersion
     * @covers PATCH /content/objects/<contentId>/versions>/<versionNumber>
     *
     * @param string $restContentVersionHref /content/objects/<contentId>/versions>/<versionNumber>
     */
    public function testUpdateVersion($restContentVersionHref)
    {
        $xml = <<< XML
<VersionUpdate>
    <fields>
        <field>
            <fieldDefinitionIdentifier>name</fieldDefinitionIdentifier>
            <languageCode>eng-GB</languageCode>
            <fieldValue>testUpdateVersion</fieldValue>
        </field>
    </fields>
</VersionUpdate>
XML;

        $request = $this->createHttpRequest('PATCH', $restContentVersionHref, 'VersionUpdate+xml', 'Version+json');
        $request->setContent($xml);
        $response = $this->sendHttpRequest(
            $request
        );

        self::assertHttpResponseCodeEquals($response, 200);
    }

    /**
     * @depends testPublishContent
     * @covers GET /content/objects/<contentId>/relations
     */
    public function testRedirectCurrentVersionRelations($restContentHref)
    {
        $response = $this->sendHttpRequest(
            $this->createHttpRequest('GET', "$restContentHref/relations")
        );

        self::assertHttpResponseCodeEquals($response, 307);

        // @todo Fix, see EZP-21059. Meanwhile, the test is skipped if it fails as expected
        // self::assertHttpResponseHasHeader( $response, 'Location', "$restContentHref/versions/1/relations" );
        self::assertHttpResponseHasHeader($response, 'Location', "$restContentHref/relations?versionNumber=1");
        self::markTestIncomplete('@todo Fix issue EZP-21059');
    }

    /**
     * @depends testCreateDraftFromVersion
     * @covers GET /content/objects/<contentId>/versions/<versionNumber>/relations
     */
    public function testLoadVersionRelations($restContentVersionHref)
    {
        $response = $this->sendHttpRequest(
            $this->createHttpRequest('GET', "$restContentVersionHref/relations")
        );

        self::assertHttpResponseCodeEquals($response, 200);

        $this->assertHttpResponseHasCacheTags(
            $response,
            [
                'content-' . $this->extractContentIdFromHref($restContentVersionHref),
            ]
        );
    }

    /**
     * @depends testCreateDraftFromVersion
     * @covers POST /content/objects/<contentId>/versions/<versionNumber>/relations/<relationId>
     *
     * @return string created relation HREF (/content/objects/<contentId>/versions/<versionNumber>/relations/<relationId>
     */
    public function testCreateRelation($restContentVersionHref)
    {
        $content = <<< XML
<?xml version="1.0" encoding="UTF-8"?>
<RelationCreate>
  <Destination href="/api/ezp/v2/content/objects/10"/>
</RelationCreate>
XML;

        $request = $this->createHttpRequest('POST', "$restContentVersionHref/relations", 'RelationCreate+xml', 'Relation+json');
        $request->setContent($content);

        $response = $this->sendHttpRequest($request);

        self::assertHttpResponseCodeEquals($response, 201);

        $response = json_decode($response->getContent(), true);

        return $response['Relation']['_href'];
    }

    /**
     * @depends testCreateRelation
     * @covers GET /content/objects/<contentId>/versions/<versionNo>/relations/<relationId>
     */
    public function testLoadVersionRelation($restContentRelationHref)
    {
        $response = $this->sendHttpRequest(
            $this->createHttpRequest('GET', $restContentRelationHref)
        );

        self::assertHttpResponseCodeEquals($response, 200);

        $this->assertHttpResponseHasCacheTags(
            $response,
            ['content-' . $this->extractContentIdFromHref($restContentRelationHref)]
        );
    }

    /**
     * Returns the Content key from the decoded JSON of $restContentId's contentInfo.
     *
     *
     * @throws \InvalidArgumentException
     *
     * @param string $restContentHref /api/ezp/v2/content/objects/<contentId>
     *
     * @return array
     */
    private function loadContent($restContentHref)
    {
        $response = $this->sendHttpRequest(
            $this->createHttpRequest('GET', $restContentHref, '', 'ContentInfo+json')
        );

        if ($response->getStatusCode() != 200) {
            throw new \InvalidArgumentException("Content with ID $restContentHref could not be loaded");
        }

        $array = json_decode($response->getContent(), true);
        if ($array === null) {
            self::fail('Error loading content. Response: ' . $response->getContent());
        }

        return $array['Content'];
    }

    public function testCreateView()
    {
        $body = <<< XML
<?xml version="1.0" encoding="UTF-8"?>
<ViewInput>
  <identifier>testCreateView</identifier>
  <Query>
    <Criteria>
      <ContentTypeIdentifierCriterion>folder</ContentTypeIdentifierCriterion>
    </Criteria>
    <limit>10</limit>
    <offset>0</offset>
  </Query>
</ViewInput>
XML;
        $request = $this->createHttpRequest('POST', '/api/ezp/v2/content/views', 'ViewInput+xml', 'View+json');
        $request->setContent($body);
        $response = $this->sendHttpRequest(
            $request
        );

        // Returns 301 since 6.0 (deprecated in favour of /views)
        self::assertHttpResponseCodeEquals($response, 301);
        self::assertHttpResponseHasHeader($response, 'Location');
    }

    /**
     * @param Response $response
     *
     * @return \eZ\Publish\API\Repository\Values\Content\ContentInfo
     */
    private function parseContentInfoFromResponse(Response $response)
    {
        $struct = json_decode($response->getContent(), true);

        return new ContentInfo(
            [
                'mainLocationId' => $this->extractLastIdFromHref($struct['Content']['MainLocation']['_href']),
                'id' => $struct['Content']['_id'],
                'contentTypeId' => $this->extractLastIdFromHref($struct['Content']['ContentType']['_href']),
            ]
        );
    }

    /**
     * @return \eZ\Publish\Core\REST\Server\Values\Version
     */
    private function parseVersionFromResponse(Response $response)
    {
        $responseStruct = json_decode($response->getContent(), true);

        return new Version(
            new Content(
                [
                    'versionInfo' => new VersionInfo(
                        [
                            'contentInfo' => new ContentInfo(
                                [
                                    'id' => $this->extractLastIdFromHref(
                                        $responseStruct['Version']['VersionInfo']['Content']['_href']
                                    ),
                                ]
                            ),
                        ]
                    ),
                ]
            ),
            new ContentType(['id' => $this->createdContentTypeId, 'fieldDefinitions' => []]),
            []
        );
    }
}


1		<?php
2
3		/**
4		* File containing the Functional\ContentTest class.
5		*
6		* @copyright Copyright (C) eZ Systems AS. All rights reserved.
7		* @license For full copyright and license information view LICENSE file distributed with this source code.
8		*
9		* @version //autogentag//
10		*/
11		namespace eZ\Bundle\EzPublishRestBundle\Tests\Functional;
12
13		use Buzz\Message\Response;
14		use eZ\Bundle\EzPublishRestBundle\Tests\Functional\TestCase as RESTFunctionalTestCase;
15		use eZ\Publish\API\Repository\Values\Content\ContentInfo;
16		use eZ\Publish\Core\Repository\Values\Content\Content;
17		use eZ\Publish\Core\Repository\Values\Content\VersionInfo;
18		use eZ\Publish\Core\Repository\Values\ContentType\ContentType;
19		use eZ\Publish\Core\REST\Server\Values\Version;
20
21		class ContentTest extends RESTFunctionalTestCase
22		{
23		private $createdContentTypeId = 1;
24
25		/**
26		* @covers POST /content/objects
27		*
28		* @return string REST content ID
29		*/
30	View Code Duplication	public function testCreateContent()
31		{
32		$request = $this->createHttpRequest('POST', '/api/ezp/v2/content/objects', 'ContentCreate+xml', 'ContentInfo+json');
33		$string = $this->addTestSuffix(__FUNCTION__);
34		$body = <<< XML
35		<?xml version="1.0" encoding="UTF-8"?>
36		<ContentCreate>
37		<ContentType href="/api/ezp/v2/content/types/{$this->createdContentTypeId}" />
38		<mainLanguageCode>eng-GB</mainLanguageCode>
39		<LocationCreate>
40		<ParentLocation href="/api/ezp/v2/content/locations/1/2" />
41		<priority>0</priority>
42		<hidden>false</hidden>
43		<sortField>PATH</sortField>
44		<sortOrder>ASC</sortOrder>
45		</LocationCreate>
46		<Section href="/api/ezp/v2/content/sections/1" />
47		<alwaysAvailable>true</alwaysAvailable>
48		<remoteId>{$string}</remoteId>
49		<User href="/api/ezp/v2/user/users/14" />
50		<modificationDate>2012-09-30T12:30:00</modificationDate>
51		<fields>
52		<field>
53		<fieldDefinitionIdentifier>name</fieldDefinitionIdentifier>
54		<languageCode>eng-GB</languageCode>
55		<fieldValue>{$string}</fieldValue>
56		</field>
57		</fields>
58		</ContentCreate>
59		XML;
60		$request->setContent($body);
61
62		$response = $this->sendHttpRequest($request);
63
64		self::assertHttpResponseCodeEquals($response, 201);
65		self::assertHttpResponseHasHeader($response, 'Location');
66
67		$href = $response->getHeader('Location');
68		$this->addCreatedElement($href);
69
70		return $href;
71		}
72
73		/**
74		* @depends testCreateContent
75		* @covers PUBLISH /content/objects/<contentId>/versions/<versionNumber>
76		*
77		* @return string REST content ID
78		*/
79		public function testPublishContent($restContentHref)
80		{
81		$response = $this->sendHttpRequest(
82		$this->createHttpRequest('PUBLISH', "$restContentHref/versions/1")
83		);
84		self::assertHttpResponseCodeEquals($response, 204);
85
86		return $restContentHref;
87		}
88
89		/**
90		* @depends testPublishContent
91		* @covers GET /content/objects?remoteId=<remoteId>
92		*/
93		public function testRedirectContent($restContentHref)
94		{
95		$response = $this->sendHttpRequest(
96		$this->createHttpRequest('GET', '/api/ezp/v2/content/objects?remoteId=' . $this->addTestSuffix('testCreateContent'))
97		);
98
99		self::assertHttpResponseCodeEquals($response, 307);
100		self::assertEquals($response->getHeader('Location'), $restContentHref);
101		}
102
103		/**
104		* @depends testPublishContent
105		*/
106	View Code Duplication	public function testLoadContent($restContentHref)
107		{
108		$response = $this->sendHttpRequest(
109		$this->createHttpRequest('GET', $restContentHref, '', 'ContentInfo+json')
110		);
111
112		self::assertHttpResponseCodeEquals($response, 200);
113
114		return $response;
115		}
116
117		/**
118		* @depends testLoadContent
119		*/
120		public function testLoadContentCacheTags(Response $response)
121		{
122		$contentInfo = $this->parseContentInfoFromResponse($response);
123
124		$this->assertHttpResponseHasCacheTags(
125		$response,
126		[
127		'location-' . $contentInfo->mainLocationId,
128		'content-' . $contentInfo->id,
129		'content-type-' . $contentInfo->contentTypeId,
130		]
131		);
132		}
133
134		/**
135		* @depends testPublishContent
136		*/
137		public function testUpdateContentMetadata($restContentHref)
138		{
139		$string = $this->addTestSuffix(__FUNCTION__);
140		$content = <<< XML
141		<?xml version="1.0" encoding="UTF-8"?>
142		<ContentUpdate>
143		<Owner href="/api/ezp/v2/user/users/10"/>
144		<remoteId>{$string}</remoteId>
145		</ContentUpdate>
146		XML;
147		$request = $this->createHttpRequest('PATCH', $restContentHref, 'ContentUpdate+xml', 'ContentInfo+json');
148		$request->setContent($content);
149		$response = $this->sendHttpRequest($request);
150		self::assertHttpResponseCodeEquals($response, 200);
151
152		// @todo test data
153		}
154
155		/**
156		* @depends testPublishContent
157		*
158		* @return string ContentVersion REST ID
159		*/
160	View Code Duplication	public function testCreateDraftFromVersion($restContentHref)
161		{
162		$response = $this->sendHttpRequest(
163		$this->createHttpRequest('COPY', "{$restContentHref}/versions/1")
164		);
165
166		self::assertHttpResponseCodeEquals($response, 201);
167		self::assertEquals($response->getHeader('Location'), "{$restContentHref}/versions/2");
168
169		return $response->getHeader('Location');
170		}
171
172		/**
173		* @depends testPublishContent
174		* @covers GET /content/objects/<contentId>/currentversion
175		* @covers \eZ\Publish\Core\REST\Server\Controller\Content::redirectCurrentVersion
176		*/
177	View Code Duplication	public function testRedirectCurrentVersion($restContentHref)
178		{
179		$response = $this->sendHttpRequest(
180		$this->createHttpRequest('GET', "$restContentHref/currentversion")
181		);
182
183		self::assertHttpResponseCodeEquals($response, 307);
184		self::assertHttpResponseHasHeader($response, 'Location', "$restContentHref/versions/1");
185
186		$this->assertHttpResponseHasCacheTags(
187		$response,
188		[
189		'content-' . $this->extractLastIdFromHref($restContentHref),
190		]
191		);
192		}
193
194		/**
195		* @depends testCreateDraftFromVersion
196		* @covers GET /content/objects/<contentId>/versions/<versionNumber>
197		*
198		* @param string $restContentVersionHref
199		*/
200	View Code Duplication	public function testLoadContentVersion($restContentVersionHref)
201		{
202		$response = $this->sendHttpRequest(
203		$this->createHttpRequest('GET', $restContentVersionHref, '', 'Version+json')
204		);
205
206		self::assertHttpResponseCodeEquals($response, 200);
207		// @todo test data
208		// @todo test filtering (language, fields, etc)
209
210		return $response;
211		}
212
213		/**
214		* @depends testLoadContentVersion
215		*/
216		public function testLoadContentVersionCacheTags(Response $response)
217		{
218		$version = $this->parseVersionFromResponse($response);
219
220		$this->assertHttpResponseHasCacheTags(
221		$response,
222		[
223		'content-' . $version->content->contentInfo->id,
224		'content-type-' . $version->contentType->id,
225		]
226		);
227		}
228
229		/**
230		* @covers COPY /content/objects/<contentId>
231		* @depends testPublishContent
232		*
233		* @return string the copied content href
234		*/
235		public function testCopyContent($restContentHref)
236		{
237		$testContent = $this->loadContent($restContentHref);
238
239		$request = $this->createHttpRequest('COPY', $restContentHref);
240		$request->addHeader('Destination: ' . $testContent['MainLocation']['_href']);
241
242		$response = $this->sendHttpRequest($request);
243
244		self::assertHttpResponseCodeEquals($response, 201);
245		self::assertStringStartsWith('/api/ezp/v2/content/objects/', $response->getHeader('Location'));
246
247		$this->addCreatedElement($response->getHeader('Location'));
248
249		return $response->getHeader('Location');
250		}
251
252		/**
253		* @covers DELETE /content/objects/<versionNumber>
254		* @depends testCopyContent
255		*/
256		public function testDeleteContent($restContentHref)
257		{
258		self::markTestSkipped("Fails as the content created by copyContent isn't found");
259		$response = $this->sendHttpRequest(
260		$this->createHttpRequest('DELETE', $restContentHref)
261		);
262
263		self::assertHttpResponseCodeEquals($response, 204);
264		}
265
266		/**
267		* @depends testPublishContent
268		* @covers GET /content/objects/<contentId>/versions
269		*/
270	View Code Duplication	public function testLoadContentVersions($restContentHref)
271		{
272		$response = $this->sendHttpRequest(
273		$this->createHttpRequest('GET', "$restContentHref/versions", '', 'VersionList')
274		);
275
276		self::assertHttpResponseCodeEquals($response, 200);
277
278		$this->assertHttpResponseHasCacheTags(
279		$response,
280		['content-' . $this->extractContentIdFromHref($restContentHref)]
281		);
282		}
283
284		/**
285		* @depends testPublishContent
286		*
287		* @param string $restContentHref /content/objects/<contentId>
288		* @covers COPY /content/objects/<contentId>/currentversion
289		*
290		* @return string the ID of the created version (/content/objects/<contentId>/versions/<versionNumber>
291		*/
292	View Code Duplication	public function testCreateDraftFromCurrentVersion($restContentHref)
293		{
294		$response = $this->sendHttpRequest(
295		$this->createHttpRequest('COPY', "$restContentHref/currentversion")
296		);
297
298		self::assertHttpResponseCodeEquals($response, 201);
299		self::assertHttpResponseHasHeader($response, 'Location');
300
301		return $response->getHeader('Location');
302		}
303
304		/**
305		* @depends testCreateDraftFromCurrentVersion
306		*
307		* @param string $restContentVersionHref /api/ezp/v2/content/objects/<contentId>/versions>/<versionNumber>
308		* @covers DELETE /api/ezp/v2/content/objects/<contentId>/versions>/<versionNumber>
309		*/
310		public function testDeleteContentVersion($restContentVersionHref)
311		{
312		$response = $this->sendHttpRequest(
313		$this->createHttpRequest('DELETE', $restContentVersionHref)
314		);
315
316		self::assertHttpResponseCodeEquals($response, 204);
317		}
318
319		/**
320		* @depends testCreateDraftFromVersion
321		* @covers PATCH /content/objects/<contentId>/versions>/<versionNumber>
322		*
323		* @param string $restContentVersionHref /content/objects/<contentId>/versions>/<versionNumber>
324		*/
325		public function testUpdateVersion($restContentVersionHref)
326		{
327		$xml = <<< XML
328		<VersionUpdate>
329		<fields>
330		<field>
331		<fieldDefinitionIdentifier>name</fieldDefinitionIdentifier>
332		<languageCode>eng-GB</languageCode>
333		<fieldValue>testUpdateVersion</fieldValue>
334		</field>
335		</fields>
336		</VersionUpdate>
337		XML;
338
339		$request = $this->createHttpRequest('PATCH', $restContentVersionHref, 'VersionUpdate+xml', 'Version+json');
340		$request->setContent($xml);
341		$response = $this->sendHttpRequest(
342		$request
343		);
344
345		self::assertHttpResponseCodeEquals($response, 200);
346		}
347
348		/**
349		* @depends testPublishContent
350		* @covers GET /content/objects/<contentId>/relations
351		*/
352		public function testRedirectCurrentVersionRelations($restContentHref)
353		{
354		$response = $this->sendHttpRequest(
355		$this->createHttpRequest('GET', "$restContentHref/relations")
356		);
357
358		self::assertHttpResponseCodeEquals($response, 307);
359
360		// @todo Fix, see EZP-21059. Meanwhile, the test is skipped if it fails as expected
361		// self::assertHttpResponseHasHeader( $response, 'Location', "$restContentHref/versions/1/relations" );
362		self::assertHttpResponseHasHeader($response, 'Location', "$restContentHref/relations?versionNumber=1");
363		self::markTestIncomplete('@todo Fix issue EZP-21059');
364		}
365
366		/**
367		* @depends testCreateDraftFromVersion
368		* @covers GET /content/objects/<contentId>/versions/<versionNumber>/relations
369		*/
370	View Code Duplication	public function testLoadVersionRelations($restContentVersionHref)
371		{
372		$response = $this->sendHttpRequest(
373		$this->createHttpRequest('GET', "$restContentVersionHref/relations")
374		);
375
376		self::assertHttpResponseCodeEquals($response, 200);
377
378		$this->assertHttpResponseHasCacheTags(
379		$response,
380		[
381		'content-' . $this->extractContentIdFromHref($restContentVersionHref),
382		]
383		);
384		}
385
386		/**
387		* @depends testCreateDraftFromVersion
388		* @covers POST /content/objects/<contentId>/versions/<versionNumber>/relations/<relationId>
389		*
390		* @return string created relation HREF (/content/objects/<contentId>/versions/<versionNumber>/relations/<relationId>
391		*/
392		public function testCreateRelation($restContentVersionHref)
393		{
394		$content = <<< XML
395		<?xml version="1.0" encoding="UTF-8"?>
396		<RelationCreate>
397		<Destination href="/api/ezp/v2/content/objects/10"/>
398		</RelationCreate>
399		XML;
400
401		$request = $this->createHttpRequest('POST', "$restContentVersionHref/relations", 'RelationCreate+xml', 'Relation+json');
402		$request->setContent($content);
403
404		$response = $this->sendHttpRequest($request);
405
406		self::assertHttpResponseCodeEquals($response, 201);
407
408		$response = json_decode($response->getContent(), true);
409
410		return $response['Relation']['_href'];
411		}
412
413		/**
414		* @depends testCreateRelation
415		* @covers GET /content/objects/<contentId>/versions/<versionNo>/relations/<relationId>
416		*/
417		public function testLoadVersionRelation($restContentRelationHref)
418		{
419		$response = $this->sendHttpRequest(
420		$this->createHttpRequest('GET', $restContentRelationHref)
421		);
422
423		self::assertHttpResponseCodeEquals($response, 200);
424
425		$this->assertHttpResponseHasCacheTags(
426		$response,
427		['content-' . $this->extractContentIdFromHref($restContentRelationHref)]
428		);
429		}
430
431		/**
432		* Returns the Content key from the decoded JSON of $restContentId's contentInfo.
433		*
434		*
435		* @throws \InvalidArgumentException
436		*
437		* @param string $restContentHref /api/ezp/v2/content/objects/<contentId>
438		*
439		* @return array
440		*/
441		private function loadContent($restContentHref)
442		{
443		$response = $this->sendHttpRequest(
444		$this->createHttpRequest('GET', $restContentHref, '', 'ContentInfo+json')
445		);
446
447		if ($response->getStatusCode() != 200) {
448		throw new \InvalidArgumentException("Content with ID $restContentHref could not be loaded");
449		}
450
451		$array = json_decode($response->getContent(), true);
452		if ($array === null) {
453		self::fail('Error loading content. Response: ' . $response->getContent());
454		}
455
456		return $array['Content'];
457		}
458
459		public function testCreateView()
460		{
461		$body = <<< XML
462		<?xml version="1.0" encoding="UTF-8"?>
463		<ViewInput>
464		<identifier>testCreateView</identifier>
465		<Query>
466		<Criteria>
467		<ContentTypeIdentifierCriterion>folder</ContentTypeIdentifierCriterion>
468		</Criteria>
469		<limit>10</limit>
470		<offset>0</offset>
471		</Query>
472		</ViewInput>
473		XML;
474		$request = $this->createHttpRequest('POST', '/api/ezp/v2/content/views', 'ViewInput+xml', 'View+json');
475		$request->setContent($body);
476		$response = $this->sendHttpRequest(
477		$request
478		);
479
480		// Returns 301 since 6.0 (deprecated in favour of /views)
481		self::assertHttpResponseCodeEquals($response, 301);
482		self::assertHttpResponseHasHeader($response, 'Location');
483		}
484
485		/**
486		* @param Response $response
487		*
488		* @return \eZ\Publish\API\Repository\Values\Content\ContentInfo
489		*/
490		private function parseContentInfoFromResponse(Response $response)
491		{
492		$struct = json_decode($response->getContent(), true);
493
494		return new ContentInfo(
495		[
496		'mainLocationId' => $this->extractLastIdFromHref($struct['Content']['MainLocation']['_href']),
497		'id' => $struct['Content']['_id'],
498		'contentTypeId' => $this->extractLastIdFromHref($struct['Content']['ContentType']['_href']),
499		]
500		);
501		}
502
503		/**
504		* @return \eZ\Publish\Core\REST\Server\Values\Version
505		*/
506		private function parseVersionFromResponse(Response $response)
507		{
508		$responseStruct = json_decode($response->getContent(), true);
509
510		return new Version(
511		new Content(
512		[
513		'versionInfo' => new VersionInfo(
514		[
515		'contentInfo' => new ContentInfo(
516		[
517		'id' => $this->extractLastIdFromHref(
518		$responseStruct['Version']['VersionInfo']['Content']['_href']
519		),
520		]
521		),
522		]
523		),
524		]
525		),
526		new ContentType(['id' => $this->createdContentTypeId, 'fieldDefinitions' => []]),
527		[]
528		);
529		}
530		}
531

ezsystems / ezpublish-kernel

Push — ezp26297-rest_embedding_http_c... ( 6dcd26...7b4207 )

ContentTest::parseContentInfoFromResponse() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like