ILIAS\Cache\CacheTest Class Reference

Inheritance diagram for ILIAS\Cache\CacheTest:

Collaboration diagram for ILIAS\Cache\CacheTest:

Public Member Functions
	testActivatedComponents ()
	testMultipleContainers ()
	testLock ()
	testInvalidLockTimes (float|int $time)
	getInvalidLockTimes More...
	testDelete ()
	testDefaultAdaptor ()
	testFlush ()
	testAPCAdapter ()
	testObjectStorage ()
	testTypes ()
	testIncomatibleType ()
	testIncomatibleNestedType ()
	testIncomatibleTypeNested ()

Static Public Member Functions
static	getInvalidLockTimes ()

Data Fields
const	TEST_CONTAINER = 'test_container'

Protected Member Functions
	setUp ()
	getConfig (string $adaptor_name=Config::PHPSTATIC)
	getDummyRequest (string $container_key)

Private Member Functions
	deactivatedTestMemcachedAdapter ()
	this test cannot be executed in the CI on github sincewe do not have a memcached server there. More...

Private Attributes
ilLanguage	$language_mock
ILIAS Refinery Factory	$refinery

Detailed Description

Author

Fabian Schmid fabia.nosp@m.n@sr.nosp@m..solu.nosp@m.tion.nosp@m.s

Definition at line 37 of file CacheTest.php.

Member Function Documentation

deactivatedTestMemcachedAdapter()

ILIAS\Cache\CacheTest::deactivatedTestMemcachedAdapter ( )

private

this test cannot be executed in the CI on github sincewe do not have a memcached server there.

I leave it here for local testing if needed.

Definition at line 301 of file CacheTest.php.

References $container, ILIAS\Cache\CacheTest\getConfig(), ILIAS\Cache\CacheTest\getDummyRequest(), and ILIAS\Cache\Config\MEMCACHED.

                                                      : void
    {
        $config = $this->getConfig(Config::MEMCACHED);
        $services = new Services($config);
        $container = $services->get($this->getDummyRequest(self::TEST_CONTAINER));
        $this->assertEquals(Config::MEMCACHED, $container->getAdaptorName());
        $this->assertEquals(self::TEST_CONTAINER, $container->getContainerName());

        $apcu = new Memcached($config);
        if (!$apcu->isAvailable()) {
            $this->markTestSkipped('Memcached is not available');
        }

        $this->assertFalse($container->has('test'));
        $container->set('test', 'test_value');
        $this->assertTrue($container->has('test'));
        $this->assertEquals('test_value', $container->get('test'));
        $container->delete('test');
        $this->assertFalse($container->has('test'));

        $container->set('test2', 'test_value2');
        $container->set('test3', 'test_value3');
        $this->assertTrue($container->has('test2'));
        $this->assertTrue($container->has('test3'));

        $container->flush();

        $this->assertFalse($container->has('test2'));
        $this->assertFalse($container->has('test3'));
    }

Here is the call graph for this function:

getConfig()

ILIAS\Cache\CacheTest::getConfig ( string  $adaptor_name = Config::PHPSTATIC )

protected

Returns

Config

Definition at line 61 of file CacheTest.php.

Referenced by ILIAS\Cache\CacheTest\deactivatedTestMemcachedAdapter(), ILIAS\Cache\CacheTest\setUp(), ILIAS\Cache\CacheTest\testAPCAdapter(), ILIAS\Cache\CacheTest\testDefaultAdaptor(), ILIAS\Cache\CacheTest\testDelete(), ILIAS\Cache\CacheTest\testFlush(), ILIAS\Cache\CacheTest\testIncomatibleNestedType(), ILIAS\Cache\CacheTest\testIncomatibleType(), ILIAS\Cache\CacheTest\testIncomatibleTypeNested(), ILIAS\Cache\CacheTest\testInvalidLockTimes(), ILIAS\Cache\CacheTest\testLock(), ILIAS\Cache\CacheTest\testObjectStorage(), and ILIAS\Cache\CacheTest\testTypes().

                                                                        : Config
    {
        return new Config(
            $adaptor_name,
            true,
            [self::TEST_CONTAINER],
            new class () extends NullNodeRepository {
                public function getNodes(): array
                {
                    return [new Node('127.0.0.1', 11211, 100)];
                }
            }
        );
    }

