StatementTest::testQueryForListResultClass() - Code Metrics - Inspection of "Merge pull request #572 from pradosoft/travis" - pradosoft/prado - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Branch — master (4dc390)

by Fabio
created 2016-02-29 19:31 UTC
StatementTest::testQueryForListResultClass() A

↳ Parent: StatementTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	12
Code Lines	9
Duplication

Lines	0
Ratio	0 %
Metric	Value
dl	0
loc	12
rs	9.4285
cc	1
eloc	9
nc	1
nop	0
<?php
require_once(dirname(__FILE__).'/BaseCase.php');

/**
 * @package System.DataAccess.SQLMap
 */
class StatementTest extends BaseCase
{
	function __construct()
	{
		parent::__construct();
		$this->initSqlMap();

		//force autoload
		new Account;
		new Order;
		new LineItem;
		new LineItemCollection;
		new A; new B; new C; new D; new E; new F;
// Bad
$a = 5; $b = 6; $c = 7;

// Good
$a = 5;
$b = 6;
$c = 7;
	}

	public function setup()
	{

	}

	function resetDatabase()
	{
		$this->initScript('account-init.sql');
		$this->initScript('order-init.sql');
		$this->initScript('line-item-init.sql');
//		$this->initScript('enumeration-init.sql');
		$this->initScript('other-init.sql');
	}


	#region Object Query tests


	/**
	 * Test Open connection with a connection string
	 */
	function testOpenConnection()
	{
		$conn = $this->sqlmap->getDbConnection();
		$conn->setActive(true);
		$account= $this->sqlmap->QueryForObject("SelectWithProperty");
		$conn->setActive(false);
		$this->assertAccount1($account);
	}

	/**
	 * Test use a statement with property subtitution
	 * (JIRA 22)
	 */
	function testSelectWithProperty()
	{
		$account= $this->sqlmap->QueryForObject("SelectWithProperty");
		$this->assertAccount1($account);
	}

	/**
	 * Test ExecuteQueryForObject Via ColumnName
	 */
	function testExecuteQueryForObjectViaColumnName()
	{
		$account= $this->sqlmap->QueryForObject("GetAccountViaColumnName", 1);
		$this->assertAccount1($account);
	}

	/**
	 * Test ExecuteQueryForObject Via ColumnIndex
	 */
	function testExecuteQueryForObjectViaColumnIndex()
	{
		$account= $this->sqlmap->QueryForObject("GetAccountViaColumnIndex", 1);
		$this->assertAccount1($account);
	}

	/**
	 * Test ExecuteQueryForObject Via ResultClass
	 */
	function testExecuteQueryForObjectViaResultClass()
	{
		$account= $this->sqlmap->QueryForObject("GetAccountViaResultClass", 1);
		$this->assertAccount1($account);
	}

	/**
	 * Test ExecuteQueryForObject With simple ResultClass : string
	 */
	function testExecuteQueryForObjectWithSimpleResultClass()
	{
		$email = $this->sqlmap->QueryForObject("GetEmailAddressViaResultClass", 1);
		$this->assertIdentical("[email protected]", $email);
	}

	/**
	 * Test ExecuteQueryForObject With simple ResultMap : string
	 */
	function testExecuteQueryForObjectWithSimpleResultMap()
	{
		$email = $this->sqlmap->QueryForObject("GetEmailAddressViaResultMap", 1);
		$this->assertIdentical("[email protected]", $email);
	}

	/**
	 * Test Primitive ReturnValue : TDateTime
	 */
	function testPrimitiveReturnValue()
	{
		$CardExpiry = $this->sqlmap->QueryForObject("GetOrderCardExpiryViaResultClass", 1);
		$date = @mktime(8, 15, 00, 2, 15, 2003);
		$this->assertIdentical($date, $CardExpiry->getTimeStamp());
	}

	/**
	 * Test ExecuteQueryForObject with result object : Account
	 */
	function testExecuteQueryForObjectWithResultObject()
	{
		$account= new Account();
		$testAccount = $this->sqlmap->QueryForObject("GetAccountViaColumnName", 1, $account);
		$this->assertAccount1($account);
		$this->assertTrue($account == $testAccount);
	}

	/**
	 * Test ExecuteQueryForObject as array
	 */
	function testExecuteQueryForObjectAsHashArray()
	{
		$account = $this->sqlmap->QueryForObject("GetAccountAsHashtable", 1);
		$this->assertAccount1AsHashArray($account);
	}

	/**
	 * Test ExecuteQueryForObject as Hashtable ResultClass
	 */
	function testExecuteQueryForObjectAsHashtableResultClass()
	{
		$account = $this->sqlmap->QueryForObject("GetAccountAsHashtableResultClass", 1);
		$this->assertAccount1AsHashArray($account);
	}

	/**
	 * Test ExecuteQueryForObject via Hashtable
	 */
	function testExecuteQueryForObjectViaHashtable()
	{
		$param["LineItem_ID"] = 2;
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
		$param["Order_ID"] = 9;

		$testItem = $this->sqlmap->QueryForObject("GetSpecificLineItem", $param);

		$this->assertNotNull($testItem);
		$this->assertIdentical("TSM-12", $testItem->getCode());
	}
	/**/

