Adds replaceUser route and remove replaceIfExists option in createUser

src/Security/Document.php

@@ -103,7 +103,7 @@ public function update(array $content, array $options = [])
     }
 
     /**
-     * Creates or replaces the profile in Kuzzle’s database layer.
+     * Creates or replaces the document in Kuzzle’s database layer.
      *
      * @param array $options Optional parameters
      * @return Document

src/Security/Security.php

@@ -122,10 +122,6 @@ public function createUser($id, array $content, array $options = [])
             'body' => $content
         ];
 
-        if (array_key_exists('replaceIfExist', $options)) {
-            $action = 'createOrReplaceUser';
-        }
-
         $response = $this->kuzzle->query(
             $this->buildQueryArgs($action),
             $data,
@@ -160,6 +156,31 @@ public function createRestrictedUser($id, array $content, array $options = [])
         return new User($this, $response['result']['_id'], $response['result']['_source']);
     }
 
+    /**
+     * Replaces an existing user in Kuzzle.
+     *
+     * @param integer $id Unique user identifier, will be used as username
+     * @param array $content Data representing the user
+     * @param array $options Optional arguments
+     * @return User
+     */
+    public function replaceUser($id, array $content, array $options = [])
+    {
+        $action = 'replaceUser';
+        $data = [
+            '_id' => $id,
+            'body' => $content
+        ];
+
+        $response = $this->kuzzle->query(
+            $this->buildQueryArgs($action),
+            $data,
+            $options
+        );
+
+        return new User($this, $response['result']['_id'], $response['result']['_source']);
+    }
+
     /**
      * Delete profile.
      *

src/Security/User.php

@@ -2,6 +2,8 @@
 
 namespace Kuzzle\Security;
 
+use BadMethodCallException;
+
 /**
  * Class User
  * @package kuzzleio/kuzzle-sdk
@@ -12,10 +14,12 @@ class User extends Document
 
     protected $updateActionName = 'updateUser';
 
-    protected $saveActionName = 'createOrReplaceUser';
+    protected $saveActionName = 'createUser';
 
     const DEFAULT_PROFILE = 'default';
 
+    protected $credentials = [];
+
     /**
      * Role constructor.
      *
@@ -136,4 +140,116 @@ protected function extractProfileId($profile)
 
         return $profile;
     }
+
+    /**
+     * Throws an error as this method can't be implemented for User
+     *
+     * @param array $options Optional parameters
+     * @return void
+     * @throws BadMethodCallException
+     */
+    public function save(array $options = [])
+    {
+        throw new BadMethodCallException('This method does not exist in User');
+    }
+
+
+    /**
+     * Performs a partial content update on this object.
+     *
+     * @param array $content New profile content
+     * @param array $options Optional parameters
+     * @return Document
+     */
+    public function update(array $content, array $options = [])
+    {
+        $data = [
+            '_id' => $this->id,
+            'body' => $content
+        ];
+
+        $response = $this->security->getKuzzle()->query(
+            $this->security->buildQueryArgs($this->updateActionName),
+            $data,
+            $options
+        );
+
+        $this->setContent($response['result']['_source']);
+
+        return $this;
+    }
+
+    /**
+     * Creates the user in Kuzzle’s database layer.
+     *
+     * @param array $options Optional parameters
+     * @return Document
+     */
+    public function create(array $options = [])
+    {
+        $data = $this->creationSerialize();
+
+        $this->security->getKuzzle()->query(
+            $this->security->buildQueryArgs('createUser'),
+            $data,
+            $options
+        );
+
+        return $this;
+    }
+
+    /**
+     * Replaces the user in Kuzzle’s database layer.
+     *
+     * @param array $options Optional parameters
+     * @return Document
+     */
+    public function replace(array $options = [])
+    {
+        $data = $this->serialize();
+
+        $this->security->getKuzzle()->query(
+            $this->security->buildQueryArgs('replaceUser'),
+            $data,
+            $options
+        );
+
+        return $this;
+    }
+
+    /**
+     * @return array
+     */
+    private function creationSerialize()
+    {
+        $data = [];
+
+        if (!empty($this->id)) {
+            $data['_id'] = $this->id;
+        }
+
+        $data['body'] = [
+            'content' => $this->content,
+            'credentials' => $this->credentials
+        ];
+
+
+        return $data;
+    }
+
+    /**
+     * @param array $credentials
+     * @return $this
+     * @throws \InvalidArgumentException
+     */
+    public function setCredentials($credentials)
+    {
+        if (!is_array($credentials)) {
+            throw new \InvalidArgumentException('Parameter "credentials" must be a object');
+        }
+
+        $this->credentials = $credentials;
+
+        return $this;
+    }
 }

src/config/routes.json

@@ -1556,6 +1556,11 @@
       "route": "/users/:_id/_createRestricted",
       "method": "post"
     },
