nextcloud / server

lib/private/Http/Client/Client.php

Indentation +657 added lines, -657 removed lines

@@ -28,661 +28,661 @@
  * @package OC\Http
  */
 class Client implements IClient {
-	/** @var GuzzleClient */
-	private $client;
-	/** @var IConfig */
-	private $config;
-	/** @var ICertificateManager */
-	private $certificateManager;
-	private IRemoteHostValidator $remoteHostValidator;
-
-	public function __construct(
-		IConfig $config,
-		ICertificateManager $certificateManager,
-		GuzzleClient $client,
-		IRemoteHostValidator $remoteHostValidator,
-		protected LoggerInterface $logger,
-		protected ServerVersion $serverVersion,
-	) {
-		$this->config = $config;
-		$this->client = $client;
-		$this->certificateManager = $certificateManager;
-		$this->remoteHostValidator = $remoteHostValidator;
-	}
-
-	private function buildRequestOptions(array $options): array {
-		$proxy = $this->getProxyUri();
-
-		$defaults = [
-			RequestOptions::VERIFY => $this->getCertBundle(),
-			RequestOptions::TIMEOUT => IClient::DEFAULT_REQUEST_TIMEOUT,
-		];
-
-		$options['nextcloud']['allow_local_address'] = $this->isLocalAddressAllowed($options);
-		if ($options['nextcloud']['allow_local_address'] === false) {
-			$onRedirectFunction = function (
-				\Psr\Http\Message\RequestInterface $request,
-				\Psr\Http\Message\ResponseInterface $response,
-				\Psr\Http\Message\UriInterface $uri,
-			) use ($options) {
-				$this->preventLocalAddress($uri->__toString(), $options);
-			};
-
-			$defaults[RequestOptions::ALLOW_REDIRECTS] = [
-				'on_redirect' => $onRedirectFunction
-			];
-		}
-
-		// Only add RequestOptions::PROXY if Nextcloud is explicitly
-		// configured to use a proxy. This is needed in order not to override
-		// Guzzle default values.
-		if ($proxy !== null) {
-			$defaults[RequestOptions::PROXY] = $proxy;
-		}
-
-		$options = array_merge($defaults, $options);
-
-		if (!isset($options[RequestOptions::HEADERS]['User-Agent'])) {
-			$userAgent = 'Nextcloud-Server-Crawler/' . $this->serverVersion->getVersionString();
-			$options[RequestOptions::HEADERS]['User-Agent'] = $userAgent;
-		}
-
-		if (!isset($options[RequestOptions::HEADERS]['Accept-Encoding'])) {
-			$options[RequestOptions::HEADERS]['Accept-Encoding'] = 'gzip';
-		}
-
-		// Fallback for save_to
-		if (isset($options['save_to'])) {
-			$options['sink'] = $options['save_to'];
-			unset($options['save_to']);
-		}
-
-		return $options;
-	}
-
-	private function getCertBundle(): string {
-		// If the instance is not yet setup we need to use the static path as
-		// $this->certificateManager->getAbsoluteBundlePath() tries to instantiate
-		// a view
-		if (!$this->config->getSystemValueBool('installed', false)) {
-			return \OC::$SERVERROOT . '/resources/config/ca-bundle.crt';
-		}
-
-		return $this->certificateManager->getAbsoluteBundlePath();
-	}
-
-	/**
-	 * Returns a null or an associative array specifying the proxy URI for
-	 * 'http' and 'https' schemes, in addition to a 'no' key value pair
-	 * providing a list of host names that should not be proxied to.
-	 *
-	 * @return array|null
-	 *
-	 * The return array looks like:
-	 * [
-	 *   'http' => 'username:password@proxy.example.com',
-	 *   'https' => 'username:password@proxy.example.com',
-	 *   'no' => ['foo.com', 'bar.com']
-	 * ]
-	 *
-	 */
-	private function getProxyUri(): ?array {
-		$proxyHost = $this->config->getSystemValueString('proxy', '');
-
-		if ($proxyHost === '') {
-			return null;
-		}
-
-		$proxyUserPwd = $this->config->getSystemValueString('proxyuserpwd', '');
-		if ($proxyUserPwd !== '') {
-			$proxyHost = $proxyUserPwd . '@' . $proxyHost;
-		}
-
-		$proxy = [
-			'http' => $proxyHost,
-			'https' => $proxyHost,
-		];
-
-		$proxyExclude = $this->config->getSystemValue('proxyexclude', []);
-		if ($proxyExclude !== [] && $proxyExclude !== null) {
-			$proxy['no'] = $proxyExclude;
-		}
-
-		return $proxy;
-	}
-
-	private function isLocalAddressAllowed(array $options) : bool {
-		if (($options['nextcloud']['allow_local_address'] ?? false)
-			|| $this->config->getSystemValueBool('allow_local_remote_servers', false)) {
-			return true;
-		}
-
-		return false;
-	}
-
-	protected function preventLocalAddress(string $uri, array $options): void {
-		$host = parse_url($uri, PHP_URL_HOST);
-		if ($host === false || $host === null) {
-			throw new LocalServerException('Could not detect any host');
-		}
-
-		if ($this->isLocalAddressAllowed($options)) {
-			return;
-		}
-
-		if (!$this->remoteHostValidator->isValid($host)) {
-			throw new LocalServerException('Host "' . $host . '" violates local access rules');
-		}
-	}
-
-	/**
-	 * Sends a GET request
-	 *
-	 * @param string $uri
-	 * @param array $options Array such as
-	 *                       'query' => [
-	 *                       'field' => 'abc',
-	 *                       'other_field' => '123',
-	 *                       'file_name' => fopen('/path/to/file', 'r'),
-	 *                       ],
-	 *                       'headers' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'cookies' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'allow_redirects' => [
-	 *                       'max'       => 10,  // allow at most 10 redirects.
-	 *                       'strict'    => true,     // use "strict" RFC compliant redirects.
-	 *                       'referer'   => true,     // add a Referer header
-	 *                       'protocols' => ['https'] // only allow https URLs
-	 *                       ],
-	 *                       'sink' => '/path/to/file', // save to a file or a stream
-	 *                       'verify' => true, // bool or string to CA file
-	 *                       'debug' => true,
-	 *                       'timeout' => 5,
-	 * @return IResponse
-	 * @throws \Exception If the request could not get completed
-	 */
-	public function get(string $uri, array $options = []): IResponse {
-		$this->preventLocalAddress($uri, $options);
-		$response = $this->client->request('get', $uri, $this->buildRequestOptions($options));
-		$isStream = isset($options['stream']) && $options['stream'];
-		return new Response($response, $isStream);
-	}
-
-	/**
-	 * Sends a HEAD request
-	 *
-	 * @param string $uri
-	 * @param array $options Array such as
-	 *                       'headers' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'cookies' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'allow_redirects' => [
-	 *                       'max'       => 10,  // allow at most 10 redirects.
-	 *                       'strict'    => true,     // use "strict" RFC compliant redirects.
-	 *                       'referer'   => true,     // add a Referer header
-	 *                       'protocols' => ['https'] // only allow https URLs
-	 *                       ],
-	 *                       'sink' => '/path/to/file', // save to a file or a stream
-	 *                       'verify' => true, // bool or string to CA file
-	 *                       'debug' => true,
-	 *                       'timeout' => 5,
-	 * @return IResponse
-	 * @throws \Exception If the request could not get completed
-	 */
-	public function head(string $uri, array $options = []): IResponse {
-		$this->preventLocalAddress($uri, $options);
-		$response = $this->client->request('head', $uri, $this->buildRequestOptions($options));
-		return new Response($response);
-	}
-
-	/**
-	 * Sends a POST request
-	 *
-	 * @param string $uri
-	 * @param array $options Array such as
-	 *                       'body' => [
-	 *                       'field' => 'abc',
-	 *                       'other_field' => '123',
-	 *                       'file_name' => fopen('/path/to/file', 'r'),
-	 *                       ],
-	 *                       'headers' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'cookies' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'allow_redirects' => [
-	 *                       'max'       => 10,  // allow at most 10 redirects.
-	 *                       'strict'    => true,     // use "strict" RFC compliant redirects.
-	 *                       'referer'   => true,     // add a Referer header
-	 *                       'protocols' => ['https'] // only allow https URLs
-	 *                       ],
-	 *                       'sink' => '/path/to/file', // save to a file or a stream
-	 *                       'verify' => true, // bool or string to CA file
-	 *                       'debug' => true,
-	 *                       'timeout' => 5,
-	 * @return IResponse
-	 * @throws \Exception If the request could not get completed
-	 */
-	public function post(string $uri, array $options = []): IResponse {
-		$this->preventLocalAddress($uri, $options);
-
-		if (isset($options['body']) && is_array($options['body'])) {
-			$options['form_params'] = $options['body'];
-			unset($options['body']);
-		}
-		$response = $this->client->request('post', $uri, $this->buildRequestOptions($options));
-		$isStream = isset($options['stream']) && $options['stream'];
-		return new Response($response, $isStream);
-	}
-
-	/**
-	 * Sends a PUT request
-	 *
-	 * @param string $uri
-	 * @param array $options Array such as
-	 *                       'body' => [
-	 *                       'field' => 'abc',
-	 *                       'other_field' => '123',
-	 *                       'file_name' => fopen('/path/to/file', 'r'),
-	 *                       ],
-	 *                       'headers' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'cookies' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'allow_redirects' => [
-	 *                       'max'       => 10,  // allow at most 10 redirects.
-	 *                       'strict'    => true,     // use "strict" RFC compliant redirects.
-	 *                       'referer'   => true,     // add a Referer header
-	 *                       'protocols' => ['https'] // only allow https URLs
-	 *                       ],
-	 *                       'sink' => '/path/to/file', // save to a file or a stream
-	 *                       'verify' => true, // bool or string to CA file
-	 *                       'debug' => true,
-	 *                       'timeout' => 5,
-	 * @return IResponse
-	 * @throws \Exception If the request could not get completed
-	 */
-	public function put(string $uri, array $options = []): IResponse {
-		$this->preventLocalAddress($uri, $options);
-		$response = $this->client->request('put', $uri, $this->buildRequestOptions($options));
-		return new Response($response);
-	}
-
-	/**
-	 * Sends a PATCH request
-	 *
-	 * @param string $uri
-	 * @param array $options Array such as
-	 *                       'body' => [
-	 *                       'field' => 'abc',
-	 *                       'other_field' => '123',
-	 *                       'file_name' => fopen('/path/to/file', 'r'),
-	 *                       ],
-	 *                       'headers' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'cookies' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'allow_redirects' => [
-	 *                       'max'       => 10,  // allow at most 10 redirects.
-	 *                       'strict'    => true,     // use "strict" RFC compliant redirects.
-	 *                       'referer'   => true,     // add a Referer header
-	 *                       'protocols' => ['https'] // only allow https URLs
-	 *                       ],
-	 *                       'sink' => '/path/to/file', // save to a file or a stream
-	 *                       'verify' => true, // bool or string to CA file
-	 *                       'debug' => true,
-	 *                       'timeout' => 5,
-	 * @return IResponse
-	 * @throws \Exception If the request could not get completed
-	 */
-	public function patch(string $uri, array $options = []): IResponse {
-		$this->preventLocalAddress($uri, $options);
-		$response = $this->client->request('patch', $uri, $this->buildRequestOptions($options));
-		return new Response($response);
-	}
-
-	/**
-	 * Sends a DELETE request
-	 *
-	 * @param string $uri
-	 * @param array $options Array such as
-	 *                       'body' => [
-	 *                       'field' => 'abc',
-	 *                       'other_field' => '123',
-	 *                       'file_name' => fopen('/path/to/file', 'r'),
-	 *                       ],
-	 *                       'headers' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'cookies' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'allow_redirects' => [
-	 *                       'max'       => 10,  // allow at most 10 redirects.
-	 *                       'strict'    => true,     // use "strict" RFC compliant redirects.
-	 *                       'referer'   => true,     // add a Referer header
-	 *                       'protocols' => ['https'] // only allow https URLs
-	 *                       ],
-	 *                       'sink' => '/path/to/file', // save to a file or a stream
-	 *                       'verify' => true, // bool or string to CA file
-	 *                       'debug' => true,
-	 *                       'timeout' => 5,
-	 * @return IResponse
-	 * @throws \Exception If the request could not get completed
-	 */
-	public function delete(string $uri, array $options = []): IResponse {
-		$this->preventLocalAddress($uri, $options);
-		$response = $this->client->request('delete', $uri, $this->buildRequestOptions($options));
-		return new Response($response);
-	}
-
-	/**
-	 * Sends an OPTIONS request
-	 *
-	 * @param string $uri
-	 * @param array $options Array such as
-	 *                       'body' => [
-	 *                       'field' => 'abc',
-	 *                       'other_field' => '123',
-	 *                       'file_name' => fopen('/path/to/file', 'r'),
-	 *                       ],
-	 *                       'headers' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'cookies' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'allow_redirects' => [
-	 *                       'max'       => 10,  // allow at most 10 redirects.
-	 *                       'strict'    => true,     // use "strict" RFC compliant redirects.
-	 *                       'referer'   => true,     // add a Referer header
-	 *                       'protocols' => ['https'] // only allow https URLs
-	 *                       ],
-	 *                       'sink' => '/path/to/file', // save to a file or a stream
-	 *                       'verify' => true, // bool or string to CA file
-	 *                       'debug' => true,
-	 *                       'timeout' => 5,
-	 * @return IResponse
-	 * @throws \Exception If the request could not get completed
-	 */
-	public function options(string $uri, array $options = []): IResponse {
-		$this->preventLocalAddress($uri, $options);
-		$response = $this->client->request('options', $uri, $this->buildRequestOptions($options));
-		return new Response($response);
-	}
-
-	/**
-	 * Get the response of a Throwable thrown by the request methods when possible
-	 *
-	 * @param \Throwable $e
-	 * @return IResponse
-	 * @throws \Throwable When $e did not have a response
-	 * @since 29.0.0
-	 */
-	public function getResponseFromThrowable(\Throwable $e): IResponse {
-		if (method_exists($e, 'hasResponse') && method_exists($e, 'getResponse') && $e->hasResponse()) {
-			return new Response($e->getResponse());
-		}
-
-		throw $e;
-	}
-
-	/**
-	 * Sends a HTTP request
-	 *
-	 * @param string $method The HTTP method to use
-	 * @param string $uri
-	 * @param array $options Array such as
-	 *                       'query' => [
-	 *                       'field' => 'abc',
-	 *                       'other_field' => '123',
-	 *                       'file_name' => fopen('/path/to/file', 'r'),
-	 *                       ],
-	 *                       'headers' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'cookies' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'allow_redirects' => [
-	 *                       'max'       => 10,  // allow at most 10 redirects.
-	 *                       'strict'    => true,     // use "strict" RFC compliant redirects.
-	 *                       'referer'   => true,     // add a Referer header
-	 *                       'protocols' => ['https'] // only allow https URLs
-	 *                       ],
-	 *                       'sink' => '/path/to/file', // save to a file or a stream
-	 *                       'verify' => true, // bool or string to CA file
-	 *                       'debug' => true,
-	 *                       'timeout' => 5,
-	 * @return IResponse
-	 * @throws \Exception If the request could not get completed
-	 */
-	public function request(string $method, string $uri, array $options = []): IResponse {
-		$this->preventLocalAddress($uri, $options);
-		$response = $this->client->request($method, $uri, $this->buildRequestOptions($options));
-		$isStream = isset($options['stream']) && $options['stream'];
-		return new Response($response, $isStream);
-	}
-
-	protected function wrapGuzzlePromise(PromiseInterface $promise): IPromise {
-		return new GuzzlePromiseAdapter(
-			$promise,
-			$this->logger
-		);
-	}
-
-	/**
-	 * Sends an asynchronous GET request
-	 *
-	 * @param string $uri
-	 * @param array $options Array such as
-	 *                       'query' => [
-	 *                       'field' => 'abc',
-	 *                       'other_field' => '123',
-	 *                       'file_name' => fopen('/path/to/file', 'r'),
-	 *                       ],
-	 *                       'headers' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'cookies' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'allow_redirects' => [
-	 *                       'max'       => 10,  // allow at most 10 redirects.
-	 *                       'strict'    => true,     // use "strict" RFC compliant redirects.
-	 *                       'referer'   => true,     // add a Referer header
-	 *                       'protocols' => ['https'] // only allow https URLs
-	 *                       ],
-	 *                       'sink' => '/path/to/file', // save to a file or a stream
-	 *                       'verify' => true, // bool or string to CA file
-	 *                       'debug' => true,
-	 *                       'timeout' => 5,
-	 * @return IPromise
-	 */
-	public function getAsync(string $uri, array $options = []): IPromise {
-		$this->preventLocalAddress($uri, $options);
-		$response = $this->client->requestAsync('get', $uri, $this->buildRequestOptions($options));
-		return $this->wrapGuzzlePromise($response);
-	}
-
-	/**
-	 * Sends an asynchronous HEAD request
-	 *
-	 * @param string $uri
-	 * @param array $options Array such as
-	 *                       'headers' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'cookies' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'allow_redirects' => [
-	 *                       'max'       => 10,  // allow at most 10 redirects.
-	 *                       'strict'    => true,     // use "strict" RFC compliant redirects.
-	 *                       'referer'   => true,     // add a Referer header
-	 *                       'protocols' => ['https'] // only allow https URLs
-	 *                       ],
-	 *                       'sink' => '/path/to/file', // save to a file or a stream
-	 *                       'verify' => true, // bool or string to CA file
-	 *                       'debug' => true,
-	 *                       'timeout' => 5,
-	 * @return IPromise
-	 */
-	public function headAsync(string $uri, array $options = []): IPromise {
-		$this->preventLocalAddress($uri, $options);
-		$response = $this->client->requestAsync('head', $uri, $this->buildRequestOptions($options));
-		return $this->wrapGuzzlePromise($response);
-	}
-
-	/**
-	 * Sends an asynchronous POST request
-	 *
-	 * @param string $uri
-	 * @param array $options Array such as
-	 *                       'body' => [
-	 *                       'field' => 'abc',
-	 *                       'other_field' => '123',
-	 *                       'file_name' => fopen('/path/to/file', 'r'),
-	 *                       ],
-	 *                       'headers' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'cookies' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'allow_redirects' => [
-	 *                       'max'       => 10,  // allow at most 10 redirects.
-	 *                       'strict'    => true,     // use "strict" RFC compliant redirects.
-	 *                       'referer'   => true,     // add a Referer header
-	 *                       'protocols' => ['https'] // only allow https URLs
-	 *                       ],
-	 *                       'sink' => '/path/to/file', // save to a file or a stream
-	 *                       'verify' => true, // bool or string to CA file
-	 *                       'debug' => true,
-	 *                       'timeout' => 5,
-	 * @return IPromise
-	 */
-	public function postAsync(string $uri, array $options = []): IPromise {
-		$this->preventLocalAddress($uri, $options);
-
-		if (isset($options['body']) && is_array($options['body'])) {
-			$options['form_params'] = $options['body'];
-			unset($options['body']);
-		}
-
-		return $this->wrapGuzzlePromise($this->client->requestAsync('post', $uri, $this->buildRequestOptions($options)));
-	}
-
-	/**
-	 * Sends an asynchronous PUT request
-	 *
-	 * @param string $uri
-	 * @param array $options Array such as
-	 *                       'body' => [
-	 *                       'field' => 'abc',
-	 *                       'other_field' => '123',
-	 *                       'file_name' => fopen('/path/to/file', 'r'),
-	 *                       ],
-	 *                       'headers' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'cookies' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'allow_redirects' => [
-	 *                       'max'       => 10,  // allow at most 10 redirects.
-	 *                       'strict'    => true,     // use "strict" RFC compliant redirects.
-	 *                       'referer'   => true,     // add a Referer header
-	 *                       'protocols' => ['https'] // only allow https URLs
-	 *                       ],
-	 *                       'sink' => '/path/to/file', // save to a file or a stream
-	 *                       'verify' => true, // bool or string to CA file
-	 *                       'debug' => true,
-	 *                       'timeout' => 5,
-	 * @return IPromise
-	 */
-	public function putAsync(string $uri, array $options = []): IPromise {
-		$this->preventLocalAddress($uri, $options);
-		$response = $this->client->requestAsync('put', $uri, $this->buildRequestOptions($options));
-		return $this->wrapGuzzlePromise($response);
-	}
-
-	/**
-	 * Sends an asynchronous DELETE request
-	 *
-	 * @param string $uri
-	 * @param array $options Array such as
-	 *                       'body' => [
-	 *                       'field' => 'abc',
-	 *                       'other_field' => '123',
-	 *                       'file_name' => fopen('/path/to/file', 'r'),
-	 *                       ],
-	 *                       'headers' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'cookies' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'allow_redirects' => [
-	 *                       'max'       => 10,  // allow at most 10 redirects.
-	 *                       'strict'    => true,     // use "strict" RFC compliant redirects.
-	 *                       'referer'   => true,     // add a Referer header
-	 *                       'protocols' => ['https'] // only allow https URLs
-	 *                       ],
-	 *                       'sink' => '/path/to/file', // save to a file or a stream
-	 *                       'verify' => true, // bool or string to CA file
-	 *                       'debug' => true,
-	 *                       'timeout' => 5,
-	 * @return IPromise
-	 */
-	public function deleteAsync(string $uri, array $options = []): IPromise {
-		$this->preventLocalAddress($uri, $options);
-		$response = $this->client->requestAsync('delete', $uri, $this->buildRequestOptions($options));
-		return $this->wrapGuzzlePromise($response);
-	}
-
-	/**
-	 * Sends an asynchronous OPTIONS request
-	 *
-	 * @param string $uri
-	 * @param array $options Array such as
-	 *                       'body' => [
-	 *                       'field' => 'abc',
-	 *                       'other_field' => '123',
-	 *                       'file_name' => fopen('/path/to/file', 'r'),
-	 *                       ],
-	 *                       'headers' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'cookies' => [
-	 *                       'foo' => 'bar',
-	 *                       ],
-	 *                       'allow_redirects' => [
-	 *                       'max'       => 10,  // allow at most 10 redirects.
-	 *                       'strict'    => true,     // use "strict" RFC compliant redirects.
-	 *                       'referer'   => true,     // add a Referer header
-	 *                       'protocols' => ['https'] // only allow https URLs
-	 *                       ],
-	 *                       'sink' => '/path/to/file', // save to a file or a stream
-	 *                       'verify' => true, // bool or string to CA file
-	 *                       'debug' => true,
-	 *                       'timeout' => 5,
-	 * @return IPromise
-	 */
-	public function optionsAsync(string $uri, array $options = []): IPromise {
-		$this->preventLocalAddress($uri, $options);
-		$response = $this->client->requestAsync('options', $uri, $this->buildRequestOptions($options));
-		return $this->wrapGuzzlePromise($response);
-	}
+    /** @var GuzzleClient */
+    private $client;
+    /** @var IConfig */
+    private $config;
+    /** @var ICertificateManager */
+    private $certificateManager;
+    private IRemoteHostValidator $remoteHostValidator;
+
+    public function __construct(
+        IConfig $config,
+        ICertificateManager $certificateManager,
+        GuzzleClient $client,
+        IRemoteHostValidator $remoteHostValidator,
+        protected LoggerInterface $logger,
+        protected ServerVersion $serverVersion,
+    ) {
+        $this->config = $config;
+        $this->client = $client;
+        $this->certificateManager = $certificateManager;
+        $this->remoteHostValidator = $remoteHostValidator;
+    }
+
+    private function buildRequestOptions(array $options): array {
+        $proxy = $this->getProxyUri();
+
+        $defaults = [
+            RequestOptions::VERIFY => $this->getCertBundle(),
+            RequestOptions::TIMEOUT => IClient::DEFAULT_REQUEST_TIMEOUT,
+        ];
+
+        $options['nextcloud']['allow_local_address'] = $this->isLocalAddressAllowed($options);
+        if ($options['nextcloud']['allow_local_address'] === false) {
+            $onRedirectFunction = function (
+                \Psr\Http\Message\RequestInterface $request,
+                \Psr\Http\Message\ResponseInterface $response,
+                \Psr\Http\Message\UriInterface $uri,
+            ) use ($options) {
+                $this->preventLocalAddress($uri->__toString(), $options);
+            };
+
+            $defaults[RequestOptions::ALLOW_REDIRECTS] = [
+                'on_redirect' => $onRedirectFunction
+            ];
+        }
+
+        // Only add RequestOptions::PROXY if Nextcloud is explicitly
+        // configured to use a proxy. This is needed in order not to override
+        // Guzzle default values.
+        if ($proxy !== null) {
+            $defaults[RequestOptions::PROXY] = $proxy;
+        }
+
+        $options = array_merge($defaults, $options);
+
+        if (!isset($options[RequestOptions::HEADERS]['User-Agent'])) {
+            $userAgent = 'Nextcloud-Server-Crawler/' . $this->serverVersion->getVersionString();
+            $options[RequestOptions::HEADERS]['User-Agent'] = $userAgent;
+        }
+
+        if (!isset($options[RequestOptions::HEADERS]['Accept-Encoding'])) {
+            $options[RequestOptions::HEADERS]['Accept-Encoding'] = 'gzip';
+        }
+
+        // Fallback for save_to
+        if (isset($options['save_to'])) {
+            $options['sink'] = $options['save_to'];
+            unset($options['save_to']);
+        }
+
+        return $options;
+    }
+
+    private function getCertBundle(): string {
+        // If the instance is not yet setup we need to use the static path as
+        // $this->certificateManager->getAbsoluteBundlePath() tries to instantiate
+        // a view
+        if (!$this->config->getSystemValueBool('installed', false)) {
+            return \OC::$SERVERROOT . '/resources/config/ca-bundle.crt';
+        }
+
+        return $this->certificateManager->getAbsoluteBundlePath();
+    }
+
+    /**
+     * Returns a null or an associative array specifying the proxy URI for
+     * 'http' and 'https' schemes, in addition to a 'no' key value pair
+     * providing a list of host names that should not be proxied to.
+     *
+     * @return array|null
+     *
+     * The return array looks like:
+     * [
+     *   'http' => 'username:password@proxy.example.com',
+     *   'https' => 'username:password@proxy.example.com',
+     *   'no' => ['foo.com', 'bar.com']
+     * ]
+     *
+     */
+    private function getProxyUri(): ?array {
+        $proxyHost = $this->config->getSystemValueString('proxy', '');
+
+        if ($proxyHost === '') {
+            return null;
+        }
+
+        $proxyUserPwd = $this->config->getSystemValueString('proxyuserpwd', '');
+        if ($proxyUserPwd !== '') {
+            $proxyHost = $proxyUserPwd . '@' . $proxyHost;
+        }
+
+        $proxy = [
+            'http' => $proxyHost,
+            'https' => $proxyHost,
+        ];
+
+        $proxyExclude = $this->config->getSystemValue('proxyexclude', []);
+        if ($proxyExclude !== [] && $proxyExclude !== null) {
+            $proxy['no'] = $proxyExclude;
+        }
+
+        return $proxy;
+    }
+
+    private function isLocalAddressAllowed(array $options) : bool {
+        if (($options['nextcloud']['allow_local_address'] ?? false)
+            || $this->config->getSystemValueBool('allow_local_remote_servers', false)) {
+            return true;
+        }
+
+        return false;
+    }
+
+    protected function preventLocalAddress(string $uri, array $options): void {
+        $host = parse_url($uri, PHP_URL_HOST);
+        if ($host === false || $host === null) {
+            throw new LocalServerException('Could not detect any host');
+        }
+
+        if ($this->isLocalAddressAllowed($options)) {
+            return;
+        }
+
+        if (!$this->remoteHostValidator->isValid($host)) {
+            throw new LocalServerException('Host "' . $host . '" violates local access rules');
+        }
+    }
+
+    /**
+     * Sends a GET request
+     *
+     * @param string $uri
+     * @param array $options Array such as
+     *                       'query' => [
+     *                       'field' => 'abc',
+     *                       'other_field' => '123',
+     *                       'file_name' => fopen('/path/to/file', 'r'),
+     *                       ],
+     *                       'headers' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'cookies' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'allow_redirects' => [
+     *                       'max'       => 10,  // allow at most 10 redirects.
+     *                       'strict'    => true,     // use "strict" RFC compliant redirects.
+     *                       'referer'   => true,     // add a Referer header
+     *                       'protocols' => ['https'] // only allow https URLs
+     *                       ],
+     *                       'sink' => '/path/to/file', // save to a file or a stream
+     *                       'verify' => true, // bool or string to CA file
+     *                       'debug' => true,
+     *                       'timeout' => 5,
+     * @return IResponse
+     * @throws \Exception If the request could not get completed
+     */
+    public function get(string $uri, array $options = []): IResponse {
+        $this->preventLocalAddress($uri, $options);
+        $response = $this->client->request('get', $uri, $this->buildRequestOptions($options));
+        $isStream = isset($options['stream']) && $options['stream'];
+        return new Response($response, $isStream);
+    }
+
+    /**
+     * Sends a HEAD request
+     *
+     * @param string $uri
+     * @param array $options Array such as
+     *                       'headers' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'cookies' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'allow_redirects' => [
+     *                       'max'       => 10,  // allow at most 10 redirects.
+     *                       'strict'    => true,     // use "strict" RFC compliant redirects.
+     *                       'referer'   => true,     // add a Referer header
+     *                       'protocols' => ['https'] // only allow https URLs
+     *                       ],
+     *                       'sink' => '/path/to/file', // save to a file or a stream
+     *                       'verify' => true, // bool or string to CA file
+     *                       'debug' => true,
+     *                       'timeout' => 5,
+     * @return IResponse
+     * @throws \Exception If the request could not get completed
+     */
+    public function head(string $uri, array $options = []): IResponse {
+        $this->preventLocalAddress($uri, $options);
+        $response = $this->client->request('head', $uri, $this->buildRequestOptions($options));
+        return new Response($response);
+    }
+
+    /**
+     * Sends a POST request
+     *
+     * @param string $uri
+     * @param array $options Array such as
+     *                       'body' => [
+     *                       'field' => 'abc',
+     *                       'other_field' => '123',
+     *                       'file_name' => fopen('/path/to/file', 'r'),
+     *                       ],
+     *                       'headers' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'cookies' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'allow_redirects' => [
+     *                       'max'       => 10,  // allow at most 10 redirects.
+     *                       'strict'    => true,     // use "strict" RFC compliant redirects.
+     *                       'referer'   => true,     // add a Referer header
+     *                       'protocols' => ['https'] // only allow https URLs
+     *                       ],
+     *                       'sink' => '/path/to/file', // save to a file or a stream
+     *                       'verify' => true, // bool or string to CA file
+     *                       'debug' => true,
+     *                       'timeout' => 5,
+     * @return IResponse
+     * @throws \Exception If the request could not get completed
+     */
+    public function post(string $uri, array $options = []): IResponse {
+        $this->preventLocalAddress($uri, $options);
+
+        if (isset($options['body']) && is_array($options['body'])) {
+            $options['form_params'] = $options['body'];
+            unset($options['body']);
+        }
+        $response = $this->client->request('post', $uri, $this->buildRequestOptions($options));
+        $isStream = isset($options['stream']) && $options['stream'];
+        return new Response($response, $isStream);
+    }
+
+    /**
+     * Sends a PUT request
+     *
+     * @param string $uri
+     * @param array $options Array such as
+     *                       'body' => [
+     *                       'field' => 'abc',
+     *                       'other_field' => '123',
+     *                       'file_name' => fopen('/path/to/file', 'r'),
+     *                       ],
+     *                       'headers' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'cookies' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'allow_redirects' => [
+     *                       'max'       => 10,  // allow at most 10 redirects.
+     *                       'strict'    => true,     // use "strict" RFC compliant redirects.
+     *                       'referer'   => true,     // add a Referer header
+     *                       'protocols' => ['https'] // only allow https URLs
+     *                       ],
+     *                       'sink' => '/path/to/file', // save to a file or a stream
+     *                       'verify' => true, // bool or string to CA file
+     *                       'debug' => true,
+     *                       'timeout' => 5,
+     * @return IResponse
+     * @throws \Exception If the request could not get completed
+     */
+    public function put(string $uri, array $options = []): IResponse {
+        $this->preventLocalAddress($uri, $options);
+        $response = $this->client->request('put', $uri, $this->buildRequestOptions($options));
+        return new Response($response);
+    }
+
+    /**
+     * Sends a PATCH request
+     *
+     * @param string $uri
+     * @param array $options Array such as
+     *                       'body' => [
+     *                       'field' => 'abc',
+     *                       'other_field' => '123',
+     *                       'file_name' => fopen('/path/to/file', 'r'),
+     *                       ],
+     *                       'headers' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'cookies' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'allow_redirects' => [
+     *                       'max'       => 10,  // allow at most 10 redirects.
+     *                       'strict'    => true,     // use "strict" RFC compliant redirects.
+     *                       'referer'   => true,     // add a Referer header
+     *                       'protocols' => ['https'] // only allow https URLs
+     *                       ],
+     *                       'sink' => '/path/to/file', // save to a file or a stream
+     *                       'verify' => true, // bool or string to CA file
+     *                       'debug' => true,
+     *                       'timeout' => 5,
+     * @return IResponse
+     * @throws \Exception If the request could not get completed
+     */
+    public function patch(string $uri, array $options = []): IResponse {
+        $this->preventLocalAddress($uri, $options);
+        $response = $this->client->request('patch', $uri, $this->buildRequestOptions($options));
+        return new Response($response);
+    }
+
+    /**
+     * Sends a DELETE request
+     *
+     * @param string $uri
+     * @param array $options Array such as
+     *                       'body' => [
+     *                       'field' => 'abc',
+     *                       'other_field' => '123',
+     *                       'file_name' => fopen('/path/to/file', 'r'),
+     *                       ],
+     *                       'headers' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'cookies' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'allow_redirects' => [
+     *                       'max'       => 10,  // allow at most 10 redirects.
+     *                       'strict'    => true,     // use "strict" RFC compliant redirects.
+     *                       'referer'   => true,     // add a Referer header
+     *                       'protocols' => ['https'] // only allow https URLs
+     *                       ],
+     *                       'sink' => '/path/to/file', // save to a file or a stream
+     *                       'verify' => true, // bool or string to CA file
+     *                       'debug' => true,
+     *                       'timeout' => 5,
+     * @return IResponse
+     * @throws \Exception If the request could not get completed
+     */
+    public function delete(string $uri, array $options = []): IResponse {
+        $this->preventLocalAddress($uri, $options);
+        $response = $this->client->request('delete', $uri, $this->buildRequestOptions($options));
+        return new Response($response);
+    }
+
+    /**
+     * Sends an OPTIONS request
+     *
+     * @param string $uri
+     * @param array $options Array such as
+     *                       'body' => [
+     *                       'field' => 'abc',
+     *                       'other_field' => '123',
+     *                       'file_name' => fopen('/path/to/file', 'r'),
+     *                       ],
+     *                       'headers' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'cookies' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'allow_redirects' => [
+     *                       'max'       => 10,  // allow at most 10 redirects.
+     *                       'strict'    => true,     // use "strict" RFC compliant redirects.
+     *                       'referer'   => true,     // add a Referer header
+     *                       'protocols' => ['https'] // only allow https URLs
+     *                       ],
+     *                       'sink' => '/path/to/file', // save to a file or a stream
+     *                       'verify' => true, // bool or string to CA file
+     *                       'debug' => true,
+     *                       'timeout' => 5,
+     * @return IResponse
+     * @throws \Exception If the request could not get completed
+     */
+    public function options(string $uri, array $options = []): IResponse {
+        $this->preventLocalAddress($uri, $options);
+        $response = $this->client->request('options', $uri, $this->buildRequestOptions($options));
+        return new Response($response);
+    }
+
+    /**
+     * Get the response of a Throwable thrown by the request methods when possible
+     *
+     * @param \Throwable $e
+     * @return IResponse
+     * @throws \Throwable When $e did not have a response
+     * @since 29.0.0
+     */
+    public function getResponseFromThrowable(\Throwable $e): IResponse {
+        if (method_exists($e, 'hasResponse') && method_exists($e, 'getResponse') && $e->hasResponse()) {
+            return new Response($e->getResponse());
+        }
+
+        throw $e;
+    }
+
+    /**
+     * Sends a HTTP request
+     *
+     * @param string $method The HTTP method to use
+     * @param string $uri
+     * @param array $options Array such as
+     *                       'query' => [
+     *                       'field' => 'abc',
+     *                       'other_field' => '123',
+     *                       'file_name' => fopen('/path/to/file', 'r'),
+     *                       ],
+     *                       'headers' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'cookies' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'allow_redirects' => [
+     *                       'max'       => 10,  // allow at most 10 redirects.
+     *                       'strict'    => true,     // use "strict" RFC compliant redirects.
+     *                       'referer'   => true,     // add a Referer header
+     *                       'protocols' => ['https'] // only allow https URLs
+     *                       ],
+     *                       'sink' => '/path/to/file', // save to a file or a stream
+     *                       'verify' => true, // bool or string to CA file
+     *                       'debug' => true,
+     *                       'timeout' => 5,
+     * @return IResponse
+     * @throws \Exception If the request could not get completed
+     */
+    public function request(string $method, string $uri, array $options = []): IResponse {
+        $this->preventLocalAddress($uri, $options);
+        $response = $this->client->request($method, $uri, $this->buildRequestOptions($options));
+        $isStream = isset($options['stream']) && $options['stream'];
+        return new Response($response, $isStream);
+    }
+
+    protected function wrapGuzzlePromise(PromiseInterface $promise): IPromise {
+        return new GuzzlePromiseAdapter(
+            $promise,
+            $this->logger
+        );
+    }
+
+    /**
+     * Sends an asynchronous GET request
+     *
+     * @param string $uri
+     * @param array $options Array such as
+     *                       'query' => [
+     *                       'field' => 'abc',
+     *                       'other_field' => '123',
+     *                       'file_name' => fopen('/path/to/file', 'r'),
+     *                       ],
+     *                       'headers' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'cookies' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'allow_redirects' => [
+     *                       'max'       => 10,  // allow at most 10 redirects.
+     *                       'strict'    => true,     // use "strict" RFC compliant redirects.
+     *                       'referer'   => true,     // add a Referer header
+     *                       'protocols' => ['https'] // only allow https URLs
+     *                       ],
+     *                       'sink' => '/path/to/file', // save to a file or a stream
+     *                       'verify' => true, // bool or string to CA file
+     *                       'debug' => true,
+     *                       'timeout' => 5,
+     * @return IPromise
+     */
+    public function getAsync(string $uri, array $options = []): IPromise {
+        $this->preventLocalAddress($uri, $options);
+        $response = $this->client->requestAsync('get', $uri, $this->buildRequestOptions($options));
+        return $this->wrapGuzzlePromise($response);
+    }
+
+    /**
+     * Sends an asynchronous HEAD request
+     *
+     * @param string $uri
+     * @param array $options Array such as
+     *                       'headers' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'cookies' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'allow_redirects' => [
+     *                       'max'       => 10,  // allow at most 10 redirects.
+     *                       'strict'    => true,     // use "strict" RFC compliant redirects.
+     *                       'referer'   => true,     // add a Referer header
+     *                       'protocols' => ['https'] // only allow https URLs
+     *                       ],
+     *                       'sink' => '/path/to/file', // save to a file or a stream
+     *                       'verify' => true, // bool or string to CA file
+     *                       'debug' => true,
+     *                       'timeout' => 5,
+     * @return IPromise
+     */
+    public function headAsync(string $uri, array $options = []): IPromise {
+        $this->preventLocalAddress($uri, $options);
+        $response = $this->client->requestAsync('head', $uri, $this->buildRequestOptions($options));
+        return $this->wrapGuzzlePromise($response);
+    }
+
+    /**
+     * Sends an asynchronous POST request
+     *
+     * @param string $uri
+     * @param array $options Array such as
+     *                       'body' => [
+     *                       'field' => 'abc',
+     *                       'other_field' => '123',
+     *                       'file_name' => fopen('/path/to/file', 'r'),
+     *                       ],
+     *                       'headers' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'cookies' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'allow_redirects' => [
+     *                       'max'       => 10,  // allow at most 10 redirects.
+     *                       'strict'    => true,     // use "strict" RFC compliant redirects.
+     *                       'referer'   => true,     // add a Referer header
+     *                       'protocols' => ['https'] // only allow https URLs
+     *                       ],
+     *                       'sink' => '/path/to/file', // save to a file or a stream
+     *                       'verify' => true, // bool or string to CA file
+     *                       'debug' => true,
+     *                       'timeout' => 5,
+     * @return IPromise
+     */
+    public function postAsync(string $uri, array $options = []): IPromise {
+        $this->preventLocalAddress($uri, $options);
+
+        if (isset($options['body']) && is_array($options['body'])) {
+            $options['form_params'] = $options['body'];
+            unset($options['body']);
+        }
+
+        return $this->wrapGuzzlePromise($this->client->requestAsync('post', $uri, $this->buildRequestOptions($options)));
+    }
+
+    /**
+     * Sends an asynchronous PUT request
+     *
+     * @param string $uri
+     * @param array $options Array such as
+     *                       'body' => [
+     *                       'field' => 'abc',
+     *                       'other_field' => '123',
+     *                       'file_name' => fopen('/path/to/file', 'r'),
+     *                       ],
+     *                       'headers' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'cookies' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'allow_redirects' => [
+     *                       'max'       => 10,  // allow at most 10 redirects.
+     *                       'strict'    => true,     // use "strict" RFC compliant redirects.
+     *                       'referer'   => true,     // add a Referer header
+     *                       'protocols' => ['https'] // only allow https URLs
+     *                       ],
+     *                       'sink' => '/path/to/file', // save to a file or a stream
+     *                       'verify' => true, // bool or string to CA file
+     *                       'debug' => true,
+     *                       'timeout' => 5,
+     * @return IPromise
+     */
+    public function putAsync(string $uri, array $options = []): IPromise {
+        $this->preventLocalAddress($uri, $options);
+        $response = $this->client->requestAsync('put', $uri, $this->buildRequestOptions($options));
+        return $this->wrapGuzzlePromise($response);
+    }
+
+    /**
+     * Sends an asynchronous DELETE request
+     *
+     * @param string $uri
+     * @param array $options Array such as
+     *                       'body' => [
+     *                       'field' => 'abc',
+     *                       'other_field' => '123',
+     *                       'file_name' => fopen('/path/to/file', 'r'),
+     *                       ],
+     *                       'headers' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'cookies' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'allow_redirects' => [
+     *                       'max'       => 10,  // allow at most 10 redirects.
+     *                       'strict'    => true,     // use "strict" RFC compliant redirects.
+     *                       'referer'   => true,     // add a Referer header
+     *                       'protocols' => ['https'] // only allow https URLs
+     *                       ],
+     *                       'sink' => '/path/to/file', // save to a file or a stream
+     *                       'verify' => true, // bool or string to CA file
+     *                       'debug' => true,
+     *                       'timeout' => 5,
+     * @return IPromise
+     */
+    public function deleteAsync(string $uri, array $options = []): IPromise {
+        $this->preventLocalAddress($uri, $options);
+        $response = $this->client->requestAsync('delete', $uri, $this->buildRequestOptions($options));
+        return $this->wrapGuzzlePromise($response);
+    }
+
+    /**
+     * Sends an asynchronous OPTIONS request
+     *
+     * @param string $uri
+     * @param array $options Array such as
+     *                       'body' => [
+     *                       'field' => 'abc',
+     *                       'other_field' => '123',
+     *                       'file_name' => fopen('/path/to/file', 'r'),
+     *                       ],
+     *                       'headers' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'cookies' => [
+     *                       'foo' => 'bar',
+     *                       ],
+     *                       'allow_redirects' => [
+     *                       'max'       => 10,  // allow at most 10 redirects.
+     *                       'strict'    => true,     // use "strict" RFC compliant redirects.
+     *                       'referer'   => true,     // add a Referer header
+     *                       'protocols' => ['https'] // only allow https URLs
+     *                       ],
+     *                       'sink' => '/path/to/file', // save to a file or a stream
+     *                       'verify' => true, // bool or string to CA file
+     *                       'debug' => true,
+     *                       'timeout' => 5,
+     * @return IPromise
+     */
+    public function optionsAsync(string $uri, array $options = []): IPromise {
+        $this->preventLocalAddress($uri, $options);
+        $response = $this->client->requestAsync('options', $uri, $this->buildRequestOptions($options));
+        return $this->wrapGuzzlePromise($response);
+    }
 }

