nextcloud / server

apps/dav/appinfo/v1/caldav.php

Indentation +31 added lines, -31 removed lines

@@ -36,26 +36,26 @@ 
 use Psr\Log\LoggerInterface;
 
 $authBackend = new Auth(
-	Server::get(ISession::class),
-	Server::get(IUserSession::class),
-	Server::get(IRequest::class),
-	Server::get(\OC\Authentication\TwoFactorAuth\Manager::class),
-	Server::get(IThrottler::class),
-	Server::get(SetupManager::class),
-	'principals/'
+    Server::get(ISession::class),
+    Server::get(IUserSession::class),
+    Server::get(IRequest::class),
+    Server::get(\OC\Authentication\TwoFactorAuth\Manager::class),
+    Server::get(IThrottler::class),
+    Server::get(SetupManager::class),
+    'principals/'
 );
 $principalBackend = new Principal(
-	Server::get(IUserManager::class),
-	Server::get(IGroupManager::class),
-	Server::get(IAccountManager::class),
-	Server::get(\OCP\Share\IManager::class),
-	Server::get(IUserSession::class),
-	Server::get(IAppManager::class),
-	Server::get(ProxyMapper::class),
-	Server::get(KnownUserService::class),
-	Server::get(IConfig::class),
-	\OC::$server->getL10NFactory(),
-	'principals/'
+    Server::get(IUserManager::class),
+    Server::get(IGroupManager::class),
+    Server::get(IAccountManager::class),
+    Server::get(\OCP\Share\IManager::class),
+    Server::get(IUserSession::class),
+    Server::get(IAppManager::class),
+    Server::get(ProxyMapper::class),
+    Server::get(KnownUserService::class),
+    Server::get(IConfig::class),
+    \OC::$server->getL10NFactory(),
+    'principals/'
 );
 $db = Server::get(IDBConnection::class);
 $userManager = Server::get(IUserManager::class);
@@ -65,15 +65,15 @@ 
 $config = Server::get(IConfig::class);
 
 $calDavBackend = new CalDavBackend(
-	$db,
-	$principalBackend,
-	$userManager,
-	$random,
-	$logger,
-	$dispatcher,
-	$config,
-	Server::get(\OCA\DAV\CalDAV\Sharing\Backend::class),
-	true
+    $db,
+    $principalBackend,
+    $userManager,
+    $random,
+    $logger,
+    $dispatcher,
+    $config,
+    Server::get(\OCA\DAV\CalDAV\Sharing\Backend::class),
+    true
 );
 
 $debugging = Server::get(IConfig::class)->getSystemValue('debug', false);
@@ -87,8 +87,8 @@ 
 $addressBookRoot->disableListing = !$debugging; // Disable listing
 
 $nodes = [
-	$principalCollection,
-	$addressBookRoot,
+    $principalCollection,
+    $addressBookRoot,
 ];
 
 // Fire up server
@@ -104,7 +104,7 @@ 
 
 $server->addPlugin(new LegacyDAVACL());
 if ($debugging) {
-	$server->addPlugin(new Sabre\DAV\Browser\Plugin());
+    $server->addPlugin(new Sabre\DAV\Browser\Plugin());
 }
 
 $server->addPlugin(new \Sabre\DAV\Sync\Plugin());
@@ -112,7 +112,7 @@ 
 $server->addPlugin(new \OCA\DAV\CalDAV\Schedule\Plugin(Server::get(IConfig::class), Server::get(LoggerInterface::class), Server::get(DefaultCalendarValidator::class)));
 
 if ($sendInvitations) {
-	$server->addPlugin(Server::get(IMipPlugin::class));
+    $server->addPlugin(Server::get(IMipPlugin::class));
 }
 $server->addPlugin(new ExceptionLoggerPlugin('caldav', $logger));
 $server->addPlugin(Server::get(RateLimitingPlugin::class));

apps/dav/tests/unit/Connector/Sabre/AuthTest.php

Indentation +578 added lines, -578 removed lines

