public function testCanFilterOnRelatedModelProperties() { $gcd = new Company(); $gcd->CompanyName = "GCD"; $gcd->save(); $widgetCo = new Company(); $widgetCo->CompanyName = "Widgets"; $widgetCo->save(); $example = new User(); $example->Username = "******"; $widgetCo->Users->Append($example); $example = new User(); $example->Username = "******"; $gcd->Users->Append($example); $example = new User(); $example->Username = "******"; $widgetCo->Users->Append($example); $example = new User(); $example->Username = "******"; $gcd->Users->Append($example); $list = new Collection("Rhubarb\\Stem\\Tests\\Fixtures\\User"); $list->filter(new Equals("Company.CompanyName", "GCD")); $this->assertCount(2, $list); $this->assertEquals("b", $list[0]->Username); $this->assertEquals("d", $list[1]->Username); }
public function testOneToMany() { SolutionSchema::registerSchema("MySchema", "Rhubarb\\Stem\\Tests\\Fixtures\\UnitTestingSolutionSchema"); $company = new Company(); $company->getRepository()->clearObjectCache(); $company->CompanyName = "Test Company"; $company->save(); $user = new User(); $user->getRepository()->clearObjectCache(); $user->Username = "******"; $user->Password = "******"; $user->Active = 1; $user->CompanyID = $company->CompanyID; $user->save(); $user = new User(); $user->Username = "******"; $user->Password = ""; $user->Active = 1; $user->CompanyID = $company->CompanyID; $user->save(); $user = new User(); $user->Username = "******"; $user->Password = ""; $user->Active = 0; $user->CompanyID = $company->CompanyID; $user->save(); $oneToMany = new OneToMany("Unused", "Company", "CompanyID", "UnitTestUser"); $list = $oneToMany->fetchFor($company); $this->assertCount(2, $list); $this->assertEquals("msmith", $list[1]->Username); }
public function testColumnFormatter() { Company::clearObjectCache(); $company = new Company(); $company->CompanyName = "abc"; $company->save(); $decorator = DataDecorator::getDecoratorForModel($company); $this->assertSame("00001", $decorator->CompanyID); }
public function testSchemaDetectsWhenItCanUpdate() { $comparisonSchema = MySqlComparisonSchema::fromTable("tblCompany"); $example = new Company(); $schema = $example->getSchema(); $compareTo = MySqlComparisonSchema::fromMySqlSchema($schema); $this->assertFalse($compareTo->createAlterTableStatementFor($comparisonSchema)); $schema->addColumn(new String("Town", 60, null)); $compareTo = MySqlComparisonSchema::fromMySqlSchema($schema); $this->assertContains("ADD COLUMN `Town` varchar(60) DEFAULT NULL", $compareTo->createAlterTableStatementFor($comparisonSchema)); }
public function testRepositoryGetsDateFormat() { $company = new Company(); $company->CompanyName = "GCD"; $company->LastUpdatedDate = "2012-01-01 10:01:02"; $company->save(); $params = MySql::getPreviousParameters(); $this->assertContains("2012-01-01 10:01:02", $params["LastUpdatedDate"]); $company->reload(); $this->assertEquals("2012-01-01 10:01:02", $company->LastUpdatedDate->format("Y-m-d H:i:s")); }
public function testRepositoryGetsTimeFormat() { $company = new Company(); $company->CompanyName = "GCD"; $company->KnockOffTime = "17:01:02"; $company->save(); $params = MySql::getPreviousParameters(); $this->assertContains("17:01:02", $params["KnockOffTime"]); $company->reload(); $this->assertEquals("2000-01-01 17:01:02", $company->KnockOffTime->format("Y-m-d H:i:s")); }
public function testValidJsonTransform() { $company = new Company(); $company->CompanyName = "Gcd Technologies"; $company->CompanyData = $this->data; $company->save(); $params = MySql::getPreviousParameters(); $this->assertEquals($this->constraint, $params["CompanyData"]); Model::clearAllRepositories(); $company = new Company($company->UniqueIdentifier); $this->assertEquals($this->data, $company->CompanyData); }
public function testAppendingCreatesRowInModel() { $companyCategory = new CompanyCategory(); $companyCategory->getRepository()->clearObjectCache(); $company = new Company(); $company->CompanyName = "GCD"; $company->save(); $category = new Category(); $category->CategoryName = "AppendTest"; $category->save(); $company->Categories->Append($category); $this->assertCount(1, $company->Categories); $this->assertEquals($company->CompanyID, $companyCategory->getRepository()->cachedObjectData[1]["CompanyID"]); $this->assertEquals($category->CategoryID, $companyCategory->getRepository()->cachedObjectData[1]["CategoryID"]); }
public function testRepositoryGetsDateFormat() { $company = new Company(); $company->CompanyName = "GCD"; $company->InceptionDate = "2012-01-01"; $company->save(); $params = MySql::getPreviousParameters(); $this->assertContains("2012-01-01", $params["InceptionDate"]); $company->reload(); $this->assertEquals("2012-01-01", $company->InceptionDate->format("Y-m-d")); $company->InceptionDate = "2011-01-01"; $company->save(); $company->reload(); $this->assertEquals("2011-01-01", $company->InceptionDate->format("Y-m-d")); }
public function testOneToOne() { SolutionSchema::registerSchema("MySchema", "Rhubarb\\Stem\\Tests\\Fixtures\\UnitTestingSolutionSchema"); $company = new Company(); $company->CompanyName = "Test Company"; $company->save(); $user = new User(); $user->Username = "******"; $user->Password = "******"; $user->Active = 1; $user->CompanyID = $company->CompanyID; $user->save(); $oneToOne = new OneToOne("Unused", "User", "CompanyID", "Company", "CompanyID"); $result = $oneToOne->fetchFor($user); $this->assertEquals("Test Company", $result->CompanyName); }
public function testManyToMany() { // UnitTestingSolutionSchema sets up a many to many relationship between company and category $company1 = new Company(); $company2 = new Company(); $company3 = new Company(); $company1->getRepository()->clearObjectCache(); $companyCategory = new CompanyCategory(); $companyCategory->getRepository()->clearObjectCache(); $category1 = new Category(); $category2 = new Category(); $category1->getRepository()->clearObjectCache(); $company1->CompanyName = "GCD"; $company1->save(); $company2->CompanyName = "UTV"; $company2->save(); $company3->CompanyName = 'Inactive'; $company3->Active = 0; $company3->save(); $category1->CategoryName = "Fruit"; $category1->save(); $category2->CategoreName = "Apples"; $category2->save(); $companyCategory->CategoryID = $category1->CategoryID; $companyCategory->CompanyID = $company1->CompanyID; $companyCategory->save(); $companyCategory = new CompanyCategory(); $companyCategory->CategoryID = $category1->CategoryID; $companyCategory->CompanyID = $company2->CompanyID; $companyCategory->save(); $companyCategory = new CompanyCategory(); $companyCategory->CategoryID = $category2->CategoryID; $companyCategory->CompanyID = $company2->CompanyID; $companyCategory->save(); $companyCategory = new CompanyCategory(); $companyCategory->CategoryID = $category1->CategoryID; $companyCategory->CompanyID = $company3->CompanyID; $companyCategory->save(); // At this point GCD is in Fruit, while UTV is in Fruit and Apples. $company1 = new Company($company1->CompanyID); $this->assertCount(1, $company1->Categories); $this->assertCount(2, $company2->Categories); $this->assertCount(2, $category1->Companies); $this->assertCount(1, $category2->Companies); $this->assertEquals("UTV", $category2->Companies[0]->CompanyName); }
public function testCount() { $company = new Company(); $company->CompanyName = "a"; $company->save(); $company = new Company(); $company->CompanyName = "b"; $company->save(); $company = new Company(); $company->CompanyName = "b"; $company->save(); $company = new Company(); $company->CompanyName = "a"; $company->save(); $collection = Company::find(); list($companies) = $collection->calculateAggregates(new CountDistinct("CompanyName")); $this->assertEquals(2, $companies); }
public function testRelationships() { SolutionSchema::clearSchemas(); SolutionSchema::registerSchema("MySchema", "Rhubarb\\Stem\\Tests\\Fixtures\\UnitTestingSolutionSchema"); error_reporting(E_ALL); ini_set("display_errors", "on"); $schema = new UnitTestingSolutionSchema(); $schema->defineRelationships(); $relationship = $schema->getRelationship("UnitTestUser", "Company"); $this->assertInstanceOf("Rhubarb\\Stem\\Schema\\Relationships\\OneToOne", $relationship); $this->assertInstanceOf("Rhubarb\\Stem\\Schema\\Relationships\\OneToMany", $relationship->getOtherSide()); $relationship = $schema->getRelationship("Company", "Users"); $this->assertInstanceOf("Rhubarb\\Stem\\Schema\\Relationships\\OneToMany", $relationship); $relationship = $schema->getRelationship("Company", "Unknown"); $this->assertNull($relationship); $relationship = $schema->getRelationship("Example", "ExampleRelationshipName"); $this->assertInstanceOf("Rhubarb\\Stem\\Schema\\Relationships\\OneToOne", $relationship); $columnRelationships = SolutionSchema::getAllOneToOneRelationshipsForModelBySourceColumnName("UnitTestUser"); $this->assertArrayHasKey("CompanyID", $columnRelationships); $this->assertInstanceOf("Rhubarb\\Stem\\Schema\\Relationships\\OneToOne", $columnRelationships["CompanyID"]); $company = new Company(); $company->CompanyName = "GCD"; $company->save(); $user = new User(); $user->getRepository()->clearObjectCache(); $user->Forename = "a"; $user->save(); $company->Users->Append($user); $b = $user = new User(); $user->Forename = "b"; $user->save(); $company->Users->Append($user); // Just to make sure this doesn't get in our relationship! $user = new User(); $user->Forename = "c"; $user->save(); $company = new Company($company->CompanyID); $this->assertCount(2, $company->Users); $this->assertEquals("a", $company->Users[0]->Forename); $this->assertEquals("b", $company->Users[1]->Forename); $company = $b->Company; $this->assertEquals("GCD", $company->CompanyName); }
protected function setUp() { parent::setUp(); MySql::executeStatement("TRUNCATE TABLE tblCompany"); $example = new Company(); $example->getRepository()->clearObjectCache(); $example = new Company(); $example->CompanyName = "a"; $example->Balance = 1; $example->save(); $example = new Company(); $example->CompanyName = "b"; $example->Balance = 2; $example->save(); $example = new Company(); $example->CompanyName = "c"; $example->Balance = 3; $example->save(); }
public function testModelReturnsConsistencyErrors() { $company = new Company(); $errors = []; try { $company->isConsistent(); } catch (ModelConsistencyValidationException $er) { $errors = $er->GetErrors(); } $this->assertCount(1, $errors); $this->assertEquals("CompanyName", key($errors)); }
public function testLimits() { MySql::executeStatement("TRUNCATE TABLE tblCompany"); $company = new Company(); $repos = $company->getRepository(); $repos->clearObjectCache(); $company = new Company(); $company->CompanyName = "A"; $company->save(); $company = new Company(); $company->CompanyName = "B"; $company->save(); $company = new Company(); $company->CompanyName = "B"; $company->save(); $company = new Company(); $company->CompanyName = "B"; $company->save(); $company = new Company(); $company->CompanyName = "C"; $company->save(); $company = new Company(); $company->CompanyName = "D"; $company->save(); $list = new Collection("\\Rhubarb\\Stem\\Tests\\Fixtures\\Company"); $list->setRange(2, 6); $this->assertCount(6, $list); $this->assertEquals("C", $list[2]->CompanyName); $sql = MySql::getPreviousStatement(true); $this->assertContains("LIMIT 2, 6", $sql); // Sorting by a computed column should mean that limits are no longer used. $list->addSort("CompanyIDSquared", true); $this->assertCount(6, $list); $this->assertEquals("C", $list[2]->CompanyName); $sql = MySql::getPreviousStatement(); $this->assertNotContains("LIMIT 2, 6", $sql); $sql = MySql::getPreviousStatement(true); $this->assertNotContains("LIMIT 2, 6", $sql); }
public function testIsNullFilter() { MySql::executeStatement("TRUNCATE TABLE tblCompany"); $company = new \Rhubarb\Stem\Tests\Fixtures\Company(); $company->CompanyName = "GCD"; $company->save(); $companies = new Collection('Rhubarb\\Stem\\Tests\\Fixtures\\Company'); $companies->filter(new Equals("CompanyName", null)); $this->assertEquals(0, $companies->count()); $companies = new Collection('Rhubarb\\Stem\\Tests\\Fixtures\\Company'); $companies->filter(new Equals("ProjectCount", null)); $this->assertEquals(1, $companies->count()); }
public function testMySqlAggregateSupport() { MySql::executeStatement("TRUNCATE TABLE tblCompany"); MySql::executeStatement("TRUNCATE TABLE tblUser"); $company1 = new Company(); $company1->getRepository()->clearObjectCache(); $company1->CompanyName = "1"; $company1->save(); $company2 = new Company(); $company2->CompanyName = "2"; $company2->save(); $user1 = new User(); $user1->Wage = 100; $company1->Users->Append($user1); $user2 = new User(); $user2->Wage = 200; $company1->Users->Append($user2); $user3 = new User(); $user3->Wage = 300; $company2->Users->Append($user3); $user4 = new User(); $user4->Wage = 400; $company2->Users->Append($user4); $companies = new Collection("Company"); $companies->addAggregateColumn(new Sum("Users.Wage")); $results = []; foreach ($companies as $company) { $results[] = $company->SumOfUsersWage; } $this->assertEquals([300, 700], $results); $sql = MySql::getPreviousStatement(); $this->assertEquals("SELECT `tblCompany`.*, SUM( `Users`.`Wage` ) AS `SumOfUsersWage` FROM `tblCompany` LEFT JOIN `tblUser` AS `Users` ON `tblCompany`.`CompanyID` = `Users`.`CompanyID` GROUP BY `tblCompany`.`CompanyID`", $sql); $companies = new Collection("Company"); $companies->addAggregateColumn(new Sum("Users.BigWage")); $results = []; foreach ($companies as $company) { $results[] = $company->SumOfUsersBigWage; } $this->assertEquals([3000, 7000], $results); }