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)
	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
Factory	$refinery

Detailed Description

Author

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

Definition at line 39 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 63 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 473 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 174 of file CacheTest.php.

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

setUp()

ILIAS\Cache\CacheTest::setUp ( )

protected

Definition at line 48 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 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 78 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 441 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 430 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 459 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

)

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 141 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 102 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(), null, 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(
                fn($value) => $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 45 of file CacheTest.php.

$refinery

Factory ILIAS\Cache\CacheTest::$refinery

private

Definition at line 46 of file CacheTest.php.

TEST_CONTAINER

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

Definition at line 41 of file CacheTest.php.

---

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

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