added internal rates (#1591)

tests/EventSubscriber/DashboardSubscriberTest.php

@@ -27,8 +27,8 @@ class DashboardSubscriberTest extends TestCase
     public function testGetSubscribedEvents()
     {
         $events = DashboardSubscriber::getSubscribedEvents();
-        $this->assertArrayHasKey(DashboardEvent::DASHBOARD, $events);
-        $methodName = $events[DashboardEvent::DASHBOARD][0];
+        $this->assertArrayHasKey(DashboardEvent::class, $events);
+        $methodName = $events[DashboardEvent::class][0];
         $this->assertTrue(method_exists(DashboardSubscriber::class, $methodName));
     }
 

tests/EventSubscriber/RegistrationSubscriberTest.php

@@ -16,7 +16,9 @@ use FOS\UserBundle\FOSUserEvents;
 use FOS\UserBundle\Model\UserManagerInterface;
 use PHPUnit\Framework\TestCase;
 use Symfony\Component\Form\FormInterface;
+use Symfony\Component\HttpFoundation\RedirectResponse;
 use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
 
 /**
  * @covers \App\EventSubscriber\RegistrationSubscriber
@@ -29,13 +31,14 @@ class RegistrationSubscriberTest extends TestCase
         $this->assertArrayHasKey(FOSUserEvents::REGISTRATION_SUCCESS, $events);
         $methodName = $events[FOSUserEvents::REGISTRATION_SUCCESS][0];
         $this->assertTrue(method_exists(RegistrationSubscriber::class, $methodName));
+
+        $this->assertArrayHasKey(FOSUserEvents::RESETTING_RESET_SUCCESS, $events);
+        $methodName = $events[FOSUserEvents::RESETTING_RESET_SUCCESS][0];
+        $this->assertTrue(method_exists(RegistrationSubscriber::class, $methodName));
     }
 
     /**
-     * Legacy test becuase the user bundle won't update to a new release
-     *
      * @dataProvider getTestData
-     * @group legacy
      */
     public function testRoleAssignmentForNewUser(array $existingUsers, $expectedRoles)
     {
@@ -54,7 +57,7 @@ class RegistrationSubscriberTest extends TestCase
 
         $event = new FormEvent($form, $request);
 
-        $sut = new RegistrationSubscriber($userManager);
+        $sut = new RegistrationSubscriber($userManager, $this->createMock(UrlGeneratorInterface::class));
         $sut->onRegistrationSuccess($event);
 
         $this->assertEquals($expectedRoles, $user->getRoles());
@@ -70,4 +73,27 @@ class RegistrationSubscriberTest extends TestCase
             [[new User()], [User::ROLE_USER]],
         ];
     }
+
+    public function testResetting()
+    {
+        $userManager = $this->createMock(UserManagerInterface::class);
+        $form = $this->createMock(FormInterface::class);
+        $request = $this->createMock(Request::class);
+        $router = $this->createMock(UrlGeneratorInterface::class);
+
+        $router->expects($this->any())->method('generate')->willReturnArgument(0);
+        $request->expects($this->any())->method('getLocale')->willReturn('ru');
+
+        $event = new FormEvent($form, $request);
+        self::assertNull($event->getResponse());
+
+        $sut = new RegistrationSubscriber($userManager, $router);
+        $sut->onResettingSuccess($event);
+
+        self::assertInstanceOf(RedirectResponse::class, $event->getResponse());
+
+        /** @var RedirectResponse $response */
+        $response = $event->getResponse();
+        self::assertEquals('my_profile', $response->getTargetUrl());
+    }
 }

tests/EventSubscriber/ResetPasswordSubscriberTest.php

@@ -32,6 +32,9 @@ class ResetPasswordSubscriberTest extends TestCase
         $this->assertTrue(method_exists(ResetPasswordSubscriber::class, $methodName));
     }
 
+    /**
+     * @group legacy
+     */
     public function testUnknownUserTypeIsIgnored()
     {
         $user = new TestUserEntity();

tests/EventSubscriber/UserPreferenceSubscriberTest.php

@@ -0,0 +1,96 @@
+<?php
+
+/*
+ * This file is part of the Kimai time-tracking app.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace App\Tests\EventSubscriber;
+
+use App\Configuration\FormConfiguration;
+use App\Entity\User;
+use App\Entity\UserPreference;
+use App\Event\PrepareUserEvent;
+use App\EventSubscriber\UserPreferenceSubscriber;
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\EventDispatcher\EventDispatcherInterface;
+use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
+use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
+
+/**
+ * @covers \App\EventSubscriber\UserPreferenceSubscriber
+ */
+class UserPreferenceSubscriberTest extends TestCase
+{
+    public function testGetSubscribedEvents()
+    {
+        $events = UserPreferenceSubscriber::getSubscribedEvents();
+        $this->assertArrayHasKey(PrepareUserEvent::class, $events);
+        $methodName = $events[PrepareUserEvent::class][0];
+        $this->assertTrue(method_exists(UserPreferenceSubscriber::class, $methodName));
+    }
+
+    public function testWithHourlyRateAllowed()
+    {
+        $sut = $this->getSubscriber(true);
+        $user = new User();
+        $event = new PrepareUserEvent($user);
+
+        self::assertSame($user, $event->getUser());
+
+        $prefs = $sut->getDefaultPreferences($user);
+        self::assertCount(11, $prefs);
+
+        foreach ($prefs as $pref) {
+            switch ($pref->getName()) {
+                case UserPreference::HOURLY_RATE:
+                case UserPreference::INTERNAL_RATE:
+                    self::assertTrue($pref->isEnabled());
+                break;
+
+                default:
+                    self::assertTrue($pref->isEnabled());
+            }
+        }
+    }
+
+    public function testWithHourlyRateNotAllowed()
+    {
+        $sut = $this->getSubscriber(false);
+        $user = new User();
+        $event = new PrepareUserEvent($user);
+
+        self::assertSame($user, $event->getUser());
+
+        // TODO test merging values
+        $sut->loadUserPreferences($event);
+        $prefs = $event->getUser()->getPreferences();
+        self::assertCount(11, $prefs);
+
+        foreach ($prefs as $pref) {
+            switch ($pref->getName()) {
+                case UserPreference::HOURLY_RATE:
+                case UserPreference::INTERNAL_RATE:
+                    self::assertFalse($pref->isEnabled());
+                break;
+
+                default:
+                    self::assertTrue($pref->isEnabled());
+            }
+        }
+    }
+
+    protected function getSubscriber(bool $seeHourlyRate)
+    {
+        $authMock = $this->createMock(AuthorizationCheckerInterface::class);
+        $authMock->expects($this->once())->method('isGranted')->willReturn($seeHourlyRate);
+
+        $eventMock = $this->createMock(EventDispatcherInterface::class);
+        $tokenMock = $this->createMock(TokenStorageInterface::class);
+        $formConfigMock = $this->createMock(FormConfiguration::class);
+
+        return new UserPreferenceSubscriber($eventMock, $tokenMock, $authMock, $formConfigMock);
+    }
+}