partkeepr

fork of partkeepr
git clone https://git.e1e0.net/partkeepr.git
Log | Files | Refs | Submodules | README | LICENSE

UserTest.php (7669B)

      1 <?php
      2 
      3 namespace PartKeepr\AuthBundle\Tests;
      4 
      5 use Doctrine\Common\DataFixtures\Executor\ORMExecutor;
      6 use Doctrine\Common\DataFixtures\ProxyReferenceRepository;
      7 use PartKeepr\AuthBundle\Entity\FOSUser;
      8 use PartKeepr\AuthBundle\Entity\User;
      9 use PartKeepr\AuthBundle\Exceptions\UserProtectedException;
     10 use PartKeepr\CoreBundle\Tests\WebTestCase;
     11 
     12 class UserTest extends WebTestCase
     13 {
     14     /**
     15      * @var ProxyReferenceRepository
     16      */
     17     protected $fixtures;
     18 
     19     public function setUp()
     20     {
     21         /**
     22          * @var ORMExecutor
     23          */
     24         $ormExecutor = $this->loadFixtures(
     25             [
     26                 'PartKeepr\AuthBundle\DataFixtures\LoadUserData',
     27             ]
     28         );
     29 
     30         $this->fixtures = $ormExecutor->getReferenceRepository();
     31     }
     32 
     33     public function testCreateUser()
     34     {
     35         $client = static::makeClient(true);
     36 
     37         $data = [
     38             'username'    => 'foobartest',
     39             'newPassword' => '1234',
     40         ];
     41 
     42         $client->request('POST', '/api/users', [], [], [], json_encode($data));
     43 
     44         $response = json_decode($client->getResponse()->getContent());
     45 
     46         $this->assertEquals(201, $client->getResponse()->getStatusCode());
     47         $this->assertEquals('foobartest', $response->{'username'});
     48         $this->assertEmpty($response->{'password'});
     49         $this->assertEmpty($response->{'newPassword'});
     50         $this->assertFalse($response->{'legacy'});
     51     }
     52 
     53     public function testChangeUserPassword()
     54     {
     55         $builtinProvider = $this->getContainer()->get('partkeepr.userservice')->getBuiltinProvider();
     56 
     57         $user = new User('bernd');
     58         $user->setPassword(md5('admin'));
     59         $user->setLegacy(true);
     60         $user->setProvider($builtinProvider);
     61 
     62         $this->getContainer()->get('doctrine.orm.default_entity_manager')->persist($user);
     63         $this->getContainer()->get('doctrine.orm.default_entity_manager')->flush($user);
     64 
     65         $client = static::makeClient(true);
     66 
     67         $iriConverter = $this->getContainer()->get('api.iri_converter');
     68         $iri = $iriConverter->getIriFromItem($user);
     69 
     70         $client->request('GET', $iri);
     71 
     72         $response = json_decode($client->getResponse()->getContent());
     73 
     74         $response->{'newPassword'} = 'foobar';
     75 
     76         $client->request('PUT', $iri, [], [], [], json_encode($response));
     77 
     78         $response = json_decode($client->getResponse()->getContent());
     79 
     80         $this->assertEquals(200, $client->getResponse()->getStatusCode());
     81         $this->assertEmpty($response->{'password'});
     82         $this->assertEmpty($response->{'newPassword'});
     83         $this->assertFalse($response->{'legacy'});
     84     }
     85 
     86     public function testSelfChangeUserPassword()
     87     {
     88         $builtinProvider = $this->getContainer()->get('partkeepr.userservice')->getBuiltinProvider();
     89 
     90         $user = new User('bernd2');
     91         $user->setPassword(md5('admin'));
     92         $user->setLegacy(true);
     93         $user->setProvider($builtinProvider);
     94 
     95         $this->getContainer()->get('doctrine.orm.default_entity_manager')->persist($user);
     96         $this->getContainer()->get('doctrine.orm.default_entity_manager')->flush($user);
     97 
     98         $client = static::makeClient(
     99             false,
    100             [
    101                 'PHP_AUTH_USER' => 'bernd2',
    102                 'PHP_AUTH_PW'   => 'admin',
    103             ]
    104         );
    105 
    106         $iriConverter = $this->getContainer()->get('api.iri_converter');
    107         $iri = $iriConverter->getIriFromItem($user).'/changePassword';
    108 
    109         $parameters = [
    110             'oldpassword' => 'admin',
    111             'newpassword' => 'foobar',
    112         ];
    113 
    114         $client->request('PUT', $iri, $parameters);
    115 
    116         $response = json_decode($client->getResponse()->getContent());
    117 
    118         $this->assertEquals(200, $client->getResponse()->getStatusCode());
    119         $this->assertFalse($response->{'legacy'});
    120         $this->assertEmpty($response->{'password'});
    121         $this->assertEmpty($response->{'newPassword'});
    122 
    123         $client = static::makeClient(
    124             false,
    125             [
    126                 'PHP_AUTH_USER' => 'bernd2',
    127                 'PHP_AUTH_PW'   => 'foobar',
    128             ]
    129         );
    130 
    131         $client->request('PUT', $iri, $parameters);
    132 
    133         $response = json_decode($client->getResponse()->getContent());
    134 
    135         $this->assertEquals(500, $client->getResponse()->getStatusCode());
    136         $this->assertObjectHasAttribute('@type', $response);
    137         $this->assertEquals('Error', $response->{'@type'});
    138     }
    139 
    140     public function testUserProtect()
    141     {
    142         /**
    143          * @var FOSUser
    144          */
    145         $fosUser = $this->fixtures->getReference('user.admin');
    146         $userService = $this->getContainer()->get('partkeepr.userservice');
    147 
    148         $user = $userService->getProxyUser($fosUser->getUsername(), $userService->getBuiltinProvider(), true);
    149 
    150         /*
    151          * @var User $user
    152          */
    153         $userService->protect($user);
    154 
    155         $this->assertTrue($user->isProtected());
    156 
    157         $client = static::makeClient(true);
    158 
    159         $iriConverter = $this->getContainer()->get('api.iri_converter');
    160         $iri = $iriConverter->getIriFromItem($user);
    161 
    162         $data = [
    163             'username' => 'foo',
    164         ];
    165         $client->request('PUT', $iri, [], [], [], json_encode($data));
    166 
    167         $response = json_decode($client->getResponse()->getContent());
    168 
    169         $exception = new UserProtectedException();
    170         $this->assertEquals(500, $client->getResponse()->getStatusCode());
    171         $this->assertObjectHasAttribute('hydra:description', $response);
    172         $this->assertEquals($exception->getMessageKey(), $response->{'hydra:description'});
    173 
    174         $client->request('DELETE', $iri);
    175 
    176         $response = json_decode($client->getResponse()->getContent());
    177         $this->assertEquals(500, $client->getResponse()->getStatusCode());
    178         $this->assertObjectHasAttribute('hydra:description', $response);
    179         $this->assertEquals($exception->getMessageKey(), $response->{'hydra:description'});
    180     }
    181 
    182     public function testUserUnprotect()
    183     {
    184         /**
    185          * @var FOSUser
    186          */
    187         $fosUser = $this->fixtures->getReference('user.admin');
    188         $userService = $this->getContainer()->get('partkeepr.userservice');
    189 
    190         $user = $userService->getProxyUser($fosUser->getUsername(), $userService->getBuiltinProvider(), true);
    191 
    192         /*
    193          * @var User $user
    194          */
    195         $userService->unprotect($user);
    196 
    197         $this->assertFalse($user->isProtected());
    198     }
    199 
    200     /**
    201      * Tests the proper user deletion if user preferences exist.
    202      *
    203      * Unit test for Bug #569
    204      *
    205      * @see https://github.com/partkeepr/PartKeepr/issues/569
    206      */
    207     public function testUserWithPreferencesDeletion()
    208     {
    209         $client = static::makeClient(true);
    210 
    211         $data = [
    212             'username'    => 'preferenceuser',
    213             'newPassword' => '1234',
    214         ];
    215 
    216         $client->request('POST', '/api/users', [], [], [], json_encode($data));
    217 
    218         $userPreferenceService = $this->getContainer()->get('partkeepr.user_preference_service');
    219         $userService = $this->getContainer()->get('partkeepr.userservice');
    220 
    221         /**
    222          * @var User
    223          */
    224         $user = $userService->getProxyUser('preferenceuser', $userService->getBuiltinProvider(), true);
    225 
    226         $userPreferenceService->setPreference($user, 'foo', 'bar');
    227 
    228         $iriConverter = $this->getContainer()->get('api.iri_converter');
    229         $iri = $iriConverter->getIriFromItem($user);
    230 
    231         $client->request('DELETE', $iri);
    232 
    233         $this->assertEquals(204, $client->getResponse()->getStatusCode());
    234         $this->assertEmpty($client->getResponse()->getContent());
    235     }
    236 }