	//TODO: Test Query Dynamic Sql Element

	function testQueryDynamicSqlElement()
	{
		//$list = $this->sqlmap->QueryForList("GetDynamicOrderedEmailAddressesViaResultMap", "Account_ID");

		//$this->assertIdentical("[email protected]", $list[0]);

		//list = $this->sqlmap->QueryForList("GetDynamicOrderedEmailAddressesViaResultMap", "Account_FirstName");

		//$this->assertIdentical("[email protected]", $list[0]);

	}

	// TODO: Test Execute QueryForList With ResultMap With Dynamic Element

	function testExecuteQueryForListWithResultMapWithDynamicElement()
	{
		//$list = $this->sqlmap->QueryForList("GetAllAccountsViaResultMapWithDynamicElement", "LIKE");

		//$this->assertAccount1$list[0]);
		//$this->assertIdentical(3, $list->getCount());
		//$this->assertIdentical(1, $list[0]->getID());
		//$this->assertIdentical(2, $list[1]->getID());
		//$this->assertIdentical(4, $list[2]->getID());

		//list = $this->sqlmap->QueryForList("GetAllAccountsViaResultMapWithDynamicElement", "=");

		//$this->assertIdentical(0, $list->getCount());
	}



	/**
	 * Test Get Account Via Inline Parameters
	 */
	function testExecuteQueryForObjectViaInlineParameters()
	{
		$account= new Account();
		$account->setID(1);

		$testAccount = $this->sqlmap->QueryForObject("GetAccountViaInlineParameters", $account);

		$this->assertAccount1($testAccount);
	}
	/**/

	// TODO: Test ExecuteQuery For Object With Enum property


	function testExecuteQueryForObjectWithEnum()
	{
		//$enumClass = $this->sqlmap->QueryForObject("GetEnumeration", 1);

		//$this->assertIdentical(enumClass.Day, Days.Sat);
		//$this->assertIdentical(enumClass.Color, Colors.Red);
		//$this->assertIdentical(enumClass.Month, Months.August);

		//enumClass = $this->sqlmap->QueryForObject("GetEnumeration", 3) as Enumeration;

		//$this->assertIdentical(enumClass.Day, Days.Mon);
		//$this->assertIdentical(enumClass.Color, Colors.Blue);
		//$this->assertIdentical(enumClass.Month, Months.September);*/
	}

	#endregion


	#region  List Query tests


	/**
	 * Test QueryForList with Hashtable ResultMap
	 */
	function testQueryForListWithHashtableResultMap()
	{
		$this->initScript('account-init.sql');
		$list = $this->sqlmap->QueryForList("GetAllAccountsAsHashMapViaResultMap");

		$this->assertAccount1AsHashArray($list[0]);
		$this->assertIdentical(5, count($list));

		$this->assertIdentical(1, (int)$list[0]["Id"]);
		$this->assertIdentical(2, (int)$list[1]["Id"]);
		$this->assertIdentical(3, (int)$list[2]["Id"]);
		$this->assertIdentical(4, (int)$list[3]["Id"]);
		$this->assertIdentical(5, (int)$list[4]["Id"]);
	}

	/**
	 * Test QueryForList with Hashtable ResultClass
	 */
	function testQueryForListWithHashtableResultClass()
	{
		$list = $this->sqlmap->QueryForList("GetAllAccountsAsHashtableViaResultClass");

		$this->assertAccount1AsHashArray($list[0]);
		$this->assertIdentical(5, count($list));

		$this->assertIdentical(1, (int)$list[0]["Id"]);
		$this->assertIdentical(2, (int)$list[1]["Id"]);
		$this->assertIdentical(3, (int)$list[2]["Id"]);
		$this->assertIdentical(4, (int)$list[3]["Id"]);
		$this->assertIdentical(5, (int)$list[4]["Id"]);
	}

	/**
	 * Test QueryForList with IList ResultClass
	 */
	function testQueryForListWithIListResultClass()
	{
		$list = $this->sqlmap->QueryForList("GetAllAccountsAsArrayListViaResultClass");

		$listAccount = $list[0];

		$this->assertIdentical(1,(int)$listAccount[0]);
		$this->assertIdentical("Joe",$listAccount[1]);
		$this->assertIdentical("Dalton",$listAccount[2]);
		$this->assertIdentical("[email protected]",$listAccount[3]);

		$this->assertIdentical(5, count($list));

		$listAccount = $list[0];
		$this->assertIdentical(1, (int)$listAccount[0]);
		$listAccount = $list[1];
		$this->assertIdentical(2, (int)$listAccount[0]);
		$listAccount = $list[2];
		$this->assertIdentical(3, (int)$listAccount[0]);
		$listAccount = $list[3];
		$this->assertIdentical(4, (int)$listAccount[0]);
		$listAccount = $list[4];
		$this->assertIdentical(5, (int)$listAccount[0]);
	}

