<?php

use Illuminate\Support\Facades\Cache;

use Illuminate\Support\Facades\Facade;

use SimpleSoftwareIO\Cache\QueryCache;

use SimpleSoftwareIO\Cache\QueryCacheBuilder;

class QueryCacheTest extends PHPUnit_Framework_TestCase

{

public function setUp()

{

Facade::clearResolvedInstances();

}

public function tearDown()

{

Mockery::close();

}

/** @test */

public function enable_returns_true_when_a_length_exists()

{

$queryCache = new QueryCache(null, 30);

$this->assertTrue($queryCache->enabled());

}

/** @test */

public function enable_returns_false_when_a_length_does_not_exists()

{

$queryCache = new QueryCache(null, 0);

$this->assertFalse($queryCache->enabled());

}

/** @test */

public function disable_turns_off_caching()

{

$queryCache = new QueryCache(null, 30);

$queryCache->disable();

$this->assertFalse($queryCache->enabled());

}

/** @test */

public function enable_turns_on_caching()

{

$queryCache = new QueryCache(null, 0);

$queryCache->enable();

$this->assertTrue($queryCache->enabled());

}

/** @test */

public function length_sets_the_length_to_cache()

{

$queryCache = new QueryCache(null, 30);

$queryCache->length(20);

$this->assertAttributeEquals(20, 'length', $queryCache);

}

/** @test */

public function cache_is_not_called_when_it_is_disabled()

{

$queryCacheBuilder = Mockery::mock(QueryCacheBuilder::class);

$queryCache = Mockery::mock('SimpleSoftwareIO\Cache\QueryCache[performQuery]', [null, 0])

->shouldAllowMockingProtectedMethods()

->shouldIgnoreMissing();

Cache::shouldReceive('remember')

->times(0);

$queryCache->get($queryCacheBuilder);

}

/** @test */

public function cache_is_called_when_it_is_enabled()

{

$queryCacheBuilder = Mockery::mock(QueryCacheBuilder::class);

$queryCache = Mockery::mock('SimpleSoftwareIO\Cache\QueryCache[generateKey,performQuery]', [null, 30])

->shouldAllowMockingProtectedMethods()

->shouldIgnoreMissing();

Cache::shouldReceive('getStore');

Cache::shouldReceive('store->remember')

->once();

$queryCache->get($queryCacheBuilder);

}

/** @test */

public function cache_is_called_on_the_correct_store()

{

$queryCacheBuilder = Mockery::mock(QueryCacheBuilder::class);

$queryCache = Mockery::mock('SimpleSoftwareIO\Cache\QueryCache[generateKey,performQuery]', ['fooStore', 30])

->shouldAllowMockingProtectedMethods()

->shouldIgnoreMissing();

Cache::shouldReceive('getStore');

Cache::shouldReceive('store')

->withArgs(['fooStore'])

->once()

->andReturn(Mockery::self())

->shouldReceive('remember');

$queryCache->get($queryCacheBuilder);

}

/** @test */

public function cache_is_called_with_correct_key_and_length()

{

$queryCacheBuilder = Mockery::mock(QueryCacheBuilder::class);

$queryCache = Mockery::mock('SimpleSoftwareIO\Cache\QueryCache[generateKey,performQuery]', [null, 30])

->shouldAllowMockingProtectedMethods()

->shouldIgnoreMissing();

$queryCache->shouldReceive('generateKey')

->once()

->andReturn('fooKey');

Cache::shouldReceive('getStore');

Cache::shouldReceive('store->remember')

->withArgs(['fooKey', 30, Mockery::any()])

->once();

$queryCache->get($queryCacheBuilder);

}

/** @test */

public function cache_is_called_with_tags_if_the_driver_supports_tags()

{

$queryCacheBuilder = Mockery::mock(QueryCacheBuilder::class);

$queryCache = Mockery::mock('SimpleSoftwareIO\Cache\QueryCache[generateKey,performQuery,isTaggable]', [null, 30])

->shouldAllowMockingProtectedMethods()

->shouldIgnoreMissing();

$queryCache->shouldReceive('isTaggable')

->andReturn(true);

Cache::shouldReceive('store->tags')

->once()

->andReturn(Mockery::self())

->shouldReceive('remember');

$queryCache->get($queryCacheBuilder);

}

/** @test */

public function cache_is_called_without_tags_if_the_driver_does_not_support_tags()

{

$queryCacheBuilder = Mockery::mock(QueryCacheBuilder::class);

$queryCache = Mockery::mock('SimpleSoftwareIO\Cache\QueryCache[generateKey,performQuery,isTaggable]', [null, 30])

->shouldAllowMockingProtectedMethods()

->shouldIgnoreMissing();

$queryCache->shouldReceive('isTaggable')

->andReturn(false);

Cache::shouldReceive('tags')

->times(0)

->andReturn(Mockery::self())

->shouldReceive('store->remember');

$queryCache->get($queryCacheBuilder);

}

/** @test */

public function cache_is_tagged_with_the_correct_model()

{

$queryCacheBuilder = Mockery::mock(QueryCacheBuilder::class);

$queryCache = Mockery::mock('SimpleSoftwareIO\Cache\QueryCache[generateKey,performQuery,isTaggable]', [null, 30])

->shouldAllowMockingProtectedMethods()

->shouldIgnoreMissing();

$queryCacheBuilder->from = 'fooTable';

$queryCache->shouldReceive('isTaggable')

->andReturn(true);

Cache::shouldReceive('store->tags')

->once()

->withArgs(['fooTable'])

->andReturn(Mockery::self())

->shouldReceive('remember');

$queryCache->get($queryCacheBuilder);

}

/** @test */

public function cache_is_flushed_for_a_model_if_tagging_is_supported()

{

$queryCache = Mockery::mock('SimpleSoftwareIO\Cache\QueryCache[isTaggable]', [null, 30])

->shouldAllowMockingProtectedMethods()

->shouldIgnoreMissing();

$queryCache->shouldReceive('isTaggable')

->andReturn(true);

Cache::shouldReceive('tags')

->once()

->withArgs(['fooTable'])

->andReturn(Mockery::self())

->shouldReceive('flush')

->once();

$queryCache->flush('fooTable');

}

/** @test */

public function cache_is_flushed_for_everything_if_tagging_is_not_supported()

{

$queryCacheBuilder = Mockery::mock(QueryCacheBuilder::class);

$queryCache = Mockery::mock('SimpleSoftwareIO\Cache\QueryCache[isTaggable]', [null, 30])

->shouldAllowMockingProtectedMethods()

->shouldIgnoreMissing();

$queryCacheBuilder->from = 'fooTable';

$queryCache->shouldReceive('isTaggable')

->andReturn(false);

Cache::shouldReceive('tags')

->times(0);

Cache::shouldReceive('flush')

->once();

$queryCache->flush($queryCacheBuilder);

}

}