public function testDalResolver()
{
$resolver = new DalResolver();
$resolver->boot();
$resolver->addDataStore('test', $this->getMock('\\Packaged\\Dal\\IDataStore'));
$mock = new MockAbstractDao();
$mock->init();
$this->assertInstanceOf('\\Packaged\\Dal\\IDataStore', $mock->getDataStore());
$this->assertSame($resolver, $mock->getDalResolver());
Dao::unsetDalResolver();
$this->assertNull($mock->getDalResolver());
}
public function testGetConnection()
{
$datastore = new MockCacheDataStore();
$datastore->configure(new ConfigSection('cache', ['connection' => 'cacheconn']));
$connection = new EphemeralConnection();
$connection->configure(new ConfigSection('ephemeral', ['pool_name' => 'mock']));
$resolver = new DalResolver();
$resolver->addDataStore('cache', $datastore);
$resolver->addConnection('cacheconn', $connection);
$resolver->boot();
$this->assertSame($connection, $datastore->getConnection());
Dao::unsetDalResolver();
}
public function testGetConnection()
{
$resolver = new DalResolver();
$conn = new PdoConnection();
$resolver->addConnection('pdo', $conn);
$resolver->boot();
$datastore = new QlDataStore();
$datastore->configure(new ConfigSection('qldatastore', ['connection' => 'pdo']));
$this->assertSame($conn, $datastore->getConnection());
$datastore = new QlDataStore();
$datastore->configure(new ConfigSection('qldatastore', ['connection' => 'mizzing']));
$this->setExpectedException('\\Packaged\\Dal\\Exceptions\\DalResolver\\ConnectionNotFoundException');
$datastore->getConnection();
Dao::unsetDalResolver();
}
/**
* Get the data store for this dao
*
* @return IDataStore
*/
public function getDataStore()
{
return static::$_resolver->getDataStore($this->_dataStoreName);
}
public function testPerformanceMetrics()
{
$dal = new DalResolver();
$this->assertFalse($dal->isCollectingPerformanceMetrics());
$dal->enablePerformanceMetrics();
$this->assertTrue($dal->isCollectingPerformanceMetrics());
$dal->disablePerformanceMetrics();
$this->assertFalse($dal->isCollectingPerformanceMetrics());
$dal->enablePerformanceMetrics();
$id = $dal->startPerformanceMetric('test', DalResolver::MODE_READ, 'SLEEP');
sleep(1);
$dal->closePerformanceMetric($id);
$perfData = $dal->getPerformanceMetrics();
$this->assertCount(1, $perfData);
$perfData = reset($perfData);
$this->assertEquals('test', $perfData['c']);
$this->assertEquals('SLEEP', $perfData['q']);
$this->assertEquals(DalResolver::MODE_READ, $perfData['m']);
$this->assertGreaterThan(1000, $perfData['t']);
$this->setExpectedException(DalException::class, "You cannot close performance metrics that are not open");
$dal->closePerformanceMetric($id);
}
public function testAddDataStoreConfig()
{
$config = new \Packaged\Config\Provider\ConfigSection('datastore_test');
$config->addItem('construct_class', ConfigurableDataStore::class);
$unique = uniqid();
$config->addItem('unique', $unique);
$resolver = new \Packaged\Dal\DalResolver();
$this->assertNull($resolver->getDataStoreConfig('invalid_datastore'));
$resolver->addDataStoreConfig($config);
$this->assertSame($config, $resolver->getDataStoreConfig('datastore_test'));
$config2 = new \Packaged\Config\Provider\ConfigSection('datastore_test');
$config2->addItem('construct_class', ConfigurableDataStore::class);
$unique = uniqid();
$config2->addItem('unique', $unique);
$resolver->addDataStoreConfig($config2);
$this->assertNotSame($config, $resolver->getDataStoreConfig('datastore_test'));
$this->assertSame($config2, $resolver->getDataStoreConfig('datastore_test'));
/**
* @var $dataStore ConfigurableDataStore
*/
$dataStore = $resolver->getDataStore('datastore_test');
$this->assertInstanceOf(ConfigurableDataStore::class, $dataStore);
$this->assertEquals($unique, $dataStore->getConfig()->getItem('unique'));
}
public function testLsd()
{
$datastore = new MockQlDataStore();
$connection = new MockPdoConnection();
$connection->config();
$datastore->setConnection($connection);
$connection->connect();
$resolver = new DalResolver();
$resolver->addDataStore('mockql', $datastore);
$resolver->boot();
$resolver->enablePerformanceMetrics();
$connection->setResolver($resolver);
$dao = new MockQlDao();
$dao->username = time() . 'user';
$dao->display = 'User ' . date("Y-m-d");
$dao->boolTest = true;
$datastore->save($dao);
$dao->username = '******';
$dao->display = 'Brooke';
$dao->boolTest = false;
$datastore->save($dao);
$dao->username = '******';
$datastore->load($dao);
$this->assertEquals('test 1', $dao->username);
$this->assertEquals(0, $dao->boolTest);
$dao->display = 'Save 2';
$datastore->save($dao);
$staticLoad = MockQlDao::loadById($dao->id);
$this->assertEquals($dao->username, $staticLoad->username);
$datastore->delete($dao);
$metrics = $resolver->getPerformanceMetrics();
$resolver->disablePerformanceMetrics();
$this->assertCount(6, $metrics);
$resolver->shutdown();
}
protected function setUp()
{
$resolver = new DalResolver();
$resolver->boot();
}
public function testCounters()
{
$datastore = new MockCqlDataStore();
$connection = new CqlConnection();
$this->_configureConnection($connection);
$datastore->setConnection($connection);
$connection->connect();
$resolver = new DalResolver();
$resolver->boot();
$connection->setResolver($resolver);
Dao::getDalResolver()->addDataStore('mockcql', $datastore);
$dao = new MockCounterCqlDao();
$dao->id = 'test1';
$dao->c1->increment(10);
$dao->c1->decrement(5);
$datastore->save($dao);
$dao->c2->increment(1);
$dao->c2->decrement(3);
$datastore->save($dao);
$loaded = MockCounterCqlDao::loadById('test1');
$this->assertEquals(5, $loaded->c1->calculated());
$this->assertEquals(-2, $loaded->c2->calculated());
$dao = new MockCounterCqlDao();
$dao->id = 'test1';
$dao->c1->increment(5);
$dao->c1->decrement(5);
$datastore->save($dao);
$dao->c2->increment(0);
$datastore->save($dao);
}
public function testNoDataStore()
{
$resolver = new DalResolver();
$resolver->boot();
$mock = new MockQlDao();
$this->setExpectedException('\\Packaged\\Dal\\Exceptions\\DalResolver\\DataStoreNotFoundException');
$mock->getDataStore();
}
public function testCounters()
{
$datastore = new MockQlDataStore();
$connection = new MockPdoConnection();
$connection->config();
$datastore->setConnection($connection);
$connection->connect();
$resolver = new DalResolver();
$resolver->boot();
$connection->setResolver($resolver);
Dao::getDalResolver()->addDataStore('mockql', $datastore);
$datastore->getConnection()->runQuery('TRUNCATE TABLE mock_counter_daos');
$dao = MockCounterDao::loadOrNew('test1');
$dao->c1->increment(10);
$dao->c1->decrement(5);
$datastore->save($dao);
$dao->c2->increment(1);
$dao->c2->decrement(3);
$datastore->save($dao);
$dao = new MockCounterDao();
$dao->id = 'test1';
$dao->c2->increment(1);
$dao->c2->decrement(3);
$datastore->save($dao);
$dao = MockCounterDao::loadById('test1');
$this->assertEquals(5, $dao->c1->calculated());
$this->assertEquals(-4, $dao->c2->calculated());
$dao = MockCounterDao::loadById('test1');
$dao->c1->increment(0);
$datastore->save($dao);
$dao->c1->increment(10);
$datastore->save($dao);
$dao->c1->increment(15);
$datastore->save($dao);
$dao->c3->increment(8);
$datastore->save($dao);
$dao->c3->increment(9.699999999999999);
$datastore->save($dao);
$dao->c3->increment(99);
$datastore->save($dao);
$dao->c3->increment(1.3);
$datastore->save($dao);
$dao->c3->increment(0.0);
$datastore->save($dao);
$dao->c3->increment(null);
$datastore->save($dao);
$dao->c3->increment('goat');
$datastore->save($dao);
$dao->c3->increment('99
a');
$datastore->save($dao);
$dao->c2->increment(0);
$datastore->save($dao);
$dao1 = MockCounterDao::loadById('test1');
$dao1->c1->increment(7);
$dao2 = MockCounterDao::loadById('test1');
$dao2->c1->increment(3);
$dao1->save();
$dao2->save();
$dao = MockCounterDao::loadById('test1');
$this->assertEquals(40, $dao->c1->calculated());
$this->assertEquals(217, $dao->c3->calculated());
$dao = new MockCounterDao();
$dao->id = 'test1';
$dao->markDaoAsLoaded();
$dao->markDaoDatasetAsSaved();
$dao->c3->increment('0.00');
$datastore->save($dao);
$dao = MockCounterDao::loadById('test1');
$this->assertEquals(217, $dao->c3->calculated());
$dao = MockCounterDao::loadById('test1');
$this->assertEquals(40, $dao->c1->calculated());
$this->assertEquals(-4, $dao->c2->calculated());
$this->assertEquals(217, $dao->c3->calculated());
$dao = MockCounterDao::loadById('test1');
$this->assertEquals(40, $dao->c1->calculated());
$dao->c1 = 100;
$dao->save();
$dao = MockCounterDao::loadById('test1');
$this->assertEquals(100, $dao->c1->calculated());
$dao->c1->setValue(500);
$dao->save();
$dao = MockCounterDao::loadById('test1');
$this->assertEquals(500, $dao->c1->calculated());
$json = json_encode($dao);
$this->assertEquals('{"id":"test1","c1":"500","c2":"-4","c3":"217.00"}', $json);
$dao = new MockCounterDao();
$dao->id = 'test1';
$dao->c1->setValue(6);
$dao->c2->setValue(-8);
$datastore->save($dao);
$json = json_encode($dao);
$this->assertEquals('{"id":"test1","c1":"6","c2":"-8","c3":"0"}', $json);
}
