We recently ran comprehensive feature tests inside a real Laravel project. Here's what SmartCache delivered:
+
+
+Laravel SmartCache → Store: 9.3ms, Retrieve: 3.5ms
+Laravel Cache → Store: 3.6ms, Retrieve: 8.5ms
+
+👉 SmartCache trades a slightly slower write for much faster reads!
+
+
📚 View Documentation
📥 Download Latest
diff --git a/examples/usage.php b/examples/usage.php
deleted file mode 100644
index cc84b48..0000000
--- a/examples/usage.php
+++ /dev/null
@@ -1,48 +0,0 @@
-whereHas('roles')
- ->get();
-});
-
-// Dependency Injection example
-class UserService
-{
- protected $cache;
-
- public function __construct(\SmartCache\Contracts\SmartCache $cache)
- {
- $this->cache = $cache;
- }
-
- public function getAllUsers()
- {
- return $this->cache->remember('all_users', 3600, function () {
- return User::with('relations')->get();
- });
- }
-}
-
-// Clearing specific keys
-SmartCache::forget('large-array');
-
-// Clearing all SmartCache managed keys
-// This is useful when you want to clear only SmartCache items without affecting other cache
-SmartCache::clear();
\ No newline at end of file
diff --git a/phpunit.xml b/phpunit.xml
new file mode 100644
index 0000000..338fabe
--- /dev/null
+++ b/phpunit.xml
@@ -0,0 +1,34 @@
+
+
+
+
+ ./tests/Unit
+
+
+ ./tests/Feature
+
+
+
+
+ ./src
+
+
+ ./src/Console
+ ./src/helpers.php
+
+
+
+
+
+
+
+
+
diff --git a/src/Providers/SmartCacheServiceProvider.php b/src/Providers/SmartCacheServiceProvider.php
index 1d95200..488a3f1 100644
--- a/src/Providers/SmartCacheServiceProvider.php
+++ b/src/Providers/SmartCacheServiceProvider.php
@@ -24,7 +24,7 @@ public function register(): void
// Register the service
$this->app->singleton(SmartCacheContract::class, function ($app) {
- $cache = $app['cache'];
+ $cacheManager = $app['cache'];
$config = $app['config'];
// Create strategies based on config
@@ -44,7 +44,7 @@ public function register(): void
);
}
- return new SmartCache($cache->store(), $config, $strategies);
+ return new SmartCache($cacheManager->store(), $cacheManager, $config, $strategies);
});
// Register alias for facade
@@ -58,7 +58,7 @@ public function boot(): void
{
// Publish config
$this->publishes([
- __DIR__ . '/../../config/smart-cache.php' => config_path('smart-cache.php'),
+ __DIR__ . '/../../config/smart-cache.php' => $this->app->configPath('smart-cache.php'),
], 'smart-cache-config');
// Register commands
diff --git a/src/SmartCache.php b/src/SmartCache.php
index 4e63105..bcdf7af 100644
--- a/src/SmartCache.php
+++ b/src/SmartCache.php
@@ -3,6 +3,7 @@
namespace SmartCache;
use Illuminate\Contracts\Cache\Repository;
+use Illuminate\Contracts\Cache\Factory as CacheManager;
use Illuminate\Contracts\Config\Repository as ConfigRepository;
use Illuminate\Support\Facades\Log;
use SmartCache\Contracts\OptimizationStrategy;
@@ -15,6 +16,11 @@ class SmartCache implements SmartCacheContract
*/
protected Repository $cache;
+ /**
+ * @var CacheManager
+ */
+ protected CacheManager $cacheManager;
+
/**
* @var ConfigRepository
*/
@@ -39,12 +45,14 @@ class SmartCache implements SmartCacheContract
* SmartCache constructor.
*
* @param Repository $cache
+ * @param CacheManager $cacheManager
* @param ConfigRepository $config
* @param array $strategies
*/
- public function __construct(Repository $cache, ConfigRepository $config, array $strategies = [])
+ public function __construct(Repository $cache, CacheManager $cacheManager, ConfigRepository $config, array $strategies = [])
{
$this->cache = $cache;
+ $this->cacheManager = $cacheManager;
$this->config = $config;
foreach ($strategies as $strategy) {
@@ -178,7 +186,11 @@ public function rememberForever(string $key, \Closure $callback): mixed
*/
public function store(string $name = null): Repository
{
- return $this->cache->store($name);
+ if ($name === null) {
+ return $this->cache;
+ }
+
+ return $this->cacheManager->store($name);
}
/**
diff --git a/src/helpers.php b/src/helpers.php
index 01771df..65c994d 100644
--- a/src/helpers.php
+++ b/src/helpers.php
@@ -18,7 +18,7 @@ function smart_cache()
$arguments = func_get_args();
if (empty($arguments)) {
- return app('smart-cache');
+ return function_exists('app') ? app('smart-cache') : \Illuminate\Container\Container::getInstance()->make('smart-cache');
}
if (is_string($arguments[0])) {
diff --git a/tests/Feature/SmartCacheIntegrationTest.php b/tests/Feature/SmartCacheIntegrationTest.php
new file mode 100644
index 0000000..1286cb1
--- /dev/null
+++ b/tests/Feature/SmartCacheIntegrationTest.php
@@ -0,0 +1,351 @@
+smartCache = $this->app->make(SmartCache::class);
+ }
+
+ public function test_full_workflow_with_compression_and_retrieval()
+ {
+ // Test the complete workflow: store large data, ensure it's compressed, retrieve it
+ $key = 'integration-compression-test';
+ $largeData = $this->createCompressibleData();
+
+ // Store the data
+ $this->assertTrue($this->smartCache->put($key, $largeData, 3600));
+
+ // Verify it's tracked as optimized
+ $managedKeys = $this->smartCache->getManagedKeys();
+ $this->assertContains($key, $managedKeys);
+
+ // Verify we can retrieve the original data
+ $retrieved = $this->smartCache->get($key);
+ $this->assertEquals($largeData, $retrieved);
+
+ // Verify the raw cache entry is compressed
+ $rawCached = Cache::get($key);
+ $this->assertIsArray($rawCached);
+ $this->assertArrayHasKey('_sc_compressed', $rawCached);
+ $this->assertTrue($rawCached['_sc_compressed']);
+
+ // Clean up
+ $this->smartCache->forget($key);
+ $this->assertFalse($this->smartCache->has($key));
+ }
+
+ public function test_full_workflow_with_chunking_and_retrieval()
+ {
+ // Disable compression for this test to ensure chunking is applied
+ $this->app['config']->set('smart-cache.strategies.compression.enabled', false);
+
+ // Create a fresh SmartCache instance with chunking only
+ $chunkingSmartCache = new \SmartCache\SmartCache(
+ $this->getCacheStore(),
+ $this->getCacheManager(),
+ $this->app['config'],
+ [new \SmartCache\Strategies\ChunkingStrategy(2048, 100)]
+ );
+
+ // Test chunking workflow
+ $key = 'integration-chunking-test';
+ $largeArray = $this->createChunkableData();
+
+ // Store the data
+ $this->assertTrue($chunkingSmartCache->put($key, $largeArray, 3600));
+
+ // Verify it's tracked as optimized
+ $managedKeys = $chunkingSmartCache->getManagedKeys();
+ $this->assertContains($key, $managedKeys);
+
+ // Verify we can retrieve the original data
+ $retrieved = $chunkingSmartCache->get($key);
+ $this->assertEquals($largeArray, $retrieved);
+
+ // Verify the raw cache entry is chunked
+ $rawCached = Cache::get($key);
+ $this->assertIsArray($rawCached);
+ $this->assertArrayHasKey('_sc_chunked', $rawCached);
+ $this->assertTrue($rawCached['_sc_chunked']);
+
+ // Verify chunk keys exist in cache
+ foreach ($rawCached['chunk_keys'] as $chunkKey) {
+ $this->assertTrue(Cache::has($chunkKey));
+ }
+
+ // Clean up
+ $chunkingSmartCache->forget($key);
+ $this->assertFalse($chunkingSmartCache->has($key));
+
+ // Verify chunk keys are also cleaned up
+ foreach ($rawCached['chunk_keys'] as $chunkKey) {
+ $this->assertFalse(Cache::has($chunkKey));
+ }
+ }
+
+ public function test_remember_method_integration()
+ {
+ $key = 'integration-remember-test';
+ $callCount = 0;
+
+ $callback = function () use (&$callCount) {
+ $callCount++;
+ return $this->createCompressibleData(); // Large data that should be compressed
+ };
+
+ // First call should execute callback and store compressed data
+ $result1 = $this->smartCache->remember($key, 3600, $callback);
+ $this->assertEquals(1, $callCount);
+
+ // Verify it's optimized
+ $managedKeys = $this->smartCache->getManagedKeys();
+ $this->assertContains($key, $managedKeys);
+
+ // Second call should retrieve from cache without executing callback
+ $result2 = $this->smartCache->remember($key, 3600, $callback);
+ $this->assertEquals(1, $callCount); // Should not increment
+ $this->assertEquals($result1, $result2);
+
+ // Clean up
+ $this->smartCache->forget($key);
+ }
+
+ public function test_remember_forever_integration()
+ {
+ $key = 'integration-remember-forever-test';
+
+ $result = $this->smartCache->rememberForever($key, function () {
+ return $this->createLargeTestData(100);
+ });
+
+ // Should be retrievable
+ $retrieved = $this->smartCache->get($key);
+ $this->assertEquals($result, $retrieved);
+
+ // Should be optimized
+ $managedKeys = $this->smartCache->getManagedKeys();
+ $this->assertContains($key, $managedKeys);
+
+ // Clean up
+ $this->smartCache->forget($key);
+ }
+
+ public function test_mixed_data_types_integration()
+ {
+ // Test storing different types of data
+ $testCases = [
+ 'string-small' => 'small string',
+ 'string-large' => $this->createCompressibleData(),
+ 'array-small' => ['key' => 'value'],
+ 'array-large' => $this->createLargeTestData(50),
+ 'array-chunked' => $this->createChunkableData(),
+ 'integer' => 42,
+ 'float' => 3.14159,
+ 'boolean' => true,
+ 'null' => null,
+ ];
+
+ // Store all test cases
+ foreach ($testCases as $key => $value) {
+ $this->assertTrue($this->smartCache->put($key, $value, 3600));
+ }
+
+ // Verify all can be retrieved correctly
+ foreach ($testCases as $key => $originalValue) {
+ $retrievedValue = $this->smartCache->get($key);
+ $this->assertEquals($originalValue, $retrievedValue, "Failed for key: $key");
+ }
+
+ // Check which ones are managed (optimized)
+ $managedKeys = $this->smartCache->getManagedKeys();
+
+ // Large string and arrays should be managed
+ $this->assertContains('string-large', $managedKeys);
+ $this->assertContains('array-large', $managedKeys);
+ $this->assertContains('array-chunked', $managedKeys);
+
+ // Small values should not be managed
+ $this->assertNotContains('string-small', $managedKeys);
+ $this->assertNotContains('array-small', $managedKeys);
+ $this->assertNotContains('integer', $managedKeys);
+
+ // Clean up
+ foreach (array_keys($testCases) as $key) {
+ $this->smartCache->forget($key);
+ }
+ }
+
+ public function test_cache_clear_integration()
+ {
+ // Store multiple optimized items
+ $keys = [];
+ for ($i = 0; $i < 5; $i++) {
+ $key = "clear-test-$i";
+ $keys[] = $key;
+ $this->smartCache->put($key, $this->createCompressibleData());
+ }
+
+ // Verify all are managed
+ $managedKeys = $this->smartCache->getManagedKeys();
+ foreach ($keys as $key) {
+ $this->assertContains($key, $managedKeys);
+ }
+
+ // Clear all
+ $this->assertTrue($this->smartCache->clear());
+
+ // Verify all are gone
+ $this->assertEmpty($this->smartCache->getManagedKeys());
+ foreach ($keys as $key) {
+ $this->assertFalse($this->smartCache->has($key));
+ }
+ }
+
+ public function test_concurrent_access_simulation()
+ {
+ // Simulate concurrent access patterns
+ $baseKey = 'concurrent-test';
+
+ // Simulate multiple "processes" storing and retrieving data
+ for ($process = 0; $process < 3; $process++) {
+ $key = "{$baseKey}-{$process}";
+ $data = $this->createLargeTestData(100 + $process * 10);
+
+ // Store
+ $this->assertTrue($this->smartCache->put($key, $data));
+
+ // Immediate retrieval
+ $retrieved = $this->smartCache->get($key);
+ $this->assertEquals($data, $retrieved);
+
+ // Verify optimization
+ $this->assertTrue($this->smartCache->has($key));
+ }
+
+ // Clean up
+ for ($process = 0; $process < 3; $process++) {
+ $key = "{$baseKey}-{$process}";
+ $this->smartCache->forget($key);
+ }
+ }
+
+ public function test_fallback_behavior_integration()
+ {
+ // This tests the fallback behavior when strategies fail
+ // Since we can't easily make strategies fail in integration tests,
+ // we'll test that the system gracefully handles edge cases
+
+ // Test with empty data
+ $this->assertTrue($this->smartCache->put('empty-string', ''));
+ $this->assertEquals('', $this->smartCache->get('empty-string'));
+
+ // Test with empty array
+ $this->assertTrue($this->smartCache->put('empty-array', []));
+ $this->assertEquals([], $this->smartCache->get('empty-array'));
+
+ // Test with very large single string (might challenge compression)
+ $veryLargeString = str_repeat('x', 1000000); // 1MB of 'x'
+ $this->assertTrue($this->smartCache->put('very-large', $veryLargeString));
+ $this->assertEquals($veryLargeString, $this->smartCache->get('very-large'));
+
+ // Clean up
+ $this->smartCache->forget('empty-string');
+ $this->smartCache->forget('empty-array');
+ $this->smartCache->forget('very-large');
+ }
+
+ public function test_cache_store_switching()
+ {
+ // Test using different cache stores
+ $defaultStore = $this->smartCache->store();
+ $arrayStore = $this->smartCache->store('array');
+
+ // Store in default store
+ $defaultStore->put('default-key', 'default-value');
+
+ // Store in array store
+ $arrayStore->put('array-key', 'array-value');
+
+ // Values should be accessible from their respective stores
+ $this->assertTrue($defaultStore->has('default-key'));
+ $this->assertTrue($arrayStore->has('array-key'));
+
+ // Verify values are correct
+ $this->assertEquals('default-value', $defaultStore->get('default-key'));
+ $this->assertEquals('array-value', $arrayStore->get('array-key'));
+
+ // Clean up
+ $defaultStore->forget('default-key');
+ $arrayStore->forget('array-key');
+ }
+
+ public function test_performance_characteristics()
+ {
+ // Simple performance test to ensure operations complete reasonably quickly
+ $startTime = microtime(true);
+
+ // Perform a series of operations
+ for ($i = 0; $i < 10; $i++) {
+ $key = "perf-test-$i";
+ $data = $this->createLargeTestData(50); // Moderate size data
+
+ $this->smartCache->put($key, $data);
+ $retrieved = $this->smartCache->get($key);
+ $this->assertEquals($data, $retrieved);
+ $this->smartCache->forget($key);
+ }
+
+ $endTime = microtime(true);
+ $duration = $endTime - $startTime;
+
+ // Should complete in reasonable time (adjust threshold as needed)
+ $this->assertLessThan(5.0, $duration, 'Performance test took too long: ' . $duration . ' seconds');
+ }
+
+ public function test_memory_usage_with_large_datasets()
+ {
+ $initialMemory = memory_get_usage();
+
+ // Store and retrieve several large datasets
+ $keys = [];
+ for ($i = 0; $i < 5; $i++) {
+ $key = "memory-test-$i";
+ $keys[] = $key;
+
+ $largeData = $this->createLargeTestData(200);
+ $this->smartCache->put($key, $largeData);
+
+ // Verify retrieval
+ $retrieved = $this->smartCache->get($key);
+ $this->assertEquals($largeData, $retrieved);
+ }
+
+ $afterStoreMemory = memory_get_usage();
+
+ // Clean up
+ foreach ($keys as $key) {
+ $this->smartCache->forget($key);
+ }
+
+ $finalMemory = memory_get_usage();
+
+ // Memory usage should be reasonable (this is more of a smoke test)
+ $memoryIncrease = $afterStoreMemory - $initialMemory;
+ $this->assertLessThan(50 * 1024 * 1024, $memoryIncrease, 'Memory usage increased too much: ' . ($memoryIncrease / 1024 / 1024) . ' MB');
+ }
+}
diff --git a/tests/TestCase.php b/tests/TestCase.php
new file mode 100644
index 0000000..fb031ee
--- /dev/null
+++ b/tests/TestCase.php
@@ -0,0 +1,198 @@
+loadPackageConfiguration();
+ }
+
+ /**
+ * Get package providers.
+ *
+ * @param \Illuminate\Foundation\Application $app
+ * @return array
+ */
+ protected function getPackageProviders($app): array
+ {
+ return [
+ SmartCacheServiceProvider::class,
+ ];
+ }
+
+ /**
+ * Define aliases.
+ *
+ * @param \Illuminate\Foundation\Application $app
+ * @return array
+ */
+ protected function getPackageAliases($app): array
+ {
+ return [
+ 'SmartCache' => \SmartCache\Facades\SmartCache::class,
+ ];
+ }
+
+ /**
+ * Define environment setup.
+ *
+ * @param \Illuminate\Foundation\Application $app
+ */
+ protected function defineEnvironment($app): void
+ {
+ // Setup the application environment
+ $app['config']->set('app.key', 'base64:' . base64_encode(random_bytes(32)));
+ $app['config']->set('app.debug', true);
+
+ // Setup cache configuration
+ $app['config']->set('cache.default', 'array');
+ $app['config']->set('cache.stores.array', [
+ 'driver' => 'array',
+ 'serialize' => false,
+ ]);
+
+ $app['config']->set('cache.stores.file', [
+ 'driver' => 'file',
+ 'path' => __DIR__ . '/storage/framework/cache',
+ ]);
+
+ // Setup SmartCache configuration
+ $app['config']->set('smart-cache', [
+ 'strategies' => [
+ 'compression' => [
+ 'enabled' => true,
+ 'level' => 6,
+ ],
+ 'chunking' => [
+ 'enabled' => true,
+ 'chunk_size' => 1000,
+ ],
+ ],
+ 'thresholds' => [
+ 'compression' => 1024, // 1KB for testing (lower than default)
+ 'chunking' => 2048, // 2KB for testing (lower than default)
+ ],
+ 'fallback' => [
+ 'enabled' => true,
+ 'log_errors' => false, // Disable logging in tests
+ ],
+ ]);
+ }
+
+ /**
+ * Load package configuration for testing.
+ */
+ protected function loadPackageConfiguration(): void
+ {
+ // This method can be overridden in individual test classes
+ // to provide specific configuration for different test scenarios
+ }
+
+ /**
+ * Get a cache manager instance for testing.
+ */
+ protected function getCacheManager(): CacheManager
+ {
+ return $this->app['cache'];
+ }
+
+ /**
+ * Get a specific cache store for testing.
+ */
+ protected function getCacheStore(string $store = null)
+ {
+ return $this->getCacheManager()->store($store);
+ }
+
+ /**
+ * Create a large test dataset for optimization testing.
+ */
+ protected function createLargeTestData(int $size = 2000): array
+ {
+ $data = [];
+ for ($i = 0; $i < $size; $i++) {
+ $data[] = [
+ 'id' => $i,
+ 'name' => 'Test Item ' . $i,
+ 'description' => str_repeat('Lorem ipsum dolor sit amet, consectetur adipiscing elit. ', 10),
+ 'metadata' => [
+ 'created_at' => now()->toISOString(),
+ 'tags' => ['tag1', 'tag2', 'tag3'],
+ 'nested' => [
+ 'level1' => [
+ 'level2' => [
+ 'data' => str_repeat('nested data ', 20)
+ ]
+ ]
+ ]
+ ]
+ ];
+ }
+
+ return $data;
+ }
+
+ /**
+ * Create test data that should trigger compression.
+ */
+ protected function createCompressibleData(): string
+ {
+ // Create repetitive string that compresses well
+ return str_repeat('This is test data that should compress well. ', 100);
+ }
+
+ /**
+ * Create test data that should trigger chunking.
+ */
+ protected function createChunkableData(): array
+ {
+ return $this->createLargeTestData(1200); // Creates much larger data to ensure chunking threshold is met
+ }
+
+ /**
+ * Assert that a value is optimized (not the original value).
+ */
+ protected function assertValueIsOptimized($original, $cached): void
+ {
+ $this->assertNotEquals($original, $cached, 'Value should be optimized and different from original');
+ }
+
+ /**
+ * Assert that a value has compression metadata.
+ */
+ protected function assertValueIsCompressed($value): void
+ {
+ $this->assertIsArray($value, 'Compressed value should be an array');
+ $this->assertArrayHasKey('_sc_compressed', $value, 'Compressed value should have compression marker');
+ $this->assertTrue($value['_sc_compressed'], 'Compression marker should be true');
+ $this->assertArrayHasKey('data', $value, 'Compressed value should have data key');
+ }
+
+ /**
+ * Assert that a value has chunking metadata.
+ */
+ protected function assertValueIsChunked($value): void
+ {
+ $this->assertIsArray($value, 'Chunked value should be an array');
+ $this->assertArrayHasKey('_sc_chunked', $value, 'Chunked value should have chunking marker');
+ $this->assertTrue($value['_sc_chunked'], 'Chunking marker should be true');
+ $this->assertArrayHasKey('chunk_keys', $value, 'Chunked value should have chunk_keys');
+ $this->assertArrayHasKey('total_items', $value, 'Chunked value should have total_items');
+ }
+}
diff --git a/tests/Unit/Console/ClearCommandTest.php b/tests/Unit/Console/ClearCommandTest.php
new file mode 100644
index 0000000..ec91da9
--- /dev/null
+++ b/tests/Unit/Console/ClearCommandTest.php
@@ -0,0 +1,177 @@
+mockSmartCache = Mockery::mock(SmartCache::class);
+ $this->command = new ClearCommand();
+
+ // Set up command tester using Symfony Console Application instead
+ $application = new \Symfony\Component\Console\Application();
+ $application->add($this->command);
+ $this->commandTester = new CommandTester($this->command);
+ }
+
+ public function test_command_has_correct_signature_and_description()
+ {
+ $this->assertEquals('smart-cache:clear', $this->command->getName());
+ $this->assertEquals('Clear all SmartCache managed items', $this->command->getDescription());
+ }
+
+ public function test_clear_command_with_no_managed_keys()
+ {
+ // Setup mock to return empty array for managed keys
+ $this->mockSmartCache->shouldReceive('getManagedKeys')
+ ->once()
+ ->andReturn([]);
+
+ // Inject the mock into the command
+ $this->command->setLaravel($this->app);
+ $this->app->instance(SmartCache::class, $this->mockSmartCache);
+
+ // Execute the command
+ $exitCode = $this->commandTester->execute([]);
+
+ // Assert success exit code
+ $this->assertEquals(0, $exitCode);
+
+ // Assert correct output
+ $output = $this->commandTester->getDisplay();
+ $this->assertStringContainsString('No SmartCache managed items found.', $output);
+ }
+
+ public function test_clear_command_with_managed_keys_success()
+ {
+ $managedKeys = ['key1', 'key2', 'key3'];
+
+ // Setup mock expectations
+ $this->mockSmartCache->shouldReceive('getManagedKeys')
+ ->once()
+ ->andReturn($managedKeys);
+
+ $this->mockSmartCache->shouldReceive('clear')
+ ->once()
+ ->andReturn(true);
+
+ // Inject the mock into the command
+ $this->command->setLaravel($this->app);
+ $this->app->instance(SmartCache::class, $this->mockSmartCache);
+
+ // Execute the command
+ $exitCode = $this->commandTester->execute([]);
+
+ // Assert success exit code
+ $this->assertEquals(0, $exitCode);
+
+ // Assert correct output
+ $output = $this->commandTester->getDisplay();
+ $this->assertStringContainsString('Clearing 3 SmartCache managed items...', $output);
+ $this->assertStringContainsString('All SmartCache items have been cleared successfully.', $output);
+ }
+
+ public function test_clear_command_with_managed_keys_failure()
+ {
+ $managedKeys = ['key1', 'key2'];
+
+ // Setup mock expectations
+ $this->mockSmartCache->shouldReceive('getManagedKeys')
+ ->once()
+ ->andReturn($managedKeys);
+
+ $this->mockSmartCache->shouldReceive('clear')
+ ->once()
+ ->andReturn(false);
+
+ // Inject the mock into the command
+ $this->command->setLaravel($this->app);
+ $this->app->instance(SmartCache::class, $this->mockSmartCache);
+
+ // Execute the command
+ $exitCode = $this->commandTester->execute([]);
+
+ // Assert error exit code
+ $this->assertEquals(1, $exitCode);
+
+ // Assert correct output
+ $output = $this->commandTester->getDisplay();
+ $this->assertStringContainsString('Clearing 2 SmartCache managed items...', $output);
+ $this->assertStringContainsString('Some SmartCache items could not be cleared.', $output);
+ }
+
+ public function test_clear_command_with_single_managed_key()
+ {
+ $managedKeys = ['single-key'];
+
+ // Setup mock expectations
+ $this->mockSmartCache->shouldReceive('getManagedKeys')
+ ->once()
+ ->andReturn($managedKeys);
+
+ $this->mockSmartCache->shouldReceive('clear')
+ ->once()
+ ->andReturn(true);
+
+ // Inject the mock into the command
+ $this->command->setLaravel($this->app);
+ $this->app->instance(SmartCache::class, $this->mockSmartCache);
+
+ // Execute the command
+ $exitCode = $this->commandTester->execute([]);
+
+ // Assert success exit code
+ $this->assertEquals(0, $exitCode);
+
+ // Assert correct output
+ $output = $this->commandTester->getDisplay();
+ $this->assertStringContainsString('Clearing 1 SmartCache managed items...', $output);
+ $this->assertStringContainsString('All SmartCache items have been cleared successfully.', $output);
+ }
+
+ public function test_clear_command_integration_with_real_smart_cache()
+ {
+ // Use real SmartCache instance from service container
+ $smartCache = $this->app->make(\SmartCache\Contracts\SmartCache::class);
+
+ // Add some test data
+ $smartCache->put('test-key-1', $this->createCompressibleData());
+ $smartCache->put('test-key-2', $this->createLargeTestData(50));
+
+ // Verify keys are managed
+ $managedKeys = $smartCache->getManagedKeys();
+ $this->assertNotEmpty($managedKeys);
+
+ // Create command with Laravel application set
+ $command = new ClearCommand();
+ $command->setLaravel($this->app);
+
+ $commandTester = new CommandTester($command);
+ $exitCode = $commandTester->execute([]);
+
+ // Assert success
+ $this->assertEquals(0, $exitCode);
+
+ // Verify keys are cleared
+ $this->assertEmpty($smartCache->getManagedKeys());
+ }
+
+ protected function tearDown(): void
+ {
+ Mockery::close();
+ parent::tearDown();
+ }
+}
diff --git a/tests/Unit/Console/StatusCommandTest.php b/tests/Unit/Console/StatusCommandTest.php
new file mode 100644
index 0000000..6e3c14c
--- /dev/null
+++ b/tests/Unit/Console/StatusCommandTest.php
@@ -0,0 +1,318 @@
+mockSmartCache = Mockery::mock(SmartCache::class);
+ $this->mockConfig = Mockery::mock(ConfigRepository::class);
+ $this->command = new StatusCommand();
+
+ // Set up command tester using Symfony Console Application instead
+ $application = new Application();
+ $application->add($this->command);
+ $this->commandTester = new CommandTester($this->command);
+ }
+
+ public function test_command_has_correct_signature_and_description()
+ {
+ $this->assertEquals('smart-cache:status', $this->command->getName());
+ $this->assertEquals('Display information about SmartCache usage and configuration', $this->command->getDescription());
+ }
+
+ public function test_status_command_with_no_managed_keys()
+ {
+ // Setup mocks
+ $this->mockSmartCache->shouldReceive('getManagedKeys')
+ ->once()
+ ->andReturn([]);
+
+ $this->mockConfig->shouldReceive('get')
+ ->with('smart-cache')
+ ->once()
+ ->andReturn($this->getDefaultSmartCacheConfig());
+
+ // Inject mocks
+ $this->command->setLaravel($this->app);
+ $this->app->instance(SmartCache::class, $this->mockSmartCache);
+ $this->app->instance(ConfigRepository::class, $this->mockConfig);
+
+ // Execute the command
+ $exitCode = $this->commandTester->execute([]);
+
+ // Assert success exit code
+ $this->assertEquals(0, $exitCode);
+
+ // Assert correct output
+ $output = $this->commandTester->getDisplay();
+ $this->assertStringContainsString('SmartCache Status', $output);
+ $this->assertStringContainsString('Managed Keys: 0', $output);
+ $this->assertStringContainsString('Cache Driver:', $output);
+ $this->assertStringContainsString('Compression: Enabled', $output);
+ $this->assertStringContainsString('Chunking: Enabled', $output);
+ }
+
+ public function test_status_command_with_managed_keys()
+ {
+ $managedKeys = ['key1', 'key2', 'key3', 'key4', 'key5', 'key6', 'key7'];
+
+ // Setup mocks
+ $this->mockSmartCache->shouldReceive('getManagedKeys')
+ ->once()
+ ->andReturn($managedKeys);
+
+ $this->mockConfig->shouldReceive('get')
+ ->with('smart-cache')
+ ->once()
+ ->andReturn($this->getDefaultSmartCacheConfig());
+
+ // Inject mocks
+ $this->command->setLaravel($this->app);
+ $this->app->instance(SmartCache::class, $this->mockSmartCache);
+ $this->app->instance(ConfigRepository::class, $this->mockConfig);
+
+ // Execute the command
+ $exitCode = $this->commandTester->execute([]);
+
+ // Assert success exit code
+ $this->assertEquals(0, $exitCode);
+
+ // Assert correct output
+ $output = $this->commandTester->getDisplay();
+ $this->assertStringContainsString('Managed Keys: 7', $output);
+ $this->assertStringContainsString('Examples:', $output);
+ $this->assertStringContainsString('key1', $output);
+ $this->assertStringContainsString('key2', $output);
+ $this->assertStringContainsString('key3', $output);
+ $this->assertStringContainsString('key4', $output);
+ $this->assertStringContainsString('key5', $output);
+ $this->assertStringContainsString('and 2 more', $output);
+ }
+
+ public function test_status_command_with_few_managed_keys()
+ {
+ $managedKeys = ['key1', 'key2', 'key3'];
+
+ // Setup mocks
+ $this->mockSmartCache->shouldReceive('getManagedKeys')
+ ->once()
+ ->andReturn($managedKeys);
+
+ $this->mockConfig->shouldReceive('get')
+ ->with('smart-cache')
+ ->once()
+ ->andReturn($this->getDefaultSmartCacheConfig());
+
+ // Inject mocks
+ $this->command->setLaravel($this->app);
+ $this->app->instance(SmartCache::class, $this->mockSmartCache);
+ $this->app->instance(ConfigRepository::class, $this->mockConfig);
+
+ // Execute the command
+ $exitCode = $this->commandTester->execute([]);
+
+ // Assert success exit code
+ $this->assertEquals(0, $exitCode);
+
+ // Assert correct output
+ $output = $this->commandTester->getDisplay();
+ $this->assertStringContainsString('Managed Keys: 3', $output);
+ $this->assertStringContainsString('Examples:', $output);
+ $this->assertStringContainsString('key1', $output);
+ $this->assertStringContainsString('key2', $output);
+ $this->assertStringContainsString('key3', $output);
+ $this->assertStringNotContainsString('and', $output); // No "and X more" message
+ }
+
+ public function test_status_command_displays_configuration_correctly()
+ {
+ $customConfig = [
+ 'strategies' => [
+ 'compression' => [
+ 'enabled' => false,
+ 'level' => 9
+ ],
+ 'chunking' => [
+ 'enabled' => true,
+ 'chunk_size' => 1000
+ ]
+ ],
+ 'thresholds' => [
+ 'compression' => 2048, // 2KB
+ 'chunking' => 4096 // 4KB
+ ]
+ ];
+
+ // Setup mocks
+ $this->mockSmartCache->shouldReceive('getManagedKeys')
+ ->once()
+ ->andReturn([]);
+
+ $this->mockConfig->shouldReceive('get')
+ ->with('smart-cache')
+ ->once()
+ ->andReturn($customConfig);
+
+ // Inject mocks
+ $this->command->setLaravel($this->app);
+ $this->app->instance(SmartCache::class, $this->mockSmartCache);
+ $this->app->instance(ConfigRepository::class, $this->mockConfig);
+
+ // Execute the command
+ $exitCode = $this->commandTester->execute([]);
+
+ // Assert success exit code
+ $this->assertEquals(0, $exitCode);
+
+ // Assert correct output
+ $output = $this->commandTester->getDisplay();
+ $this->assertStringContainsString('Compression: Disabled', $output);
+ $this->assertStringContainsString('Threshold: 2.00 KB', $output);
+ $this->assertStringContainsString('Level: 9', $output);
+ $this->assertStringContainsString('Chunking: Enabled', $output);
+ $this->assertStringContainsString('Threshold: 4.00 KB', $output);
+ }
+
+ public function test_status_command_displays_cache_driver()
+ {
+ // Setup mocks
+ $this->mockSmartCache->shouldReceive('getManagedKeys')
+ ->once()
+ ->andReturn([]);
+
+ $this->mockConfig->shouldReceive('get')
+ ->with('smart-cache')
+ ->once()
+ ->andReturn($this->getDefaultSmartCacheConfig());
+
+ // Inject mocks
+ $this->command->setLaravel($this->app);
+ $this->app->instance(SmartCache::class, $this->mockSmartCache);
+ $this->app->instance(ConfigRepository::class, $this->mockConfig);
+
+ // Execute the command
+ $exitCode = $this->commandTester->execute([]);
+
+ // Assert success exit code
+ $this->assertEquals(0, $exitCode);
+
+ // Assert correct output
+ $output = $this->commandTester->getDisplay();
+ $this->assertStringContainsString('Cache Driver: array', $output); // Default test driver
+ }
+
+ public function test_status_command_integration_with_real_dependencies()
+ {
+ // Use real dependencies from service container
+ $smartCache = $this->app->make(\SmartCache\Contracts\SmartCache::class);
+
+ // Add some test data
+ $smartCache->put('integration-test-key', $this->createCompressibleData());
+
+ // Create command with Laravel application set
+ $command = new StatusCommand();
+ $command->setLaravel($this->app);
+
+ $commandTester = new CommandTester($command);
+ $exitCode = $commandTester->execute([]);
+
+ // Assert success
+ $this->assertEquals(0, $exitCode);
+
+ // Verify output contains expected elements
+ $output = $commandTester->getDisplay();
+ $this->assertStringContainsString('SmartCache Status', $output);
+ $this->assertStringContainsString('Managed Keys:', $output);
+ $this->assertStringContainsString('Configuration:', $output);
+
+ // Clean up
+ $smartCache->forget('integration-test-key');
+ }
+
+ public function test_status_command_handles_missing_config_gracefully()
+ {
+ // Setup mocks with minimal config
+ $this->mockSmartCache->shouldReceive('getManagedKeys')
+ ->once()
+ ->andReturn([]);
+
+ $incompleteConfig = [
+ 'strategies' => [
+ 'compression' => ['enabled' => true, 'level' => 6],
+ 'chunking' => ['enabled' => true, 'chunk_size' => 1000]
+ ],
+ 'thresholds' => [
+ 'compression' => 1024,
+ 'chunking' => 2048
+ ]
+ ];
+
+ $this->mockConfig->shouldReceive('get')
+ ->with('smart-cache')
+ ->once()
+ ->andReturn($incompleteConfig);
+
+ // Inject mocks
+ $this->command->setLaravel($this->app);
+ $this->app->instance(SmartCache::class, $this->mockSmartCache);
+ $this->app->instance(ConfigRepository::class, $this->mockConfig);
+
+ // Execute the command
+ $exitCode = $this->commandTester->execute([]);
+
+ // Should still complete successfully
+ $this->assertEquals(0, $exitCode);
+
+ // Should display available configuration
+ $output = $this->commandTester->getDisplay();
+ $this->assertStringContainsString('Configuration:', $output);
+ $this->assertStringContainsString('Compression: Enabled', $output);
+ $this->assertStringContainsString('Chunking: Enabled', $output);
+ }
+
+ /**
+ * Get default smart cache configuration for testing.
+ */
+ protected function getDefaultSmartCacheConfig(): array
+ {
+ return [
+ 'strategies' => [
+ 'compression' => [
+ 'enabled' => true,
+ 'level' => 6
+ ],
+ 'chunking' => [
+ 'enabled' => true,
+ 'chunk_size' => 1000
+ ]
+ ],
+ 'thresholds' => [
+ 'compression' => 1024,
+ 'chunking' => 2048
+ ]
+ ];
+ }
+
+ protected function tearDown(): void
+ {
+ Mockery::close();
+ parent::tearDown();
+ }
+}
diff --git a/tests/Unit/Providers/SmartCacheServiceProviderTest.php b/tests/Unit/Providers/SmartCacheServiceProviderTest.php
new file mode 100644
index 0000000..e0cb310
--- /dev/null
+++ b/tests/Unit/Providers/SmartCacheServiceProviderTest.php
@@ -0,0 +1,277 @@
+assertTrue($this->app->bound(SmartCacheContract::class));
+
+ // Should return the same instance on multiple calls
+ $instance1 = $this->app->make(SmartCacheContract::class);
+ $instance2 = $this->app->make(SmartCacheContract::class);
+
+ $this->assertSame($instance1, $instance2);
+ $this->assertInstanceOf(SmartCache::class, $instance1);
+ }
+
+ public function test_service_provider_registers_smart_cache_alias()
+ {
+ // The service should also be available via alias
+ $this->assertTrue($this->app->bound('smart-cache'));
+
+ $instanceFromContract = $this->app->make(SmartCacheContract::class);
+ $instanceFromAlias = $this->app->make('smart-cache');
+
+ $this->assertSame($instanceFromContract, $instanceFromAlias);
+ }
+
+ public function test_smart_cache_is_constructed_with_correct_dependencies()
+ {
+ $smartCache = $this->app->make(SmartCacheContract::class);
+
+ // Should be able to use basic cache operations
+ $this->assertTrue($smartCache->put('test-key', 'test-value'));
+ $this->assertEquals('test-value', $smartCache->get('test-key'));
+ $this->assertTrue($smartCache->has('test-key'));
+ $this->assertTrue($smartCache->forget('test-key'));
+ }
+
+ public function test_smart_cache_uses_compression_strategy_when_enabled()
+ {
+ // Compression is enabled in test configuration
+ $smartCache = $this->app->make(SmartCacheContract::class);
+
+ // Store a large compressible string
+ $largeData = $this->createCompressibleData();
+ $smartCache->put('compression-test', $largeData);
+
+ // Should be tracked as a managed key since it was optimized
+ $managedKeys = $smartCache->getManagedKeys();
+ $this->assertContains('compression-test', $managedKeys);
+
+ // Should be able to retrieve the original data
+ $retrieved = $smartCache->get('compression-test');
+ $this->assertEquals($largeData, $retrieved);
+ }
+
+ public function test_smart_cache_uses_chunking_strategy_when_enabled()
+ {
+ // Chunking is enabled in test configuration
+ $smartCache = $this->app->make(SmartCacheContract::class);
+
+ // Store a large array that should trigger chunking
+ $largeArray = $this->createChunkableData();
+ $smartCache->put('chunking-test', $largeArray);
+
+ // Should be tracked as a managed key since it was optimized
+ $managedKeys = $smartCache->getManagedKeys();
+ $this->assertContains('chunking-test', $managedKeys);
+
+ // Should be able to retrieve the original data
+ $retrieved = $smartCache->get('chunking-test');
+ $this->assertEquals($largeArray, $retrieved);
+ }
+
+ public function test_service_provider_respects_compression_configuration()
+ {
+ // Test with compression disabled
+ $this->app['config']->set('smart-cache.strategies.compression.enabled', false);
+
+ // Re-register the service provider to pick up new config
+ $provider = new SmartCacheServiceProvider($this->app);
+ $provider->register();
+
+ $smartCache = $this->app->make(SmartCacheContract::class);
+
+ // Store compressible data - should not be optimized
+ $largeData = $this->createCompressibleData();
+ $smartCache->put('no-compression-test', $largeData);
+
+ // Should not be tracked since compression is disabled
+ $managedKeys = $smartCache->getManagedKeys();
+ $this->assertNotContains('no-compression-test', $managedKeys);
+ }
+
+ public function test_service_provider_respects_chunking_configuration()
+ {
+ // Test with both compression and chunking disabled
+ $this->app['config']->set('smart-cache.strategies.compression.enabled', false);
+ $this->app['config']->set('smart-cache.strategies.chunking.enabled', false);
+
+ // Re-register the service provider to pick up new config
+ $provider = new SmartCacheServiceProvider($this->app);
+ $provider->register();
+
+ $smartCache = $this->app->make(SmartCacheContract::class);
+
+ // Store chunkable data - should not be optimized since both strategies are disabled
+ $largeArray = $this->createChunkableData();
+ $smartCache->put('no-chunking-test', $largeArray);
+
+ // Should not be tracked since both strategies are disabled
+ $managedKeys = $smartCache->getManagedKeys();
+ $this->assertNotContains('no-chunking-test', $managedKeys);
+ }
+
+ public function test_service_provider_uses_custom_compression_settings()
+ {
+ // Set custom compression settings
+ $this->app['config']->set('smart-cache.thresholds.compression', 500); // 500 bytes
+ $this->app['config']->set('smart-cache.strategies.compression.level', 9); // Max compression
+
+ // Re-register the service provider
+ $provider = new SmartCacheServiceProvider($this->app);
+ $provider->register();
+
+ $smartCache = $this->app->make(SmartCacheContract::class);
+
+ // Store data that exceeds the lower threshold
+ $mediumData = str_repeat('test ', 150); // ~750 bytes
+ $smartCache->put('custom-compression-test', $mediumData);
+
+ // Should be optimized with the lower threshold
+ $managedKeys = $smartCache->getManagedKeys();
+ $this->assertContains('custom-compression-test', $managedKeys);
+
+ // Should still retrieve original data
+ $retrieved = $smartCache->get('custom-compression-test');
+ $this->assertEquals($mediumData, $retrieved);
+ }
+
+ public function test_service_provider_uses_custom_chunking_settings()
+ {
+ // Set custom chunking settings
+ $this->app['config']->set('smart-cache.thresholds.chunking', 1024); // 1KB
+ $this->app['config']->set('smart-cache.strategies.chunking.chunk_size', 50); // 50 items per chunk
+
+ // Re-register the service provider
+ $provider = new SmartCacheServiceProvider($this->app);
+ $provider->register();
+
+ $smartCache = $this->app->make(SmartCacheContract::class);
+
+ // Store array that should trigger chunking with custom settings
+ $testArray = $this->createLargeTestData(100); // 100 items, should be chunked
+ $smartCache->put('custom-chunking-test', $testArray);
+
+ // Should be optimized
+ $managedKeys = $smartCache->getManagedKeys();
+ $this->assertContains('custom-chunking-test', $managedKeys);
+
+ // Should retrieve original data
+ $retrieved = $smartCache->get('custom-chunking-test');
+ $this->assertEquals($testArray, $retrieved);
+ }
+
+ public function test_service_provider_registers_console_commands_in_console_environment()
+ {
+ // Simulate console environment
+ $this->app['env'] = 'testing'; // This should trigger console registration
+
+ // Get all registered commands
+ $registeredCommands = [];
+
+ // Mock the commands method to capture registered commands
+ $originalProvider = new SmartCacheServiceProvider($this->app);
+
+ // Check that commands are available in artisan
+ $artisan = $this->app['Illuminate\Contracts\Console\Kernel'];
+
+ // The commands should be registered and available
+ $clearCommand = $this->app->make(ClearCommand::class);
+ $statusCommand = $this->app->make(StatusCommand::class);
+
+ $this->assertInstanceOf(ClearCommand::class, $clearCommand);
+ $this->assertInstanceOf(StatusCommand::class, $statusCommand);
+
+ // Verify command signatures
+ $this->assertEquals('smart-cache:clear', $clearCommand->getName());
+ $this->assertEquals('smart-cache:status', $statusCommand->getName());
+ }
+
+ public function test_service_provider_merges_configuration()
+ {
+ // The service provider should merge the package configuration
+ $config = $this->app['config']->get('smart-cache');
+
+ $this->assertIsArray($config);
+ $this->assertArrayHasKey('strategies', $config);
+ $this->assertArrayHasKey('thresholds', $config);
+ $this->assertArrayHasKey('compression', $config['strategies']);
+ $this->assertArrayHasKey('chunking', $config['strategies']);
+ }
+
+ public function test_service_provider_config_publishing()
+ {
+ $provider = new SmartCacheServiceProvider($this->app);
+
+ // Boot the provider to register publishable assets
+ $provider->boot();
+
+ // In a minimal test environment, we can't test the exact publishing mechanism
+ // but we can verify the provider boots without error and that configuration is available
+ $config = $this->app['config']->get('smart-cache');
+ $this->assertNotEmpty($config);
+
+ // This test mainly ensures the boot method works correctly
+ $this->assertTrue(true);
+ }
+
+ public function test_multiple_smart_cache_instances_are_same_singleton()
+ {
+ $instance1 = $this->app->make(SmartCacheContract::class);
+ $instance2 = app(SmartCacheContract::class);
+ $instance3 = resolve(SmartCacheContract::class);
+
+ $this->assertSame($instance1, $instance2);
+ $this->assertSame($instance2, $instance3);
+ }
+
+ public function test_smart_cache_integrates_with_laravel_cache_manager()
+ {
+ $smartCache = $this->app->make(SmartCacheContract::class);
+
+ // Should be able to access different cache stores
+ $defaultStore = $smartCache->store();
+ $arrayStore = $smartCache->store('array');
+
+ $this->assertNotNull($defaultStore);
+ $this->assertNotNull($arrayStore);
+
+ // Both should be usable for caching
+ $defaultStore->put('default-test', 'value');
+ $arrayStore->put('array-test', 'value');
+
+ $this->assertTrue($defaultStore->has('default-test'));
+ $this->assertTrue($arrayStore->has('array-test'));
+ }
+
+ public function test_service_provider_handles_missing_strategies_gracefully()
+ {
+ // Remove all strategies from config
+ $this->app['config']->set('smart-cache.strategies', []);
+
+ // Re-register the service provider
+ $provider = new SmartCacheServiceProvider($this->app);
+ $provider->register();
+
+ $smartCache = $this->app->make(SmartCacheContract::class);
+
+ // Should still work, just without optimizations
+ $this->assertTrue($smartCache->put('test-key', 'test-value'));
+ $this->assertEquals('test-value', $smartCache->get('test-key'));
+
+ // No strategies means no managed keys
+ $this->assertEmpty($smartCache->getManagedKeys());
+ }
+}
diff --git a/tests/Unit/SmartCacheTest.php b/tests/Unit/SmartCacheTest.php
new file mode 100644
index 0000000..6d6aab6
--- /dev/null
+++ b/tests/Unit/SmartCacheTest.php
@@ -0,0 +1,347 @@
+smartCache = $this->app->make(\SmartCache\Contracts\SmartCache::class);
+ }
+
+ public function test_can_store_and_retrieve_simple_value()
+ {
+ $key = 'test-key';
+ $value = 'Simple test value';
+
+ $this->assertTrue($this->smartCache->put($key, $value));
+ $this->assertEquals($value, $this->smartCache->get($key));
+ $this->assertTrue($this->smartCache->has($key));
+ }
+
+ public function test_can_store_and_retrieve_array_value()
+ {
+ $key = 'test-array';
+ $value = ['name' => 'John', 'age' => 30, 'city' => 'New York'];
+
+ $this->assertTrue($this->smartCache->put($key, $value));
+ $this->assertEquals($value, $this->smartCache->get($key));
+ }
+
+ public function test_get_returns_default_when_key_not_exists()
+ {
+ $default = 'default-value';
+ $this->assertEquals($default, $this->smartCache->get('non-existent-key', $default));
+ }
+
+ public function test_can_use_remember_method()
+ {
+ $key = 'remember-key';
+ $expectedValue = 'remembered-value';
+
+ $result = $this->smartCache->remember($key, 3600, function () use ($expectedValue) {
+ return $expectedValue;
+ });
+
+ $this->assertEquals($expectedValue, $result);
+ $this->assertEquals($expectedValue, $this->smartCache->get($key));
+ }
+
+ public function test_remember_returns_cached_value_on_subsequent_calls()
+ {
+ $key = 'remember-cached-key';
+ $callCount = 0;
+
+ $callback = function () use (&$callCount) {
+ $callCount++;
+ return 'value-' . $callCount;
+ };
+
+ // First call should execute callback
+ $result1 = $this->smartCache->remember($key, 3600, $callback);
+ $this->assertEquals('value-1', $result1);
+ $this->assertEquals(1, $callCount);
+
+ // Second call should return cached value without executing callback
+ $result2 = $this->smartCache->remember($key, 3600, $callback);
+ $this->assertEquals('value-1', $result2);
+ $this->assertEquals(1, $callCount); // Count shouldn't increase
+ }
+
+ public function test_can_use_remember_forever_method()
+ {
+ $key = 'remember-forever-key';
+ $expectedValue = 'forever-value';
+
+ $result = $this->smartCache->rememberForever($key, function () use ($expectedValue) {
+ return $expectedValue;
+ });
+
+ $this->assertEquals($expectedValue, $result);
+ $this->assertEquals($expectedValue, $this->smartCache->get($key));
+ }
+
+ public function test_can_store_value_forever()
+ {
+ $key = 'forever-key';
+ $value = 'forever-value';
+
+ $this->assertTrue($this->smartCache->forever($key, $value));
+ $this->assertEquals($value, $this->smartCache->get($key));
+ }
+
+ public function test_can_forget_value()
+ {
+ $key = 'forget-key';
+ $value = 'forget-value';
+
+ $this->smartCache->put($key, $value);
+ $this->assertTrue($this->smartCache->has($key));
+
+ $this->assertTrue($this->smartCache->forget($key));
+ $this->assertFalse($this->smartCache->has($key));
+ $this->assertNull($this->smartCache->get($key));
+ }
+
+ public function test_compression_strategy_is_applied_to_large_string()
+ {
+ // Create a fresh SmartCache instance with only compression strategy
+ $smartCache = new SmartCache(
+ $this->getCacheStore(),
+ $this->getCacheManager(),
+ $this->app['config'],
+ [new CompressionStrategy(1024, 6)] // 1KB threshold, level 6
+ );
+
+ $key = 'large-string-key';
+ $value = $this->createCompressibleData(); // Creates string > 1KB
+
+ $smartCache->put($key, $value);
+
+ // Get the raw cached value to check if it's compressed
+ $cached = $this->getCacheStore()->get($key);
+ $this->assertValueIsCompressed($cached);
+
+ // Verify we can still retrieve the original value
+ $retrieved = $smartCache->get($key);
+ $this->assertEquals($value, $retrieved);
+ }
+
+ public function test_compression_strategy_is_applied_to_large_array()
+ {
+ // Create a fresh SmartCache instance with only compression strategy
+ $smartCache = new SmartCache(
+ $this->getCacheStore(),
+ $this->getCacheManager(),
+ $this->app['config'],
+ [new CompressionStrategy(1024, 6)] // 1KB threshold, level 6
+ );
+
+ $key = 'large-array-key';
+ $value = $this->createLargeTestData(50); // Creates array that should exceed threshold
+
+ $smartCache->put($key, $value);
+
+ // Get the raw cached value to check if it's compressed
+ $cached = $this->getCacheStore()->get($key);
+ $this->assertValueIsCompressed($cached);
+
+ // Verify we can still retrieve the original value
+ $retrieved = $smartCache->get($key);
+ $this->assertEquals($value, $retrieved);
+ }
+
+ public function test_chunking_strategy_is_applied_to_very_large_array()
+ {
+ // Disable compression for this test to ensure chunking is applied
+ $this->app['config']->set('smart-cache.strategies.compression.enabled', false);
+
+ // Create a fresh SmartCache instance with the new configuration
+ $smartCache = new SmartCache(
+ $this->getCacheStore(),
+ $this->getCacheManager(),
+ $this->app['config'],
+ [new ChunkingStrategy(2048, 100)]
+ );
+
+ $key = 'chunked-array-key';
+ $value = $this->createChunkableData(); // Creates array that should trigger chunking
+
+ $smartCache->put($key, $value);
+
+ // Get the raw cached value to check if it's chunked
+ $cached = $this->getCacheStore()->get($key);
+ $this->assertValueIsChunked($cached);
+
+ // Verify we can still retrieve the original value
+ $retrieved = $smartCache->get($key);
+ $this->assertEquals($value, $retrieved);
+ }
+
+ public function test_small_values_are_not_optimized()
+ {
+ $key = 'small-value-key';
+ $value = 'small value';
+
+ $this->smartCache->put($key, $value);
+
+ // Get the raw cached value - should not be optimized
+ $cached = $this->getCacheStore()->get($key);
+ $this->assertEquals($value, $cached);
+ }
+
+ public function test_can_clear_all_managed_keys()
+ {
+ // Store multiple values that will be optimized (use large data)
+ $keys = ['key1', 'key2', 'key3'];
+ $largeValue = $this->createCompressibleData(); // Use compressible data to ensure optimization
+
+ foreach ($keys as $key) {
+ $this->smartCache->put($key, $largeValue);
+ }
+
+ // Verify all are stored
+ foreach ($keys as $key) {
+ $this->assertTrue($this->smartCache->has($key));
+ }
+
+ // Clear all
+ $this->assertTrue($this->smartCache->clear());
+
+ // Verify all are removed
+ foreach ($keys as $key) {
+ $this->assertFalse($this->smartCache->has($key));
+ }
+ }
+
+ public function test_managed_keys_tracking()
+ {
+ $key1 = 'tracked-key-1';
+ $key2 = 'tracked-key-2';
+
+ // Store a large value that triggers optimization
+ $largeValue = $this->createCompressibleData();
+ $this->smartCache->put($key1, $largeValue);
+
+ // Store a small value that doesn't trigger optimization
+ $this->smartCache->put($key2, 'small value');
+
+ $managedKeys = $this->smartCache->getManagedKeys();
+
+ // Only the optimized key should be tracked
+ $this->assertContains($key1, $managedKeys);
+ $this->assertNotContains($key2, $managedKeys);
+ }
+
+ public function test_can_get_different_cache_stores()
+ {
+ // Test getting default store
+ $defaultStore = $this->smartCache->store();
+ $this->assertEquals($this->getCacheStore(), $defaultStore);
+
+ // Test getting named store
+ $arrayStore = $this->smartCache->store('array');
+ $this->assertNotNull($arrayStore);
+ }
+
+ public function test_chunked_data_cleanup_on_forget()
+ {
+ // Disable compression for this test to ensure chunking is applied
+ $this->app['config']->set('smart-cache.strategies.compression.enabled', false);
+
+ // Create a fresh SmartCache instance with the new configuration
+ $smartCache = new SmartCache(
+ $this->getCacheStore(),
+ $this->getCacheManager(),
+ $this->app['config'],
+ [new ChunkingStrategy(2048, 100)]
+ );
+
+ $key = 'chunked-cleanup-key';
+ $value = $this->createChunkableData();
+
+ $smartCache->put($key, $value);
+
+ // Get the chunked metadata
+ $cached = $this->getCacheStore()->get($key);
+ $this->assertValueIsChunked($cached);
+
+ // Verify chunk keys exist
+ foreach ($cached['chunk_keys'] as $chunkKey) {
+ $this->assertTrue($this->getCacheStore()->has($chunkKey));
+ }
+
+ // Forget the main key
+ $smartCache->forget($key);
+
+ // Verify main key and all chunk keys are removed
+ $this->assertFalse($smartCache->has($key));
+ foreach ($cached['chunk_keys'] as $chunkKey) {
+ $this->assertFalse($this->getCacheStore()->has($chunkKey));
+ }
+ }
+
+ public function test_optimization_fallback_on_strategy_failure()
+ {
+ // Create a SmartCache instance with a failing strategy
+ $failingStrategy = Mockery::mock(OptimizationStrategy::class);
+ $failingStrategy->shouldReceive('getIdentifier')->andReturn('failing');
+ $failingStrategy->shouldReceive('shouldApply')->andReturn(true);
+ $failingStrategy->shouldReceive('optimize')->andThrow(new \Exception('Strategy failed'));
+
+ $smartCache = new SmartCache(
+ $this->getCacheStore(),
+ $this->getCacheManager(),
+ $this->app['config'],
+ [$failingStrategy]
+ );
+
+ $key = 'fallback-key';
+ $value = 'test value';
+
+ // Should not throw exception due to fallback
+ $this->assertTrue($smartCache->put($key, $value));
+ $this->assertEquals($value, $smartCache->get($key));
+ }
+
+ public function test_restoration_fallback_on_strategy_failure()
+ {
+ // First store a value normally
+ $key = 'restoration-fallback-key';
+ $value = 'test value';
+ $this->smartCache->put($key, $value);
+
+ // Create a SmartCache instance with a failing restoration strategy
+ $failingStrategy = Mockery::mock(OptimizationStrategy::class);
+ $failingStrategy->shouldReceive('getIdentifier')->andReturn('failing');
+ $failingStrategy->shouldReceive('restore')->andThrow(new \Exception('Restoration failed'));
+
+ $smartCache = new SmartCache(
+ $this->getCacheStore(),
+ $this->getCacheManager(),
+ $this->app['config'],
+ [$failingStrategy]
+ );
+
+ // Should return the original cached value as fallback
+ $retrieved = $smartCache->get($key);
+ $this->assertEquals($value, $retrieved);
+ }
+
+ protected function tearDown(): void
+ {
+ Mockery::close();
+ parent::tearDown();
+ }
+}
diff --git a/tests/Unit/Strategies/ChunkingStrategyTest.php b/tests/Unit/Strategies/ChunkingStrategyTest.php
new file mode 100644
index 0000000..b7ac267
--- /dev/null
+++ b/tests/Unit/Strategies/ChunkingStrategyTest.php
@@ -0,0 +1,312 @@
+strategy = new ChunkingStrategy(2048, 100); // 2KB threshold, 100 items per chunk
+ $this->mockCache = Mockery::mock(Repository::class);
+ }
+
+ public function test_get_identifier_returns_chunking()
+ {
+ $this->assertEquals('chunking', $this->strategy->getIdentifier());
+ }
+
+ public function test_should_apply_returns_true_for_large_array()
+ {
+ $largeArray = $this->createLargeTestData(150); // 150 items, should exceed both size and count thresholds
+ $this->assertTrue($this->strategy->shouldApply($largeArray));
+ }
+
+ public function test_should_apply_returns_false_for_small_array()
+ {
+ $smallArray = range(1, 50); // Small array
+ $this->assertFalse($this->strategy->shouldApply($smallArray));
+ }
+
+ public function test_should_apply_returns_false_for_non_array_types()
+ {
+ $this->assertFalse($this->strategy->shouldApply('string'));
+ $this->assertFalse($this->strategy->shouldApply(123));
+ $this->assertFalse($this->strategy->shouldApply(true));
+ $this->assertFalse($this->strategy->shouldApply((object) ['key' => 'value']));
+ }
+
+ public function test_should_apply_respects_driver_configuration()
+ {
+ $largeArray = $this->createLargeTestData(150);
+
+ $context = [
+ 'driver' => 'redis',
+ 'config' => [
+ 'drivers' => [
+ 'redis' => [
+ 'chunking' => false
+ ]
+ ]
+ ]
+ ];
+
+ $this->assertFalse($this->strategy->shouldApply($largeArray, $context));
+ }
+
+ public function test_should_apply_returns_false_if_array_count_below_chunk_size()
+ {
+ // Create array that's large in bytes but small in count
+ $largeItemArray = [];
+ for ($i = 0; $i < 50; $i++) { // Only 50 items (below chunk size of 100)
+ $largeItemArray[$i] = str_repeat('large content ', 100); // Each item is large
+ }
+
+ // Should return false because count is below chunk size threshold
+ $this->assertFalse($this->strategy->shouldApply($largeItemArray));
+ }
+
+ public function test_optimize_creates_chunks()
+ {
+ $largeArray = range(1, 250); // 250 items
+
+ // Setup mock cache expectations
+ $this->mockCache->shouldReceive('put')->times(3); // 250 items / 100 per chunk = 3 chunks
+
+ $context = [
+ 'cache' => $this->mockCache,
+ 'key' => 'test-key',
+ 'ttl' => 3600,
+ 'driver' => 'array'
+ ];
+
+ $optimized = $this->strategy->optimize($largeArray, $context);
+
+ $this->assertIsArray($optimized);
+ $this->assertArrayHasKey('_sc_chunked', $optimized);
+ $this->assertTrue($optimized['_sc_chunked']);
+ $this->assertArrayHasKey('chunk_keys', $optimized);
+ $this->assertArrayHasKey('total_items', $optimized);
+ $this->assertArrayHasKey('is_collection', $optimized);
+ $this->assertArrayHasKey('original_key', $optimized);
+
+ $this->assertEquals(250, $optimized['total_items']);
+ $this->assertFalse($optimized['is_collection']);
+ $this->assertCount(3, $optimized['chunk_keys']); // 3 chunks
+ }
+
+ public function test_optimize_handles_collection_types()
+ {
+ // Skip if Collection class doesn't exist (in case illuminate/collections isn't available)
+ if (!class_exists('\Illuminate\Support\Collection')) {
+ $this->markTestSkipped('Illuminate\Support\Collection not available');
+ }
+
+ $collection = collect(range(1, 150));
+
+ $this->mockCache->shouldReceive('put')->times(2); // 150 items / 100 per chunk = 2 chunks
+
+ $context = [
+ 'cache' => $this->mockCache,
+ 'key' => 'collection-key',
+ 'ttl' => 3600
+ ];
+
+ $optimized = $this->strategy->optimize($collection, $context);
+
+ $this->assertTrue($optimized['is_collection']);
+ $this->assertCount(2, $optimized['chunk_keys']);
+ }
+
+ public function test_optimize_without_cache_in_context()
+ {
+ $largeArray = range(1, 150);
+
+ $context = [
+ 'key' => 'test-key',
+ 'ttl' => 3600
+ ];
+
+ $optimized = $this->strategy->optimize($largeArray, $context);
+
+ // Should still create the metadata structure even without cache
+ $this->assertArrayHasKey('_sc_chunked', $optimized);
+ $this->assertTrue($optimized['_sc_chunked']);
+ $this->assertArrayHasKey('chunk_keys', $optimized);
+ }
+
+ public function test_restore_reconstructs_original_array()
+ {
+ $originalArray = range(1, 250);
+
+ // Create mock chunk data
+ $chunk1 = array_slice($originalArray, 0, 100, true);
+ $chunk2 = array_slice($originalArray, 100, 100, true);
+ $chunk3 = array_slice($originalArray, 200, 50, true);
+
+ $chunkedMetadata = [
+ '_sc_chunked' => true,
+ 'chunk_keys' => ['chunk_1', 'chunk_2', 'chunk_3'],
+ 'total_items' => 250,
+ 'is_collection' => false
+ ];
+
+ // Setup mock cache to return chunks
+ $this->mockCache->shouldReceive('get')
+ ->with('chunk_1')->andReturn($chunk1)
+ ->shouldReceive('get')
+ ->with('chunk_2')->andReturn($chunk2)
+ ->shouldReceive('get')
+ ->with('chunk_3')->andReturn($chunk3);
+
+ $context = ['cache' => $this->mockCache];
+
+ $restored = $this->strategy->restore($chunkedMetadata, $context);
+
+ $this->assertEquals($originalArray, $restored);
+ }
+
+ public function test_restore_returns_collection_when_original_was_collection()
+ {
+ if (!class_exists('\Illuminate\Support\Collection')) {
+ $this->markTestSkipped('Illuminate\Support\Collection not available');
+ }
+
+ $originalArray = range(1, 150);
+ $chunk1 = array_slice($originalArray, 0, 100, true);
+ $chunk2 = array_slice($originalArray, 100, 50, true);
+
+ $chunkedMetadata = [
+ '_sc_chunked' => true,
+ 'chunk_keys' => ['chunk_1', 'chunk_2'],
+ 'total_items' => 150,
+ 'is_collection' => true
+ ];
+
+ $this->mockCache->shouldReceive('get')
+ ->with('chunk_1')->andReturn($chunk1)
+ ->shouldReceive('get')
+ ->with('chunk_2')->andReturn($chunk2);
+
+ $context = ['cache' => $this->mockCache];
+
+ $restored = $this->strategy->restore($chunkedMetadata, $context);
+
+ $this->assertInstanceOf(\Illuminate\Support\Collection::class, $restored);
+ $this->assertEquals($originalArray, $restored->all());
+ }
+
+ public function test_restore_returns_null_when_chunk_missing()
+ {
+ $chunkedMetadata = [
+ '_sc_chunked' => true,
+ 'chunk_keys' => ['chunk_1', 'chunk_2'],
+ 'total_items' => 150,
+ 'is_collection' => false
+ ];
+
+ // Second chunk returns null (cache miss)
+ $this->mockCache->shouldReceive('get')
+ ->with('chunk_1')->andReturn(['some' => 'data'])
+ ->shouldReceive('get')
+ ->with('chunk_2')->andReturn(null);
+
+ $context = ['cache' => $this->mockCache];
+
+ $restored = $this->strategy->restore($chunkedMetadata, $context);
+
+ $this->assertNull($restored);
+ }
+
+ public function test_restore_throws_exception_without_cache()
+ {
+ $chunkedMetadata = [
+ '_sc_chunked' => true,
+ 'chunk_keys' => ['chunk_1'],
+ 'total_items' => 100,
+ 'is_collection' => false
+ ];
+
+ $this->expectException(\RuntimeException::class);
+ $this->expectExceptionMessage('Cache repository is required to restore chunked data');
+
+ $this->strategy->restore($chunkedMetadata, []); // No cache in context
+ }
+
+ public function test_restore_returns_unmodified_value_if_not_chunked()
+ {
+ $normalValue = ['not' => 'chunked'];
+ $restored = $this->strategy->restore($normalValue, ['cache' => $this->mockCache]);
+ $this->assertEquals($normalValue, $restored);
+ }
+
+ public function test_chunking_with_custom_chunk_size()
+ {
+ $strategy = new ChunkingStrategy(2048, 50); // 50 items per chunk
+ $largeArray = range(1, 125); // 125 items
+
+ $this->mockCache->shouldReceive('put')->times(3); // 125 / 50 = 3 chunks
+
+ $context = [
+ 'cache' => $this->mockCache,
+ 'key' => 'custom-chunk-key',
+ 'ttl' => 3600
+ ];
+
+ $optimized = $strategy->optimize($largeArray, $context);
+
+ $this->assertCount(3, $optimized['chunk_keys']);
+ }
+
+ public function test_chunking_preserves_array_keys()
+ {
+ $originalArray = [
+ 'first' => 'value1',
+ 'second' => 'value2',
+ 'third' => 'value3'
+ ];
+
+ // Add more items to exceed threshold
+ for ($i = 0; $i < 200; $i++) {
+ $originalArray["item_$i"] = "value_$i";
+ }
+
+ $this->mockCache->shouldReceive('put')->atLeast(1);
+
+ // Also setup mock returns for restoration test
+ $chunks = array_chunk($originalArray, 100, true);
+ foreach ($chunks as $index => $chunk) {
+ $this->mockCache->shouldReceive('get')
+ ->with("_sc_chunk_test-key_$index")
+ ->andReturn($chunk);
+ }
+
+ $context = [
+ 'cache' => $this->mockCache,
+ 'key' => 'test-key',
+ 'ttl' => 3600
+ ];
+
+ $optimized = $this->strategy->optimize($originalArray, $context);
+ $restored = $this->strategy->restore($optimized, $context);
+
+ $this->assertEquals($originalArray, $restored);
+ $this->assertArrayHasKey('first', $restored);
+ $this->assertArrayHasKey('second', $restored);
+ $this->assertArrayHasKey('third', $restored);
+ }
+
+ protected function tearDown(): void
+ {
+ Mockery::close();
+ parent::tearDown();
+ }
+}
diff --git a/tests/Unit/Strategies/CompressionStrategyTest.php b/tests/Unit/Strategies/CompressionStrategyTest.php
new file mode 100644
index 0000000..22287ec
--- /dev/null
+++ b/tests/Unit/Strategies/CompressionStrategyTest.php
@@ -0,0 +1,236 @@
+strategy = new CompressionStrategy(1024, 6); // 1KB threshold, level 6
+ }
+
+ public function test_get_identifier_returns_compression()
+ {
+ $this->assertEquals('compression', $this->strategy->getIdentifier());
+ }
+
+ public function test_should_apply_returns_true_for_large_string()
+ {
+ $largeString = str_repeat('a', 2000); // 2KB string
+ $this->assertTrue($this->strategy->shouldApply($largeString));
+ }
+
+ public function test_should_apply_returns_false_for_small_string()
+ {
+ $smallString = str_repeat('a', 500); // 500 bytes string
+ $this->assertFalse($this->strategy->shouldApply($smallString));
+ }
+
+ public function test_should_apply_returns_true_for_large_array()
+ {
+ $largeArray = $this->createLargeTestData(50); // Creates large array
+ $this->assertTrue($this->strategy->shouldApply($largeArray));
+ }
+
+ public function test_should_apply_returns_false_for_small_array()
+ {
+ $smallArray = ['key' => 'value'];
+ $this->assertFalse($this->strategy->shouldApply($smallArray));
+ }
+
+ public function test_should_apply_returns_true_for_large_object()
+ {
+ $largeObject = (object) $this->createLargeTestData(50);
+ $this->assertTrue($this->strategy->shouldApply($largeObject));
+ }
+
+ public function test_should_apply_returns_false_for_non_compressible_types()
+ {
+ $this->assertFalse($this->strategy->shouldApply(123));
+ $this->assertFalse($this->strategy->shouldApply(123.45));
+ $this->assertFalse($this->strategy->shouldApply(true));
+ $this->assertFalse($this->strategy->shouldApply(null));
+ }
+
+ public function test_should_apply_respects_driver_configuration()
+ {
+ $largeString = str_repeat('a', 2000);
+
+ $context = [
+ 'driver' => 'redis',
+ 'config' => [
+ 'drivers' => [
+ 'redis' => [
+ 'compression' => false
+ ]
+ ]
+ ]
+ ];
+
+ $this->assertFalse($this->strategy->shouldApply($largeString, $context));
+ }
+
+ public function test_optimize_compresses_string_data()
+ {
+ $originalString = str_repeat('Hello World! ', 200); // Repetitive string compresses well
+ $optimized = $this->strategy->optimize($originalString);
+
+ $this->assertIsArray($optimized);
+ $this->assertArrayHasKey('_sc_compressed', $optimized);
+ $this->assertTrue($optimized['_sc_compressed']);
+ $this->assertArrayHasKey('data', $optimized);
+ $this->assertArrayHasKey('is_string', $optimized);
+ $this->assertTrue($optimized['is_string']);
+
+ // Verify the compressed data is base64 encoded
+ $this->assertNotFalse(base64_decode($optimized['data'], true));
+ }
+
+ public function test_optimize_compresses_array_data()
+ {
+ $originalArray = $this->createLargeTestData(50);
+ $optimized = $this->strategy->optimize($originalArray);
+
+ $this->assertIsArray($optimized);
+ $this->assertArrayHasKey('_sc_compressed', $optimized);
+ $this->assertTrue($optimized['_sc_compressed']);
+ $this->assertArrayHasKey('data', $optimized);
+ $this->assertArrayHasKey('is_string', $optimized);
+ $this->assertFalse($optimized['is_string']);
+ }
+
+ public function test_optimize_compresses_object_data()
+ {
+ $originalObject = (object) $this->createLargeTestData(50);
+ $optimized = $this->strategy->optimize($originalObject);
+
+ $this->assertIsArray($optimized);
+ $this->assertArrayHasKey('_sc_compressed', $optimized);
+ $this->assertTrue($optimized['_sc_compressed']);
+ $this->assertArrayHasKey('is_string', $optimized);
+ $this->assertFalse($optimized['is_string']);
+ }
+
+ public function test_restore_returns_original_string()
+ {
+ $originalString = str_repeat('Hello World! ', 200);
+ $optimized = $this->strategy->optimize($originalString);
+ $restored = $this->strategy->restore($optimized);
+
+ $this->assertEquals($originalString, $restored);
+ }
+
+ public function test_restore_returns_original_array()
+ {
+ $originalArray = $this->createLargeTestData(50);
+ $optimized = $this->strategy->optimize($originalArray);
+ $restored = $this->strategy->restore($optimized);
+
+ $this->assertEquals($originalArray, $restored);
+ }
+
+ public function test_restore_returns_original_object()
+ {
+ $originalObject = (object) $this->createLargeTestData(50);
+ $optimized = $this->strategy->optimize($originalObject);
+ $restored = $this->strategy->restore($optimized);
+
+ $this->assertEquals($originalObject, $restored);
+ }
+
+ public function test_restore_returns_unmodified_value_if_not_compressed()
+ {
+ $normalValue = 'not compressed';
+ $restored = $this->strategy->restore($normalValue);
+ $this->assertEquals($normalValue, $restored);
+
+ $normalArray = ['not' => 'compressed'];
+ $restored = $this->strategy->restore($normalArray);
+ $this->assertEquals($normalArray, $restored);
+ }
+
+ public function test_restore_returns_unmodified_value_if_invalid_compressed_format()
+ {
+ $invalidCompressed = [
+ '_sc_compressed' => false, // Wrong marker
+ 'data' => 'some-data',
+ 'is_string' => true
+ ];
+
+ $restored = $this->strategy->restore($invalidCompressed);
+ $this->assertEquals($invalidCompressed, $restored);
+ }
+
+ public function test_compression_reduces_size()
+ {
+ $repetitiveString = str_repeat('This is a test string that should compress very well. ', 100);
+ $originalSize = strlen($repetitiveString);
+
+ $optimized = $this->strategy->optimize($repetitiveString);
+ $compressedSize = strlen($optimized['data']);
+
+ // Base64 adds some overhead, but the compressed data should still be significantly smaller
+ // than the original for repetitive data
+ $this->assertLessThan($originalSize, $compressedSize);
+ }
+
+ public function test_compression_with_different_levels()
+ {
+ $data = str_repeat('Test data for compression level testing. ', 100);
+
+ $strategy1 = new CompressionStrategy(1024, 1); // Low compression
+ $strategy9 = new CompressionStrategy(1024, 9); // High compression
+
+ $optimized1 = $strategy1->optimize($data);
+ $optimized9 = $strategy9->optimize($data);
+
+ // Higher compression level should produce smaller result
+ $size1 = strlen($optimized1['data']);
+ $size9 = strlen($optimized9['data']);
+
+ $this->assertLessThanOrEqual($size1, $size9);
+
+ // Both should restore to the same original data
+ $restored1 = $strategy1->restore($optimized1);
+ $restored9 = $strategy9->restore($optimized9);
+
+ $this->assertEquals($data, $restored1);
+ $this->assertEquals($data, $restored9);
+ }
+
+ public function test_compression_with_custom_threshold()
+ {
+ $strategy = new CompressionStrategy(5000, 6); // 5KB threshold
+
+ $smallData = str_repeat('a', 2000); // 2KB
+ $largeData = str_repeat('a', 6000); // 6KB
+
+ $this->assertFalse($strategy->shouldApply($smallData));
+ $this->assertTrue($strategy->shouldApply($largeData));
+ }
+
+ public function test_round_trip_compression_preserves_data_integrity()
+ {
+ $testCases = [
+ 'Simple string',
+ str_repeat('Repetitive content ', 100),
+ ['array' => 'data', 'nested' => ['deep' => 'value']],
+ $this->createLargeTestData(30),
+ (object) ['property' => 'value', 'nested' => (object) ['deep' => 'data']]
+ ];
+
+ foreach ($testCases as $testCase) {
+ $optimized = $this->strategy->optimize($testCase);
+ $restored = $this->strategy->restore($optimized);
+
+ $this->assertEquals($testCase, $restored,
+ 'Round-trip compression should preserve data integrity for: ' . gettype($testCase));
+ }
+ }
+}
diff --git a/tests/bootstrap.php b/tests/bootstrap.php
new file mode 100644
index 0000000..6da9a00
--- /dev/null
+++ b/tests/bootstrap.php
@@ -0,0 +1,54 @@
+isDir() ? 'rmdir' : 'unlink');
+ $todo($fileinfo->getRealPath());
+ }
+ }
+}