Here is the caller graph for this function:

getDummyRequest()

ILIAS\Cache\CacheTest::getDummyRequest ( string  $container_key )

protected

Definition at line 478 of file CacheTest.php.

Referenced by ILIAS\Cache\CacheTest\deactivatedTestMemcachedAdapter(), ILIAS\Cache\CacheTest\testAPCAdapter(), ILIAS\Cache\CacheTest\testDefaultAdaptor(), ILIAS\Cache\CacheTest\testDelete(), ILIAS\Cache\CacheTest\testFlush(), ILIAS\Cache\CacheTest\testIncomatibleNestedType(), ILIAS\Cache\CacheTest\testIncomatibleType(), ILIAS\Cache\CacheTest\testIncomatibleTypeNested(), ILIAS\Cache\CacheTest\testInvalidLockTimes(), ILIAS\Cache\CacheTest\testLock(), ILIAS\Cache\CacheTest\testMultipleContainers(), ILIAS\Cache\CacheTest\testObjectStorage(), and ILIAS\Cache\CacheTest\testTypes().

                                                             : Request
    {
        return new BaseRequest($container_key);
    }

Here is the caller graph for this function:

getInvalidLockTimes()

static ILIAS\Cache\CacheTest::getInvalidLockTimes ( )

static

Definition at line 172 of file CacheTest.php.

                                                : array
    {
        return [
            [-10],
            [-1],
            [301],
            [300.1],
        ];
    }

setUp()

ILIAS\Cache\CacheTest::setUp ( )

protected

Definition at line 46 of file CacheTest.php.

References ILIAS\Cache\CacheTest\getConfig(), ILIAS\Cache\Config\PHPSTATIC, and ILIAS\Repository\refinery().

                              : void
    {
        $this->language_mock = $this->createMock(\ilLanguage::class);
        $this->refinery = new \ILIAS\Refinery\Factory(
            new \ILIAS\Data\Factory(),
            $this->language_mock
        );
        // prevent chached values between tests
        $static_flush = new PHPStatic($this->getConfig(Config::PHPSTATIC));
        $static_flush->flush();
    }

Here is the call graph for this function:

testActivatedComponents()

ILIAS\Cache\CacheTest::testActivatedComponents

(

)

Definition at line 76 of file CacheTest.php.

References ILIAS\Cache\Config\PHPSTATIC.

                                             : void
    {
        $config = new Config(
            Config::PHPSTATIC,
            true,
            ['one', 'two']
        );

        $services = new Services($config);
        $this->assertInstanceOf(ActiveContainer::class, $services->get($this->getDummyRequest('one')));
        $this->assertInstanceOf(ActiveContainer::class, $services->get($this->getDummyRequest('two')));
        $this->assertInstanceOf(VoidContainer::class, $services->get($this->getDummyRequest('three')));

        $config = new Config(
            Config::PHPSTATIC,
            true,
            ['*']
        );
        $services = new Services($config);
        $this->assertInstanceOf(ActiveContainer::class, $services->get($this->getDummyRequest('one')));
        $this->assertInstanceOf(ActiveContainer::class, $services->get($this->getDummyRequest('two')));
        $this->assertInstanceOf(ActiveContainer::class, $services->get($this->getDummyRequest('three')));
    }

testAPCAdapter()

ILIAS\Cache\CacheTest::testAPCAdapter

(

)

Definition at line 264 of file CacheTest.php.