	/**
	 * Test QueryForList With ResultMap, result collection as ArrayList
	 */
	function testQueryForListWithResultMap()
	{
		$list = $this->sqlmap->QueryForList("GetAllAccountsViaResultMap");

		$this->assertAccount1($list[0]);
		$this->assertIdentical(5, count($list));
		$this->assertIdentical(1, $list[0]->getID());
		$this->assertIdentical(2, $list[1]->getID());
		$this->assertIdentical(3, $list[2]->getID());
		$this->assertIdentical(4, $list[3]->getID());
		$this->assertIdentical(5, $list[4]->getID());
	}

	/**
	 * Test ExecuteQueryForPaginatedList
	 */
	function testExecuteQueryForPaginatedList()
	{
		// Get List of all 5
		$list = $this->sqlmap->QueryForPagedList("GetAllAccountsViaResultMap", null, 2);

		// Test initial state (page 0)
		$this->assertFalse($list->getIsPreviousPageAvailable());
		$this->assertTrue($list->getIsNextPageAvailable());
		$this->assertAccount1($list[0]);
		$this->assertIdentical(2, $list->getCount());
		$this->assertIdentical(1, $list[0]->getID());
		$this->assertIdentical(2, $list[1]->getID());

		// Test illegal previous page (no effect, state should be same)
		$list->PreviousPage();
		$this->assertFalse($list->getIsPreviousPageAvailable());
		$this->assertTrue($list->getIsNextPageAvailable());
		$this->assertAccount1($list[0]);
		$this->assertIdentical(2, $list->getCount());
		$this->assertIdentical(1, $list[0]->getID());
		$this->assertIdentical(2, $list[1]->getID());

		// Test next (page 1)
		$list->NextPage();
		$this->assertTrue($list->getIsPreviousPageAvailable());
		$this->assertTrue($list->getIsNextPageAvailable());
		$this->assertIdentical(2, $list->getCount());
		$this->assertIdentical(3, $list[0]->getID());
		$this->assertIdentical(4, $list[1]->getID());

		// Test next (page 2 -last)
		$list->NextPage();
		$this->assertTrue($list->getIsPreviousPageAvailable());
		$this->assertFalse($list->getIsNextPageAvailable());
		$this->assertIdentical(1, $list->getCount());
		$this->assertIdentical(5, $list[0]->getID());

		// Test previous (page 1)
		$list->PreviousPage();
		$this->assertTrue($list->getIsPreviousPageAvailable());
		$this->assertTrue($list->getIsNextPageAvailable());
		$this->assertIdentical(2, $list->getCount());
		$this->assertIdentical(3, $list[0]->getID());
		$this->assertIdentical(4, $list[1]->getID());

		// Test previous (page 0 -first)
		$list->PreviousPage();
		$this->assertFalse($list->getIsPreviousPageAvailable());
		$this->assertTrue($list->getIsNextPageAvailable());
		$this->assertAccount1($list[0]);
		$this->assertIdentical(2, $list->getCount());
		$this->assertIdentical(1, $list[0]->getID());
		$this->assertIdentical(2, $list[1]->getID());

		// Test goto (page 0)
		$list->GotoPage(0);
		$this->assertFalse($list->getIsPreviousPageAvailable());
		$this->assertTrue($list->getIsNextPageAvailable());
		$this->assertIdentical(2, $list->getCount());
		$this->assertIdentical(1, $list[0]->getID());
		$this->assertIdentical(2, $list[1]->getID());

		// Test goto (page 1)
		$list->GotoPage(1);
		$this->assertTrue($list->getIsPreviousPageAvailable());
		$this->assertTrue($list->getIsNextPageAvailable());
		$this->assertIdentical(2, $list->getCount());
		$this->assertIdentical(3, $list[0]->getID());
		$this->assertIdentical(4, $list[1]->getID());

		// Test goto (page 2)
		$list->GotoPage(2);
		$this->assertTrue($list->getIsPreviousPageAvailable());
		$this->assertFalse($list->getIsNextPageAvailable());
		$this->assertIdentical(1, $list->getCount());
		$this->assertIdentical(5, $list[0]->getID());

		// Test illegal goto (page 0)
		$list->GotoPage(3);
		$this->assertTrue($list->getIsPreviousPageAvailable());
		$this->assertFalse($list->getIsNextPageAvailable());
		$this->assertIdentical(0, $list->getCount());

		$list = $this->sqlmap->QueryForPagedList("GetNoAccountsViaResultMap", null, 2);

		// Test empty list
		$this->assertFalse($list->getIsPreviousPageAvailable());
		$this->assertFalse($list->getIsNextPageAvailable());
		$this->assertIdentical(0, $list->getCount());

		// Test next
		$list->NextPage();
		$this->assertFalse($list->getIsPreviousPageAvailable());
		$this->assertFalse($list->getIsNextPageAvailable());
		$this->assertIdentical(0, $list->getCount());

		// Test previous
		$list->PreviousPage();
		$this->assertFalse($list->getIsPreviousPageAvailable());
		$this->assertFalse($list->getIsNextPageAvailable());
		$this->assertIdentical(0, $list->getCount());

		// Test previous
		$list->GotoPage(0);
		$this->assertFalse($list->getIsPreviousPageAvailable());
		$this->assertFalse($list->getIsNextPageAvailable());
		$this->assertIdentical(0, $list->getCount());
		$list = $this->sqlmap->QueryForPagedList("GetFewAccountsViaResultMap", null, 2);

		$this->assertFalse($list->getIsPreviousPageAvailable());
		$this->assertFalse($list->getIsNextPageAvailable());
		$this->assertIdentical(1, $list->getCount());

		// Test next
		$list->NextPage();
		$this->assertFalse($list->getIsPreviousPageAvailable());
		$this->assertFalse($list->getIsNextPageAvailable());
		$this->assertIdentical(1, $list->getCount());
		// Test previous
		$list->PreviousPage();
		$this->assertFalse($list->getIsPreviousPageAvailable());
		$this->assertFalse($list->getIsNextPageAvailable());
		$this->assertIdentical(1, $list->getCount());

		// Test previous
		$list->GotoPage(0);
		$this->assertFalse($list->getIsPreviousPageAvailable());
		$this->assertFalse($list->getIsNextPageAvailable());
		$this->assertIdentical(1, $list->getCount());


		$list = $this->sqlmap->QueryForPagedList("GetAllAccountsViaResultMap", null, 5);

		$this->assertIdentical(5, $list->getCount());

		$list->NextPage();
		$this->assertIdentical(5, $list->getCount());

		$b = $list->getIsPreviousPageAvailable();
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
		$list->PreviousPage();
		$this->assertIdentical(5, $list->getCount());
	}