@@ -31,582 +31,582 @@
  * @group DB
  */
 class AuthTest extends TestCase {
-	private ISession&MockObject $session;
-	private Session&MockObject $userSession;
-	private IRequest&MockObject $request;
-	private Manager&MockObject $twoFactorManager;
-	private IThrottler&MockObject $throttler;
-	private SetupManager&MockObject $setupManager;
-	private Auth $auth;
-
-	protected function setUp(): void {
-		parent::setUp();
-		$this->session = $this->createMock(ISession::class);
-		$this->userSession = $this->createMock(Session::class);
-		$this->request = $this->createMock(IRequest::class);
-		$this->twoFactorManager = $this->createMock(Manager::class);
-		$this->throttler = $this->createMock(IThrottler::class);
-		$this->setupManager = $this->createMock(SetupManager::class);
-		$this->auth = new Auth(
-			$this->session,
-			$this->userSession,
-			$this->request,
-			$this->twoFactorManager,
-			$this->throttler,
-			$this->setupManager,
-		);
-	}
-
-	public function testIsDavAuthenticatedWithoutDavSession(): void {
-		$this->session
-			->expects($this->once())
-			->method('get')
-			->with('AUTHENTICATED_TO_DAV_BACKEND')
-			->willReturn(null);
-
-		$this->assertFalse(self::invokePrivate($this->auth, 'isDavAuthenticated', ['MyTestUser']));
-	}
-
-	public function testIsDavAuthenticatedWithWrongDavSession(): void {
-		$this->session
-			->expects($this->exactly(2))
-			->method('get')
-			->with('AUTHENTICATED_TO_DAV_BACKEND')
-			->willReturn('AnotherUser');
-
-		$this->assertFalse(self::invokePrivate($this->auth, 'isDavAuthenticated', ['MyTestUser']));
-	}
-
-	public function testIsDavAuthenticatedWithCorrectDavSession(): void {
-		$this->session
-			->expects($this->exactly(2))
-			->method('get')
-			->with('AUTHENTICATED_TO_DAV_BACKEND')
-			->willReturn('MyTestUser');
-
-		$this->assertTrue(self::invokePrivate($this->auth, 'isDavAuthenticated', ['MyTestUser']));
-	}
-
-	public function testValidateUserPassOfAlreadyDAVAuthenticatedUser(): void {
-		$user = $this->createMock(IUser::class);
-		$user->expects($this->exactly(1))
-			->method('getUID')
-			->willReturn('MyTestUser');
-		$this->userSession
-			->expects($this->once())
-			->method('isLoggedIn')
-			->willReturn(true);
-		$this->userSession
-			->expects($this->exactly(1))
-			->method('getUser')
-			->willReturn($user);
-		$this->session
-			->expects($this->exactly(2))
-			->method('get')
-			->with('AUTHENTICATED_TO_DAV_BACKEND')
-			->willReturn('MyTestUser');
-		$this->session
-			->expects($this->once())
-			->method('close');
-
-		$this->assertTrue(self::invokePrivate($this->auth, 'validateUserPass', ['MyTestUser', 'MyTestPassword']));
-	}
-
-	public function testValidateUserPassOfInvalidDAVAuthenticatedUser(): void {
-		$user = $this->createMock(IUser::class);
-		$user->expects($this->once())
-			->method('getUID')
-			->willReturn('MyTestUser');
-		$this->userSession
-			->expects($this->once())
-			->method('isLoggedIn')
-			->willReturn(true);
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->willReturn($user);
-		$this->session
-			->expects($this->exactly(2))
-			->method('get')
-			->with('AUTHENTICATED_TO_DAV_BACKEND')
-			->willReturn('AnotherUser');
-		$this->session
-			->expects($this->once())
-			->method('close');
-
-		$this->assertFalse(self::invokePrivate($this->auth, 'validateUserPass', ['MyTestUser', 'MyTestPassword']));
-	}
-
-	public function testValidateUserPassOfInvalidDAVAuthenticatedUserWithValidPassword(): void {
-		$user = $this->createMock(IUser::class);
-		$user->expects($this->exactly(2))
-			->method('getUID')
-			->willReturn('MyTestUser');
-		$this->userSession
-			->expects($this->once())
-			->method('isLoggedIn')
-			->willReturn(true);
-		$this->userSession
-			->expects($this->exactly(2))
-			->method('getUser')
-			->willReturn($user);
-		$this->session
-			->expects($this->exactly(2))
-			->method('get')
-			->with('AUTHENTICATED_TO_DAV_BACKEND')
-			->willReturn('AnotherUser');
-		$this->userSession
-			->expects($this->once())
-			->method('logClientIn')
-			->with('MyTestUser', 'MyTestPassword', $this->request)
-			->willReturn(true);
-		$this->session
-			->expects($this->once())
-			->method('set')
-			->with('AUTHENTICATED_TO_DAV_BACKEND', 'MyTestUser');
-		$this->session
-			->expects($this->once())
-			->method('close');
-
-		$this->assertTrue(self::invokePrivate($this->auth, 'validateUserPass', ['MyTestUser', 'MyTestPassword']));
-	}
-
-	public function testValidateUserPassWithInvalidPassword(): void {
-		$this->userSession
-			->expects($this->once())
-			->method('isLoggedIn')
-			->willReturn(false);
-		$this->userSession
-			->expects($this->once())
-			->method('logClientIn')
-			->with('MyTestUser', 'MyTestPassword')
-			->willReturn(false);
-		$this->session
-			->expects($this->once())
-			->method('close');
-
-		$this->assertFalse(self::invokePrivate($this->auth, 'validateUserPass', ['MyTestUser', 'MyTestPassword']));
-	}
-
-
-	public function testValidateUserPassWithPasswordLoginForbidden(): void {
-		$this->expectException(PasswordLoginForbidden::class);
-
-		$this->userSession
-			->expects($this->once())
-			->method('isLoggedIn')
-			->willReturn(false);
-		$this->userSession
-			->expects($this->once())
-			->method('logClientIn')
-			->with('MyTestUser', 'MyTestPassword')
-			->willThrowException(new PasswordLoginForbiddenException());
-		$this->session
-			->expects($this->once())
-			->method('close');
-
-		self::invokePrivate($this->auth, 'validateUserPass', ['MyTestUser', 'MyTestPassword']);
-	}
-
-	public function testAuthenticateAlreadyLoggedInWithoutCsrfTokenForNonGet(): void {
-		$request = $this->createMock(RequestInterface::class);
-		$response = $this->createMock(ResponseInterface::class);
-		$this->userSession
-			->expects($this->any())
-			->method('isLoggedIn')
-			->willReturn(true);
-		$this->request
-			->expects($this->any())
-			->method('getMethod')
-			->willReturn('POST');
-		$this->session
-			->expects($this->any())
-			->method('get')
-			->with('AUTHENTICATED_TO_DAV_BACKEND')
-			->willReturn(null);
-		$user = $this->createMock(IUser::class);
-		$user->expects($this->any())
-			->method('getUID')
-			->willReturn('MyWrongDavUser');
-		$this->userSession
-			->expects($this->any())
-			->method('getUser')
-			->willReturn($user);
-		$this->request
-			->expects($this->once())
-			->method('passesCSRFCheck')
-			->willReturn(false);
-
-		$expectedResponse = [
-			false,
-			"No 'Authorization: Basic' header found. Either the client didn't send one, or the server is misconfigured",
-		];
-		$response = $this->auth->check($request, $response);
-		$this->assertSame($expectedResponse, $response);
-	}
-
-	public function testAuthenticateAlreadyLoggedInWithoutCsrfTokenAndCorrectlyDavAuthenticated(): void {
-		$request = $this->createMock(RequestInterface::class);
-		$response = $this->createMock(ResponseInterface::class);
-		$this->userSession
-			->expects($this->any())
-			->method('isLoggedIn')
-			->willReturn(true);
-		$this->request
-			->expects($this->any())
-			->method('getMethod')
-			->willReturn('PROPFIND');
-		$this->request
-			->expects($this->any())
-			->method('isUserAgent')
-			->willReturn(false);
-		$this->session
-			->expects($this->any())
-			->method('get')
-			->with('AUTHENTICATED_TO_DAV_BACKEND')
-			->willReturn('LoggedInUser');
-		$user = $this->createMock(IUser::class);
-		$user->expects($this->any())
-			->method('getUID')
-			->willReturn('LoggedInUser');
-		$this->userSession
-			->expects($this->any())
-			->method('getUser')
-			->willReturn($user);
-		$this->request
-			->expects($this->once())
-			->method('passesCSRFCheck')
-			->willReturn(false);
-		$this->auth->check($request, $response);
-	}
-
-
-	public function testAuthenticateAlreadyLoggedInWithoutTwoFactorChallengePassed(): void {
-		$this->expectException(\Sabre\DAV\Exception\NotAuthenticated::class);
-		$this->expectExceptionMessage('2FA challenge not passed.');
-
-		$request = $this->createMock(RequestInterface::class);
-		$response = $this->createMock(ResponseInterface::class);
-		$this->userSession
-			->expects($this->any())
-			->method('isLoggedIn')
-			->willReturn(true);
-		$this->request
-			->expects($this->any())
-			->method('getMethod')
-			->willReturn('PROPFIND');
-		$this->request
-			->expects($this->any())
-			->method('isUserAgent')
-			->willReturn(false);
-		$this->session
-			->expects($this->any())
-			->method('get')
-			->with('AUTHENTICATED_TO_DAV_BACKEND')
-			->willReturn('LoggedInUser');
-		$user = $this->createMock(IUser::class);
-		$user->expects($this->any())
-			->method('getUID')
-			->willReturn('LoggedInUser');
-		$this->userSession
-			->expects($this->any())
-			->method('getUser')
-			->willReturn($user);
-		$this->request
-			->expects($this->once())
-			->method('passesCSRFCheck')
-			->willReturn(true);
-		$this->twoFactorManager->expects($this->once())
-			->method('needsSecondFactor')
-			->with($user)
-			->willReturn(true);
-		$this->auth->check($request, $response);
-	}
-
-
-	public function testAuthenticateAlreadyLoggedInWithoutCsrfTokenAndIncorrectlyDavAuthenticated(): void {
-		$this->expectException(\Sabre\DAV\Exception\NotAuthenticated::class);
-		$this->expectExceptionMessage('CSRF check not passed.');
-
-		$request = $this->createMock(RequestInterface::class);
-		$response = $this->createMock(ResponseInterface::class);
-		$this->userSession
-			->expects($this->any())
-			->method('isLoggedIn')
-			->willReturn(true);
-		$this->request
-			->expects($this->any())
-			->method('getMethod')
-			->willReturn('PROPFIND');
-		$this->request
-			->expects($this->any())
-			->method('isUserAgent')
-			->willReturn(false);
-		$this->session
-			->expects($this->any())
-			->method('get')
-			->with('AUTHENTICATED_TO_DAV_BACKEND')
-			->willReturn('AnotherUser');
-		$user = $this->createMock(IUser::class);
-		$user->expects($this->any())
-			->method('getUID')
-			->willReturn('LoggedInUser');
-		$this->userSession
-			->expects($this->any())
-			->method('getUser')
-			->willReturn($user);
-		$this->request
-			->expects($this->once())
-			->method('passesCSRFCheck')
-			->willReturn(false);
-		$this->auth->check($request, $response);
-	}
-
-	public function testAuthenticateAlreadyLoggedInWithoutCsrfTokenForNonGetAndDesktopClient(): void {
-		$request = $this->createMock(RequestInterface::class);
-		$response = $this->createMock(ResponseInterface::class);
-		$this->userSession
-			->expects($this->any())
-			->method('isLoggedIn')
-			->willReturn(true);
-		$this->request
-			->expects($this->any())
-			->method('getMethod')
-			->willReturn('POST');
-		$this->request
-			->expects($this->any())
-			->method('isUserAgent')
-			->willReturn(true);
-		$this->session
-			->expects($this->any())
-			->method('get')
-			->with('AUTHENTICATED_TO_DAV_BACKEND')
-			->willReturn(null);
-		$user = $this->createMock(IUser::class);
-		$user->expects($this->any())
-			->method('getUID')
-			->willReturn('MyWrongDavUser');
-		$this->userSession
-			->expects($this->any())
-			->method('getUser')
-			->willReturn($user);
-		$this->request
-			->expects($this->once())
-			->method('passesCSRFCheck')
-			->willReturn(false);
-
-		$this->auth->check($request, $response);
-	}
-
-	public function testAuthenticateAlreadyLoggedInWithoutCsrfTokenForGet(): void {
-		$request = $this->createMock(RequestInterface::class);
-		$response = $this->createMock(ResponseInterface::class);
-		$this->userSession
-			->expects($this->any())
-			->method('isLoggedIn')
-			->willReturn(true);
-		$this->session
-			->expects($this->any())
-			->method('get')
-			->with('AUTHENTICATED_TO_DAV_BACKEND')
-			->willReturn(null);
-		$user = $this->createMock(IUser::class);
-		$user->expects($this->any())
-			->method('getUID')
-			->willReturn('MyWrongDavUser');
-		$this->userSession
-			->expects($this->any())
-			->method('getUser')
-			->willReturn($user);
-		$this->request
-			->expects($this->any())
-			->method('getMethod')
-			->willReturn('GET');
-
-		$response = $this->auth->check($request, $response);
-		$this->assertEquals([true, 'principals/users/MyWrongDavUser'], $response);
-	}
-
-	public function testAuthenticateAlreadyLoggedInWithCsrfTokenForGet(): void {
-		$request = $this->createMock(RequestInterface::class);
-		$response = $this->createMock(ResponseInterface::class);
-		$this->userSession
-			->expects($this->any())
-			->method('isLoggedIn')
-			->willReturn(true);
-		$this->session
-			->expects($this->any())
-			->method('get')
-			->with('AUTHENTICATED_TO_DAV_BACKEND')
-			->willReturn(null);
-		$user = $this->createMock(IUser::class);
-		$user->expects($this->any())
-			->method('getUID')
-			->willReturn('MyWrongDavUser');
-		$this->userSession
-			->expects($this->any())
-			->method('getUser')
-			->willReturn($user);
-		$this->request
-			->expects($this->once())
-			->method('passesCSRFCheck')
-			->willReturn(true);
-
-		$response = $this->auth->check($request, $response);
-		$this->assertEquals([true, 'principals/users/MyWrongDavUser'], $response);
-	}
-
-	public function testAuthenticateNoBasicAuthenticateHeadersProvided(): void {
-		$server = $this->createMock(Server::class);
-		$server->httpRequest = $this->createMock(RequestInterface::class);
-		$server->httpResponse = $this->createMock(ResponseInterface::class);
-		$response = $this->auth->check($server->httpRequest, $server->httpResponse);
-		$this->assertEquals([false, 'No \'Authorization: Basic\' header found. Either the client didn\'t send one, or the server is misconfigured'], $response);
-	}
-
-
-	public function testAuthenticateNoBasicAuthenticateHeadersProvidedWithAjax(): void {
-		$this->expectException(\Sabre\DAV\Exception\NotAuthenticated::class);
-		$this->expectExceptionMessage('Cannot authenticate over ajax calls');
-
-		/** @var \Sabre\HTTP\RequestInterface&MockObject $httpRequest */
-		$httpRequest = $this->createMock(RequestInterface::class);
-		/** @var \Sabre\HTTP\ResponseInterface&MockObject $httpResponse */
-		$httpResponse = $this->createMock(ResponseInterface::class);
-		$this->userSession
-			->expects($this->any())
-			->method('isLoggedIn')
-			->willReturn(false);
-		$httpRequest
-			->expects($this->exactly(2))
-			->method('getHeader')
-			->willReturnMap([
-				['X-Requested-With', 'XMLHttpRequest'],
-				['Authorization', null],
-			]);
-
-		$this->auth->check($httpRequest, $httpResponse);
-	}
-
-	public function testAuthenticateWithBasicAuthenticateHeadersProvidedWithAjax(): void {
-		// No CSRF
-		$this->request
-			->expects($this->once())
-			->method('passesCSRFCheck')
-			->willReturn(false);
-
-		/** @var \Sabre\HTTP\RequestInterface&MockObject $httpRequest */
-		$httpRequest = $this->createMock(RequestInterface::class);
-		/** @var \Sabre\HTTP\ResponseInterface&MockObject $httpResponse */
-		$httpResponse = $this->createMock(ResponseInterface::class);
-		$httpRequest
-			->expects($this->any())
-			->method('getHeader')
-			->willReturnMap([
-				['X-Requested-With', 'XMLHttpRequest'],
-				['Authorization', 'basic dXNlcm5hbWU6cGFzc3dvcmQ='],
-			]);
-
-		$user = $this->createMock(IUser::class);
-		$user->expects($this->any())
-			->method('getUID')
-			->willReturn('MyDavUser');
-		$this->userSession
-			->expects($this->any())
-			->method('isLoggedIn')
-			->willReturn(false);
-		$this->userSession
-			->expects($this->once())
-			->method('logClientIn')
-			->with('username', 'password')
-			->willReturn(true);
-		$this->userSession
-			->expects($this->any())
-			->method('getUser')
-			->willReturn($user);
-
-		$this->auth->check($httpRequest, $httpResponse);
-	}
-
-	public function testAuthenticateNoBasicAuthenticateHeadersProvidedWithAjaxButUserIsStillLoggedIn(): void {
-		/** @var \Sabre\HTTP\RequestInterface $httpRequest */
-		$httpRequest = $this->createMock(RequestInterface::class);
-		/** @var \Sabre\HTTP\ResponseInterface $httpResponse */
-		$httpResponse = $this->createMock(ResponseInterface::class);
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')->willReturn('MyTestUser');
-		$this->userSession
-			->expects($this->any())
-			->method('isLoggedIn')
-			->willReturn(true);
-		$this->userSession
-			->expects($this->any())
-			->method('getUser')
-			->willReturn($user);
-		$this->session
-			->expects($this->atLeastOnce())
-			->method('get')
-			->with('AUTHENTICATED_TO_DAV_BACKEND')
-			->willReturn('MyTestUser');
-		$this->request
-			->expects($this->once())
-			->method('getMethod')
-			->willReturn('GET');
-		$httpRequest
-			->expects($this->atLeastOnce())
-			->method('getHeader')
-			->with('Authorization')
-			->willReturn(null);
-		$this->assertEquals(
-			[true, 'principals/users/MyTestUser'],
-			$this->auth->check($httpRequest, $httpResponse)
-		);
-	}
-
-	public function testAuthenticateValidCredentials(): void {
-		$server = $this->createMock(Server::class);
-		$server->httpRequest = $this->createMock(RequestInterface::class);
-		$server->httpRequest
-			->expects($this->once())
-			->method('getHeader')
-			->with('Authorization')
-			->willReturn('basic dXNlcm5hbWU6cGFzc3dvcmQ=');
-
-		$server->httpResponse = $this->createMock(ResponseInterface::class);
-		$this->userSession
-			->expects($this->once())
-			->method('logClientIn')
-			->with('username', 'password')
-			->willReturn(true);
-		$user = $this->createMock(IUser::class);
-		$user->expects($this->exactly(2))
-			->method('getUID')
-			->willReturn('MyTestUser');
-		$this->userSession
-			->expects($this->exactly(4))
-			->method('getUser')
-			->willReturn($user);
-		$response = $this->auth->check($server->httpRequest, $server->httpResponse);
-		$this->assertEquals([true, 'principals/users/MyTestUser'], $response);
-	}
-
-	public function testAuthenticateInvalidCredentials(): void {
-		$server = $this->createMock(Server::class);
-		$server->httpRequest = $this->createMock(RequestInterface::class);
-		$server->httpRequest
-			->expects($this->exactly(2))
-			->method('getHeader')
-			->willReturnMap([
-				['Authorization', 'basic dXNlcm5hbWU6cGFzc3dvcmQ='],
-				['X-Requested-With', null],
-			]);
-		$server->httpResponse = $this->createMock(ResponseInterface::class);
-		$this->userSession
-			->expects($this->once())
-			->method('logClientIn')
-			->with('username', 'password')
-			->willReturn(false);
-		$response = $this->auth->check($server->httpRequest, $server->httpResponse);
-		$this->assertEquals([false, 'Username or password was incorrect'], $response);
-	}
+    private ISession&MockObject $session;
+    private Session&MockObject $userSession;
+    private IRequest&MockObject $request;
+    private Manager&MockObject $twoFactorManager;
+    private IThrottler&MockObject $throttler;
+    private SetupManager&MockObject $setupManager;
+    private Auth $auth;
+
+    protected function setUp(): void {
+        parent::setUp();
+        $this->session = $this->createMock(ISession::class);
+        $this->userSession = $this->createMock(Session::class);
+        $this->request = $this->createMock(IRequest::class);
+        $this->twoFactorManager = $this->createMock(Manager::class);
+        $this->throttler = $this->createMock(IThrottler::class);
+        $this->setupManager = $this->createMock(SetupManager::class);
+        $this->auth = new Auth(
+            $this->session,
+            $this->userSession,
+            $this->request,
+            $this->twoFactorManager,
+            $this->throttler,
+            $this->setupManager,
+        );
+    }
+
+    public function testIsDavAuthenticatedWithoutDavSession(): void {
+        $this->session
+            ->expects($this->once())
+            ->method('get')
+            ->with('AUTHENTICATED_TO_DAV_BACKEND')
+            ->willReturn(null);
+
+        $this->assertFalse(self::invokePrivate($this->auth, 'isDavAuthenticated', ['MyTestUser']));
+    }
+
+    public function testIsDavAuthenticatedWithWrongDavSession(): void {
+        $this->session
+            ->expects($this->exactly(2))
+            ->method('get')
+            ->with('AUTHENTICATED_TO_DAV_BACKEND')
+            ->willReturn('AnotherUser');
+
+        $this->assertFalse(self::invokePrivate($this->auth, 'isDavAuthenticated', ['MyTestUser']));
+    }
+
+    public function testIsDavAuthenticatedWithCorrectDavSession(): void {
+        $this->session
+            ->expects($this->exactly(2))
+            ->method('get')
+            ->with('AUTHENTICATED_TO_DAV_BACKEND')
+            ->willReturn('MyTestUser');
+
+        $this->assertTrue(self::invokePrivate($this->auth, 'isDavAuthenticated', ['MyTestUser']));
+    }
+
+    public function testValidateUserPassOfAlreadyDAVAuthenticatedUser(): void {
+        $user = $this->createMock(IUser::class);
+        $user->expects($this->exactly(1))
+            ->method('getUID')
+            ->willReturn('MyTestUser');
+        $this->userSession
+            ->expects($this->once())
+            ->method('isLoggedIn')
+            ->willReturn(true);
+        $this->userSession
+            ->expects($this->exactly(1))
+            ->method('getUser')
+            ->willReturn($user);
+        $this->session
+            ->expects($this->exactly(2))
+            ->method('get')
+            ->with('AUTHENTICATED_TO_DAV_BACKEND')
+            ->willReturn('MyTestUser');
+        $this->session
+            ->expects($this->once())
+            ->method('close');
+
+        $this->assertTrue(self::invokePrivate($this->auth, 'validateUserPass', ['MyTestUser', 'MyTestPassword']));
+    }
+
+    public function testValidateUserPassOfInvalidDAVAuthenticatedUser(): void {
+        $user = $this->createMock(IUser::class);
+        $user->expects($this->once())
+            ->method('getUID')
+            ->willReturn('MyTestUser');
+        $this->userSession
+            ->expects($this->once())
+            ->method('isLoggedIn')
+            ->willReturn(true);
+        $this->userSession
+            ->expects($this->once())
+            ->method('getUser')
+            ->willReturn($user);
+        $this->session
+            ->expects($this->exactly(2))
+            ->method('get')
+            ->with('AUTHENTICATED_TO_DAV_BACKEND')
+            ->willReturn('AnotherUser');
+        $this->session
+            ->expects($this->once())
+            ->method('close');
+
+        $this->assertFalse(self::invokePrivate($this->auth, 'validateUserPass', ['MyTestUser', 'MyTestPassword']));
+    }
+
+    public function testValidateUserPassOfInvalidDAVAuthenticatedUserWithValidPassword(): void {
+        $user = $this->createMock(IUser::class);
+        $user->expects($this->exactly(2))
+            ->method('getUID')
+            ->willReturn('MyTestUser');
+        $this->userSession
+            ->expects($this->once())
+            ->method('isLoggedIn')
+            ->willReturn(true);
+        $this->userSession
+            ->expects($this->exactly(2))
+            ->method('getUser')
+            ->willReturn($user);
+        $this->session
+            ->expects($this->exactly(2))
+            ->method('get')
+            ->with('AUTHENTICATED_TO_DAV_BACKEND')
+            ->willReturn('AnotherUser');
+        $this->userSession
+            ->expects($this->once())
+            ->method('logClientIn')
+            ->with('MyTestUser', 'MyTestPassword', $this->request)
+            ->willReturn(true);
+        $this->session
+            ->expects($this->once())
+            ->method('set')
+            ->with('AUTHENTICATED_TO_DAV_BACKEND', 'MyTestUser');
+        $this->session
+            ->expects($this->once())
+            ->method('close');
+
+        $this->assertTrue(self::invokePrivate($this->auth, 'validateUserPass', ['MyTestUser', 'MyTestPassword']));
+    }
+
+    public function testValidateUserPassWithInvalidPassword(): void {
+        $this->userSession
+            ->expects($this->once())
+            ->method('isLoggedIn')
+            ->willReturn(false);
+        $this->userSession
+            ->expects($this->once())
+            ->method('logClientIn')
+            ->with('MyTestUser', 'MyTestPassword')
+            ->willReturn(false);
+        $this->session
+            ->expects($this->once())
+            ->method('close');
+
+        $this->assertFalse(self::invokePrivate($this->auth, 'validateUserPass', ['MyTestUser', 'MyTestPassword']));
+    }
+
+
+    public function testValidateUserPassWithPasswordLoginForbidden(): void {
+        $this->expectException(PasswordLoginForbidden::class);
+
+        $this->userSession
+            ->expects($this->once())
+            ->method('isLoggedIn')
+            ->willReturn(false);
+        $this->userSession
+            ->expects($this->once())
+            ->method('logClientIn')
+            ->with('MyTestUser', 'MyTestPassword')
+            ->willThrowException(new PasswordLoginForbiddenException());
+        $this->session
+            ->expects($this->once())
+            ->method('close');
+
+        self::invokePrivate($this->auth, 'validateUserPass', ['MyTestUser', 'MyTestPassword']);
+    }
+
+    public function testAuthenticateAlreadyLoggedInWithoutCsrfTokenForNonGet(): void {
+        $request = $this->createMock(RequestInterface::class);
+        $response = $this->createMock(ResponseInterface::class);
+        $this->userSession
+            ->expects($this->any())
+            ->method('isLoggedIn')
+            ->willReturn(true);
+        $this->request
+            ->expects($this->any())
+            ->method('getMethod')
+            ->willReturn('POST');
+        $this->session
+            ->expects($this->any())
+            ->method('get')
+            ->with('AUTHENTICATED_TO_DAV_BACKEND')
+            ->willReturn(null);
+        $user = $this->createMock(IUser::class);
+        $user->expects($this->any())
+            ->method('getUID')
+            ->willReturn('MyWrongDavUser');
+        $this->userSession
+            ->expects($this->any())
+            ->method('getUser')
+            ->willReturn($user);
+        $this->request
+            ->expects($this->once())
+            ->method('passesCSRFCheck')
+            ->willReturn(false);
+
+        $expectedResponse = [
+            false,
+            "No 'Authorization: Basic' header found. Either the client didn't send one, or the server is misconfigured",
+        ];
+        $response = $this->auth->check($request, $response);
+        $this->assertSame($expectedResponse, $response);
+    }
+
+    public function testAuthenticateAlreadyLoggedInWithoutCsrfTokenAndCorrectlyDavAuthenticated(): void {
+        $request = $this->createMock(RequestInterface::class);
+        $response = $this->createMock(ResponseInterface::class);
+        $this->userSession
+            ->expects($this->any())
+            ->method('isLoggedIn')
+            ->willReturn(true);
+        $this->request
+            ->expects($this->any())
+            ->method('getMethod')
+            ->willReturn('PROPFIND');
+        $this->request
+            ->expects($this->any())
+            ->method('isUserAgent')
+            ->willReturn(false);
+        $this->session
+            ->expects($this->any())
+            ->method('get')
+            ->with('AUTHENTICATED_TO_DAV_BACKEND')
+            ->willReturn('LoggedInUser');
+        $user = $this->createMock(IUser::class);
+        $user->expects($this->any())
+            ->method('getUID')
+            ->willReturn('LoggedInUser');
+        $this->userSession
+            ->expects($this->any())
+            ->method('getUser')
+            ->willReturn($user);
+        $this->request
+            ->expects($this->once())
+            ->method('passesCSRFCheck')
+            ->willReturn(false);
+        $this->auth->check($request, $response);
+    }
+
+
+    public function testAuthenticateAlreadyLoggedInWithoutTwoFactorChallengePassed(): void {
+        $this->expectException(\Sabre\DAV\Exception\NotAuthenticated::class);
+        $this->expectExceptionMessage('2FA challenge not passed.');
+
+        $request = $this->createMock(RequestInterface::class);
+        $response = $this->createMock(ResponseInterface::class);
+        $this->userSession
+            ->expects($this->any())
+            ->method('isLoggedIn')
+            ->willReturn(true);
+        $this->request
+            ->expects($this->any())
+            ->method('getMethod')
+            ->willReturn('PROPFIND');
+        $this->request
+            ->expects($this->any())
+            ->method('isUserAgent')
+            ->willReturn(false);
+        $this->session
+            ->expects($this->any())
+            ->method('get')
+            ->with('AUTHENTICATED_TO_DAV_BACKEND')
+            ->willReturn('LoggedInUser');
+        $user = $this->createMock(IUser::class);
+        $user->expects($this->any())
+            ->method('getUID')
+            ->willReturn('LoggedInUser');
+        $this->userSession
+            ->expects($this->any())
+            ->method('getUser')
+            ->willReturn($user);
+        $this->request
+            ->expects($this->once())
+            ->method('passesCSRFCheck')
+            ->willReturn(true);
+        $this->twoFactorManager->expects($this->once())
+            ->method('needsSecondFactor')
+            ->with($user)
+            ->willReturn(true);
+        $this->auth->check($request, $response);
+    }
+
+
+    public function testAuthenticateAlreadyLoggedInWithoutCsrfTokenAndIncorrectlyDavAuthenticated(): void {
+        $this->expectException(\Sabre\DAV\Exception\NotAuthenticated::class);
+        $this->expectExceptionMessage('CSRF check not passed.');
+
+        $request = $this->createMock(RequestInterface::class);
+        $response = $this->createMock(ResponseInterface::class);
+        $this->userSession
+            ->expects($this->any())
+            ->method('isLoggedIn')
+            ->willReturn(true);
+        $this->request
+            ->expects($this->any())
+            ->method('getMethod')
+            ->willReturn('PROPFIND');
+        $this->request
+            ->expects($this->any())
+            ->method('isUserAgent')
+            ->willReturn(false);
+        $this->session
+            ->expects($this->any())
+            ->method('get')
+            ->with('AUTHENTICATED_TO_DAV_BACKEND')
+            ->willReturn('AnotherUser');
+        $user = $this->createMock(IUser::class);
+        $user->expects($this->any())
+            ->method('getUID')
+            ->willReturn('LoggedInUser');
+        $this->userSession
+            ->expects($this->any())
+            ->method('getUser')
+            ->willReturn($user);
+        $this->request
+            ->expects($this->once())
+            ->method('passesCSRFCheck')
+            ->willReturn(false);
+        $this->auth->check($request, $response);
+    }
+
+    public function testAuthenticateAlreadyLoggedInWithoutCsrfTokenForNonGetAndDesktopClient(): void {
+        $request = $this->createMock(RequestInterface::class);
+        $response = $this->createMock(ResponseInterface::class);
+        $this->userSession
+            ->expects($this->any())
+            ->method('isLoggedIn')
+            ->willReturn(true);
+        $this->request
+            ->expects($this->any())
+            ->method('getMethod')
+            ->willReturn('POST');
+        $this->request
+            ->expects($this->any())
+            ->method('isUserAgent')
+            ->willReturn(true);
+        $this->session
+            ->expects($this->any())
+            ->method('get')
+            ->with('AUTHENTICATED_TO_DAV_BACKEND')
+            ->willReturn(null);
+        $user = $this->createMock(IUser::class);
+        $user->expects($this->any())
+            ->method('getUID')
+            ->willReturn('MyWrongDavUser');
+        $this->userSession
+            ->expects($this->any())
+            ->method('getUser')
+            ->willReturn($user);
+        $this->request
+            ->expects($this->once())
+            ->method('passesCSRFCheck')
+            ->willReturn(false);
+
+        $this->auth->check($request, $response);
+    }
+
+    public function testAuthenticateAlreadyLoggedInWithoutCsrfTokenForGet(): void {
+        $request = $this->createMock(RequestInterface::class);
+        $response = $this->createMock(ResponseInterface::class);
+        $this->userSession
+            ->expects($this->any())
+            ->method('isLoggedIn')
+            ->willReturn(true);
+        $this->session
+            ->expects($this->any())
+            ->method('get')
+            ->with('AUTHENTICATED_TO_DAV_BACKEND')
+            ->willReturn(null);
+        $user = $this->createMock(IUser::class);
+        $user->expects($this->any())
+            ->method('getUID')
+            ->willReturn('MyWrongDavUser');
+        $this->userSession
+            ->expects($this->any())
+            ->method('getUser')
+            ->willReturn($user);
+        $this->request
+            ->expects($this->any())
+            ->method('getMethod')
+            ->willReturn('GET');
+
+        $response = $this->auth->check($request, $response);
+        $this->assertEquals([true, 'principals/users/MyWrongDavUser'], $response);
+    }
+
+    public function testAuthenticateAlreadyLoggedInWithCsrfTokenForGet(): void {
+        $request = $this->createMock(RequestInterface::class);
+        $response = $this->createMock(ResponseInterface::class);
+        $this->userSession
+            ->expects($this->any())
+            ->method('isLoggedIn')
+            ->willReturn(true);
+        $this->session
+            ->expects($this->any())
+            ->method('get')
+            ->with('AUTHENTICATED_TO_DAV_BACKEND')
+            ->willReturn(null);
+        $user = $this->createMock(IUser::class);
+        $user->expects($this->any())
+            ->method('getUID')
+            ->willReturn('MyWrongDavUser');
+        $this->userSession
+            ->expects($this->any())
+            ->method('getUser')
+            ->willReturn($user);
+        $this->request
+            ->expects($this->once())
+            ->method('passesCSRFCheck')
+            ->willReturn(true);
+
+        $response = $this->auth->check($request, $response);
+        $this->assertEquals([true, 'principals/users/MyWrongDavUser'], $response);
+    }
+
+    public function testAuthenticateNoBasicAuthenticateHeadersProvided(): void {
+        $server = $this->createMock(Server::class);
+        $server->httpRequest = $this->createMock(RequestInterface::class);
+        $server->httpResponse = $this->createMock(ResponseInterface::class);
+        $response = $this->auth->check($server->httpRequest, $server->httpResponse);
+        $this->assertEquals([false, 'No \'Authorization: Basic\' header found. Either the client didn\'t send one, or the server is misconfigured'], $response);
+    }
+
+
+    public function testAuthenticateNoBasicAuthenticateHeadersProvidedWithAjax(): void {
+        $this->expectException(\Sabre\DAV\Exception\NotAuthenticated::class);
+        $this->expectExceptionMessage('Cannot authenticate over ajax calls');
+
+        /** @var \Sabre\HTTP\RequestInterface&MockObject $httpRequest */
+        $httpRequest = $this->createMock(RequestInterface::class);
+        /** @var \Sabre\HTTP\ResponseInterface&MockObject $httpResponse */
+        $httpResponse = $this->createMock(ResponseInterface::class);
+        $this->userSession
+            ->expects($this->any())
+            ->method('isLoggedIn')
+            ->willReturn(false);
+        $httpRequest
+            ->expects($this->exactly(2))
+            ->method('getHeader')
+            ->willReturnMap([
+                ['X-Requested-With', 'XMLHttpRequest'],
+                ['Authorization', null],
+            ]);
+
+        $this->auth->check($httpRequest, $httpResponse);
+    }
+
+    public function testAuthenticateWithBasicAuthenticateHeadersProvidedWithAjax(): void {
+        // No CSRF
+        $this->request
+            ->expects($this->once())
+            ->method('passesCSRFCheck')
+            ->willReturn(false);
+
+        /** @var \Sabre\HTTP\RequestInterface&MockObject $httpRequest */
+        $httpRequest = $this->createMock(RequestInterface::class);
+        /** @var \Sabre\HTTP\ResponseInterface&MockObject $httpResponse */
+        $httpResponse = $this->createMock(ResponseInterface::class);
+        $httpRequest
+            ->expects($this->any())
+            ->method('getHeader')
+            ->willReturnMap([
+                ['X-Requested-With', 'XMLHttpRequest'],
+                ['Authorization', 'basic dXNlcm5hbWU6cGFzc3dvcmQ='],
+            ]);
+
+        $user = $this->createMock(IUser::class);
+        $user->expects($this->any())
+            ->method('getUID')
+            ->willReturn('MyDavUser');
+        $this->userSession
+            ->expects($this->any())
+            ->method('isLoggedIn')
+            ->willReturn(false);
+        $this->userSession
+            ->expects($this->once())
+            ->method('logClientIn')
+            ->with('username', 'password')
+            ->willReturn(true);
+        $this->userSession
+            ->expects($this->any())
+            ->method('getUser')
+            ->willReturn($user);
+
+        $this->auth->check($httpRequest, $httpResponse);
+    }
+
+    public function testAuthenticateNoBasicAuthenticateHeadersProvidedWithAjaxButUserIsStillLoggedIn(): void {
+        /** @var \Sabre\HTTP\RequestInterface $httpRequest */
+        $httpRequest = $this->createMock(RequestInterface::class);
+        /** @var \Sabre\HTTP\ResponseInterface $httpResponse */
+        $httpResponse = $this->createMock(ResponseInterface::class);
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')->willReturn('MyTestUser');
+        $this->userSession
+            ->expects($this->any())
+            ->method('isLoggedIn')
+            ->willReturn(true);
+        $this->userSession
+            ->expects($this->any())
+            ->method('getUser')
+            ->willReturn($user);
+        $this->session
+            ->expects($this->atLeastOnce())
+            ->method('get')
+            ->with('AUTHENTICATED_TO_DAV_BACKEND')
+            ->willReturn('MyTestUser');
+        $this->request
+            ->expects($this->once())
+            ->method('getMethod')
+            ->willReturn('GET');
+        $httpRequest
+            ->expects($this->atLeastOnce())
+            ->method('getHeader')
+            ->with('Authorization')
+            ->willReturn(null);
+        $this->assertEquals(
+            [true, 'principals/users/MyTestUser'],
+            $this->auth->check($httpRequest, $httpResponse)
+        );
+    }
+
+    public function testAuthenticateValidCredentials(): void {
+        $server = $this->createMock(Server::class);
+        $server->httpRequest = $this->createMock(RequestInterface::class);
+        $server->httpRequest
+            ->expects($this->once())
+            ->method('getHeader')
+            ->with('Authorization')
+            ->willReturn('basic dXNlcm5hbWU6cGFzc3dvcmQ=');
+
+        $server->httpResponse = $this->createMock(ResponseInterface::class);
+        $this->userSession
+            ->expects($this->once())
+            ->method('logClientIn')
+            ->with('username', 'password')
+            ->willReturn(true);
+        $user = $this->createMock(IUser::class);
+        $user->expects($this->exactly(2))
+            ->method('getUID')
+            ->willReturn('MyTestUser');
+        $this->userSession
+            ->expects($this->exactly(4))
+            ->method('getUser')
+            ->willReturn($user);
+        $response = $this->auth->check($server->httpRequest, $server->httpResponse);
+        $this->assertEquals([true, 'principals/users/MyTestUser'], $response);
+    }
+
+    public function testAuthenticateInvalidCredentials(): void {
+        $server = $this->createMock(Server::class);
+        $server->httpRequest = $this->createMock(RequestInterface::class);
+        $server->httpRequest
+            ->expects($this->exactly(2))
+            ->method('getHeader')
+            ->willReturnMap([
+                ['Authorization', 'basic dXNlcm5hbWU6cGFzc3dvcmQ='],
+                ['X-Requested-With', null],
+            ]);
+        $server->httpResponse = $this->createMock(ResponseInterface::class);
+        $this->userSession
+            ->expects($this->once())
+            ->method('logClientIn')
+            ->with('username', 'password')
+            ->willReturn(false);
+        $response = $this->auth->check($server->httpRequest, $server->httpResponse);
+        $this->assertEquals([false, 'Username or password was incorrect'], $response);
+    }
 }