+    "replaceUser": {
+      "name": "replaceUser",
+      "route": "/users/:_id/_replace",
+      "method": "put"
+    },
     "updateUser": {
       "name": "updateUser",
       "route": "/users/:_id/_update",

tests/Security/SecurityTest.php

@@ -278,7 +278,10 @@ function testCreateUser()
 
         $userId = uniqid();
         $userContent = [
-            'profileIds' => ['admin']
+            'content' => [
+                'profileIds' => ['admin']
+            ],
+            'credentials' => ['some' => 'credentials']
         ];
 
         $httpRequest = [
@@ -385,37 +388,38 @@ function testCreateRestrictedUser()
         $this->assertAttributeEquals($userContent, 'content', $result);
     }
 
-    function testCreateOrReplaceUser()
+    function testReplaceUser()
     {
         $url = KuzzleTest::FAKE_KUZZLE_HOST;
         $requestId = uniqid();
 
         $userId = uniqid();
+
         $userContent = [
             'profileIds' => ['admin']
         ];
 
         $httpRequest = [
-            'route' => '/users/' . $userId,
+            'route' => '/users/' . $userId . '/_replace',
             'method' => 'PUT',
             'request' => [
                 'volatile' => [],
                 'controller' => 'security',
-                'action' => 'createOrReplaceUser',
+                'action' => 'replaceUser',
                 'requestId' => $requestId,
                 '_id' => $userId,
                 'body' => $userContent
             ],
-            'query_parameters' => []
+            'query_parameters' => [],
         ];
-        $saveResponse = [
+        $replaceResponse = [
             '_id' => $userId,
             '_source' => $userContent,
             '_version' => 1
         ];
         $httpResponse = [
             'error' => null,
-            'result' => $saveResponse
+            'result' => $replaceResponse
         ];
 
         $kuzzle = $this
@@ -435,14 +439,9 @@ function testCreateOrReplaceUser()
          */
         $security = new Security($kuzzle);
 
-        $result = $security->createUser($userId, $userContent, [
-            'replaceIfExist' => true,
-            'requestId' => $requestId
-        ]);
+        $result = $security->replaceUser($userId, $userContent, ['requestId' => $requestId]);
 
-        $this->assertInstanceOf('Kuzzle\Security\User', $result);
-        $this->assertAttributeEquals($userId, 'id', $result);
-        $this->assertAttributeEquals($userContent, 'content', $result);
+        $this->assertEquals($userContent, $result->getContent());
     }
 
     function testDeleteProfile()

tests/Security/UserTest.php

@@ -39,7 +39,7 @@ function testAddProfile()
         $this->assertEquals($user, $user->addProfile('myProfile'));
     }
 
-    function testSave()
+    function testCreate()
     {
         $url = KuzzleTest::FAKE_KUZZLE_HOST;
         $requestId = uniqid();
@@ -48,17 +48,23 @@ function testSave()
         $userContent = [
             'profileIds' => ['admin']
         ];
+        $userCredentials = [
+            'some' => 'credentials'
+        ];
 
         $httpRequest = [
-            'route' => '/users/' . $userId,
-            'method' => 'PUT',
+            'route' => '/users/' . $userId . '/_create',
+            'method' => 'POST',
             'request' => [
                 'volatile' => [],
                 'controller' => 'security',
-                'action' => 'createOrReplaceUser',
+                'action' => 'createUser',
                 'requestId' => $requestId,
                 '_id' => $userId,
-                'body' => $userContent
+                'body' => [
+                    'content' => $userContent,
+                    'credentials' => $userCredentials
+                ]
             ],
             'query_parameters' => []
         ];
@@ -79,7 +85,7 @@ function testSave()
             ->getMock();
 
         $kuzzle
-            ->expects($this->exactly(2))
+            ->expects($this->exactly(1))
             ->method('emitRestRequest')
             ->with($httpRequest)
             ->willReturn($httpResponse);
@@ -91,15 +97,71 @@ function testSave()
         $user = new User($security, $userId);
 
         $user->setContent($userContent);
-        $result = $user->save(['requestId' => $requestId]);
+        $user->setCredentials($userCredentials);
+        $profile = new Profile($security, $userContent['profileIds'][0]);
+        $user->setProfiles([$profile]);
+        $result = $user->create(['requestId' => $requestId]);
 
         $this->assertInstanceOf('Kuzzle\Security\User', $result);
         $this->assertAttributeEquals($userId, 'id', $result);
         $this->assertAttributeEquals($userContent, 'content', $result);
+    }
+
+    function testReplace()
+    {
+        $url = KuzzleTest::FAKE_KUZZLE_HOST;
+        $requestId = uniqid();
+
+        $userId = uniqid();
+        $userContent = [
+            'profileIds' => ['admin']
+        ];
+
+        $httpRequest = [
+            'route' => '/users/' . $userId . '/_replace',
+            'method' => 'PUT',
+            'request' => [
+                'volatile' => [],
+                'controller' => 'security',
+                'action' => 'replaceUser',
+                'requestId' => $requestId,
+                '_id' => $userId,
+                'body' => $userContent
+            ],
+            'query_parameters' => []
+        ];
+        $saveResponse = [
+            '_id' => $userId,
+            '_source' => $userContent,
+            '_version' => 1
+        ];
+        $httpResponse = [
+            'error' => null,
+            'result' => $saveResponse
+        ];
+
+        $kuzzle = $this
+            ->getMockBuilder('\Kuzzle\Kuzzle')
+            ->setMethods(['emitRestRequest'])
+            ->setConstructorArgs([$url])
+            ->getMock();
+
+        $kuzzle
+            ->expects($this->exactly(1))
+            ->method('emitRestRequest')
+            ->with($httpRequest)
+            ->willReturn($httpResponse);
+
+        /**
+         * @var Kuzzle $kuzzle
+         */
+        $security = new Security($kuzzle);
+        $user = new User($security, $userId);
 
         $profile = new Profile($security, $userContent['profileIds'][0]);
         $user->setProfiles([$profile]);
-        $result = $user->save(['requestId' => $requestId]);
+        $user->setContent($userContent);
+        $result = $user->replace(['requestId' => $requestId]);
 
         $this->assertInstanceOf('Kuzzle\Security\User', $result);
         $this->assertAttributeEquals($userId, 'id', $result);