	/**
	 * Test QueryForList with ResultObject :
	 * AccountCollection strongly typed collection
	 */
	function testQueryForListWithResultObject()
	{
		$accounts = new AccountCollection();

		$this->sqlmap->QueryForList("GetAllAccountsViaResultMap", null, $accounts);
		$this->assertAccount1($accounts[0]);
		$this->assertIdentical(5, $accounts->getCount());
		$this->assertIdentical(1, $accounts[0]->getID());
		$this->assertIdentical(2, $accounts[1]->getID());
		$this->assertIdentical(3, $accounts[2]->getID());
		$this->assertIdentical(4, $accounts[3]->getID());
		$this->assertIdentical(5, $accounts[4]->GetId());
	}

	/**
	 * Test QueryForList with ListClass : LineItemCollection
	 */
	function testQueryForListWithListClass()
	{
		$linesItem = $this->sqlmap->QueryForList("GetLineItemsForOrderWithListClass", 10);

		$this->assertNotNull($linesItem);
		$this->assertIdentical(2, $linesItem->getCount());
		$this->assertIdentical("ESM-34", $linesItem[0]->getCode());
		$this->assertIdentical("QSM-98", $linesItem[1]->getCode());
	}

	/**
	 * Test QueryForList with no result.
	 */
	function testQueryForListWithNoResult()
	{
		$list = $this->sqlmap->QueryForList("GetNoAccountsViaResultMap");

		$this->assertIdentical(0, count($list));
	}

	/**
	 * Test QueryForList with ResultClass : Account.
	 */
	function testQueryForListResultClass()
	{
		$list = $this->sqlmap->QueryForList("GetAllAccountsViaResultClass");

		$this->assertAccount1($list[0]);
		$this->assertIdentical(5, count($list));
		$this->assertIdentical(1, $list[0]->getID());
		$this->assertIdentical(2, $list[1]->getID());
		$this->assertIdentical(3, $list[2]->getID());
		$this->assertIdentical(4, $list[3]->getID());
		$this->assertIdentical(5, $list[4]->getID());
	}

	/**
	 * Test QueryForList with simple resultClass : string
	 */
	function testQueryForListWithSimpleResultClass()
	{
		$list = $this->sqlmap->QueryForList("GetAllEmailAddressesViaResultClass");

		$this->assertIdentical("[email protected]", $list[0]);
		$this->assertIdentical("[email protected]", $list[1]);
		$this->assertIdentical('', $list[2]);
		$this->assertIdentical("[email protected]", $list[3]);
		$this->assertIdentical('', $list[4]);
	}

	/**
	 * Test  QueryForList with simple ResultMap : string
	 */
	function testQueryForListWithSimpleResultMap()
	{
		$list = $this->sqlmap->QueryForList("GetAllEmailAddressesViaResultMap");

		$this->assertIdentical("[email protected]", $list[0]);
		$this->assertIdentical("[email protected]", $list[1]);
		$this->assertIdentical('', $list[2]);
		$this->assertIdentical("[email protected]", $list[3]);
		$this->assertIdentical('', $list[4]);
	}

