BossBey File Manager

Editing: AuthTest.php

<?php
namespace authTest;
use Ably\AblyRest;
use Ably\Auth;
use Ably\Exceptions\AblyException;
use Ably\Http;
use Ably\Models\TokenDetails;
use Ably\Models\TokenParams;
use Ably\Models\TokenRequest;
use Ably\Utils\Miscellaneous;
use tests\AssertsRegularExpressions;

require_once __DIR__ . '/factories/TestApp.php';

class AuthTest extends \PHPUnit\Framework\TestCase {

use AssertsRegularExpressions;

protected static $testApp;
    protected static $defaultOptions;

public static function setUpBeforeClass(): void {
        self::$testApp = new \tests\TestApp();
        self::$defaultOptions = self::$testApp->getOptions();
    }

public static function tearDownAfterClass(): void {
        self::$testApp->release();
    }

/**
     * Init library with a key over unsecure connection
     */
    public function testAuthWithKeyInsecure() {
        $this->expectException(AblyException::class);
        $this->expectExceptionCode(40103);

$ably = new AblyRest( array_merge( self::$defaultOptions, [
            'key' => self::$testApp->getAppKeyDefault()->string,
            'tls' => false,
        ] ) );
    }

/**
     * Init library without any valid auth
     */
    public function testNoAuthParams() {
        $this->expectException(AblyException::class);
        $this->expectExceptionCode(40103);

$ably = new AblyRest( );
    }

/**
     * Init library with a token
     */
    public function testAuthWithToken() {
        $ably_for_token = new AblyRest( array_merge( self::$defaultOptions, [
            'key' => self::$testApp->getAppKeyDefault()->string,
        ] ) );
        $tokenDetails = $ably_for_token->auth->requestToken();

$this->assertNotNull($tokenDetails->token, 'Expected token id' );

$ably = new AblyRest( array_merge( self::$defaultOptions, [
            'tokenDetails' => $tokenDetails,
        ] ) );

$this->assertFalse( $ably->auth->isUsingBasicAuth(), 'Expected token auth to be used' );

$ably->stats(); // authorized request, should pass
    }

/**
     * Init library with a key, force use of token with useTokenAuth
     */
    public function testAuthWithKeyForceToken() {
        $ably = new AblyRest( [
            'key' => 'fake.key:totallyFake',
            'useTokenAuth' => true,
        ] );

$this->assertFalse( $ably->auth->isUsingBasicAuth(), 'Expected token auth to be used' );
    }

/**
     * Init library without providing a key or a token, force use of token with useTokenAuth
     */
    public function testAuthEmptyForceToken() {
        $this->expectException(AblyException::class);
        $this->expectExceptionCode(40103);

$ably = new AblyRest( [
            'useTokenAuth' => true,
        ] );
    }

/**
     * Verify than token auth works without TLS
     */
    public function testTokenWithoutTLS() {
        $ably_for_token = new AblyRest( array_merge( self::$defaultOptions, [
            'key' => self::$testApp->getAppKeyDefault()->string,
        ] ) );
        $tokenDetails = $ably_for_token->auth->requestToken();

$this->assertNotNull($tokenDetails->token, 'Expected token id' );

$ablyInsecure = new AblyRest( array_merge( self::$defaultOptions, [
            'tokenDetails' => $tokenDetails,
            'tls' => false,
        ] ) );

$this->assertFalse( $ablyInsecure->auth->isUsingBasicAuth(), 'Expected token auth to be used' );

$ablyInsecure->stats(); // authorized request, should pass
    }

/**
     * Init library with a token callback that returns a signed TokenRequest
     */
    public function testTokenRequestWithAuthCallbackReturningSignedRequest() {
        $callbackCalled = false;

$ably = new AblyRest( array_merge( self::$defaultOptions, [
            'authCallback' => function( $tokenParams ) use( &$callbackCalled ) {
                $callbackCalled = true;

return new TokenRequest( [
                    'token' => 'this_is_not_really_a_token_request',
                    'timestamp' => time()*1000,
                    'keyName' => 'fakeKeyName',
                    'mac' => 'not_really_hmac',
                ] );
            },
            'httpClass' => 'authTest\HttpMock',
        ] ) );