References $container, ILIAS\Cache\Config\APCU, ILIAS\Cache\CacheTest\getConfig(), ILIAS\Cache\CacheTest\getDummyRequest(), and ILIAS\Repository\refinery().

                                    : void
    {
        $config = $this->getConfig(Config::APCU);
        $services = new Services($config);
        $container = $services->get($this->getDummyRequest(self::TEST_CONTAINER));
        $this->assertEquals(Config::APCU, $container->getAdaptorName());
        $this->assertEquals(self::TEST_CONTAINER, $container->getContainerName());

        $apcu = new APCu($config);
        if (!$apcu->isAvailable() || !(bool) ini_get('apc.enable_cli')) {
            $this->markTestSkipped('APCu is not available or not enabled for CLI');
        }

        $to_string = $this->refinery->kindlyTo()->string();

        $this->assertFalse($container->has('test'));
        $container->set('test', 'test_value');
        $this->assertTrue($container->has('test'));
        $this->assertEquals('test_value', $container->get('test', $to_string));
        $container->delete('test');
        $this->assertFalse($container->has('test'));

        $container->set('test2', 'test_value2');
        $container->set('test3', 'test_value3');
        $this->assertTrue($container->has('test2'));
        $this->assertTrue($container->has('test3'));

        $container->flush();

        $this->assertFalse($container->has('test2'));
        $this->assertFalse($container->has('test3'));
    }

Here is the call graph for this function:

testDefaultAdaptor()

ILIAS\Cache\CacheTest::testDefaultAdaptor

(

)

Definition at line 207 of file CacheTest.php.

References $container, ILIAS\Cache\CacheTest\getConfig(), ILIAS\Cache\CacheTest\getDummyRequest(), ILIAS\Cache\Config\PHPSTATIC, and ILIAS\Repository\refinery().

                                        : void
    {
        $request = $this->getDummyRequest(self::TEST_CONTAINER);

        $to_string = $this->refinery->kindlyTo()->string();

        $config = $this->getConfig();

        $static = new PHPStatic($config);
        $this->assertTrue($static->isAvailable());

        $services = new Services($config);
        $container = $services->get($request);
        $this->assertInstanceOf(ActiveContainer::class, $container);
        $this->assertEquals(Config::PHPSTATIC, $container->getAdaptorName());
        $this->assertEquals(self::TEST_CONTAINER, $container->getContainerName());

        $this->assertFalse($container->has('test'));
        $container->set('test', 'test_value');
        $this->assertTrue($container->has('test'));
        $this->assertEquals('test_value', $container->get('test', $to_string));
        $container->delete('test');
        $this->assertFalse($container->has('test'));

        $container->set('test2', 'test_value2');
        $container->set('test3', 'test_value3');
        $this->assertTrue($container->has('test2'));
        $this->assertTrue($container->has('test3'));

        $container->flush();

        $this->assertFalse($container->has('test2'));
        $this->assertFalse($container->has('test3'));
    }

Here is the call graph for this function:

testDelete()

ILIAS\Cache\CacheTest::testDelete

(

)

Definition at line 193 of file CacheTest.php.

References $container, ILIAS\Cache\CacheTest\getConfig(), and ILIAS\Cache\CacheTest\getDummyRequest().

                                : void
    {
        $services = new Services($this->getConfig());
        $container = $services->get($this->getDummyRequest(self::TEST_CONTAINER));

        $container->set('test', 'test_value');
        $this->assertTrue($container->has('test'));
        $this->assertEquals('test_value', $container->get('test', $this->refinery->to()->string()));

        $container->delete('test');
        $this->assertFalse($container->has('test'));
        $this->assertNull($container->get('test', $this->refinery->to()->string()));
    }

Here is the call graph for this function:

testFlush()

ILIAS\Cache\CacheTest::testFlush

(

)

Definition at line 242 of file CacheTest.php.