	/**
	 * Test QueryForListWithSkipAndMax
	 */
	function testQueryForListWithSkipAndMax()
	{
		$list = $this->sqlmap->QueryForList("GetAllAccountsViaResultMap", null, null, 2, 2);

		$this->assertIdentical(2, count($list));
		$this->assertIdentical(3, $list[0]->getID());
		$this->assertIdentical(4, $list[1]->getID());
	}


	/**
	 * Test row delegate
	 */
	function testQueryWithRowDelegate()
	{
		//$handler = new SqlMapper.RowDelegate(this.RowHandler);

		//$list = $this->sqlmap->QueryWithRowDelegate("GetAllAccountsViaResultMap", null, handler);

		//$this->assertIdentical(5, _index);
		//$this->assertIdentical(5, $list->getCount());
		//$this->assertAccount1$list[0]);
		//$this->assertIdentical(1, $list[0]->getID());
		//$this->assertIdentical(2, $list[1]->getID());
		//$this->assertIdentical(3, $list[2]->getID());
		//$this->assertIdentical(4, $list[3]->getID());
		//$this->assertIdentical(5, $list[4]->getID());
	}

	#endregion


	#region  Map Tests


	/**
	 * Test ExecuteQueryForMap : Hashtable.
	 */
	function testExecuteQueryForMap()
	{
		$map = $this->sqlmap->QueryForMap("GetAllAccountsViaResultClass", null, "FirstName");

		$this->assertIdentical(5, count($map));
		$this->assertAccount1($map["Joe"]);

		$this->assertIdentical(1, $map["Joe"]->getID());
		$this->assertIdentical(2, $map["Averel"]->getID());
		$this->assertIdentical(3, $map["William"]->getID());
		$this->assertIdentical(4, $map["Jack"]->getID());
		$this->assertIdentical(5, $map["Gilles"]->getID());
	}

	/**
	 * Test ExecuteQueryForMap : Hashtable.
	 *
	 * If the keyProperty is an integer, you must acces the map
	 * by map[integer] and not by map["integer"]
	 */
	function testExecuteQueryForMap2()
	{
		$map = $this->sqlmap->QueryForMap("GetAllOrderWithLineItems", null, "PostalCode");

		$this->assertIdentical(11, count($map));
		$order = $map["T4H 9G4"];

		$this->assertIdentical(2, $order->getLineItemsList()->getCount());
	}

	/**
	 * Test ExecuteQueryForMap with value property :
	 * "FirstName" as key, "EmailAddress" as value
	 */
	function testExecuteQueryForMapWithValueProperty()
	{
		$map = $this->sqlmap->QueryForMap("GetAllAccountsViaResultClass", null,
						"FirstName", "EmailAddress");

		$this->assertIdentical(5, count($map));

		$this->assertIdentical("[email protected]", $map["Joe"]);
		$this->assertIdentical("[email protected]", $map["Averel"]);
		$this->assertNull($map["William"]);
		$this->assertIdentical("[email protected]", $map["Jack"]);
		$this->assertNull($map["Gilles"]);
	}

	/**
	 * Test ExecuteQueryForWithJoined
	 */
	function testExecuteQueryForWithJoined()
	{
		$order = $this->sqlmap->QueryForObject("GetOrderJoinWithAccount",10);

		$this->assertNotNull($order->getAccount());

		$order = $this->sqlmap->QueryForObject("GetOrderJoinWithAccount",11);

		$this->assertNull($order->getAccount());
	}

	/**
	 * Test ExecuteQueryFor With Complex Joined
	 *
	 * A->B->C
	 *  ->E
	 *  ->F
	 */
	function testExecuteQueryForWithComplexJoined()
	{
		$a = $this->sqlmap->QueryForObject("SelectComplexJoined");
		$this->assertNotNull($a);
		$this->assertNotNull($a->getB());
		$this->assertNotNull($a->getB()->getC());
		$this->assertNull($a->getB()->getD());
		$this->assertNotNull($a->getE());
		$this->assertNull($a->getF());
	}
	#endregion


	#region Extends statement


	/**
	 * Test base Extends statement
	 */
	function testExtendsGetAllAccounts()
	{
		$list = $this->sqlmap->QueryForList("GetAllAccounts");

		$this->assertAccount1($list[0]);
		$this->assertIdentical(5, count($list));
		$this->assertIdentical(1, $list[0]->getID());
		$this->assertIdentical(2, $list[1]->getID());
		$this->assertIdentical(3, $list[2]->getID());
		$this->assertIdentical(4, $list[3]->getID());
		$this->assertIdentical(5, $list[4]->getID());
	}

	/**
	 * Test Extends statement GetAllAccountsOrderByName extends GetAllAccounts
	 */
	function testExtendsGetAllAccountsOrderByName()
	{
		$list = $this->sqlmap->QueryForList("GetAllAccountsOrderByName");

		$this->assertAccount1($list[3]);
		$this->assertIdentical(5, count($list));

		$this->assertIdentical(2, $list[0]->getID());
		$this->assertIdentical(5, $list[1]->getID());
		$this->assertIdentical(4, $list[2]->getID());
		$this->assertIdentical(1, $list[3]->getID());
		$this->assertIdentical(3, $list[4]->getID());
	}