tests/Core/Controller/AvatarControllerTest.php

Indentation +406 added lines, -406 removed lines

@@ -13,7 +13,7 @@ 
  * proper unit testing of the postAvatar call.
  */
 function is_uploaded_file($filename) {
-	return file_exists($filename);
+    return file_exists($filename);
 }
 
 namespace Tests\Core\Controller;
@@ -41,409 +41,409 @@ 
  * @package OC\Core\Controller
  */
 class AvatarControllerTest extends \Test\TestCase {
-	/** @var AvatarController */
-	private $avatarController;
-	/** @var GuestAvatarController */
-	private $guestAvatarController;
-
-	/** @var IAvatar|\PHPUnit\Framework\MockObject\MockObject */
-	private $avatarMock;
-	/** @var IUser|\PHPUnit\Framework\MockObject\MockObject */
-	private $userMock;
-	/** @var ISimpleFile|\PHPUnit\Framework\MockObject\MockObject */
-	private $avatarFile;
-	/** @var IAvatarManager|\PHPUnit\Framework\MockObject\MockObject */
-	private $avatarManager;
-	/** @var IL10N|\PHPUnit\Framework\MockObject\MockObject */
-	private $l;
-	/** @var IUserManager|\PHPUnit\Framework\MockObject\MockObject */
-	private $userManager;
-	/** @var IRootFolder|\PHPUnit\Framework\MockObject\MockObject */
-	private $rootFolder;
-	/** @var LoggerInterface|\PHPUnit\Framework\MockObject\MockObject */
-	private $logger;
-	/** @var IRequest|\PHPUnit\Framework\MockObject\MockObject */
-	private $request;
-	/** @var TimeFactory|\PHPUnit\Framework\MockObject\MockObject */
-	private $timeFactory;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->avatarManager = $this->getMockBuilder('OCP\IAvatarManager')->getMock();
-		$this->l = $this->getMockBuilder(IL10N::class)->getMock();
-		$this->l->method('t')->willReturnArgument(0);
-		$this->userManager = $this->getMockBuilder(IUserManager::class)->getMock();
-		$this->request = $this->getMockBuilder(IRequest::class)->getMock();
-		$this->rootFolder = $this->getMockBuilder('OCP\Files\IRootFolder')->getMock();
-		$this->logger = $this->getMockBuilder(LoggerInterface::class)->getMock();
-		$this->timeFactory = $this->getMockBuilder('OC\AppFramework\Utility\TimeFactory')->getMock();
-
-		$this->avatarMock = $this->getMockBuilder('OCP\IAvatar')->getMock();
-		$this->userMock = $this->getMockBuilder(IUser::class)->getMock();
-
-		$this->guestAvatarController = new GuestAvatarController(
-			'core',
-			$this->request,
-			$this->avatarManager,
-			$this->logger
-		);
-
-		$this->avatarController = new AvatarController(
-			'core',
-			$this->request,
-			$this->avatarManager,
-			$this->l,
-			$this->userManager,
-			$this->rootFolder,
-			$this->logger,
-			'userid',
-			$this->timeFactory,
-			$this->guestAvatarController,
-		);
-
-		// Configure userMock
-		$this->userMock->method('getDisplayName')->willReturn('displayName');
-		$this->userMock->method('getUID')->willReturn('userId');
-		$this->userManager->method('get')
-			->willReturnMap([['userId', $this->userMock]]);
-
-		$this->avatarFile = $this->getMockBuilder(ISimpleFile::class)->getMock();
-		$this->avatarFile->method('getContent')->willReturn('image data');
-		$this->avatarFile->method('getMimeType')->willReturn('image type');
-		$this->avatarFile->method('getEtag')->willReturn('my etag');
-		$this->avatarFile->method('getName')->willReturn('my name');
-		$this->avatarFile->method('getMTime')->willReturn(42);
-	}
-
-	protected function tearDown(): void {
-		parent::tearDown();
-	}
-
-	/**
-	 * Fetch an avatar if a user has no avatar
-	 */
-	public function testGetAvatarNoAvatar(): void {
-		$this->avatarManager->method('getAvatar')->willReturn($this->avatarMock);
-		$this->avatarMock->method('getFile')->willThrowException(new NotFoundException());
-		$response = $this->avatarController->getAvatar('userId', 32);
-
-		//Comment out until JS is fixed
-		$this->assertEquals(Http::STATUS_NOT_FOUND, $response->getStatus());
-	}
-
-	/**
-	 * Fetch the user's avatar
-	 */
-	public function testGetAvatar(): void {
-		$this->avatarMock->method('getFile')->willReturn($this->avatarFile);
-		$this->avatarManager->method('getAvatar')->with('userId')->willReturn($this->avatarMock);
-		$this->avatarMock->expects($this->once())
-			->method('isCustomAvatar')
-			->willReturn(true);
-
-		$response = $this->avatarController->getAvatar('userId', 32);
-
-		$this->assertEquals(Http::STATUS_OK, $response->getStatus());
-		$this->assertArrayHasKey('Content-Type', $response->getHeaders());
-		$this->assertEquals('image type', $response->getHeaders()['Content-Type']);
-		$this->assertArrayHasKey('X-NC-IsCustomAvatar', $response->getHeaders());
-		$this->assertEquals('1', $response->getHeaders()['X-NC-IsCustomAvatar']);
-
-		$this->assertEquals('my etag', $response->getETag());
-	}
-
-	/**
-	 * Fetch the user's avatar
-	 */
-	public function testGetGeneratedAvatar(): void {
-		$this->avatarMock->method('getFile')->willReturn($this->avatarFile);
-		$this->avatarManager->method('getAvatar')->with('userId')->willReturn($this->avatarMock);
-
-		$response = $this->avatarController->getAvatar('userId', 32);
-
-		$this->assertEquals(Http::STATUS_OK, $response->getStatus());
-		$this->assertArrayHasKey('Content-Type', $response->getHeaders());
-		$this->assertEquals('image type', $response->getHeaders()['Content-Type']);
-		$this->assertArrayHasKey('X-NC-IsCustomAvatar', $response->getHeaders());
-		$this->assertEquals('0', $response->getHeaders()['X-NC-IsCustomAvatar']);
-
-		$this->assertEquals('my etag', $response->getETag());
-	}
-
-	/**
-	 * Fetch the avatar of a non-existing user
-	 */
-	public function testGetAvatarNoUser(): void {
-		$this->avatarManager
-			->method('getAvatar')
-			->with('userDoesNotExist')
-			->willThrowException(new \Exception('user does not exist'));
-
-		$response = $this->avatarController->getAvatar('userDoesNotExist', 32);
-
-		//Comment out until JS is fixed
-		$this->assertEquals(Http::STATUS_NOT_FOUND, $response->getStatus());
-	}
-
-	public function testGetAvatarSize64(): void {
-		$this->avatarMock->expects($this->once())
-			->method('getFile')
-			->with($this->equalTo(64))
-			->willReturn($this->avatarFile);
-
-		$this->avatarManager->method('getAvatar')->willReturn($this->avatarMock);
-
-		$this->logger->expects($this->never())
-			->method('debug');
-
-		$this->avatarController->getAvatar('userId', 64);
-	}
-
-	public function testGetAvatarSize512(): void {
-		$this->avatarMock->expects($this->once())
-			->method('getFile')
-			->with($this->equalTo(512))
-			->willReturn($this->avatarFile);
-
-		$this->avatarManager->method('getAvatar')->willReturn($this->avatarMock);
-
-		$this->logger->expects($this->never())
-			->method('debug');
-
-		$this->avatarController->getAvatar('userId', 512);
-	}
-
-	/**
-	 * Small sizes return 64 and generate a log
-	 */
-	public function testGetAvatarSizeTooSmall(): void {
-		$this->avatarMock->expects($this->once())
-			->method('getFile')
-			->with($this->equalTo(64))
-			->willReturn($this->avatarFile);
-
-		$this->avatarManager->method('getAvatar')->willReturn($this->avatarMock);
-
-		$this->logger->expects($this->once())
-			->method('debug')
-			->with('Avatar requested in deprecated size 32');
-
-		$this->avatarController->getAvatar('userId', 32);
-	}
-
-	/**
-	 * Avatars between 64 and 512 are upgraded to 512
-	 */
-	public function testGetAvatarSizeBetween(): void {
-		$this->avatarMock->expects($this->once())
-			->method('getFile')
-			->with($this->equalTo(512))
-			->willReturn($this->avatarFile);
-
-		$this->avatarManager->method('getAvatar')->willReturn($this->avatarMock);
-
-		$this->logger->expects($this->once())
-			->method('debug')
-			->with('Avatar requested in deprecated size 65');
-
-		$this->avatarController->getAvatar('userId', 65);
-	}
-
-	/**
-	 * We do not support avatars larger than 512
-	 */
-	public function testGetAvatarSizeTooBig(): void {
-		$this->avatarMock->expects($this->once())
-			->method('getFile')
-			->with($this->equalTo(512))
-			->willReturn($this->avatarFile);
-
-		$this->avatarManager->method('getAvatar')->willReturn($this->avatarMock);
-
-		$this->logger->expects($this->once())
-			->method('debug')
-			->with('Avatar requested in deprecated size 513');
-
-		$this->avatarController->getAvatar('userId', 513);
-	}
-
-	/**
-	 * Remove an avatar
-	 */
-	public function testDeleteAvatar(): void {
-		$this->avatarManager->method('getAvatar')->willReturn($this->avatarMock);
-
-		$response = $this->avatarController->deleteAvatar();
-		$this->assertEquals(Http::STATUS_OK, $response->getStatus());
-	}
-
-	/**
-	 * Test what happens if the removing of the avatar fails
-	 */
-	public function testDeleteAvatarException(): void {
-		$this->avatarMock->method('remove')->willThrowException(new \Exception('foo'));
-		$this->avatarManager->method('getAvatar')->willReturn($this->avatarMock);
-
-		$this->logger->expects($this->once())
-			->method('error')
-			->with('foo', ['exception' => new \Exception('foo'), 'app' => 'core']);
-		$expectedResponse = new Http\JSONResponse(['data' => ['message' => 'An error occurred. Please contact your admin.']], Http::STATUS_BAD_REQUEST);
-		$this->assertEquals($expectedResponse, $this->avatarController->deleteAvatar());
-	}
-
-	/**
-	 * When trying to post a new avatar a path or image should be posted.
-	 */
-	public function testPostAvatarNoPathOrImage(): void {
-		$response = $this->avatarController->postAvatar(null);
-
-		$this->assertEquals(Http::STATUS_BAD_REQUEST, $response->getStatus());
-	}
-
-	/**
-	 * Test a correct post of an avatar using POST
-	 */
-	public function testPostAvatarFile(): void {
-		//Create temp file
-		$fileName = tempnam('', 'avatarTest');
-		$copyRes = copy(\OC::$SERVERROOT . '/tests/data/testimage.jpg', $fileName);
-		$this->assertTrue($copyRes);
-
-		//Create request return
-		$reqRet = ['error' => [0], 'tmp_name' => [$fileName], 'size' => [filesize(\OC::$SERVERROOT . '/tests/data/testimage.jpg')]];
-		$this->request->method('getUploadedFile')->willReturn($reqRet);
-
-		$response = $this->avatarController->postAvatar(null);
-
-		//On correct upload always respond with the notsquare message
-		$this->assertEquals('notsquare', $response->getData()['data']);
-
-		//File should be deleted
-		$this->assertFalse(file_exists($fileName));
-	}
-
-	/**
-	 * Test invalid post os an avatar using POST
-	 */
-	public function testPostAvatarInvalidFile(): void {
-		//Create request return
-		$reqRet = ['error' => [1], 'tmp_name' => ['foo']];
-		$this->request->method('getUploadedFile')->willReturn($reqRet);
-
-		$response = $this->avatarController->postAvatar(null);
-
-		$this->assertEquals(Http::STATUS_BAD_REQUEST, $response->getStatus());
-	}
-
-	/**
-	 * Check what happens when we upload a GIF
-	 */
-	public function testPostAvatarFileGif(): void {
-		//Create temp file
-		$fileName = tempnam('', 'avatarTest');
-		$copyRes = copy(\OC::$SERVERROOT . '/tests/data/testimage.gif', $fileName);
-		$this->assertTrue($copyRes);
-
-		//Create request return
-		$reqRet = ['error' => [0], 'tmp_name' => [$fileName], 'size' => [filesize(\OC::$SERVERROOT . '/tests/data/testimage.gif')]];
-		$this->request->method('getUploadedFile')->willReturn($reqRet);
-
-		$response = $this->avatarController->postAvatar(null);
-
-		$this->assertEquals('Unknown filetype', $response->getData()['data']['message']);
-
-		//File should be deleted
-		$this->assertFalse(file_exists($fileName));
-	}
-
-	/**
-	 * Test posting avatar from existing file
-	 */
-	public function testPostAvatarFromFile(): void {
-		//Mock node API call
-		$file = $this->getMockBuilder('OCP\Files\File')
-			->disableOriginalConstructor()->getMock();
-		$file->expects($this->once())
-			->method('getContent')
-			->willReturn(file_get_contents(\OC::$SERVERROOT . '/tests/data/testimage.jpg'));
-		$file->expects($this->once())
-			->method('getMimeType')
-			->willReturn('image/jpeg');
-		$userFolder = $this->getMockBuilder('OCP\Files\Folder')->getMock();
-		$this->rootFolder->method('getUserFolder')->with('userid')->willReturn($userFolder);
-		$userFolder->method('get')->willReturn($file);
-
-		//Create request return
-		$response = $this->avatarController->postAvatar('avatar.jpg');
-
-		//On correct upload always respond with the notsquare message
-		$this->assertEquals('notsquare', $response->getData()['data']);
-	}
-
-	/**
-	 * Test posting avatar from existing folder
-	 */
-	public function testPostAvatarFromNoFile(): void {
-		$file = $this->getMockBuilder('OCP\Files\Node')->getMock();
-		$userFolder = $this->getMockBuilder('OCP\Files\Folder')->getMock();
-		$this->rootFolder->method('getUserFolder')->with('userid')->willReturn($userFolder);
-		$userFolder
-			->method('get')
-			->with('folder')
-			->willReturn($file);
-
-		//Create request return
-		$response = $this->avatarController->postAvatar('folder');
-
-		//On correct upload always respond with the notsquare message
-		$this->assertEquals(['data' => ['message' => 'Please select a file.']], $response->getData());
-	}
-
-	public function testPostAvatarInvalidType(): void {
-		$file = $this->getMockBuilder('OCP\Files\File')
-			->disableOriginalConstructor()->getMock();
-		$file->expects($this->never())
-			->method('getContent');
-		$file->expects($this->exactly(2))
-			->method('getMimeType')
-			->willReturn('text/plain');
-		$userFolder = $this->getMockBuilder('OCP\Files\Folder')->getMock();
-		$this->rootFolder->method('getUserFolder')->with('userid')->willReturn($userFolder);
-		$userFolder->method('get')->willReturn($file);
-
-		$expectedResponse = new Http\JSONResponse(['data' => ['message' => 'The selected file is not an image.']], Http::STATUS_BAD_REQUEST);
-		$this->assertEquals($expectedResponse, $this->avatarController->postAvatar('avatar.jpg'));
-	}
-
-	public function testPostAvatarNotPermittedException(): void {
-		$file = $this->getMockBuilder('OCP\Files\File')
-			->disableOriginalConstructor()->getMock();
-		$file->expects($this->once())
-			->method('getContent')
-			->willThrowException(new NotPermittedException());
-		$file->expects($this->once())
-			->method('getMimeType')
-			->willReturn('image/jpeg');
-		$userFolder = $this->getMockBuilder('OCP\Files\Folder')->getMock();
-		$this->rootFolder->method('getUserFolder')->with('userid')->willReturn($userFolder);
-		$userFolder->method('get')->willReturn($file);
-
-		$expectedResponse = new Http\JSONResponse(['data' => ['message' => 'The selected file cannot be read.']], Http::STATUS_BAD_REQUEST);
-		$this->assertEquals($expectedResponse, $this->avatarController->postAvatar('avatar.jpg'));
-	}
-
-	/**
-	 * Check for proper reply on proper crop argument
-	 */
-	public function testFileTooBig(): void {
-		$fileName = \OC::$SERVERROOT . '/tests/data/testimage.jpg';
-		//Create request return
-		$reqRet = ['error' => [0], 'tmp_name' => [$fileName], 'size' => [21 * 1024 * 1024]];
-		$this->request->method('getUploadedFile')->willReturn($reqRet);
-
-		$response = $this->avatarController->postAvatar(null);
-
-		$this->assertEquals('File is too big', $response->getData()['data']['message']);
-	}
+    /** @var AvatarController */
+    private $avatarController;
+    /** @var GuestAvatarController */
+    private $guestAvatarController;
+
+    /** @var IAvatar|\PHPUnit\Framework\MockObject\MockObject */
+    private $avatarMock;
+    /** @var IUser|\PHPUnit\Framework\MockObject\MockObject */
+    private $userMock;
+    /** @var ISimpleFile|\PHPUnit\Framework\MockObject\MockObject */
+    private $avatarFile;
+    /** @var IAvatarManager|\PHPUnit\Framework\MockObject\MockObject */
+    private $avatarManager;
+    /** @var IL10N|\PHPUnit\Framework\MockObject\MockObject */
+    private $l;
+    /** @var IUserManager|\PHPUnit\Framework\MockObject\MockObject */
+    private $userManager;
+    /** @var IRootFolder|\PHPUnit\Framework\MockObject\MockObject */
+    private $rootFolder;
+    /** @var LoggerInterface|\PHPUnit\Framework\MockObject\MockObject */
+    private $logger;
+    /** @var IRequest|\PHPUnit\Framework\MockObject\MockObject */
+    private $request;
+    /** @var TimeFactory|\PHPUnit\Framework\MockObject\MockObject */
+    private $timeFactory;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->avatarManager = $this->getMockBuilder('OCP\IAvatarManager')->getMock();
+        $this->l = $this->getMockBuilder(IL10N::class)->getMock();
+        $this->l->method('t')->willReturnArgument(0);
+        $this->userManager = $this->getMockBuilder(IUserManager::class)->getMock();
+        $this->request = $this->getMockBuilder(IRequest::class)->getMock();
+        $this->rootFolder = $this->getMockBuilder('OCP\Files\IRootFolder')->getMock();
+        $this->logger = $this->getMockBuilder(LoggerInterface::class)->getMock();
+        $this->timeFactory = $this->getMockBuilder('OC\AppFramework\Utility\TimeFactory')->getMock();
+
+        $this->avatarMock = $this->getMockBuilder('OCP\IAvatar')->getMock();
+        $this->userMock = $this->getMockBuilder(IUser::class)->getMock();
+
+        $this->guestAvatarController = new GuestAvatarController(
+            'core',
+            $this->request,
+            $this->avatarManager,
+            $this->logger
+        );
+
+        $this->avatarController = new AvatarController(
+            'core',
+            $this->request,
+            $this->avatarManager,
+            $this->l,
+            $this->userManager,
+            $this->rootFolder,
+            $this->logger,
+            'userid',
+            $this->timeFactory,
+            $this->guestAvatarController,
+        );
+
+        // Configure userMock
+        $this->userMock->method('getDisplayName')->willReturn('displayName');
+        $this->userMock->method('getUID')->willReturn('userId');
+        $this->userManager->method('get')
+            ->willReturnMap([['userId', $this->userMock]]);
+
+        $this->avatarFile = $this->getMockBuilder(ISimpleFile::class)->getMock();
+        $this->avatarFile->method('getContent')->willReturn('image data');
+        $this->avatarFile->method('getMimeType')->willReturn('image type');
+        $this->avatarFile->method('getEtag')->willReturn('my etag');
+        $this->avatarFile->method('getName')->willReturn('my name');
+        $this->avatarFile->method('getMTime')->willReturn(42);
+    }
+
+    protected function tearDown(): void {
+        parent::tearDown();
+    }
+
+    /**
+     * Fetch an avatar if a user has no avatar
+     */
+    public function testGetAvatarNoAvatar(): void {
+        $this->avatarManager->method('getAvatar')->willReturn($this->avatarMock);
+        $this->avatarMock->method('getFile')->willThrowException(new NotFoundException());
+        $response = $this->avatarController->getAvatar('userId', 32);
+
+        //Comment out until JS is fixed
+        $this->assertEquals(Http::STATUS_NOT_FOUND, $response->getStatus());
+    }
+
+    /**
+     * Fetch the user's avatar
+     */
+    public function testGetAvatar(): void {
+        $this->avatarMock->method('getFile')->willReturn($this->avatarFile);
+        $this->avatarManager->method('getAvatar')->with('userId')->willReturn($this->avatarMock);
+        $this->avatarMock->expects($this->once())
+            ->method('isCustomAvatar')
+            ->willReturn(true);
+
+        $response = $this->avatarController->getAvatar('userId', 32);
+
+        $this->assertEquals(Http::STATUS_OK, $response->getStatus());
+        $this->assertArrayHasKey('Content-Type', $response->getHeaders());
+        $this->assertEquals('image type', $response->getHeaders()['Content-Type']);
+        $this->assertArrayHasKey('X-NC-IsCustomAvatar', $response->getHeaders());
+        $this->assertEquals('1', $response->getHeaders()['X-NC-IsCustomAvatar']);
+
+        $this->assertEquals('my etag', $response->getETag());
+    }
+
+    /**
+     * Fetch the user's avatar
+     */
+    public function testGetGeneratedAvatar(): void {
+        $this->avatarMock->method('getFile')->willReturn($this->avatarFile);
+        $this->avatarManager->method('getAvatar')->with('userId')->willReturn($this->avatarMock);
+
+        $response = $this->avatarController->getAvatar('userId', 32);
+
+        $this->assertEquals(Http::STATUS_OK, $response->getStatus());
+        $this->assertArrayHasKey('Content-Type', $response->getHeaders());
+        $this->assertEquals('image type', $response->getHeaders()['Content-Type']);
+        $this->assertArrayHasKey('X-NC-IsCustomAvatar', $response->getHeaders());
+        $this->assertEquals('0', $response->getHeaders()['X-NC-IsCustomAvatar']);
+
+        $this->assertEquals('my etag', $response->getETag());
+    }
+
+    /**
+     * Fetch the avatar of a non-existing user
+     */
+    public function testGetAvatarNoUser(): void {
+        $this->avatarManager
+            ->method('getAvatar')
+            ->with('userDoesNotExist')
+            ->willThrowException(new \Exception('user does not exist'));
+
+        $response = $this->avatarController->getAvatar('userDoesNotExist', 32);
+
+        //Comment out until JS is fixed
+        $this->assertEquals(Http::STATUS_NOT_FOUND, $response->getStatus());
+    }
+
+    public function testGetAvatarSize64(): void {
+        $this->avatarMock->expects($this->once())
+            ->method('getFile')
+            ->with($this->equalTo(64))
+            ->willReturn($this->avatarFile);
+
+        $this->avatarManager->method('getAvatar')->willReturn($this->avatarMock);
+
+        $this->logger->expects($this->never())
+            ->method('debug');
+
+        $this->avatarController->getAvatar('userId', 64);
+    }
+
+    public function testGetAvatarSize512(): void {
+        $this->avatarMock->expects($this->once())
+            ->method('getFile')
+            ->with($this->equalTo(512))
+            ->willReturn($this->avatarFile);
+
+        $this->avatarManager->method('getAvatar')->willReturn($this->avatarMock);
+
+        $this->logger->expects($this->never())
+            ->method('debug');
+
+        $this->avatarController->getAvatar('userId', 512);
+    }
+
+    /**
+     * Small sizes return 64 and generate a log
+     */
+    public function testGetAvatarSizeTooSmall(): void {
+        $this->avatarMock->expects($this->once())
+            ->method('getFile')
+            ->with($this->equalTo(64))
+            ->willReturn($this->avatarFile);
+
+        $this->avatarManager->method('getAvatar')->willReturn($this->avatarMock);
+
+        $this->logger->expects($this->once())
+            ->method('debug')
+            ->with('Avatar requested in deprecated size 32');
+
+        $this->avatarController->getAvatar('userId', 32);
+    }
+
+    /**
+     * Avatars between 64 and 512 are upgraded to 512
+     */
+    public function testGetAvatarSizeBetween(): void {
+        $this->avatarMock->expects($this->once())
+            ->method('getFile')
+            ->with($this->equalTo(512))
+            ->willReturn($this->avatarFile);
+
+        $this->avatarManager->method('getAvatar')->willReturn($this->avatarMock);
+
+        $this->logger->expects($this->once())
+            ->method('debug')
+            ->with('Avatar requested in deprecated size 65');
+
+        $this->avatarController->getAvatar('userId', 65);
+    }
+
+    /**
+     * We do not support avatars larger than 512
+     */
+    public function testGetAvatarSizeTooBig(): void {
+        $this->avatarMock->expects($this->once())
+            ->method('getFile')
+            ->with($this->equalTo(512))
+            ->willReturn($this->avatarFile);
+
+        $this->avatarManager->method('getAvatar')->willReturn($this->avatarMock);
+
+        $this->logger->expects($this->once())
+            ->method('debug')
+            ->with('Avatar requested in deprecated size 513');
+
+        $this->avatarController->getAvatar('userId', 513);
+    }
+
+    /**
+     * Remove an avatar
+     */
+    public function testDeleteAvatar(): void {
+        $this->avatarManager->method('getAvatar')->willReturn($this->avatarMock);
+
+        $response = $this->avatarController->deleteAvatar();
+        $this->assertEquals(Http::STATUS_OK, $response->getStatus());
+    }
+
+    /**
+     * Test what happens if the removing of the avatar fails
+     */
+    public function testDeleteAvatarException(): void {
+        $this->avatarMock->method('remove')->willThrowException(new \Exception('foo'));
+        $this->avatarManager->method('getAvatar')->willReturn($this->avatarMock);
+
+        $this->logger->expects($this->once())
+            ->method('error')
+            ->with('foo', ['exception' => new \Exception('foo'), 'app' => 'core']);
+        $expectedResponse = new Http\JSONResponse(['data' => ['message' => 'An error occurred. Please contact your admin.']], Http::STATUS_BAD_REQUEST);
+        $this->assertEquals($expectedResponse, $this->avatarController->deleteAvatar());
+    }
+
+    /**
+     * When trying to post a new avatar a path or image should be posted.
+     */
+    public function testPostAvatarNoPathOrImage(): void {
+        $response = $this->avatarController->postAvatar(null);
+
+        $this->assertEquals(Http::STATUS_BAD_REQUEST, $response->getStatus());
+    }
+
+    /**
+     * Test a correct post of an avatar using POST
+     */
+    public function testPostAvatarFile(): void {
+        //Create temp file
+        $fileName = tempnam('', 'avatarTest');
+        $copyRes = copy(\OC::$SERVERROOT . '/tests/data/testimage.jpg', $fileName);
+        $this->assertTrue($copyRes);
+
+        //Create request return
+        $reqRet = ['error' => [0], 'tmp_name' => [$fileName], 'size' => [filesize(\OC::$SERVERROOT . '/tests/data/testimage.jpg')]];
+        $this->request->method('getUploadedFile')->willReturn($reqRet);
+
+        $response = $this->avatarController->postAvatar(null);
+
+        //On correct upload always respond with the notsquare message
+        $this->assertEquals('notsquare', $response->getData()['data']);
+
+        //File should be deleted
+        $this->assertFalse(file_exists($fileName));
+    }
+
+    /**
+     * Test invalid post os an avatar using POST
+     */
+    public function testPostAvatarInvalidFile(): void {
+        //Create request return
+        $reqRet = ['error' => [1], 'tmp_name' => ['foo']];
+        $this->request->method('getUploadedFile')->willReturn($reqRet);
+
+        $response = $this->avatarController->postAvatar(null);
+
+        $this->assertEquals(Http::STATUS_BAD_REQUEST, $response->getStatus());
+    }
+
+    /**
+     * Check what happens when we upload a GIF
+     */
+    public function testPostAvatarFileGif(): void {
+        //Create temp file
+        $fileName = tempnam('', 'avatarTest');
+        $copyRes = copy(\OC::$SERVERROOT . '/tests/data/testimage.gif', $fileName);
+        $this->assertTrue($copyRes);
+
+        //Create request return
+        $reqRet = ['error' => [0], 'tmp_name' => [$fileName], 'size' => [filesize(\OC::$SERVERROOT . '/tests/data/testimage.gif')]];
+        $this->request->method('getUploadedFile')->willReturn($reqRet);
+
+        $response = $this->avatarController->postAvatar(null);
+
+        $this->assertEquals('Unknown filetype', $response->getData()['data']['message']);
+
+        //File should be deleted
+        $this->assertFalse(file_exists($fileName));
+    }
+
+    /**
+     * Test posting avatar from existing file
+     */
+    public function testPostAvatarFromFile(): void {
+        //Mock node API call
+        $file = $this->getMockBuilder('OCP\Files\File')
+            ->disableOriginalConstructor()->getMock();
+        $file->expects($this->once())
+            ->method('getContent')
+            ->willReturn(file_get_contents(\OC::$SERVERROOT . '/tests/data/testimage.jpg'));
+        $file->expects($this->once())
+            ->method('getMimeType')
+            ->willReturn('image/jpeg');
+        $userFolder = $this->getMockBuilder('OCP\Files\Folder')->getMock();
+        $this->rootFolder->method('getUserFolder')->with('userid')->willReturn($userFolder);
+        $userFolder->method('get')->willReturn($file);
+
+        //Create request return
+        $response = $this->avatarController->postAvatar('avatar.jpg');
+
+        //On correct upload always respond with the notsquare message
+        $this->assertEquals('notsquare', $response->getData()['data']);
+    }
+
+    /**
+     * Test posting avatar from existing folder
+     */
+    public function testPostAvatarFromNoFile(): void {
+        $file = $this->getMockBuilder('OCP\Files\Node')->getMock();
+        $userFolder = $this->getMockBuilder('OCP\Files\Folder')->getMock();
+        $this->rootFolder->method('getUserFolder')->with('userid')->willReturn($userFolder);
+        $userFolder
+            ->method('get')
+            ->with('folder')
+            ->willReturn($file);
+
+        //Create request return
+        $response = $this->avatarController->postAvatar('folder');
+
+        //On correct upload always respond with the notsquare message
+        $this->assertEquals(['data' => ['message' => 'Please select a file.']], $response->getData());
+    }
+
+    public function testPostAvatarInvalidType(): void {
+        $file = $this->getMockBuilder('OCP\Files\File')
+            ->disableOriginalConstructor()->getMock();
+        $file->expects($this->never())
+            ->method('getContent');
+        $file->expects($this->exactly(2))
+            ->method('getMimeType')
+            ->willReturn('text/plain');
+        $userFolder = $this->getMockBuilder('OCP\Files\Folder')->getMock();
+        $this->rootFolder->method('getUserFolder')->with('userid')->willReturn($userFolder);
+        $userFolder->method('get')->willReturn($file);
+
+        $expectedResponse = new Http\JSONResponse(['data' => ['message' => 'The selected file is not an image.']], Http::STATUS_BAD_REQUEST);
+        $this->assertEquals($expectedResponse, $this->avatarController->postAvatar('avatar.jpg'));
+    }
+
+    public function testPostAvatarNotPermittedException(): void {
+        $file = $this->getMockBuilder('OCP\Files\File')
+            ->disableOriginalConstructor()->getMock();
+        $file->expects($this->once())
+            ->method('getContent')
+            ->willThrowException(new NotPermittedException());
+        $file->expects($this->once())
+            ->method('getMimeType')
+            ->willReturn('image/jpeg');
+        $userFolder = $this->getMockBuilder('OCP\Files\Folder')->getMock();
+        $this->rootFolder->method('getUserFolder')->with('userid')->willReturn($userFolder);
+        $userFolder->method('get')->willReturn($file);
+
+        $expectedResponse = new Http\JSONResponse(['data' => ['message' => 'The selected file cannot be read.']], Http::STATUS_BAD_REQUEST);
+        $this->assertEquals($expectedResponse, $this->avatarController->postAvatar('avatar.jpg'));
+    }
+
+    /**
+     * Check for proper reply on proper crop argument
+     */
+    public function testFileTooBig(): void {
+        $fileName = \OC::$SERVERROOT . '/tests/data/testimage.jpg';
+        //Create request return
+        $reqRet = ['error' => [0], 'tmp_name' => [$fileName], 'size' => [21 * 1024 * 1024]];
+        $this->request->method('getUploadedFile')->willReturn($reqRet);
+
+        $response = $this->avatarController->postAvatar(null);
+
+        $this->assertEquals('File is too big', $response->getData()['data']['message']);
+    }
 }