References $container, ILIAS\Cache\CacheTest\getConfig(), and ILIAS\Cache\CacheTest\getDummyRequest().

                               : void
    {
        $services = new Services($this->getConfig());
        $container = $services->get($this->getDummyRequest(self::TEST_CONTAINER));

        $container->set('test', 'test_value');
        $this->assertTrue($container->has('test'));
        $this->assertEquals('test_value', $container->get('test', $this->refinery->to()->string()));

        $container->flush();
        $this->assertFalse($container->has('test'));
        $this->assertNull($container->get('test', $this->refinery->to()->string()));

        $container->set('test', 'test_value');
        $this->assertTrue($container->has('test'));
        $this->assertEquals('test_value', $container->get('test', $this->refinery->to()->string()));

        $services->flushAdapter();
        $this->assertFalse($container->has('test'));
        $this->assertNull($container->get('test', $this->refinery->to()->string()));
    }

Here is the call graph for this function:

testIncomatibleNestedType()

ILIAS\Cache\CacheTest::testIncomatibleNestedType

(

)

Definition at line 446 of file CacheTest.php.

References $container, ILIAS\Cache\CacheTest\getConfig(), and ILIAS\Cache\CacheTest\getDummyRequest().

                                               : void
    {
        $services = new Services($this->getConfig());
        $container = $services->get(
            $this->getDummyRequest(self::TEST_CONTAINER)
        );
        $array_with_incompatible_type_in_it = [
            'test' => 'test',
            'test2' => 'test2',
            'test3' => ['test' => new \stdClass()]
        ];
        $this->expectException(\InvalidArgumentException::class);
        $container->set(
            'array_with_incompatible_type_in_it',
            $array_with_incompatible_type_in_it
        );
    }

Here is the call graph for this function:

testIncomatibleType()

ILIAS\Cache\CacheTest::testIncomatibleType

(

)

Definition at line 435 of file CacheTest.php.

References $container, ILIAS\Cache\CacheTest\getConfig(), and ILIAS\Cache\CacheTest\getDummyRequest().

                                         : void
    {
        $services = new Services($this->getConfig());
        $container = $services->get(
            $this->getDummyRequest(self::TEST_CONTAINER)
        );

        $this->expectException(\TypeError::class);
        $container->set('test', new \stdClass());
    }

Here is the call graph for this function:

testIncomatibleTypeNested()

ILIAS\Cache\CacheTest::testIncomatibleTypeNested

(

)

Definition at line 464 of file CacheTest.php.

References $container, ILIAS\Cache\CacheTest\getConfig(), and ILIAS\Cache\CacheTest\getDummyRequest().

                                               : void
    {
        $services = new Services($this->getConfig());
        $container = $services->get($this->getDummyRequest(self::TEST_CONTAINER));

        $array_with_incompatible_type_in_it = [
            'test' => 'test',
            'test2' => 'test2',
            'test3' => ['test' => new \stdClass()]
        ];
        $this->expectException(\InvalidArgumentException::class);
        $container->set('array_with_incompatible_type_in_it', $array_with_incompatible_type_in_it);
    }

Here is the call graph for this function:

testInvalidLockTimes()

ILIAS\Cache\CacheTest::testInvalidLockTimes

(

float|int

$time

)

getInvalidLockTimes

Definition at line 185 of file CacheTest.php.

References $container, ILIAS\Cache\CacheTest\getConfig(), and ILIAS\Cache\CacheTest\getDummyRequest().

                                                         : void
    {
        $services = new Services($this->getConfig());
        $container = $services->get($this->getDummyRequest(self::TEST_CONTAINER));
        $this->expectException(\InvalidArgumentException::class);
        $container->lock($time);
    }

Here is the call graph for this function:

testLock()

ILIAS\Cache\CacheTest::testLock

(

)

Definition at line 139 of file CacheTest.php.