	/**
	 * Test Extends statement GetOneAccount extends GetAllAccounts
	 */
	function testExtendsGetOneAccount()
	{
		$account= $this->sqlmap->QueryForObject("GetOneAccount", 1);
		$this->assertAccount1($account);
	}

	/**
	 * Test Extends statement GetSomeAccount extends GetAllAccounts
	 */
	function testExtendsGetSomeAccount()
	{
		$param["lowID"] = 2;
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
		$param["hightID"] = 4;

		$list = $this->sqlmap->QueryForList("GetSomeAccount", $param);

		$this->assertIdentical(3, count($list));

		$this->assertIdentical(2, $list[0]->getID());
		$this->assertIdentical(3, $list[1]->getID());
		$this->assertIdentical(4, $list[2]->getID());
	}

	#endregion


	#region Update tests



	/**
	 * Test Insert account via public fields
	 */
	function testInsertAccountViaPublicFields()
	{
		$this->initScript('account-init.sql');

		$account = new AccountBis();

		$account->Id = 10;
		$account->FirstName = "Luky";
		$account->LastName = "Luke";
		$account->EmailAddress = "[email protected]";

		$this->sqlmap->Insert("InsertAccountViaPublicFields", $account);

		$testAccount = $this->sqlmap->QueryForObject("GetAccountViaColumnName", 10);

		$this->assertNotNull($testAccount);

		$this->assertIdentical(10, $testAccount->getID());

		$this->initScript('account-init.sql');
	}

	/**
	 *
	 */
	function testInsertOrderViaProperties()
	{
		$this->initScript('account-init.sql');
		$this->initScript('order-init.sql');
		$account= $this->NewAccount6();

		$this->sqlmap->Insert("InsertAccountViaParameterMap", $account);

		$order = new Order();
		$order->setId(99);
		$order->setCardExpiry("09/11");
		$order->setAccount($account);
		$order->setCardNumber("154564656");
		$order->setCardType("Visa");
		$order->setCity("Lyon");
		$order->setDate('2005-05-20');
		$order->setPostalCode("69004");
		$order->setProvince("Rhone");
		$order->setStreet("rue Durand");

		$this->sqlmap->Insert("InsertOrderViaPublicFields", $order);

		$this->initScript('account-init.sql');
		$this->initScript('order-init.sql');
	}


	/**
	 * Test Insert account via inline parameters
	 */
	function testInsertAccountViaInlineParameters()
	{
		$this->initScript('account-init.sql');
		$account= new Account();

		$account->setId(10);
		$account->setFirstName("Luky");
		$account->setLastName("Luke");
		$account->setEmailAddress("[email protected]");

		$this->sqlmap->Insert("InsertAccountViaInlineParameters", $account);

		$testAccount = $this->sqlmap->QueryForObject("GetAccountViaColumnIndex", 10);

		$this->assertNotNull($testAccount);
		$this->assertIdentical(10, $testAccount->getId());
		$this->initScript('account-init.sql');
	}

	/**
	 * Test Insert account via parameterMap
	 */
	function testInsertAccountViaParameterMap()
	{
		$this->initScript('account-init.sql');
		$account= $this->NewAccount6();
		$this->sqlmap->Insert("InsertAccountViaParameterMap", $account);

		$account = $this->sqlmap->QueryForObject("GetAccountNullableEmail", 6);
		$this->AssertAccount6($account);

		$this->initScript('account-init.sql');
	}

	/**
	 * Test Update via parameterMap
	 */
	function testUpdateViaParameterMap()
	{
		$this->initScript('account-init.sql');
		$account= $this->sqlmap->QueryForObject("GetAccountViaColumnName", 1);

		$account->setEmailAddress("[email protected]");
		$this->sqlmap->Update("UpdateAccountViaParameterMap", $account);

		$account = $this->sqlmap->QueryForObject("GetAccountViaColumnName", 1);

		$this->assertIdentical("[email protected]", $account->getEmailAddress());
		$this->initScript('account-init.sql');
	}

	/**
	 * Test Update via parameterMap V2
	 */
	function testUpdateViaParameterMap2()
	{
		$this->initScript('account-init.sql');
		$account= $this->sqlmap->QueryForObject("GetAccountViaColumnName", 1);

		$account->setEmailAddress("[email protected]");
		$this->sqlmap->Update("UpdateAccountViaParameterMap2", $account);

		$account = $this->sqlmap->QueryForObject("GetAccountViaColumnName", 1);

		$this->assertIdentical("[email protected]", $account->getEmailAddress());
		$this->initScript('account-init.sql');
	}