Spacing +5 added lines, -5 removed lines

@@ -60,7 +60,7 @@ 
 
 		$options['nextcloud']['allow_local_address'] = $this->isLocalAddressAllowed($options);
 		if ($options['nextcloud']['allow_local_address'] === false) {
-			$onRedirectFunction = function (
+			$onRedirectFunction = function(
 				\Psr\Http\Message\RequestInterface $request,
 				\Psr\Http\Message\ResponseInterface $response,
 				\Psr\Http\Message\UriInterface $uri,
@@ -83,7 +83,7 @@ 
 		$options = array_merge($defaults, $options);
 
 		if (!isset($options[RequestOptions::HEADERS]['User-Agent'])) {
-			$userAgent = 'Nextcloud-Server-Crawler/' . $this->serverVersion->getVersionString();
+			$userAgent = 'Nextcloud-Server-Crawler/'.$this->serverVersion->getVersionString();
 			$options[RequestOptions::HEADERS]['User-Agent'] = $userAgent;
 		}
 
@@ -105,7 +105,7 @@ 
 		// $this->certificateManager->getAbsoluteBundlePath() tries to instantiate
 		// a view
 		if (!$this->config->getSystemValueBool('installed', false)) {
-			return \OC::$SERVERROOT . '/resources/config/ca-bundle.crt';
+			return \OC::$SERVERROOT.'/resources/config/ca-bundle.crt';
 		}
 
 		return $this->certificateManager->getAbsoluteBundlePath();
@@ -135,7 +135,7 @@ 
 
 		$proxyUserPwd = $this->config->getSystemValueString('proxyuserpwd', '');
 		if ($proxyUserPwd !== '') {
-			$proxyHost = $proxyUserPwd . '@' . $proxyHost;
+			$proxyHost = $proxyUserPwd.'@'.$proxyHost;
 		}
 
 		$proxy = [
@@ -171,7 +171,7 @@ 
 		}
 
 		if (!$this->remoteHostValidator->isValid($host)) {
-			throw new LocalServerException('Host "' . $host . '" violates local access rules');
+			throw new LocalServerException('Host "'.$host.'" violates local access rules');
 		}
 	}
 

lib/private/Http/Client/ClientService.php

Indentation +47 added lines, -47 removed lines

@@ -28,55 +28,55 @@
  * @package OC\Http
  */
 class ClientService implements IClientService {
-	/** @var IConfig */
-	private $config;
-	/** @var ICertificateManager */
-	private $certificateManager;
-	/** @var DnsPinMiddleware */
-	private $dnsPinMiddleware;
-	private IRemoteHostValidator $remoteHostValidator;
-	private IEventLogger $eventLogger;
+    /** @var IConfig */
+    private $config;
+    /** @var ICertificateManager */
+    private $certificateManager;
+    /** @var DnsPinMiddleware */
+    private $dnsPinMiddleware;
+    private IRemoteHostValidator $remoteHostValidator;
+    private IEventLogger $eventLogger;
 
-	public function __construct(
-		IConfig $config,
-		ICertificateManager $certificateManager,
-		DnsPinMiddleware $dnsPinMiddleware,
-		IRemoteHostValidator $remoteHostValidator,
-		IEventLogger $eventLogger,
-		protected LoggerInterface $logger,
-		protected ServerVersion $serverVersion,
-	) {
-		$this->config = $config;
-		$this->certificateManager = $certificateManager;
-		$this->dnsPinMiddleware = $dnsPinMiddleware;
-		$this->remoteHostValidator = $remoteHostValidator;
-		$this->eventLogger = $eventLogger;
-	}
+    public function __construct(
+        IConfig $config,
+        ICertificateManager $certificateManager,
+        DnsPinMiddleware $dnsPinMiddleware,
+        IRemoteHostValidator $remoteHostValidator,
+        IEventLogger $eventLogger,
+        protected LoggerInterface $logger,
+        protected ServerVersion $serverVersion,
+    ) {
+        $this->config = $config;
+        $this->certificateManager = $certificateManager;
+        $this->dnsPinMiddleware = $dnsPinMiddleware;
+        $this->remoteHostValidator = $remoteHostValidator;
+        $this->eventLogger = $eventLogger;
+    }
 
-	/**
-	 * @return Client
-	 */
-	public function newClient(): IClient {
-		$handler = new CurlHandler();
-		$stack = HandlerStack::create($handler);
-		if ($this->config->getSystemValueBool('dns_pinning', true)) {
-			$stack->push($this->dnsPinMiddleware->addDnsPinning());
-		}
-		$stack->push(Middleware::tap(function (RequestInterface $request) {
-			$this->eventLogger->start('http:request', $request->getMethod() . ' request to ' . $request->getRequestTarget());
-		}, function () {
-			$this->eventLogger->end('http:request');
-		}), 'event logger');
+    /**
+     * @return Client
+     */
+    public function newClient(): IClient {
+        $handler = new CurlHandler();
+        $stack = HandlerStack::create($handler);
+        if ($this->config->getSystemValueBool('dns_pinning', true)) {
+            $stack->push($this->dnsPinMiddleware->addDnsPinning());
+        }
+        $stack->push(Middleware::tap(function (RequestInterface $request) {
+            $this->eventLogger->start('http:request', $request->getMethod() . ' request to ' . $request->getRequestTarget());
+        }, function () {
+            $this->eventLogger->end('http:request');
+        }), 'event logger');
 
-		$client = new GuzzleClient(['handler' => $stack]);
+        $client = new GuzzleClient(['handler' => $stack]);
 
-		return new Client(
-			$this->config,
-			$this->certificateManager,
-			$client,
-			$this->remoteHostValidator,
-			$this->logger,
-			$this->serverVersion,
-		);
-	}
+        return new Client(
+            $this->config,
+            $this->certificateManager,
+            $client,
+            $this->remoteHostValidator,
+            $this->logger,
+            $this->serverVersion,
+        );
+    }
 }

tests/lib/Http/Client/ClientTest.php

Indentation +580 added lines, -580 removed lines

@@ -26,584 +26,584 @@
  * Class ClientTest
  */
 class ClientTest extends \Test\TestCase {
-	/** @var \GuzzleHttp\Client|MockObject */
-	private $guzzleClient;
-	/** @var CertificateManager|MockObject */
-	private $certificateManager;
-	/** @var Client */
-	private $client;
-	/** @var IConfig|MockObject */
-	private $config;
-	/** @var IRemoteHostValidator|MockObject */
-	private IRemoteHostValidator $remoteHostValidator;
-	private LoggerInterface $logger;
-	private ServerVersion $serverVersion;
-	/** @var array */
-	private $defaultRequestOptions;
-
-	protected function setUp(): void {
-		parent::setUp();
-		$this->config = $this->createMock(IConfig::class);
-		$this->guzzleClient = $this->createMock(\GuzzleHttp\Client::class);
-		$this->certificateManager = $this->createMock(ICertificateManager::class);
-		$this->remoteHostValidator = $this->createMock(IRemoteHostValidator::class);
-		$this->logger = $this->createMock(LoggerInterface::class);
-		$this->serverVersion = $this->createMock(ServerVersion::class);
-
-		$this->client = new Client(
-			$this->config,
-			$this->certificateManager,
-			$this->guzzleClient,
-			$this->remoteHostValidator,
-			$this->logger,
-			$this->serverVersion,
-		);
-	}
-
-	public function testGetProxyUri(): void {
-		$this->config
-			->method('getSystemValueString')
-			->with('proxy', '')
-			->willReturn('');
-		$this->assertNull(self::invokePrivate($this->client, 'getProxyUri'));
-	}
-
-	public function testGetProxyUriProxyHostEmptyPassword(): void {
-		$this->config
-			->method('getSystemValue')
-			->willReturnMap([
-				['proxyexclude', [], []],
-			]);
-
-		$this->config
-			->method('getSystemValueString')
-			->willReturnMap([
-				['proxy', '', 'foo'],
-				['proxyuserpwd', '', ''],
-			]);
-
-		$this->assertEquals([
-			'http' => 'foo',
-			'https' => 'foo'
-		], self::invokePrivate($this->client, 'getProxyUri'));
-	}
-
-	public function testGetProxyUriProxyHostWithPassword(): void {
-		$this->config
-			->expects($this->once())
-			->method('getSystemValue')
-			->with('proxyexclude', [])
-			->willReturn([]);
-		$this->config
-			->expects($this->exactly(2))
-			->method('getSystemValueString')
-			->willReturnMap([
-				['proxy', '', 'foo'],
-				['proxyuserpwd', '', 'username:password'],
-			]);
-		$this->assertEquals([
-			'http' => 'username:password@foo',
-			'https' => 'username:password@foo'
-		], self::invokePrivate($this->client, 'getProxyUri'));
-	}
-
-	public function testGetProxyUriProxyHostWithPasswordAndExclude(): void {
-		$this->config
-			->expects($this->once())
-			->method('getSystemValue')
-			->with('proxyexclude', [])
-			->willReturn(['bar']);
-		$this->config
-			->expects($this->exactly(2))
-			->method('getSystemValueString')
-			->willReturnMap([
-				['proxy', '', 'foo'],
-				['proxyuserpwd', '', 'username:password'],
-			]);
-		$this->assertEquals([
-			'http' => 'username:password@foo',
-			'https' => 'username:password@foo',
-			'no' => ['bar']
-		], self::invokePrivate($this->client, 'getProxyUri'));
-	}
-
-	public function testPreventLocalAddressThrowOnInvalidUri(): void {
-		$this->expectException(LocalServerException::class);
-		$this->expectExceptionMessage('Could not detect any host');
-
-		self::invokePrivate($this->client, 'preventLocalAddress', ['!@#$', []]);
-	}
-
-	public static function dataPreventLocalAddress(): array {
-		return [
-			['https://localhost/foo.bar'],
-			['https://localHost/foo.bar'],
-			['https://random-host/foo.bar'],
-			['https://[::1]/bla.blub'],
-			['https://[::]/bla.blub'],
-			['https://192.168.0.1'],
-			['https://172.16.42.1'],
-			['https://[fdf8:f53b:82e4::53]/secret.ics'],
-			['https://[fe80::200:5aee:feaa:20a2]/secret.ics'],
-			['https://[0:0:0:0:0:0:10.0.0.1]/secret.ics'],
-			['https://[0:0:0:0:0:ffff:127.0.0.0]/secret.ics'],
-			['https://10.0.0.1'],
-			['https://another-host.local'],
-			['https://service.localhost'],
-			['https://normal.host.com'],
-			['https://com.one-.nextcloud-one.com'],
-		];
-	}
-
-	/**
-	 * @param string $uri
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataPreventLocalAddress')]
-	public function testPreventLocalAddressDisabledByGlobalConfig(string $uri): void {
-		$this->config->expects($this->once())
-			->method('getSystemValueBool')
-			->with('allow_local_remote_servers', false)
-			->willReturn(true);
-
-		self::invokePrivate($this->client, 'preventLocalAddress', [$uri, []]);
-	}
-
-	/**
-	 * @param string $uri
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataPreventLocalAddress')]
-	public function testPreventLocalAddressDisabledByOption(string $uri): void {
-		$this->config->expects($this->never())
-			->method('getSystemValueBool');
-
-		self::invokePrivate($this->client, 'preventLocalAddress', [$uri, [
-			'nextcloud' => ['allow_local_address' => true],
-		]]);
-	}
-
-	/**
-	 * @param string $uri
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataPreventLocalAddress')]
-	public function testPreventLocalAddressOnGet(string $uri): void {
-		$host = parse_url($uri, PHP_URL_HOST);
-		$this->expectException(LocalServerException::class);
-		$this->remoteHostValidator
-			->method('isValid')
-			->with($host)
-			->willReturn(false);
-
-		$this->client->get($uri);
-	}
-
-	/**
-	 * @param string $uri
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataPreventLocalAddress')]
-	public function testPreventLocalAddressOnHead(string $uri): void {
-		$host = parse_url($uri, PHP_URL_HOST);
-		$this->expectException(LocalServerException::class);
-		$this->remoteHostValidator
-			->method('isValid')
-			->with($host)
-			->willReturn(false);
-
-		$this->client->head($uri);
-	}
-
-	/**
-	 * @param string $uri
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataPreventLocalAddress')]
-	public function testPreventLocalAddressOnPost(string $uri): void {
-		$host = parse_url($uri, PHP_URL_HOST);
-		$this->expectException(LocalServerException::class);
-		$this->remoteHostValidator
-			->method('isValid')
-			->with($host)
-			->willReturn(false);
-
-		$this->client->post($uri);
-	}
-
-	/**
-	 * @param string $uri
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataPreventLocalAddress')]
-	public function testPreventLocalAddressOnPut(string $uri): void {
-		$host = parse_url($uri, PHP_URL_HOST);
-		$this->expectException(LocalServerException::class);
-		$this->remoteHostValidator
-			->method('isValid')
-			->with($host)
-			->willReturn(false);
-
-		$this->client->put($uri);
-	}
-
-	/**
-	 * @param string $uri
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataPreventLocalAddress')]
-	public function testPreventLocalAddressOnDelete(string $uri): void {
-		$host = parse_url($uri, PHP_URL_HOST);
-		$this->expectException(LocalServerException::class);
-		$this->remoteHostValidator
-			->method('isValid')
-			->with($host)
-			->willReturn(false);
-
-		$this->client->delete($uri);
-	}
-
-	private function setUpDefaultRequestOptions(): void {
-		$this->config
-			->method('getSystemValue')
-			->willReturnMap([
-				['proxyexclude', [], []],
-			]);
-		$this->config
-			->method('getSystemValueString')
-			->willReturnMap([
-				['proxy', '', 'foo'],
-				['proxyuserpwd', '', ''],
-			]);
-		$this->config
-			->method('getSystemValueBool')
-			->willReturnMap([
-				['installed', false, true],
-				['allow_local_remote_servers', false, true],
-			]);
-
-		$this->certificateManager
-			->expects($this->once())
-			->method('getAbsoluteBundlePath')
-			->with()
-			->willReturn('/my/path.crt');
-
-		$this->serverVersion->method('getVersionString')
-			->willReturn('123.45.6');
-
-		$this->defaultRequestOptions = [
-			'verify' => '/my/path.crt',
-			'proxy' => [
-				'http' => 'foo',
-				'https' => 'foo'
-			],
-			'headers' => [
-				'User-Agent' => 'Nextcloud-Server-Crawler/123.45.6',
-				'Accept-Encoding' => 'gzip',
-			],
-			'timeout' => 30,
-			'nextcloud' => [
-				'allow_local_address' => true,
-			],
-		];
-	}
-
-	public function testGet(): void {
-		$this->setUpDefaultRequestOptions();
-
-		$this->guzzleClient->method('request')
-			->with('get', 'http://localhost/', $this->defaultRequestOptions)
-			->willReturn(new Response(418));
-		$this->assertEquals(418, $this->client->get('http://localhost/', [])->getStatusCode());
-	}
-
-	public function testGetWithOptions(): void {
-		$this->setUpDefaultRequestOptions();
-
-		$options = array_merge($this->defaultRequestOptions, [
-			'verify' => false,
-			'proxy' => [
-				'http' => 'bar',
-				'https' => 'bar'
-			],
-		]);
-
-		$this->guzzleClient->method('request')
-			->with('get', 'http://localhost/', $options)
-			->willReturn(new Response(418));
-		$this->assertEquals(418, $this->client->get('http://localhost/', $options)->getStatusCode());
-	}
-
-	public function testPost(): void {
-		$this->setUpDefaultRequestOptions();
-
-		$this->guzzleClient->method('request')
-			->with('post', 'http://localhost/', $this->defaultRequestOptions)
-			->willReturn(new Response(418));
-		$this->assertEquals(418, $this->client->post('http://localhost/', [])->getStatusCode());
-	}
-
-	public function testPostWithOptions(): void {
-		$this->setUpDefaultRequestOptions();
-
-		$options = array_merge($this->defaultRequestOptions, [
-			'verify' => false,
-			'proxy' => [
-				'http' => 'bar',
-				'https' => 'bar'
-			],
-		]);
-
-		$this->guzzleClient->method('request')
-			->with('post', 'http://localhost/', $options)
-			->willReturn(new Response(418));
-		$this->assertEquals(418, $this->client->post('http://localhost/', $options)->getStatusCode());
-	}
-
-	public function testPut(): void {
-		$this->setUpDefaultRequestOptions();
-
-		$this->guzzleClient->method('request')
-			->with('put', 'http://localhost/', $this->defaultRequestOptions)
-			->willReturn(new Response(418));
-		$this->assertEquals(418, $this->client->put('http://localhost/', [])->getStatusCode());
-	}
-
-	public function testPutWithOptions(): void {
-		$this->setUpDefaultRequestOptions();
-
-		$options = array_merge($this->defaultRequestOptions, [
-			'verify' => false,
-			'proxy' => [
-				'http' => 'bar',
-				'https' => 'bar'
-			],
-		]);
-
-		$this->guzzleClient->method('request')
-			->with('put', 'http://localhost/', $options)
-			->willReturn(new Response(418));
-		$this->assertEquals(418, $this->client->put('http://localhost/', $options)->getStatusCode());
-	}
-
-	public function testDelete(): void {
-		$this->setUpDefaultRequestOptions();
-
-		$this->guzzleClient->method('request')
-			->with('delete', 'http://localhost/', $this->defaultRequestOptions)
-			->willReturn(new Response(418));
-		$this->assertEquals(418, $this->client->delete('http://localhost/', [])->getStatusCode());
-	}
-
-	public function testDeleteWithOptions(): void {
-		$this->setUpDefaultRequestOptions();
-
-		$options = array_merge($this->defaultRequestOptions, [
-			'verify' => false,
-			'proxy' => [
-				'http' => 'bar',
-				'https' => 'bar'
-			],
-		]);
-
-		$this->guzzleClient->method('request')
-			->with('delete', 'http://localhost/', $options)
-			->willReturn(new Response(418));
-		$this->assertEquals(418, $this->client->delete('http://localhost/', $options)->getStatusCode());
-	}
-
-	public function testOptions(): void {
-		$this->setUpDefaultRequestOptions();
-
-		$this->guzzleClient->method('request')
-			->with('options', 'http://localhost/', $this->defaultRequestOptions)
-			->willReturn(new Response(418));
-		$this->assertEquals(418, $this->client->options('http://localhost/', [])->getStatusCode());
-	}
-
-	public function testOptionsWithOptions(): void {
-		$this->setUpDefaultRequestOptions();
-
-		$options = array_merge($this->defaultRequestOptions, [
-			'verify' => false,
-			'proxy' => [
-				'http' => 'bar',
-				'https' => 'bar'
-			],
-		]);
-
-		$this->guzzleClient->method('request')
-			->with('options', 'http://localhost/', $options)
-			->willReturn(new Response(418));
-		$this->assertEquals(418, $this->client->options('http://localhost/', $options)->getStatusCode());
-	}
-
-	public function testHead(): void {
-		$this->setUpDefaultRequestOptions();
-
-		$this->guzzleClient->method('request')
-			->with('head', 'http://localhost/', $this->defaultRequestOptions)
-			->willReturn(new Response(418));
-		$this->assertEquals(418, $this->client->head('http://localhost/', [])->getStatusCode());
-	}
-
-	public function testHeadWithOptions(): void {
-		$this->setUpDefaultRequestOptions();
-
-		$options = array_merge($this->defaultRequestOptions, [
-			'verify' => false,
-			'proxy' => [
-				'http' => 'bar',
-				'https' => 'bar'
-			],
-		]);
-
-		$this->guzzleClient->method('request')
-			->with('head', 'http://localhost/', $options)
-			->willReturn(new Response(418));
-		$this->assertEquals(418, $this->client->head('http://localhost/', $options)->getStatusCode());
-	}
-
-	public function testSetDefaultOptionsWithNotInstalled(): void {
-		$this->config
-			->expects($this->exactly(2))
-			->method('getSystemValueBool')
-			->willReturnMap([
-				['installed', false, false],
-				['allow_local_remote_servers', false, false],
-			]);
-		$this->config
-			->expects($this->once())
-			->method('getSystemValueString')
-			->with('proxy', '')
-			->willReturn('');
-		$this->certificateManager
-			->expects($this->never())
-			->method('listCertificates');
-
-		$this->serverVersion->method('getVersionString')
-			->willReturn('123.45.6');
-
-		$this->assertEquals([
-			'verify' => \OC::$SERVERROOT . '/resources/config/ca-bundle.crt',
-			'headers' => [
-				'User-Agent' => 'Nextcloud-Server-Crawler/123.45.6',
-				'Accept-Encoding' => 'gzip',
-			],
-			'timeout' => 30,
-			'nextcloud' => [
-				'allow_local_address' => false,
-			],
-			'allow_redirects' => [
-				'on_redirect' => function (
-					\Psr\Http\Message\RequestInterface $request,
-					\Psr\Http\Message\ResponseInterface $response,
-					\Psr\Http\Message\UriInterface $uri,
-				): void {
-				},
-			],
-		], self::invokePrivate($this->client, 'buildRequestOptions', [[]]));
-	}
-
-	public function testSetDefaultOptionsWithProxy(): void {
-		$this->config
-			->expects($this->exactly(2))
-			->method('getSystemValueBool')
-			->willReturnMap([
-				['installed', false, true],
-				['allow_local_remote_servers', false, false],
-			]);
-		$this->config
-			->expects($this->once())
-			->method('getSystemValue')
-			->with('proxyexclude', [])
-			->willReturn([]);
-		$this->config
-			->expects($this->exactly(2))
-			->method('getSystemValueString')
-			->willReturnMap([
-				['proxy', '', 'foo'],
-				['proxyuserpwd', '', ''],
-			]);
-		$this->certificateManager
-			->expects($this->once())
-			->method('getAbsoluteBundlePath')
-			->with()
-			->willReturn('/my/path.crt');
-
-		$this->serverVersion->method('getVersionString')
-			->willReturn('123.45.6');
-
-		$this->assertEquals([
-			'verify' => '/my/path.crt',
-			'proxy' => [
-				'http' => 'foo',
-				'https' => 'foo'
-			],
-			'headers' => [
-				'User-Agent' => 'Nextcloud-Server-Crawler/123.45.6',
-				'Accept-Encoding' => 'gzip',
-			],
-			'timeout' => 30,
-			'nextcloud' => [
-				'allow_local_address' => false,
-			],
-			'allow_redirects' => [
-				'on_redirect' => function (
-					\Psr\Http\Message\RequestInterface $request,
-					\Psr\Http\Message\ResponseInterface $response,
-					\Psr\Http\Message\UriInterface $uri,
-				): void {
-				},
-			],
-		], self::invokePrivate($this->client, 'buildRequestOptions', [[]]));
-	}
-
-	public function testSetDefaultOptionsWithProxyAndExclude(): void {
-		$this->config
-			->expects($this->exactly(2))
-			->method('getSystemValueBool')
-			->willReturnMap([
-				['installed', false, true],
-				['allow_local_remote_servers', false, false],
-			]);
-		$this->config
-			->expects($this->once())
-			->method('getSystemValue')
-			->with('proxyexclude', [])
-			->willReturn(['bar']);
-		$this->config
-			->expects($this->exactly(2))
-			->method('getSystemValueString')
-			->willReturnMap([
-				['proxy', '', 'foo'],
-				['proxyuserpwd', '', ''],
-			]);
-		$this->certificateManager
-			->expects($this->once())
-			->method('getAbsoluteBundlePath')
-			->with()
-			->willReturn('/my/path.crt');
-
-		$this->serverVersion->method('getVersionString')
-			->willReturn('123.45.6');
-
-		$this->assertEquals([
-			'verify' => '/my/path.crt',
-			'proxy' => [
-				'http' => 'foo',
-				'https' => 'foo',
-				'no' => ['bar']
-			],
-			'headers' => [
-				'User-Agent' => 'Nextcloud-Server-Crawler/123.45.6',
-				'Accept-Encoding' => 'gzip',
-			],
-			'timeout' => 30,
-			'nextcloud' => [
-				'allow_local_address' => false,
-			],
-			'allow_redirects' => [
-				'on_redirect' => function (
-					\Psr\Http\Message\RequestInterface $request,
-					\Psr\Http\Message\ResponseInterface $response,
-					\Psr\Http\Message\UriInterface $uri,
-				): void {
-				},
-			],
-		], self::invokePrivate($this->client, 'buildRequestOptions', [[]]));
-	}
+    /** @var \GuzzleHttp\Client|MockObject */
+    private $guzzleClient;
+    /** @var CertificateManager|MockObject */
+    private $certificateManager;
+    /** @var Client */
+    private $client;
+    /** @var IConfig|MockObject */
+    private $config;
+    /** @var IRemoteHostValidator|MockObject */
+    private IRemoteHostValidator $remoteHostValidator;
+    private LoggerInterface $logger;
+    private ServerVersion $serverVersion;
+    /** @var array */
+    private $defaultRequestOptions;
+
+    protected function setUp(): void {
+        parent::setUp();
+        $this->config = $this->createMock(IConfig::class);
+        $this->guzzleClient = $this->createMock(\GuzzleHttp\Client::class);
+        $this->certificateManager = $this->createMock(ICertificateManager::class);
+        $this->remoteHostValidator = $this->createMock(IRemoteHostValidator::class);
+        $this->logger = $this->createMock(LoggerInterface::class);
+        $this->serverVersion = $this->createMock(ServerVersion::class);
+
+        $this->client = new Client(
+            $this->config,
+            $this->certificateManager,
+            $this->guzzleClient,
+            $this->remoteHostValidator,
+            $this->logger,
+            $this->serverVersion,
+        );
+    }
+
+    public function testGetProxyUri(): void {
+        $this->config
+            ->method('getSystemValueString')
+            ->with('proxy', '')
+            ->willReturn('');
+        $this->assertNull(self::invokePrivate($this->client, 'getProxyUri'));
+    }
+
+    public function testGetProxyUriProxyHostEmptyPassword(): void {
+        $this->config
+            ->method('getSystemValue')
+            ->willReturnMap([
+                ['proxyexclude', [], []],
+            ]);
+
+        $this->config
+            ->method('getSystemValueString')
+            ->willReturnMap([
+                ['proxy', '', 'foo'],
+                ['proxyuserpwd', '', ''],
+            ]);
+
+        $this->assertEquals([
+            'http' => 'foo',
+            'https' => 'foo'
+        ], self::invokePrivate($this->client, 'getProxyUri'));
+    }
+
+    public function testGetProxyUriProxyHostWithPassword(): void {
+        $this->config
+            ->expects($this->once())
+            ->method('getSystemValue')
+            ->with('proxyexclude', [])
+            ->willReturn([]);
+        $this->config
+            ->expects($this->exactly(2))
+            ->method('getSystemValueString')
+            ->willReturnMap([
+                ['proxy', '', 'foo'],
+                ['proxyuserpwd', '', 'username:password'],
+            ]);
+        $this->assertEquals([
+            'http' => 'username:password@foo',
+            'https' => 'username:password@foo'
+        ], self::invokePrivate($this->client, 'getProxyUri'));
+    }
+
+    public function testGetProxyUriProxyHostWithPasswordAndExclude(): void {
+        $this->config
+            ->expects($this->once())
+            ->method('getSystemValue')
+            ->with('proxyexclude', [])
+            ->willReturn(['bar']);
+        $this->config
+            ->expects($this->exactly(2))
+            ->method('getSystemValueString')
+            ->willReturnMap([
+                ['proxy', '', 'foo'],
+                ['proxyuserpwd', '', 'username:password'],
+            ]);
+        $this->assertEquals([
+            'http' => 'username:password@foo',
+            'https' => 'username:password@foo',
+            'no' => ['bar']
+        ], self::invokePrivate($this->client, 'getProxyUri'));
+    }
+
+    public function testPreventLocalAddressThrowOnInvalidUri(): void {
+        $this->expectException(LocalServerException::class);
+        $this->expectExceptionMessage('Could not detect any host');
+
+        self::invokePrivate($this->client, 'preventLocalAddress', ['!@#$', []]);
+    }
+
+    public static function dataPreventLocalAddress(): array {
+        return [
+            ['https://localhost/foo.bar'],
+            ['https://localHost/foo.bar'],
+            ['https://random-host/foo.bar'],
+            ['https://[::1]/bla.blub'],
+            ['https://[::]/bla.blub'],
+            ['https://192.168.0.1'],
+            ['https://172.16.42.1'],
+            ['https://[fdf8:f53b:82e4::53]/secret.ics'],
+            ['https://[fe80::200:5aee:feaa:20a2]/secret.ics'],
+            ['https://[0:0:0:0:0:0:10.0.0.1]/secret.ics'],
+            ['https://[0:0:0:0:0:ffff:127.0.0.0]/secret.ics'],
+            ['https://10.0.0.1'],
+            ['https://another-host.local'],
+            ['https://service.localhost'],
+            ['https://normal.host.com'],
+            ['https://com.one-.nextcloud-one.com'],
+        ];
+    }
+
+    /**
+     * @param string $uri
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataPreventLocalAddress')]
+    public function testPreventLocalAddressDisabledByGlobalConfig(string $uri): void {
+        $this->config->expects($this->once())
+            ->method('getSystemValueBool')
+            ->with('allow_local_remote_servers', false)
+            ->willReturn(true);
+
+        self::invokePrivate($this->client, 'preventLocalAddress', [$uri, []]);
+    }
+
+    /**
+     * @param string $uri
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataPreventLocalAddress')]
+    public function testPreventLocalAddressDisabledByOption(string $uri): void {
+        $this->config->expects($this->never())
+            ->method('getSystemValueBool');
+
+        self::invokePrivate($this->client, 'preventLocalAddress', [$uri, [
+            'nextcloud' => ['allow_local_address' => true],
+        ]]);
+    }
+
+    /**
+     * @param string $uri
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataPreventLocalAddress')]
+    public function testPreventLocalAddressOnGet(string $uri): void {
+        $host = parse_url($uri, PHP_URL_HOST);
+        $this->expectException(LocalServerException::class);
+        $this->remoteHostValidator
+            ->method('isValid')
+            ->with($host)
+            ->willReturn(false);
+
+        $this->client->get($uri);
+    }
+
+    /**
+     * @param string $uri
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataPreventLocalAddress')]
+    public function testPreventLocalAddressOnHead(string $uri): void {
+        $host = parse_url($uri, PHP_URL_HOST);
+        $this->expectException(LocalServerException::class);
+        $this->remoteHostValidator
+            ->method('isValid')
+            ->with($host)
+            ->willReturn(false);
+
+        $this->client->head($uri);
+    }
+
+    /**
+     * @param string $uri
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataPreventLocalAddress')]
+    public function testPreventLocalAddressOnPost(string $uri): void {
+        $host = parse_url($uri, PHP_URL_HOST);
+        $this->expectException(LocalServerException::class);
+        $this->remoteHostValidator
+            ->method('isValid')
+            ->with($host)
+            ->willReturn(false);
+
+        $this->client->post($uri);
+    }
+
+    /**
+     * @param string $uri
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataPreventLocalAddress')]
+    public function testPreventLocalAddressOnPut(string $uri): void {
+        $host = parse_url($uri, PHP_URL_HOST);
+        $this->expectException(LocalServerException::class);
+        $this->remoteHostValidator
+            ->method('isValid')
+            ->with($host)
+            ->willReturn(false);
+
+        $this->client->put($uri);
+    }
+
+    /**
+     * @param string $uri
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataPreventLocalAddress')]
+    public function testPreventLocalAddressOnDelete(string $uri): void {
+        $host = parse_url($uri, PHP_URL_HOST);
+        $this->expectException(LocalServerException::class);
+        $this->remoteHostValidator
+            ->method('isValid')
+            ->with($host)
+            ->willReturn(false);
+
+        $this->client->delete($uri);
+    }
+
+    private function setUpDefaultRequestOptions(): void {
+        $this->config
+            ->method('getSystemValue')
+            ->willReturnMap([
+                ['proxyexclude', [], []],
+            ]);
+        $this->config
+            ->method('getSystemValueString')
+            ->willReturnMap([
+                ['proxy', '', 'foo'],
+                ['proxyuserpwd', '', ''],
+            ]);
+        $this->config
+            ->method('getSystemValueBool')
+            ->willReturnMap([
+                ['installed', false, true],
+                ['allow_local_remote_servers', false, true],
+            ]);
+
+        $this->certificateManager
+            ->expects($this->once())
+            ->method('getAbsoluteBundlePath')
+            ->with()
+            ->willReturn('/my/path.crt');
+
+        $this->serverVersion->method('getVersionString')
+            ->willReturn('123.45.6');
+
+        $this->defaultRequestOptions = [
+            'verify' => '/my/path.crt',
+            'proxy' => [
+                'http' => 'foo',
+                'https' => 'foo'
+            ],
+            'headers' => [
+                'User-Agent' => 'Nextcloud-Server-Crawler/123.45.6',
+                'Accept-Encoding' => 'gzip',
+            ],
+            'timeout' => 30,
+            'nextcloud' => [
+                'allow_local_address' => true,
+            ],
+        ];
+    }
+
+    public function testGet(): void {
+        $this->setUpDefaultRequestOptions();
+
+        $this->guzzleClient->method('request')
+            ->with('get', 'http://localhost/', $this->defaultRequestOptions)
+            ->willReturn(new Response(418));
+        $this->assertEquals(418, $this->client->get('http://localhost/', [])->getStatusCode());
+    }
+
+    public function testGetWithOptions(): void {
+        $this->setUpDefaultRequestOptions();
+
+        $options = array_merge($this->defaultRequestOptions, [
+            'verify' => false,
+            'proxy' => [
+                'http' => 'bar',
+                'https' => 'bar'
+            ],
+        ]);
+
+        $this->guzzleClient->method('request')
+            ->with('get', 'http://localhost/', $options)
+            ->willReturn(new Response(418));
+        $this->assertEquals(418, $this->client->get('http://localhost/', $options)->getStatusCode());
+    }
+
+    public function testPost(): void {
+        $this->setUpDefaultRequestOptions();
+
+        $this->guzzleClient->method('request')
+            ->with('post', 'http://localhost/', $this->defaultRequestOptions)
+            ->willReturn(new Response(418));
+        $this->assertEquals(418, $this->client->post('http://localhost/', [])->getStatusCode());
+    }
+
+    public function testPostWithOptions(): void {
+        $this->setUpDefaultRequestOptions();
+
+        $options = array_merge($this->defaultRequestOptions, [
+            'verify' => false,
+            'proxy' => [
+                'http' => 'bar',
+                'https' => 'bar'
+            ],
+        ]);
+
+        $this->guzzleClient->method('request')
+            ->with('post', 'http://localhost/', $options)
+            ->willReturn(new Response(418));
+        $this->assertEquals(418, $this->client->post('http://localhost/', $options)->getStatusCode());
+    }
+
+    public function testPut(): void {
+        $this->setUpDefaultRequestOptions();
+
+        $this->guzzleClient->method('request')
+            ->with('put', 'http://localhost/', $this->defaultRequestOptions)
+            ->willReturn(new Response(418));
+        $this->assertEquals(418, $this->client->put('http://localhost/', [])->getStatusCode());
+    }
+
+    public function testPutWithOptions(): void {
+        $this->setUpDefaultRequestOptions();
+
+        $options = array_merge($this->defaultRequestOptions, [
+            'verify' => false,
+            'proxy' => [
+                'http' => 'bar',
+                'https' => 'bar'
+            ],
+        ]);
+
+        $this->guzzleClient->method('request')
+            ->with('put', 'http://localhost/', $options)
+            ->willReturn(new Response(418));
+        $this->assertEquals(418, $this->client->put('http://localhost/', $options)->getStatusCode());
+    }
+
+    public function testDelete(): void {
+        $this->setUpDefaultRequestOptions();
+
+        $this->guzzleClient->method('request')
+            ->with('delete', 'http://localhost/', $this->defaultRequestOptions)
+            ->willReturn(new Response(418));
+        $this->assertEquals(418, $this->client->delete('http://localhost/', [])->getStatusCode());
+    }
+
+    public function testDeleteWithOptions(): void {
+        $this->setUpDefaultRequestOptions();
+
+        $options = array_merge($this->defaultRequestOptions, [
+            'verify' => false,
+            'proxy' => [
+                'http' => 'bar',
+                'https' => 'bar'
+            ],
+        ]);
+
+        $this->guzzleClient->method('request')
+            ->with('delete', 'http://localhost/', $options)
+            ->willReturn(new Response(418));
+        $this->assertEquals(418, $this->client->delete('http://localhost/', $options)->getStatusCode());
+    }
+
+    public function testOptions(): void {
+        $this->setUpDefaultRequestOptions();
+
+        $this->guzzleClient->method('request')
+            ->with('options', 'http://localhost/', $this->defaultRequestOptions)
+            ->willReturn(new Response(418));
+        $this->assertEquals(418, $this->client->options('http://localhost/', [])->getStatusCode());
+    }
+
+    public function testOptionsWithOptions(): void {
+        $this->setUpDefaultRequestOptions();
+
+        $options = array_merge($this->defaultRequestOptions, [
+            'verify' => false,
+            'proxy' => [
+                'http' => 'bar',
+                'https' => 'bar'
+            ],
+        ]);
+
+        $this->guzzleClient->method('request')
+            ->with('options', 'http://localhost/', $options)
+            ->willReturn(new Response(418));
+        $this->assertEquals(418, $this->client->options('http://localhost/', $options)->getStatusCode());
+    }
+
+    public function testHead(): void {
+        $this->setUpDefaultRequestOptions();
+
+        $this->guzzleClient->method('request')
+            ->with('head', 'http://localhost/', $this->defaultRequestOptions)
+            ->willReturn(new Response(418));
+        $this->assertEquals(418, $this->client->head('http://localhost/', [])->getStatusCode());
+    }
+
+    public function testHeadWithOptions(): void {
+        $this->setUpDefaultRequestOptions();
+
+        $options = array_merge($this->defaultRequestOptions, [
+            'verify' => false,
+            'proxy' => [
+                'http' => 'bar',
+                'https' => 'bar'
+            ],
+        ]);
+
+        $this->guzzleClient->method('request')
+            ->with('head', 'http://localhost/', $options)
+            ->willReturn(new Response(418));
+        $this->assertEquals(418, $this->client->head('http://localhost/', $options)->getStatusCode());
+    }
+
+    public function testSetDefaultOptionsWithNotInstalled(): void {
+        $this->config
+            ->expects($this->exactly(2))
+            ->method('getSystemValueBool')
+            ->willReturnMap([
+                ['installed', false, false],
+                ['allow_local_remote_servers', false, false],
+            ]);
+        $this->config
+            ->expects($this->once())
+            ->method('getSystemValueString')
+            ->with('proxy', '')
+            ->willReturn('');
+        $this->certificateManager
+            ->expects($this->never())
+            ->method('listCertificates');
+
+        $this->serverVersion->method('getVersionString')
+            ->willReturn('123.45.6');
+
+        $this->assertEquals([
+            'verify' => \OC::$SERVERROOT . '/resources/config/ca-bundle.crt',
+            'headers' => [
+                'User-Agent' => 'Nextcloud-Server-Crawler/123.45.6',
+                'Accept-Encoding' => 'gzip',
+            ],
+            'timeout' => 30,
+            'nextcloud' => [
+                'allow_local_address' => false,
+            ],
+            'allow_redirects' => [
+                'on_redirect' => function (
+                    \Psr\Http\Message\RequestInterface $request,
+                    \Psr\Http\Message\ResponseInterface $response,
+                    \Psr\Http\Message\UriInterface $uri,
+                ): void {
+                },
+            ],
+        ], self::invokePrivate($this->client, 'buildRequestOptions', [[]]));
+    }
+
+    public function testSetDefaultOptionsWithProxy(): void {
+        $this->config
+            ->expects($this->exactly(2))
+            ->method('getSystemValueBool')
+            ->willReturnMap([
+                ['installed', false, true],
+                ['allow_local_remote_servers', false, false],
+            ]);
+        $this->config
+            ->expects($this->once())
+            ->method('getSystemValue')
+            ->with('proxyexclude', [])
+            ->willReturn([]);
+        $this->config
+            ->expects($this->exactly(2))
+            ->method('getSystemValueString')
+            ->willReturnMap([
+                ['proxy', '', 'foo'],
+                ['proxyuserpwd', '', ''],
+            ]);
+        $this->certificateManager
+            ->expects($this->once())
+            ->method('getAbsoluteBundlePath')
+            ->with()
+            ->willReturn('/my/path.crt');
+
+        $this->serverVersion->method('getVersionString')
+            ->willReturn('123.45.6');
+
+        $this->assertEquals([
+            'verify' => '/my/path.crt',
+            'proxy' => [
+                'http' => 'foo',
+                'https' => 'foo'
+            ],
+            'headers' => [
+                'User-Agent' => 'Nextcloud-Server-Crawler/123.45.6',
+                'Accept-Encoding' => 'gzip',
+            ],
+            'timeout' => 30,
+            'nextcloud' => [
+                'allow_local_address' => false,
+            ],
+            'allow_redirects' => [
+                'on_redirect' => function (
+                    \Psr\Http\Message\RequestInterface $request,
+                    \Psr\Http\Message\ResponseInterface $response,
+                    \Psr\Http\Message\UriInterface $uri,
+                ): void {
+                },
+            ],
+        ], self::invokePrivate($this->client, 'buildRequestOptions', [[]]));
+    }
+
+    public function testSetDefaultOptionsWithProxyAndExclude(): void {
+        $this->config
+            ->expects($this->exactly(2))
+            ->method('getSystemValueBool')
+            ->willReturnMap([
+                ['installed', false, true],
+                ['allow_local_remote_servers', false, false],
+            ]);
+        $this->config
+            ->expects($this->once())
+            ->method('getSystemValue')
+            ->with('proxyexclude', [])
+            ->willReturn(['bar']);
+        $this->config
+            ->expects($this->exactly(2))
+            ->method('getSystemValueString')
+            ->willReturnMap([
+                ['proxy', '', 'foo'],
+                ['proxyuserpwd', '', ''],
+            ]);
+        $this->certificateManager
+            ->expects($this->once())
+            ->method('getAbsoluteBundlePath')
+            ->with()
+            ->willReturn('/my/path.crt');
+
+        $this->serverVersion->method('getVersionString')
+            ->willReturn('123.45.6');
+
+        $this->assertEquals([
+            'verify' => '/my/path.crt',
+            'proxy' => [
+                'http' => 'foo',
+                'https' => 'foo',
+                'no' => ['bar']
+            ],
+            'headers' => [
+                'User-Agent' => 'Nextcloud-Server-Crawler/123.45.6',
+                'Accept-Encoding' => 'gzip',
+            ],
+            'timeout' => 30,
+            'nextcloud' => [
+                'allow_local_address' => false,
+            ],
+            'allow_redirects' => [
+                'on_redirect' => function (
+                    \Psr\Http\Message\RequestInterface $request,
+                    \Psr\Http\Message\ResponseInterface $response,
+                    \Psr\Http\Message\UriInterface $uri,
+                ): void {
+                },
+            ],
+        ], self::invokePrivate($this->client, 'buildRequestOptions', [[]]));
+    }
 }

Spacing +4 added lines, -4 removed lines

@@ -478,7 +478,7 @@ 
 			->willReturn('123.45.6');
 
 		$this->assertEquals([
-			'verify' => \OC::$SERVERROOT . '/resources/config/ca-bundle.crt',
+			'verify' => \OC::$SERVERROOT.'/resources/config/ca-bundle.crt',
 			'headers' => [
 				'User-Agent' => 'Nextcloud-Server-Crawler/123.45.6',
 				'Accept-Encoding' => 'gzip',
@@ -488,7 +488,7 @@ 
 				'allow_local_address' => false,
 			],
 			'allow_redirects' => [
-				'on_redirect' => function (
+				'on_redirect' => function(
 					\Psr\Http\Message\RequestInterface $request,
 					\Psr\Http\Message\ResponseInterface $response,
 					\Psr\Http\Message\UriInterface $uri,
@@ -542,7 +542,7 @@ 
 				'allow_local_address' => false,
 			],
 			'allow_redirects' => [
-				'on_redirect' => function (
+				'on_redirect' => function(
 					\Psr\Http\Message\RequestInterface $request,
 					\Psr\Http\Message\ResponseInterface $response,
 					\Psr\Http\Message\UriInterface $uri,
@@ -597,7 +597,7 @@ 
 				'allow_local_address' => false,
 			],
 			'allow_redirects' => [
-				'on_redirect' => function (
+				'on_redirect' => function(
 					\Psr\Http\Message\RequestInterface $request,
 					\Psr\Http\Message\ResponseInterface $response,
 					\Psr\Http\Message\UriInterface $uri,

tests/lib/Http/Client/ClientServiceTest.php

Indentation +95 added lines, -95 removed lines

@@ -29,106 +29,106 @@
  * Class ClientServiceTest
  */
 class ClientServiceTest extends \Test\TestCase {
-	public function testNewClient(): void {
-		/** @var IConfig $config */
-		$config = $this->createMock(IConfig::class);
-		$config->method('getSystemValueBool')
-			->with('dns_pinning', true)
-			->willReturn(true);
-		/** @var ICertificateManager $certificateManager */
-		$certificateManager = $this->createMock(ICertificateManager::class);
-		$dnsPinMiddleware = $this->createMock(DnsPinMiddleware::class);
-		$dnsPinMiddleware
-			->expects($this->atLeastOnce())
-			->method('addDnsPinning')
-			->willReturn(function (): void {
-			});
-		$remoteHostValidator = $this->createMock(IRemoteHostValidator::class);
-		$eventLogger = $this->createMock(IEventLogger::class);
-		$logger = $this->createMock(LoggerInterface::class);
-		$serverVersion = $this->createMock(ServerVersion::class);
+    public function testNewClient(): void {
+        /** @var IConfig $config */
+        $config = $this->createMock(IConfig::class);
+        $config->method('getSystemValueBool')
+            ->with('dns_pinning', true)
+            ->willReturn(true);
+        /** @var ICertificateManager $certificateManager */
+        $certificateManager = $this->createMock(ICertificateManager::class);
+        $dnsPinMiddleware = $this->createMock(DnsPinMiddleware::class);
+        $dnsPinMiddleware
+            ->expects($this->atLeastOnce())
+            ->method('addDnsPinning')
+            ->willReturn(function (): void {
+            });
+        $remoteHostValidator = $this->createMock(IRemoteHostValidator::class);
+        $eventLogger = $this->createMock(IEventLogger::class);
+        $logger = $this->createMock(LoggerInterface::class);
+        $serverVersion = $this->createMock(ServerVersion::class);
 
-		$clientService = new ClientService(
-			$config,
-			$certificateManager,
-			$dnsPinMiddleware,
-			$remoteHostValidator,
-			$eventLogger,
-			$logger,
-			$serverVersion,
-		);
+        $clientService = new ClientService(
+            $config,
+            $certificateManager,
+            $dnsPinMiddleware,
+            $remoteHostValidator,
+            $eventLogger,
+            $logger,
+            $serverVersion,
+        );
 
-		$handler = new CurlHandler();
-		$stack = HandlerStack::create($handler);
-		$stack->push($dnsPinMiddleware->addDnsPinning());
-		$stack->push(Middleware::tap(function (RequestInterface $request) use ($eventLogger): void {
-			$eventLogger->start('http:request', $request->getMethod() . ' request to ' . $request->getRequestTarget());
-		}, function () use ($eventLogger): void {
-			$eventLogger->end('http:request');
-		}), 'event logger');
-		$guzzleClient = new GuzzleClient(['handler' => $stack]);
+        $handler = new CurlHandler();
+        $stack = HandlerStack::create($handler);
+        $stack->push($dnsPinMiddleware->addDnsPinning());
+        $stack->push(Middleware::tap(function (RequestInterface $request) use ($eventLogger): void {
+            $eventLogger->start('http:request', $request->getMethod() . ' request to ' . $request->getRequestTarget());
+        }, function () use ($eventLogger): void {
+            $eventLogger->end('http:request');
+        }), 'event logger');
+        $guzzleClient = new GuzzleClient(['handler' => $stack]);
 
-		$this->assertEquals(
-			new Client(
-				$config,
-				$certificateManager,
-				$guzzleClient,
-				$remoteHostValidator,
-				$logger,
-				$serverVersion,
-			),
-			$clientService->newClient()
-		);
-	}
+        $this->assertEquals(
+            new Client(
+                $config,
+                $certificateManager,
+                $guzzleClient,
+                $remoteHostValidator,
+                $logger,
+                $serverVersion,
+            ),
+            $clientService->newClient()
+        );
+    }
 
-	public function testDisableDnsPinning(): void {
-		/** @var IConfig $config */
-		$config = $this->createMock(IConfig::class);
-		$config->method('getSystemValueBool')
-			->with('dns_pinning', true)
-			->willReturn(false);
-		/** @var ICertificateManager $certificateManager */
-		$certificateManager = $this->createMock(ICertificateManager::class);
-		$dnsPinMiddleware = $this->createMock(DnsPinMiddleware::class);
-		$dnsPinMiddleware
-			->expects($this->never())
-			->method('addDnsPinning')
-			->willReturn(function (): void {
-			});
-		$remoteHostValidator = $this->createMock(IRemoteHostValidator::class);
-		$eventLogger = $this->createMock(IEventLogger::class);
-		$logger = $this->createMock(LoggerInterface::class);
-		$serverVersion = $this->createMock(ServerVersion::class);
+    public function testDisableDnsPinning(): void {
+        /** @var IConfig $config */
+        $config = $this->createMock(IConfig::class);
+        $config->method('getSystemValueBool')
+            ->with('dns_pinning', true)
+            ->willReturn(false);
+        /** @var ICertificateManager $certificateManager */
+        $certificateManager = $this->createMock(ICertificateManager::class);
+        $dnsPinMiddleware = $this->createMock(DnsPinMiddleware::class);
+        $dnsPinMiddleware
+            ->expects($this->never())
+            ->method('addDnsPinning')
+            ->willReturn(function (): void {
+            });
+        $remoteHostValidator = $this->createMock(IRemoteHostValidator::class);
+        $eventLogger = $this->createMock(IEventLogger::class);
+        $logger = $this->createMock(LoggerInterface::class);
+        $serverVersion = $this->createMock(ServerVersion::class);
 
-		$clientService = new ClientService(
-			$config,
-			$certificateManager,
-			$dnsPinMiddleware,
-			$remoteHostValidator,
-			$eventLogger,
-			$logger,
-			$serverVersion,
-		);
+        $clientService = new ClientService(
+            $config,
+            $certificateManager,
+            $dnsPinMiddleware,
+            $remoteHostValidator,
+            $eventLogger,
+            $logger,
+            $serverVersion,
+        );
 
-		$handler = new CurlHandler();
-		$stack = HandlerStack::create($handler);
-		$stack->push(Middleware::tap(function (RequestInterface $request) use ($eventLogger): void {
-			$eventLogger->start('http:request', $request->getMethod() . ' request to ' . $request->getRequestTarget());
-		}, function () use ($eventLogger): void {
-			$eventLogger->end('http:request');
-		}), 'event logger');
-		$guzzleClient = new GuzzleClient(['handler' => $stack]);
+        $handler = new CurlHandler();
+        $stack = HandlerStack::create($handler);
+        $stack->push(Middleware::tap(function (RequestInterface $request) use ($eventLogger): void {
+            $eventLogger->start('http:request', $request->getMethod() . ' request to ' . $request->getRequestTarget());
+        }, function () use ($eventLogger): void {
+            $eventLogger->end('http:request');
+        }), 'event logger');
+        $guzzleClient = new GuzzleClient(['handler' => $stack]);
 
-		$this->assertEquals(
-			new Client(
-				$config,
-				$certificateManager,
-				$guzzleClient,
-				$remoteHostValidator,
-				$logger,
-				$serverVersion,
-			),
-			$clientService->newClient()
-		);
-	}
+        $this->assertEquals(
+            new Client(
+                $config,
+                $certificateManager,
+                $guzzleClient,
+                $remoteHostValidator,
+                $logger,
+                $serverVersion,
+            ),
+            $clientService->newClient()
+        );
+    }
 }