References $container, ILIAS\Cache\CacheTest\getConfig(), and ILIAS\Cache\CacheTest\getDummyRequest().

                              : void
    {
        $services = new Services($this->getConfig());
        $container = $services->get($this->getDummyRequest(self::TEST_CONTAINER));
        $container->unlock();

        $container->set('test', 'test_value');
        $this->assertTrue($container->has('test'));
        $this->assertEquals('test_value', $container->get('test', $this->refinery->to()->string()));

        $container->lock(1 / 1000);
        $this->assertTrue($container->isLocked());
        $this->assertFalse($container->has('test'));
        $this->assertNull($container->get('test', $this->refinery->to()->string()));
        usleep(1000);
        $this->assertFalse($container->isLocked());
        $this->assertTrue($container->has('test'));
        $this->assertEquals('test_value', $container->get('test', $this->refinery->to()->string()));

        // Second Run
        $container->lock(1 / 1000);
        $this->assertTrue($container->isLocked());
        $this->assertFalse($container->has('test'));
        $this->assertNull($container->get('test', $this->refinery->to()->string()));
        usleep(100);
        $this->assertTrue($container->isLocked());
        $this->assertFalse($container->has('test'));
        $this->assertNull($container->get('test', $this->refinery->to()->string()));

        usleep(5000); // to avoid problems with the next test
        $this->assertFalse($container->isLocked());
    }

Here is the call graph for this function:

testMultipleContainers()

ILIAS\Cache\CacheTest::testMultipleContainers

(

)

Definition at line 100 of file CacheTest.php.

References ILIAS\Cache\CacheTest\getDummyRequest(), and ILIAS\Cache\Config\PHPSTATIC.

                                            : void
    {
        $config = new Config(
            Config::PHPSTATIC,
            true,
            ['one', 'two']
        );

        $services = new Services($config);

        $one = $this->getDummyRequest('one');
        $two = $this->getDummyRequest('two');
        $three = $this->getDummyRequest('three');

        $this->assertEquals('one', $one->getContainerKey());
        $this->assertEquals('two', $two->getContainerKey());
        $this->assertEquals('three', $three->getContainerKey());

        $container_one = $services->get($one);
        $container_two = $services->get($two);
        $container_three = $services->get($three);

        $this->assertInstanceOf(ActiveContainer::class, $container_one);
        $this->assertInstanceOf(ActiveContainer::class, $container_two);
        $this->assertInstanceOf(VoidContainer::class, $container_three);

        $container_one->set('test', 'test_value');
        $this->assertTrue($container_one->has('test'));
        $this->assertEquals('test_value', $container_one->get('test', $this->refinery->to()->string()));

        $container_two->set('test', 'test_value');
        $this->assertTrue($container_two->has('test'));
        $this->assertEquals('test_value', $container_two->get('test', $this->refinery->to()->string()));

        $container_three->set('test', 'test_value');
        $this->assertFalse($container_three->has('test'));
        $this->assertNull($container_three->get('test', $this->refinery->to()->string()));
    }

Here is the call graph for this function:

testObjectStorage()

ILIAS\Cache\CacheTest::testObjectStorage

(

)

Definition at line 332 of file CacheTest.php.

References $container, $data, ILIAS\Cache\CacheTest\getConfig(), ILIAS\Cache\CacheTest\getDummyRequest(), and ILIAS\Repository\refinery().

                                       : void
    {
        $services = new Services($this->getConfig());
        $container = $services->get($this->getDummyRequest(self::TEST_CONTAINER));

        $first_object = new \stdClass();
        $first_object->test = 'test';
        $container->set('first_object', serialize($first_object));

        $this->assertTrue($container->has('first_object'));

        $to_string = $this->refinery->kindlyTo()->string();

        $data = $container->get('first_object', $to_string);
        $first_object_from_cache = unserialize($data, ['allowed_classes' => [\stdClass::class]]);
        $this->assertInstanceOf(\stdClass::class, $first_object_from_cache);
        $this->assertEquals($first_object, $first_object_from_cache);
    }

Here is the call graph for this function:

testTypes()

ILIAS\Cache\CacheTest::testTypes

(

)

Definition at line 351 of file CacheTest.php.