	/**
	 * Test Update with inline parameters
	 */
	function testUpdateWithInlineParameters()
	{
		$this->initScript('account-init.sql');
		$account= $this->sqlmap->QueryForObject("GetAccountViaColumnName", 1);

		$account->setEmailAddress("[email protected]");
		$this->sqlmap->Update("UpdateAccountViaInlineParameters", $account);

		$account = $this->sqlmap->QueryForObject("GetAccountViaColumnName", 1);

		$this->assertIdentical("[email protected]", $account->getEmailAddress());
		$this->initScript('account-init.sql');
	}

	/**
	 * Test Execute Update With Parameter Class
	 */
	function testExecuteUpdateWithParameterClass()
	{
		$this->initScript('account-init.sql');
		$account= $this->NewAccount6();

		$this->sqlmap->Insert("InsertAccountViaParameterMap", $account);

		$noRowsDeleted = $this->sqlmap->Update("DeleteAccount", null);

		$this->sqlmap->Update("DeleteAccount", $account);

		$account = $this->sqlmap->QueryForObject("GetAccountViaColumnName", 6);

		$this->assertNull($account);
		$this->assertIdentical(0, $noRowsDeleted);
		$this->initScript('account-init.sql');
	}

	/**
	 * Test Execute Delete
	 */
	function testExecuteDelete()
	{
		$this->initScript('account-init.sql');
		$account= $this->NewAccount6();

		$this->sqlmap->Insert("InsertAccountViaParameterMap", $account);

		$account = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
		$account = $this->sqlmap->QueryForObject("GetAccountViaColumnName", 6);

		$this->assertTrue($account->getId() == 6);

		$rowNumber = $this->sqlmap->Delete("DeleteAccount", $account);
		$this->assertTrue($rowNumber == 1);

		$account = $this->sqlmap->QueryForObject("GetAccountViaColumnName", 6);

		$this->assertNull($account);
		$this->initScript('account-init.sql');
	}

	/**
	 * Test Execute Delete
	 */
	function testDeleteWithComments()
	{
		$this->initScript('line-item-init.sql');
		$rowNumber = $this->sqlmap->Delete("DeleteWithComments");

		$this->assertIdentical($rowNumber, 2);
		$this->initScript('line-item-init.sql');
	}



	#endregion


	#region Row delegate


	private $_index = 0;


	function RowHandler($sender, $paramterObject, $list)
	{
		//_index++;
		//$this->assertIdentical(_index, (($account) obj).Id);
		//$list->Add(obj);
	}

	#endregion


	#region JIRA Tests


	/**
	 * Test JIRA 30 (repeating property)
	 */
	function testJIRA30()
	{
		$account= new Account();
		$account->setId(1);
		$account->setFirstName("Joe");
		$account->setLastName("Dalton");
		$account->setEmailAddress("[email protected]");

		$result = $this->sqlmap->QueryForObject("GetAccountWithRepeatingProperty", $account);

		$this->assertAccount1($result);
	}

	/**
	 * Test Bit column
	 */
	function testJIRA42()
	{
		$other = new Other();

		$other->setInt(100);
		$other->setBool(true);
		$other->setLong(789456321);

		$this->sqlmap->Insert("InsertBool", $other);
	}

	/**
	 * Test for access a result map in a different namespace
	 */
	function testJIRA45()
	{
		$account= $this->sqlmap->QueryForObject("GetAccountJIRA45", 1);
		$this->assertAccount1($account);
	}

	/**
	 * Test : Whitespace is not maintained properly when CDATA tags are used
	 */
	function testJIRA110()
	{
		$account= $this->sqlmap->QueryForObject("Get1Account");
		$this->assertAccount1($account);
	}

	/**
	 * Test : Whitespace is not maintained properly when CDATA tags are used
	 */
	function testJIRA110Bis()
	{
		$list = $this->sqlmap->QueryForList("GetAccounts");

		$this->assertAccount1($list[0]);
		$this->assertIdentical(5, count($list));
	}

	/**
	 * Test for cache stats only being calculated on CachingStatments
	 */
	function testJIRA113()
	{
	  //	$this->sqlmap->FlushCaches();

		// taken from TestFlushDataCache()
		// first query is not cached, second query is: 50% cache hit
		/*$list = $this->sqlmap->QueryForList("GetCachedAccountsViaResultMap");
		$firstId = HashCodeProvider.GetIdentityHashCode(list);
		list = $this->sqlmap->QueryForList("GetCachedAccountsViaResultMap");
		int secondId = HashCodeProvider.GetIdentityHashCode(list);
		$this->assertIdentical(firstId, secondId);

		string cacheStats = $this->sqlmap->GetDataCacheStats();

		$this->assertNotNull(cacheStats);*/
	}

	#endregion


	#region CustomTypeHandler tests