Spacing +6 added lines, -6 removed lines

@@ -307,11 +307,11 @@ 
 	public function testPostAvatarFile(): void {
 		//Create temp file
 		$fileName = tempnam('', 'avatarTest');
-		$copyRes = copy(\OC::$SERVERROOT . '/tests/data/testimage.jpg', $fileName);
+		$copyRes = copy(\OC::$SERVERROOT.'/tests/data/testimage.jpg', $fileName);
 		$this->assertTrue($copyRes);
 
 		//Create request return
-		$reqRet = ['error' => [0], 'tmp_name' => [$fileName], 'size' => [filesize(\OC::$SERVERROOT . '/tests/data/testimage.jpg')]];
+		$reqRet = ['error' => [0], 'tmp_name' => [$fileName], 'size' => [filesize(\OC::$SERVERROOT.'/tests/data/testimage.jpg')]];
 		$this->request->method('getUploadedFile')->willReturn($reqRet);
 
 		$response = $this->avatarController->postAvatar(null);
@@ -342,11 +342,11 @@ 
 	public function testPostAvatarFileGif(): void {
 		//Create temp file
 		$fileName = tempnam('', 'avatarTest');
-		$copyRes = copy(\OC::$SERVERROOT . '/tests/data/testimage.gif', $fileName);
+		$copyRes = copy(\OC::$SERVERROOT.'/tests/data/testimage.gif', $fileName);
 		$this->assertTrue($copyRes);
 
 		//Create request return
-		$reqRet = ['error' => [0], 'tmp_name' => [$fileName], 'size' => [filesize(\OC::$SERVERROOT . '/tests/data/testimage.gif')]];
+		$reqRet = ['error' => [0], 'tmp_name' => [$fileName], 'size' => [filesize(\OC::$SERVERROOT.'/tests/data/testimage.gif')]];
 		$this->request->method('getUploadedFile')->willReturn($reqRet);
 
 		$response = $this->avatarController->postAvatar(null);
@@ -366,7 +366,7 @@ 
 			->disableOriginalConstructor()->getMock();
 		$file->expects($this->once())
 			->method('getContent')
-			->willReturn(file_get_contents(\OC::$SERVERROOT . '/tests/data/testimage.jpg'));
+			->willReturn(file_get_contents(\OC::$SERVERROOT.'/tests/data/testimage.jpg'));
 		$file->expects($this->once())
 			->method('getMimeType')
 			->willReturn('image/jpeg');
@@ -437,7 +437,7 @@ 
 	 * Check for proper reply on proper crop argument
 	 */
 	public function testFileTooBig(): void {
-		$fileName = \OC::$SERVERROOT . '/tests/data/testimage.jpg';
+		$fileName = \OC::$SERVERROOT.'/tests/data/testimage.jpg';
 		//Create request return
 		$reqRet = ['error' => [0], 'tmp_name' => [$fileName], 'size' => [21 * 1024 * 1024]];
 		$this->request->method('getUploadedFile')->willReturn($reqRet);