References $container, ILIAS\Cache\CacheTest\getConfig(), ILIAS\Cache\CacheTest\getDummyRequest(), and ILIAS\Repository\refinery().

                               : void
    {
        $services = new Services($this->getConfig());
        $container = $services->get($this->getDummyRequest(self::TEST_CONTAINER));

        // TRANSFORMATION
        $to_string = $this->refinery->to()->string();
        $to_int = $this->refinery->to()->int();
        $to_array = $this->refinery->to()->listOf($to_string);
        $to_bool = $this->refinery->to()->bool();

        // STRING
        $string = 'test';
        $container->set('string', $string);
        $this->assertTrue($container->has('string'));
        $string_from_cache = $container->get('string', $to_string);
        $this->assertEquals($string, $string_from_cache);
        $this->assertEquals(null, $container->get('string', $to_int));
        $this->assertEquals(null, $container->get('string', $to_bool));
        $this->assertEquals(null, $container->get('string', $to_array));
        $this->assertIsString($string_from_cache);

        // ARRAY
        $array = ['test', 'test2', 'test3'];
        $container->set('array', $array);
        $this->assertTrue($container->has('array'));
        $array_from_cache = $container->get('array', $to_array);
        $this->assertEquals($array, $array_from_cache);
        $this->assertEquals(null, $container->get('array', $to_int));
        $this->assertEquals(null, $container->get('array', $to_bool));
        $this->assertEquals(null, $container->get('array', $to_string));
        $this->assertIsArray($array_from_cache);

        // BOOL
        $bool = true;
        $container->set('bool', $bool);
        $this->assertTrue($container->has('bool'));
        $bool_from_cache = $container->get('bool', $to_bool);
        $this->assertEquals($bool, $bool_from_cache);
        $this->assertEquals(null, $container->get('bool', $to_int));
        $this->assertEquals(null, $container->get('bool', $to_array));
        $this->assertEquals(null, $container->get('bool', $to_string));
        $this->assertIsBool($bool_from_cache);

        // ARRAY Different values
        $array_with_different_values = ['test' => true, 'test2' => 123, 'test3' => ['test' => 'test'], 'test4' => null];
        $container->set('array_with_different_values', $array_with_different_values);
        $this->assertTrue($container->has('array_with_different_values'));

        $trafo = $this->refinery->to()->dictOf(
            $this->refinery->custom()->transformation(
                function ($value) {
                    return $value;
                },
                function ($value) {
                    return $value;
                }
            )
        );

        $array_with_different_values_from_cache = $container->get('array_with_different_values', $trafo);
        $this->assertEquals($array_with_different_values, $array_with_different_values_from_cache);
        $this->assertIsArray($array_with_different_values_from_cache);
        $this->assertIsBool($array_with_different_values_from_cache['test']);
        $this->assertIsInt($array_with_different_values_from_cache['test2']);
        $this->assertIsArray($array_with_different_values_from_cache['test3']);
        $this->assertNull($array_with_different_values_from_cache['test4']);

        $this->assertEquals(null, $container->get('array_with_different_values', $to_int));
        $this->assertEquals(null, $container->get('array_with_different_values', $to_bool));
        $this->assertEquals(null, $container->get('array_with_different_values', $to_string));

        // INT
        $int = 123;
        $container->set('int', $int);
        $this->assertTrue($container->has('int'));
        $int_from_cache = $container->get('int', $to_int);
        $this->assertEquals($int, $int_from_cache);
        $this->assertEquals(null, $container->get('int', $to_string));
        $this->assertEquals(null, $container->get('int', $to_bool));
        $this->assertEquals(null, $container->get('int', $to_array));
        $this->assertIsInt($int_from_cache);
    }

Here is the call graph for this function:

Field Documentation

$language_mock

ilLanguage ILIAS\Cache\CacheTest::$language_mock

private

Definition at line 43 of file CacheTest.php.

$refinery

ILIAS Refinery Factory ILIAS\Cache\CacheTest::$refinery

private

Definition at line 44 of file CacheTest.php.

TEST_CONTAINER

const ILIAS\Cache\CacheTest::TEST_CONTAINER = 'test_container'

Definition at line 39 of file CacheTest.php.

---

The documentation for this class was generated from the following file:

• components/ILIAS/Cache/tests/CacheTest.php