	/**
	 * Test CustomTypeHandler
	 */
	function testExecuteQueryWithCustomTypeHandler()
	{
		$this->sqlmap->registerTypeHandler(new HundredsBool());
		$this->sqlmap->registerTypeHandler(new OuiNonBool());

		$list = $this->sqlmap->QueryForList("GetAllAccountsViaCustomTypeHandler");

		$this->assertAccount1($list[0]);
		$this->assertIdentical(5, count($list));
		$this->assertIdentical(1, $list[0]->getID());
		$this->assertIdentical(2, $list[1]->getID());
		$this->assertIdentical(3, $list[2]->getID());
		$this->assertIdentical(4, $list[3]->getID());
		$this->assertIdentical(5, $list[4]->getID());

		$this->assertFalse($list[0]->getCartOptions());
		$this->assertFalse($list[1]->getCartOptions());
		$this->assertTrue($list[2]->getCartOptions());
		$this->assertTrue($list[3]->getCartOptions());
		$this->assertTrue($list[4]->getCartOptions());

		$this->assertTrue($list[0]->getBannerOptions());
		$this->assertTrue($list[1]->getBannerOptions());
		$this->assertFalse($list[2]->getBannerOptions());
		$this->assertFalse($list[3]->getBannerOptions());
		$this->assertTrue($list[4]->getBannerOptions());
	}

	/**
	 * Test CustomTypeHandler Oui/Non
	 */
	function testCustomTypeHandler()
	{
		$this->initScript('other-init.sql');
		$this->initScript('account-init.sql');

		$this->sqlmap->registerTypeHandler(new OuiNonBool());

		$other = new Other();
		$other->setInt(99);
		$other->setLong(1966);
		$other->setBool(true);
		$other->setBool2(false);
		$this->sqlmap->Insert("InsertCustomTypeHandler", $other);

		$anOther = $this->sqlmap->QueryForObject("SelectByInt", 99);
		$this->assertNotNull( $anOther );
		$this->assertIdentical(99, (int)$anOther->getInt());
		$this->assertIdentical(1966, (int)$anOther->getLong());
		$this->assertIdentical(true, (boolean)$anOther->getBool());
		$this->assertIdentical(false, (boolean)$anOther->getBool2());

	}

	/**
	 * Test CustomTypeHandler Oui/Non
	 */
	function testInsertInlineCustomTypeHandlerV1()
	{
		$this->initScript('other-init.sql');
		$this->initScript('account-init.sql');

		$other = new Other();
		$other->setInt(99);
		$other->setLong(1966);
		$other->setBool(true);
		$other->setBool2(false);

		$this->sqlmap->Insert("InsertInlineCustomTypeHandlerV1", $other);

		$anOther = $this->sqlmap->QueryForObject("SelectByIntV1", 99);

		$this->assertNotNull( $anOther );
		$this->assertIdentical(99, (int)$anOther->getInt());
		$this->assertIdentical(1966, (int)$anOther->getLong());
		$this->assertIdentical(true, (boolean)$anOther->getBool());
		$this->assertIdentical(false, (boolean)$anOther->getBool2());

	}

	/**
	 * Test CustomTypeHandler Oui/Non
	 */
	function testInsertInlineCustomTypeHandlerV2()
	{
		$this->initScript('other-init.sql');
		$this->initScript('account-init.sql');

		$other = new Other();
		$other->setInt(99);
		$other->setLong(1966);
		$other->setBool(true);
		$other->setBool2(false);

		$this->sqlmap->Insert("InsertInlineCustomTypeHandlerV2", $other);

		$anOther = $this->sqlmap->QueryForObject("SelectByInt", 99);

		$this->assertNotNull( $anOther );
		$this->assertIdentical(99, (int)$anOther->getInt());
		$this->assertIdentical(1966, (int)$anOther->getLong());
		$this->assertIdentical(true, (boolean)$anOther->getBool());
		$this->assertIdentical(false, (boolean)$anOther->getBool2());
	}
	#endregion

	/**/
}

1			<?php
2			require_once(dirname(__FILE__).'/BaseCase.php');
3
4			/**
5			* @package System.DataAccess.SQLMap
6			*/
7			class StatementTest extends BaseCase
8			{
9			function __construct()
10			{
11			parent::__construct();
12			$this->initSqlMap();
13
14			//force autoload
15			new Account;
16			new Order;
17			new LineItem;
18			new LineItemCollection;
19			new A; new B; new C; new D; new E; new F;
			0 ignored issues – show Coding Style introduced 2016-02-29 19:57 UTC by Report Bug Copy Issue Report It is generally recommended to place each PHP statement on a line by itself. Let’s take a look at an example: // Bad $a = 5; $b = 6; $c = 7; // Good $a = 5; $b = 6; $c = 7; Loading history...
20			}
21
22			public function setup()
23			{
24
25			}
26
27			function resetDatabase()
28			{
29			$this->initScript('account-init.sql');
30			$this->initScript('order-init.sql');
31			$this->initScript('line-item-init.sql');
32			// $this->initScript('enumeration-init.sql');
33			$this->initScript('other-init.sql');
34			}
35
36
37			#region Object Query tests
			0 ignored issues – show Coding Style introduced 2016-02-29 19:57 UTC by Report Bug Copy Issue Report Perl-style comments are not allowed. Use "// Comment." or "/* comment */" instead. Loading history...
38
pradosoft / prado

Branch — master (4dc390)

StatementTest::testQueryForListResultClass() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like
