~tsep-dev/tsep/0.9-beta

$this->assertEqual(trim($test->simulated[0]), 'SELECT `Article`.`id` FROM `' . $this->testDb->fullTableName('article', false) . '` AS `Article` WHERE 1 = 1');

1370

1371

$test->startQuote = '[';

1372

$test->endQuote = ']';

1373

$this->assertEqual($this->Model->escapeField(), '[Article].[id]');

1374

1375

$result = $test->fields($this->Model, null, $this->Model->escapeField());

1376

$this->assertEqual($result, array('[Article].[id]'));

1377

1378

$result = $test->read($this->Model, array(

1379

'fields' => $this->Model->escapeField(),

1380

'conditions' => null,

1381

'recursive' => -1

1382

));

1383

$this->assertEqual(trim($test->simulated[1]), 'SELECT [Article].[id] FROM [' . $this->testDb->fullTableName('article', false) . '] AS [Article] WHERE 1 = 1');

1384

1385

ClassRegistry::removeObject('Article');

1386

}

1387

1388

/**

1389

* testGenerateAssociationQuerySelfJoin method

1390

1391

* @access public

1392

* @return void

1393

1394

function testGenerateAssociationQuerySelfJoin() {

1395

$this->startTime = microtime(true);

1396

$this->Model =& new Article2();

1397

$this->_buildRelatedModels($this->Model);

1398

$this->_buildRelatedModels($this->Model->Category2);

1399

$this->Model->Category2->ChildCat =& new Category2();

1400

$this->Model->Category2->ParentCat =& new Category2();

1401

1402

$queryData = array();

1403

1404

foreach ($this->Model->Category2->__associations as $type) {

1405

foreach ($this->Model->Category2->{$type} as $assoc => $assocData) {

1406

$linkModel =& $this->Model->Category2->{$assoc};

1407

$external = isset($assocData['external']);

1408

1409

if ($this->Model->Category2->alias == $linkModel->alias && $type != 'hasAndBelongsToMany' && $type != 'hasMany') {

1410

$result = $this->testDb->generateAssociationQuery($this->Model->Category2, $linkModel, $type, $assoc, $assocData, $queryData, $external, $null);

1411

$this->assertTrue($result);

1412

} else {

1413

if ($this->Model->Category2->useDbConfig == $linkModel->useDbConfig) {

1414

$result = $this->testDb->generateAssociationQuery($this->Model->Category2, $linkModel, $type, $assoc, $assocData, $queryData, $external, $null);

1415

$this->assertTrue($result);

1416

}

1417

}

1418

}

1419

}

1420

1421

$query = $this->testDb->generateAssociationQuery($this->Model->Category2, $null, null, null, null, $queryData, false, $null);

1422

$this->assertPattern('/^SELECT\s+(.+)FROM(.+)`Category2`\.`group_id`\s+=\s+`Group`\.`id`\)\s+LEFT JOIN(.+)WHERE\s+1 = 1\s*$/', $query);

1423

1424

$this->Model =& new TestModel4();

1425

$this->Model->schema();

1426

$this->_buildRelatedModels($this->Model);

1427

1428

$binding = array('type' => 'belongsTo', 'model' => 'TestModel4Parent');

1429

$queryData = array();

1430

$resultSet = null;

1431

$null = null;

1432

1433

$params = &$this->_prepareAssociationQuery($this->Model, $queryData, $binding);

1434

1435

$_queryData = $queryData;

1436

$result = $this->testDb->generateAssociationQuery($this->Model, $params['linkModel'], $params['type'], $params['assoc'], $params['assocData'], $queryData, $params['external'], $resultSet);

1437

$this->assertTrue($result);

1438

1439

$expected = array(

1440

'fields' => array(

1441

'`TestModel4`.`id`',

1442

'`TestModel4`.`name`',

1443

'`TestModel4`.`created`',

1444

'`TestModel4`.`updated`',

1445

'`TestModel4Parent`.`id`',

1446

'`TestModel4Parent`.`name`',

1447

'`TestModel4Parent`.`created`',

1448

'`TestModel4Parent`.`updated`'

1449

1450

'joins' => array(

1451

array(

1452

'table' => '`test_model4`',

1453

'alias' => 'TestModel4Parent',

1454

'type' => 'LEFT',

1455

'conditions' => '`TestModel4`.`parent_id` = `TestModel4Parent`.`id`'

1456

)

1457

1458

'limit' => array(),

1459

'offset' => array(),

1460

'conditions' => array(),

1461

'order' => array(),

1462

'group' => null

1463

);

1464

$this->assertEqual($queryData, $expected);

1465

1466

$result = $this->testDb->generateAssociationQuery($this->Model, $null, null, null, null, $queryData, false, $null);

1467

$this->assertPattern('/^SELECT\s+`TestModel4`\.`id`, `TestModel4`\.`name`, `TestModel4`\.`created`, `TestModel4`\.`updated`, `TestModel4Parent`\.`id`, `TestModel4Parent`\.`name`, `TestModel4Parent`\.`created`, `TestModel4Parent`\.`updated`\s+/', $result);

1468

$this->assertPattern('/FROM\s+`test_model4` AS `TestModel4`\s+LEFT JOIN\s+`test_model4` AS `TestModel4Parent`/', $result);

1469

$this->assertPattern('/\s+ON\s+$`TestModel4`.`parent_id` = `TestModel4Parent`.`id`$\s+WHERE/', $result);

1470

$this->assertPattern('/\s+WHERE\s+1 = 1\s+$/', $result);

1471

1472

$params['assocData']['type'] = 'INNER';

1473

$this->Model->belongsTo['TestModel4Parent']['type'] = 'INNER';

1474

$result = $this->testDb->generateAssociationQuery($this->Model, $params['linkModel'], $params['type'], $params['assoc'], $params['assocData'], $_queryData, $params['external'], $resultSet);

1475

$this->assertTrue($result);

1476

$this->assertEqual($_queryData['joins'][0]['type'], 'INNER');

1477

}

1478

1479

/**

1480

* testGenerateInnerJoinAssociationQuery method

1481

1482

* @access public

1483

* @return void

1484

1485

function testGenerateInnerJoinAssociationQuery() {

1486

$this->Model =& new TestModel9();

1487

$test =& ConnectionManager::create('test2', $this->__config);

1488

$this->Model->setDataSource('test2');

1489

$this->Model->TestModel8 =& new TestModel8();

1490

$this->Model->TestModel8->setDataSource('test2');

1491

1492

$this->testDb->read($this->Model, array('recursive' => 1));

1493

$result = $this->testDb->getLastQuery();

1494

$this->assertPattern('/`TestModel9` LEFT JOIN `' . $this->testDb->fullTableName('test_model8', false) . '`/', $result);

1495

1496

$this->Model->belongsTo['TestModel8']['type'] = 'INNER';

1497

$this->testDb->read($this->Model, array('recursive' => 1));

1498

$result = $this->testDb->getLastQuery();

1499

$this->assertPattern('/`TestModel9` INNER JOIN `' . $this->testDb->fullTableName('test_model8', false) . '`/', $result);

1500

1501

}

1502

1503

/**

1504

* testGenerateAssociationQuerySelfJoinWithConditionsInHasOneBinding method

1505

1506

* @access public

1507

* @return void

1508

1509

function testGenerateAssociationQuerySelfJoinWithConditionsInHasOneBinding() {

1510

$this->Model =& new TestModel8();

1511

$this->Model->schema();

1512

$this->_buildRelatedModels($this->Model);

1513

1514

$binding = array('type' => 'hasOne', 'model' => 'TestModel9');

1515

$queryData = array();

1516

$resultSet = null;

1517

$null = null;

1518

1519

$params = &$this->_prepareAssociationQuery($this->Model, $queryData, $binding);

1520

$_queryData = $queryData;

1521

$result = $this->testDb->generateAssociationQuery($this->Model, $params['linkModel'], $params['type'], $params['assoc'], $params['assocData'], $queryData, $params['external'], $resultSet);

1522

$this->assertTrue($result);

1523

1524

$result = $this->testDb->generateAssociationQuery($this->Model, $null, null, null, null, $queryData, false, $null);

1525

$this->assertPattern('/^SELECT\s+`TestModel8`\.`id`, `TestModel8`\.`test_model9_id`, `TestModel8`\.`name`, `TestModel8`\.`created`, `TestModel8`\.`updated`, `TestModel9`\.`id`, `TestModel9`\.`test_model8_id`, `TestModel9`\.`name`, `TestModel9`\.`created`, `TestModel9`\.`updated`\s+/', $result);

1526

$this->assertPattern('/FROM\s+`test_model8` AS `TestModel8`\s+LEFT JOIN\s+`test_model9` AS `TestModel9`/', $result);

1527

$this->assertPattern('/\s+ON\s+$`TestModel9`\.`name` != \'mariano\'\s+AND\s+`TestModel9`.`test_model8_id` = `TestModel8`.`id`$\s+WHERE/', $result);

1528

$this->assertPattern('/\s+WHERE\s+(?:$)?1\s+=\s+1(?:$)?\s*$/', $result);

1529

}

1530

1531

/**

1532

* testGenerateAssociationQuerySelfJoinWithConditionsInBelongsToBinding method

1533

1534

* @access public

1535

* @return void

1536

1537

function testGenerateAssociationQuerySelfJoinWithConditionsInBelongsToBinding() {

1538

$this->Model =& new TestModel9();

1539

$this->Model->schema();

1540

$this->_buildRelatedModels($this->Model);

1541

1542

$binding = array('type' => 'belongsTo', 'model' => 'TestModel8');

1543

$queryData = array();

1544

$resultSet = null;

1545

$null = null;

1546

1547

$params = &$this->_prepareAssociationQuery($this->Model, $queryData, $binding);

1548

$result = $this->testDb->generateAssociationQuery($this->Model, $params['linkModel'], $params['type'], $params['assoc'], $params['assocData'], $queryData, $params['external'], $resultSet);

1549

$this->assertTrue($result);

1550

1551

$result = $this->testDb->generateAssociationQuery($this->Model, $null, null, null, null, $queryData, false, $null);

1552

$this->assertPattern('/^SELECT\s+`TestModel9`\.`id`, `TestModel9`\.`test_model8_id`, `TestModel9`\.`name`, `TestModel9`\.`created`, `TestModel9`\.`updated`, `TestModel8`\.`id`, `TestModel8`\.`test_model9_id`, `TestModel8`\.`name`, `TestModel8`\.`created`, `TestModel8`\.`updated`\s+/', $result);

1553

$this->assertPattern('/FROM\s+`test_model9` AS `TestModel9`\s+LEFT JOIN\s+`test_model8` AS `TestModel8`/', $result);

1554

$this->assertPattern('/\s+ON\s+$`TestModel8`\.`name` != \'larry\'\s+AND\s+`TestModel9`.`test_model8_id` = `TestModel8`.`id`$\s+WHERE/', $result);

1555

$this->assertPattern('/\s+WHERE\s+(?:$)?1\s+=\s+1(?:$)?\s*$/', $result);

1556

}

1557

1558

/**

1559

* testGenerateAssociationQuerySelfJoinWithConditions method

1560

1561

* @access public

1562

* @return void

1563

1564

function testGenerateAssociationQuerySelfJoinWithConditions() {

1565

$this->Model =& new TestModel4();

1566

$this->Model->schema();

1567

$this->_buildRelatedModels($this->Model);

1568

1569

$binding = array('type' => 'belongsTo', 'model' => 'TestModel4Parent');

1570

$queryData = array('conditions' => array('TestModel4Parent.name !=' => 'mariano'));

1571

$resultSet = null;

1572

$null = null;

1573

1574

$params = &$this->_prepareAssociationQuery($this->Model, $queryData, $binding);

1575

1576

$result = $this->testDb->generateAssociationQuery($this->Model, $params['linkModel'], $params['type'], $params['assoc'], $params['assocData'], $queryData, $params['external'], $resultSet);

1577

$this->assertTrue($result);

1578

1579

$result = $this->testDb->generateAssociationQuery($this->Model, $null, null, null, null, $queryData, false, $null);

1580

1581

$this->assertPattern('/FROM\s+`test_model4` AS `TestModel4`\s+LEFT JOIN\s+`test_model4` AS `TestModel4Parent`/', $result);

1582

$this->assertPattern('/\s+ON\s+$`TestModel4`.`parent_id` = `TestModel4Parent`.`id`$\s+WHERE/', $result);

1583

$this->assertPattern('/\s+WHERE\s+(?:$)?`TestModel4Parent`.`name`\s+!=\s+\'mariano\'(?:$)?\s*$/', $result);

1584

1585

$this->Featured2 =& new Featured2();

1586

$this->Featured2->schema();

1587

1588

$this->Featured2->bindModel(array(

1589

'belongsTo' => array(

1590

'ArticleFeatured2' => array(

1591

'conditions' => 'ArticleFeatured2.published = \'Y\'',

1592

'fields' => 'id, title, user_id, published'

1593

)

1594

)

1595

));

1596

1597

$this->_buildRelatedModels($this->Featured2);

1598

1599

$binding = array('type' => 'belongsTo', 'model' => 'ArticleFeatured2');

1600

$queryData = array('conditions' => array());

1601

$resultSet = null;

1602

$null = null;

1603

1604

$params = &$this->_prepareAssociationQuery($this->Featured2, $queryData, $binding);

1605

1606

$result = $this->testDb->generateAssociationQuery($this->Featured2, $params['linkModel'], $params['type'], $params['assoc'], $params['assocData'], $queryData, $params['external'], $resultSet);

1607

$this->assertTrue($result);

1608

$result = $this->testDb->generateAssociationQuery($this->Featured2, $null, null, null, null, $queryData, false, $null);

1609

1610

$this->assertPattern(

1611

'/^SELECT\s+`Featured2`\.`id`, `Featured2`\.`article_id`, `Featured2`\.`category_id`, `Featured2`\.`name`,\s+'.

1612

'`ArticleFeatured2`\.`id`, `ArticleFeatured2`\.`title`, `ArticleFeatured2`\.`user_id`, `ArticleFeatured2`\.`published`\s+' .

1613

'FROM\s+`featured2` AS `Featured2`\s+LEFT JOIN\s+`article_featured` AS `ArticleFeatured2`' .

1614

'\s+ON\s+$`ArticleFeatured2`.`published` = \'Y\'\s+AND\s+`Featured2`\.`article_featured2_id` = `ArticleFeatured2`\.`id`$' .

1615

'\s+WHERE\s+1\s+=\s+1\s*$/',

1616

$result

1617

);

1618

}

1619

1620

/**

1621

* testGenerateAssociationQueryHasOne method

1622

1623

* @access public

1624

* @return void

1625

1626

function testGenerateAssociationQueryHasOne() {

1627

$this->Model =& new TestModel4();

1628

$this->Model->schema();

1629

$this->_buildRelatedModels($this->Model);

1630

1631

$binding = array('type' => 'hasOne', 'model' => 'TestModel5');

1632

1633

$queryData = array();

1634

$resultSet = null;

1635

$null = null;

1636

1637

$params = &$this->_prepareAssociationQuery($this->Model, $queryData, $binding);

1638

1639

$result = $this->testDb->generateAssociationQuery($this->Model, $params['linkModel'], $params['type'], $params['assoc'], $params['assocData'], $queryData, $params['external'], $resultSet);

1640

$this->assertTrue($result);

1641

1642

$result = $this->testDb->buildJoinStatement($queryData['joins'][0]);

1643

$expected = ' LEFT JOIN `test_model5` AS `TestModel5` ON (`TestModel5`.`test_model4_id` = `TestModel4`.`id`)';

1644

$this->assertEqual(trim($result), trim($expected));

1645

1646

$result = $this->testDb->generateAssociationQuery($this->Model, $null, null, null, null, $queryData, false, $null);

1647

$this->assertPattern('/^SELECT\s+`TestModel4`\.`id`, `TestModel4`\.`name`, `TestModel4`\.`created`, `TestModel4`\.`updated`, `TestModel5`\.`id`, `TestModel5`\.`test_model4_id`, `TestModel5`\.`name`, `TestModel5`\.`created`, `TestModel5`\.`updated`\s+/', $result);

1648

$this->assertPattern('/\s+FROM\s+`test_model4` AS `TestModel4`\s+LEFT JOIN\s+/', $result);

1649

$this->assertPattern('/`test_model5` AS `TestModel5`\s+ON\s+$`TestModel5`.`test_model4_id` = `TestModel4`.`id`$\s+WHERE/', $result);

1650

$this->assertPattern('/\s+WHERE\s+(?:$)?\s*1 = 1\s*(?:$)?\s*$/', $result);

1651

}

1652

1653

/**

1654

* testGenerateAssociationQueryHasOneWithConditions method

1655

1656

* @access public

1657

* @return void

1658

1659

function testGenerateAssociationQueryHasOneWithConditions() {

1660

$this->Model =& new TestModel4();

1661

$this->Model->schema();

1662

$this->_buildRelatedModels($this->Model);

1663

1664

$binding = array('type' => 'hasOne', 'model' => 'TestModel5');

1665

1666

$queryData = array('conditions' => array('TestModel5.name !=' => 'mariano'));

1667

$resultSet = null;

1668

$null = null;

1669

1670

$params = &$this->_prepareAssociationQuery($this->Model, $queryData, $binding);

1671

1672

$result = $this->testDb->generateAssociationQuery($this->Model, $params['linkModel'], $params['type'], $params['assoc'], $params['assocData'], $queryData, $params['external'], $resultSet);

1673

$this->assertTrue($result);

1674

1675

$result = $this->testDb->generateAssociationQuery($this->Model, $null, null, null, null, $queryData, false, $null);

1676

1677

1678

$this->assertPattern('/\s+FROM\s+`test_model4` AS `TestModel4`\s+LEFT JOIN\s+`test_model5` AS `TestModel5`/', $result);

1679

$this->assertPattern('/\s+ON\s+$`TestModel5`.`test_model4_id`\s+=\s+`TestModel4`.`id`$\s+WHERE/', $result);

1680

$this->assertPattern('/\s+WHERE\s+(?:$)?\s*`TestModel5`.`name`\s+!=\s+\'mariano\'\s*(?:$)?\s*$/', $result);

1681

}

1682

1683

/**

1684

* testGenerateAssociationQueryBelongsTo method

1685

1686

* @access public

1687

* @return void

1688

1689

function testGenerateAssociationQueryBelongsTo() {

1690

$this->Model =& new TestModel5();

1691

$this->Model->schema();

1692

$this->_buildRelatedModels($this->Model);

1693

1694

$binding = array('type'=>'belongsTo', 'model'=>'TestModel4');

1695

$queryData = array();

1696

$resultSet = null;

1697

$null = null;

1698

1699

$params = &$this->_prepareAssociationQuery($this->Model, $queryData, $binding);

1700

1701

$result = $this->testDb->generateAssociationQuery($this->Model, $params['linkModel'], $params['type'], $params['assoc'], $params['assocData'], $queryData, $params['external'], $resultSet);

1702

$this->assertTrue($result);

1703

1704

$result = $this->testDb->buildJoinStatement($queryData['joins'][0]);

1705

$expected = ' LEFT JOIN `test_model4` AS `TestModel4` ON (`TestModel5`.`test_model4_id` = `TestModel4`.`id`)';

1706

$this->assertEqual(trim($result), trim($expected));

1707

1708

$result = $this->testDb->generateAssociationQuery($this->Model, $null, null, null, null, $queryData, false, $null);

1709

$this->assertPattern('/^SELECT\s+`TestModel5`\.`id`, `TestModel5`\.`test_model4_id`, `TestModel5`\.`name`, `TestModel5`\.`created`, `TestModel5`\.`updated`, `TestModel4`\.`id`, `TestModel4`\.`name`, `TestModel4`\.`created`, `TestModel4`\.`updated`\s+/', $result);

1710

$this->assertPattern('/\s+FROM\s+`test_model5` AS `TestModel5`\s+LEFT JOIN\s+`test_model4` AS `TestModel4`/', $result);

1711

$this->assertPattern('/\s+ON\s+$`TestModel5`.`test_model4_id` = `TestModel4`.`id`$\s+WHERE\s+/', $result);

1712

$this->assertPattern('/\s+WHERE\s+(?:$)?\s*1 = 1\s*(?:$)?\s*$/', $result);

1713

}

1714

1715

/**

1716

* testGenerateAssociationQueryBelongsToWithConditions method

1717

1718

* @access public

1719

* @return void

1720

1721

function testGenerateAssociationQueryBelongsToWithConditions() {

1722

$this->Model =& new TestModel5();

1723

$this->Model->schema();

1724

$this->_buildRelatedModels($this->Model);

1725

1726

$binding = array('type' => 'belongsTo', 'model' => 'TestModel4');

1727

$queryData = array('conditions' => array('TestModel5.name !=' => 'mariano'));

1728

$resultSet = null;

1729

$null = null;

1730

1731

$params = &$this->_prepareAssociationQuery($this->Model, $queryData, $binding);

1732

1733

$result = $this->testDb->generateAssociationQuery($this->Model, $params['linkModel'], $params['type'], $params['assoc'], $params['assocData'], $queryData, $params['external'], $resultSet);

1734

$this->assertTrue($result);

1735

1736

$result = $this->testDb->buildJoinStatement($queryData['joins'][0]);

1737

$expected = ' LEFT JOIN `test_model4` AS `TestModel4` ON (`TestModel5`.`test_model4_id` = `TestModel4`.`id`)';

1738

$this->assertEqual(trim($result), trim($expected));

1739

1740

$result = $this->testDb->generateAssociationQuery($this->Model, $null, null, null, null, $queryData, false, $null);

1741

1742

$this->assertPattern('/\s+FROM\s+`test_model5` AS `TestModel5`\s+LEFT JOIN\s+`test_model4` AS `TestModel4`/', $result);

1743

$this->assertPattern('/\s+ON\s+$`TestModel5`.`test_model4_id` = `TestModel4`.`id`$\s+WHERE\s+/', $result);

1744

$this->assertPattern('/\s+WHERE\s+`TestModel5`.`name` != \'mariano\'\s*$/', $result);

1745

}

1746

1747

/**

1748

* testGenerateAssociationQueryHasMany method

1749

1750

* @access public

1751

* @return void

1752

1753

function testGenerateAssociationQueryHasMany() {

1754

$this->Model =& new TestModel5();

1755

$this->Model->schema();

1756

$this->_buildRelatedModels($this->Model);

1757

1758

$binding = array('type' => 'hasMany', 'model' => 'TestModel6');

1759

$queryData = array();

1760

$resultSet = null;

1761

$null = null;

1762

1763

$params = &$this->_prepareAssociationQuery($this->Model, $queryData, $binding);

1764

1765

$result = $this->testDb->generateAssociationQuery($this->Model, $params['linkModel'], $params['type'], $params['assoc'], $params['assocData'], $queryData, $params['external'], $resultSet);

1766

1767

$this->assertPattern('/^SELECT\s+`TestModel6`\.`id`, `TestModel6`\.`test_model5_id`, `TestModel6`\.`name`, `TestModel6`\.`created`, `TestModel6`\.`updated`\s+/', $result);

1768

$this->assertPattern('/\s+FROM\s+`test_model6` AS `TestModel6`\s+WHERE/', $result);

1769

$this->assertPattern('/\s+WHERE\s+`TestModel6`.`test_model5_id`\s+=\s+${\$__cakeID__\$}$/', $result);

1770

1771

$result = $this->testDb->generateAssociationQuery($this->Model, $null, null, null, null, $queryData, false, $null);

1772

$this->assertPattern('/^SELECT\s+`TestModel5`\.`id`, `TestModel5`\.`test_model4_id`, `TestModel5`\.`name`, `TestModel5`\.`created`, `TestModel5`\.`updated`\s+/', $result);

1773

$this->assertPattern('/\s+FROM\s+`test_model5` AS `TestModel5`\s+WHERE\s+/', $result);

1774

$this->assertPattern('/\s+WHERE\s+(?:$)?\s*1 = 1\s*(?:$)?\s*$/', $result);

1775

}

1776

1777

/**

1778

* testGenerateAssociationQueryHasManyWithLimit method

1779

1780

* @access public

1781

* @return void

1782

1783

function testGenerateAssociationQueryHasManyWithLimit() {

1784

$this->Model =& new TestModel5();

1785

$this->Model->schema();

1786

$this->_buildRelatedModels($this->Model);

1787

1788

$this->Model->hasMany['TestModel6']['limit'] = 2;

1789

1790

$binding = array('type' => 'hasMany', 'model' => 'TestModel6');

1791

$queryData = array();

1792

$resultSet = null;

1793

$null = null;

1794

1795

$params = &$this->_prepareAssociationQuery($this->Model, $queryData, $binding);

1796

1797

$result = $this->testDb->generateAssociationQuery($this->Model, $params['linkModel'], $params['type'], $params['assoc'], $params['assocData'], $queryData, $params['external'], $resultSet);

1798

$this->assertPattern(

1799

'/^SELECT\s+' .

1800

'`TestModel6`\.`id`, `TestModel6`\.`test_model5_id`, `TestModel6`\.`name`, `TestModel6`\.`created`, `TestModel6`\.`updated`\s+'.

1801

'FROM\s+`test_model6` AS `TestModel6`\s+WHERE\s+' .

1802

'`TestModel6`.`test_model5_id`\s+=\s+${\$__cakeID__\$}$\s*'.

1803

'LIMIT \d*'.

1804

'\s*$/', $result

1805

);

1806

1807

$result = $this->testDb->generateAssociationQuery($this->Model, $null, null, null, null, $queryData, false, $null);

1808

$this->assertPattern(

1809

'/^SELECT\s+'.

1810

'`TestModel5`\.`id`, `TestModel5`\.`test_model4_id`, `TestModel5`\.`name`, `TestModel5`\.`created`, `TestModel5`\.`updated`\s+'.

1811

'FROM\s+`test_model5` AS `TestModel5`\s+WHERE\s+'.

1812

'(?:$)?\s*1 = 1\s*(?:$)?'.

1813

'\s*$/', $result

1814

);

1815

}

1816

1817

/**

1818

* testGenerateAssociationQueryHasManyWithConditions method

1819

1820

* @access public

1821

* @return void

1822

1823

function testGenerateAssociationQueryHasManyWithConditions() {

1824

$this->Model =& new TestModel5();

1825

$this->Model->schema();

1826

$this->_buildRelatedModels($this->Model);

1827

1828

$binding = array('type' => 'hasMany', 'model' => 'TestModel6');

1829

$queryData = array('conditions' => array('TestModel5.name !=' => 'mariano'));

1830

$resultSet = null;

1831

$null = null;

1832

1833

$params = &$this->_prepareAssociationQuery($this->Model, $queryData, $binding);

1834

1835

$result = $this->testDb->generateAssociationQuery($this->Model, $params['linkModel'], $params['type'], $params['assoc'], $params['assocData'], $queryData, $params['external'], $resultSet);

1836

$this->assertPattern('/^SELECT\s+`TestModel6`\.`id`, `TestModel6`\.`test_model5_id`, `TestModel6`\.`name`, `TestModel6`\.`created`, `TestModel6`\.`updated`\s+/', $result);

1837

$this->assertPattern('/\s+FROM\s+`test_model6` AS `TestModel6`\s+WHERE\s+/', $result);

1838

$this->assertPattern('/WHERE\s+(?:$)?`TestModel6`\.`test_model5_id`\s+=\s+\({\$__cakeID__\$}$(?:\))?/', $result);

1839

1840

$result = $this->testDb->generateAssociationQuery($this->Model, $null, null, null, null, $queryData, false, $null);

1841

$this->assertPattern('/^SELECT\s+`TestModel5`\.`id`, `TestModel5`\.`test_model4_id`, `TestModel5`\.`name`, `TestModel5`\.`created`, `TestModel5`\.`updated`\s+/', $result);

1842

$this->assertPattern('/\s+FROM\s+`test_model5` AS `TestModel5`\s+WHERE\s+/', $result);

1843

$this->assertPattern('/\s+WHERE\s+(?:$)?`TestModel5`.`name`\s+!=\s+\'mariano\'(?:$)?\s*$/', $result);

1844

}

1845

1846

/**

1847

* testGenerateAssociationQueryHasManyWithOffsetAndLimit method

1848

1849

* @access public

1850

* @return void

1851

1852

function testGenerateAssociationQueryHasManyWithOffsetAndLimit() {

1853

$this->Model =& new TestModel5();

1854

$this->Model->schema();

1855

$this->_buildRelatedModels($this->Model);

1856

1857

$__backup = $this->Model->hasMany['TestModel6'];

1858

1859

$this->Model->hasMany['TestModel6']['offset'] = 2;

1860

$this->Model->hasMany['TestModel6']['limit'] = 5;

1861

1862

$binding = array('type' => 'hasMany', 'model' => 'TestModel6');

1863

$queryData = array();

1864

$resultSet = null;

1865

$null = null;

1866

1867

$params = &$this->_prepareAssociationQuery($this->Model, $queryData, $binding);

1868

1869

$result = $this->testDb->generateAssociationQuery($this->Model, $params['linkModel'], $params['type'], $params['assoc'], $params['assocData'], $queryData, $params['external'], $resultSet);

1870

1871

$this->assertPattern('/^SELECT\s+`TestModel6`\.`id`, `TestModel6`\.`test_model5_id`, `TestModel6`\.`name`, `TestModel6`\.`created`, `TestModel6`\.`updated`\s+/', $result);

1872

$this->assertPattern('/\s+FROM\s+`test_model6` AS `TestModel6`\s+WHERE\s+/', $result);

1873

$this->assertPattern('/WHERE\s+(?:$)?`TestModel6`\.`test_model5_id`\s+=\s+\({\$__cakeID__\$}$(?:\))?/', $result);

1874

$this->assertPattern('/\s+LIMIT 2,\s*5\s*$/', $result);

1875

1876

$result = $this->testDb->generateAssociationQuery($this->Model, $null, null, null, null, $queryData, false, $null);

1877

$this->assertPattern('/^SELECT\s+`TestModel5`\.`id`, `TestModel5`\.`test_model4_id`, `TestModel5`\.`name`, `TestModel5`\.`created`, `TestModel5`\.`updated`\s+/', $result);

1878

$this->assertPattern('/\s+FROM\s+`test_model5` AS `TestModel5`\s+WHERE\s+/', $result);

1879

$this->assertPattern('/\s+WHERE\s+(?:$)?1\s+=\s+1(?:$)?\s*$/', $result);

1880

1881

$this->Model->hasMany['TestModel6'] = $__backup;

1882

}

1883

1884

/**

1885

* testGenerateAssociationQueryHasManyWithPageAndLimit method

1886

1887

* @access public

1888

* @return void

1889

1890

function testGenerateAssociationQueryHasManyWithPageAndLimit() {

1891

$this->Model =& new TestModel5();

1892

$this->Model->schema();

1893

$this->_buildRelatedModels($this->Model);

1894

1895

$__backup = $this->Model->hasMany['TestModel6'];

1896

1897

$this->Model->hasMany['TestModel6']['page'] = 2;

1898

$this->Model->hasMany['TestModel6']['limit'] = 5;

1899

1900

$binding = array('type' => 'hasMany', 'model' => 'TestModel6');

1901

$queryData = array();

1902

$resultSet = null;

1903

$null = null;

1904

1905

$params = &$this->_prepareAssociationQuery($this->Model, $queryData, $binding);

1906

1907

$result = $this->testDb->generateAssociationQuery($this->Model, $params['linkModel'], $params['type'], $params['assoc'], $params['assocData'], $queryData, $params['external'], $resultSet);

1908

$this->assertPattern('/^SELECT\s+`TestModel6`\.`id`, `TestModel6`\.`test_model5_id`, `TestModel6`\.`name`, `TestModel6`\.`created`, `TestModel6`\.`updated`\s+/', $result);

1909

$this->assertPattern('/\s+FROM\s+`test_model6` AS `TestModel6`\s+WHERE\s+/', $result);

1910

$this->assertPattern('/WHERE\s+(?:$)?`TestModel6`\.`test_model5_id`\s+=\s+\({\$__cakeID__\$}$(?:\))?/', $result);

1911

$this->assertPattern('/\s+LIMIT 5,\s*5\s*$/', $result);

1912

1913

$result = $this->testDb->generateAssociationQuery($this->Model, $null, null, null, null, $queryData, false, $null);

1914

$this->assertPattern('/^SELECT\s+`TestModel5`\.`id`, `TestModel5`\.`test_model4_id`, `TestModel5`\.`name`, `TestModel5`\.`created`, `TestModel5`\.`updated`\s+/', $result);

1915

$this->assertPattern('/\s+FROM\s+`test_model5` AS `TestModel5`\s+WHERE\s+/', $result);

1916

$this->assertPattern('/\s+WHERE\s+(?:$)?1\s+=\s+1(?:$)?\s*$/', $result);

1917

1918

$this->Model->hasMany['TestModel6'] = $__backup;

1919

}

1920

1921

/**

1922

* testGenerateAssociationQueryHasManyWithFields method

1923

1924

* @access public

1925

* @return void

1926

1927

function testGenerateAssociationQueryHasManyWithFields() {

1928

$this->Model =& new TestModel5();

1929

$this->Model->schema();

1930

$this->_buildRelatedModels($this->Model);

1931

1932

$binding = array('type' => 'hasMany', 'model' => 'TestModel6');

1933

$queryData = array('fields' => array('`TestModel5`.`name`'));

1934

$resultSet = null;

1935

$null = null;

1936

1937

$params = &$this->_prepareAssociationQuery($this->Model, $queryData, $binding);

1938

1939

$result = $this->testDb->generateAssociationQuery($this->Model, $params['linkModel'], $params['type'], $params['assoc'], $params['assocData'], $queryData, $params['external'], $resultSet);

1940

$this->assertPattern('/^SELECT\s+`TestModel6`\.`id`, `TestModel6`\.`test_model5_id`, `TestModel6`\.`name`, `TestModel6`\.`created`, `TestModel6`\.`updated`\s+/', $result);

1941

$this->assertPattern('/\s+FROM\s+`test_model6` AS `TestModel6`\s+WHERE\s+/', $result);

1942

$this->assertPattern('/WHERE\s+(?:$)?`TestModel6`\.`test_model5_id`\s+=\s+\({\$__cakeID__\$}$(?:\))?/', $result);

1943

1944

$result = $this->testDb->generateAssociationQuery($this->Model, $null, null, null, null, $queryData, false, $null);

1945

$this->assertPattern('/^SELECT\s+`TestModel5`\.`name`, `TestModel5`\.`id`\s+/', $result);

1946

$this->assertPattern('/\s+FROM\s+`test_model5` AS `TestModel5`\s+WHERE\s+/', $result);

1947

$this->assertPattern('/\s+WHERE\s+(?:$)?1\s+=\s+1(?:$)?\s*$/', $result);

1948

1949

$binding = array('type' => 'hasMany', 'model' => 'TestModel6');

1950

$queryData = array('fields' => array('`TestModel5`.`id`, `TestModel5`.`name`'));

1951

$resultSet = null;

1952

$null = null;

1953

1954

$params = &$this->_prepareAssociationQuery($this->Model, $queryData, $binding);

1955

1956

$result = $this->testDb->generateAssociationQuery($this->Model, $params['linkModel'], $params['type'], $params['assoc'], $params['assocData'], $queryData, $params['external'], $resultSet);

1957

$this->assertPattern('/^SELECT\s+`TestModel6`\.`id`, `TestModel6`\.`test_model5_id`, `TestModel6`\.`name`, `TestModel6`\.`created`, `TestModel6`\.`updated`\s+/', $result);

1958

$this->assertPattern('/\s+FROM\s+`test_model6` AS `TestModel6`\s+WHERE\s+/', $result);

1959

$this->assertPattern('/WHERE\s+(?:$)?`TestModel6`\.`test_model5_id`\s+=\s+\({\$__cakeID__\$}$(?:\))?/', $result);

1960

1961

$result = $this->testDb->generateAssociationQuery($this->Model, $null, null, null, null, $queryData, false, $null);

1962

$this->assertPattern('/^SELECT\s+`TestModel5`\.`id`, `TestModel5`\.`name`\s+/', $result);

1963

$this->assertPattern('/\s+FROM\s+`test_model5` AS `TestModel5`\s+WHERE\s+/', $result);

1964

$this->assertPattern('/\s+WHERE\s+(?:$)?1\s+=\s+1(?:$)?\s*$/', $result);

1965

1966

$binding = array('type' => 'hasMany', 'model' => 'TestModel6');

1967

$queryData = array('fields' => array('`TestModel5`.`name`', '`TestModel5`.`created`'));

1968

$resultSet = null;

1969

$null = null;

1970

1971

$params = &$this->_prepareAssociationQuery($this->Model, $queryData, $binding);

1972

1973

$result = $this->testDb->generateAssociationQuery($this->Model, $params['linkModel'], $params['type'], $params['assoc'], $params['assocData'], $queryData, $params['external'], $resultSet);

1974

$this->assertPattern('/^SELECT\s+`TestModel6`\.`id`, `TestModel6`\.`test_model5_id`, `TestModel6`\.`name`, `TestModel6`\.`created`, `TestModel6`\.`updated`\s+/', $result);

1975

$this->assertPattern('/\s+FROM\s+`test_model6` AS `TestModel6`\s+WHERE\s+/', $result);

1976

$this->assertPattern('/WHERE\s+(?:$)?`TestModel6`\.`test_model5_id`\s+=\s+\({\$__cakeID__\$}$(?:\))?/', $result);

1977

1978

$result = $this->testDb->generateAssociationQuery($this->Model, $null, null, null, null, $queryData, false, $null);

1979

$this->assertPattern('/^SELECT\s+`TestModel5`\.`name`, `TestModel5`\.`created`, `TestModel5`\.`id`\s+/', $result);

1980

$this->assertPattern('/\s+FROM\s+`test_model5` AS `TestModel5`\s+WHERE\s+/', $result);

1981

$this->assertPattern('/\s+WHERE\s+(?:$)?1\s+=\s+1(?:$)?\s*$/', $result);

1982

1983

$this->Model->hasMany['TestModel6']['fields'] = array('name');

1984

1985

$binding = array('type' => 'hasMany', 'model' => 'TestModel6');

1986

$queryData = array('fields' => array('`TestModel5`.`id`', '`TestModel5`.`name`'));

1987

$resultSet = null;

1988

$null = null;

1989

1990

$params = &$this->_prepareAssociationQuery($this->Model, $queryData, $binding);

1991

1992

$result = $this->testDb->generateAssociationQuery($this->Model, $params['linkModel'], $params['type'], $params['assoc'], $params['assocData'], $queryData, $params['external'], $resultSet);

1993

$this->assertPattern('/^SELECT\s+`TestModel6`\.`name`, `TestModel6`\.`test_model5_id`\s+/', $result);

1994

$this->assertPattern('/\s+FROM\s+`test_model6` AS `TestModel6`\s+WHERE\s+/', $result);

1995

$this->assertPattern('/WHERE\s+(?:$)?`TestModel6`\.`test_model5_id`\s+=\s+\({\$__cakeID__\$}$(?:\))?/', $result);

1996

1997

$result = $this->testDb->generateAssociationQuery($this->Model, $null, null, null, null, $queryData, false, $null);

1998

$this->assertPattern('/^SELECT\s+`TestModel5`\.`id`, `TestModel5`\.`name`\s+/', $result);

1999

$this->assertPattern('/\s+FROM\s+`test_model5` AS `TestModel5`\s+WHERE\s+/', $result);

2000

$this->assertPattern('/\s+WHERE\s+(?:$)?1\s+=\s+1(?:$)?\s*$/', $result);

2001

2002

unset($this->Model->hasMany['TestModel6']['fields']);

2003

2004

$this->Model->hasMany['TestModel6']['fields'] = array('id', 'name');

2005

2006

$binding = array('type' => 'hasMany', 'model' => 'TestModel6');

2007

$queryData = array('fields' => array('`TestModel5`.`id`', '`TestModel5`.`name`'));

2008

$resultSet = null;

2009

$null = null;

2010

2011

$params = &$this->_prepareAssociationQuery($this->Model, $queryData, $binding);

2012

2013

$result = $this->testDb->generateAssociationQuery($this->Model, $params['linkModel'], $params['type'], $params['assoc'], $params['assocData'], $queryData, $params['external'], $resultSet);

2014

$this->assertPattern('/^SELECT\s+`TestModel6`\.`id`, `TestModel6`\.`name`, `TestModel6`\.`test_model5_id`\s+/', $result);

2015

$this->assertPattern('/\s+FROM\s+`test_model6` AS `TestModel6`\s+WHERE\s+/', $result);

2016

$this->assertPattern('/WHERE\s+(?:$)?`TestModel6`\.`test_model5_id`\s+=\s+\({\$__cakeID__\$}$(?:\))?/', $result);

2017

2018

$result = $this->testDb->generateAssociationQuery($this->Model, $null, null, null, null, $queryData, false, $null);

2019

$this->assertPattern('/^SELECT\s+`TestModel5`\.`id`, `TestModel5`\.`name`\s+/', $result);

2020

$this->assertPattern('/\s+FROM\s+`test_model5` AS `TestModel5`\s+WHERE\s+/', $result);

2021

$this->assertPattern('/\s+WHERE\s+(?:$)?1\s+=\s+1(?:$)?\s*$/', $result);

2022

2023

unset($this->Model->hasMany['TestModel6']['fields']);

2024

2025

$this->Model->hasMany['TestModel6']['fields'] = array('test_model5_id', 'name');

2026

2027

$binding = array('type' => 'hasMany', 'model' => 'TestModel6');

2028

$queryData = array('fields' => array('`TestModel5`.`id`', '`TestModel5`.`name`'));

2029

$resultSet = null;

2030

$null = null;

2031

2032

$params = &$this->_prepareAssociationQuery($this->Model, $queryData, $binding);

2033

2034

$result = $this->testDb->generateAssociationQuery($this->Model, $params['linkModel'], $params['type'], $params['assoc'], $params['assocData'], $queryData, $params['external'], $resultSet);

2035

$this->assertPattern('/^SELECT\s+`TestModel6`\.`test_model5_id`, `TestModel6`\.`name`\s+/', $result);

2036

$this->assertPattern('/\s+FROM\s+`test_model6` AS `TestModel6`\s+WHERE\s+/', $result);

2037

$this->assertPattern('/WHERE\s+(?:$)?`TestModel6`\.`test_model5_id`\s+=\s+\({\$__cakeID__\$}$(?:\))?/', $result);

2038

2039

$result = $this->testDb->generateAssociationQuery($this->Model, $null, null, null, null, $queryData, false, $null);

2040

$this->assertPattern('/^SELECT\s+`TestModel5`\.`id`, `TestModel5`\.`name`\s+/', $result);

2041

$this->assertPattern('/\s+FROM\s+`test_model5` AS `TestModel5`\s+WHERE\s+/', $result);

2042

$this->assertPattern('/\s+WHERE\s+(?:$)?1\s+=\s+1(?:$)?\s*$/', $result);

2043

2044

unset($this->Model->hasMany['TestModel6']['fields']);

2045

}

2046

2047

/**

2048

* test generateAssociationQuery with a hasMany and an aggregate function.

2049

2050

* @return void

2051

2052

function testGenerateAssociationQueryHasManyAndAggregateFunction() {

2053

$this->Model =& new TestModel5();

2054

$this->Model->schema();

2055

$this->_buildRelatedModels($this->Model);

2056

2057

$binding = array('type' => 'hasMany', 'model' => 'TestModel6');

2058

$queryData = array('fields' => array('MIN(TestModel5.test_model4_id)'));

2059

$resultSet = null;

2060

$null = null;

2061

2062

$params = &$this->_prepareAssociationQuery($this->Model, $queryData, $binding);

2063

$this->Model->recursive = 0;

2064

2065

$result = $this->testDb->generateAssociationQuery($this->Model, $null, $params['type'], $params['assoc'], $params['assocData'], $queryData, false, $resultSet);

2066

$this->assertPattern('/^SELECT\s+MIN$`TestModel5`\.`test_model4_id`$\s+FROM/', $result);

2067

}

2068

2069

/**

2070

* testGenerateAssociationQueryHasAndBelongsToMany method

2071

2072

* @access public

2073

* @return void

2074

2075

function testGenerateAssociationQueryHasAndBelongsToMany() {

2076

$this->Model =& new TestModel4();

2077

$this->Model->schema();

2078

$this->_buildRelatedModels($this->Model);

2079

2080

$binding = array('type' => 'hasAndBelongsToMany', 'model' => 'TestModel7');

2081

$queryData = array();

2082

$resultSet = null;

2083

$null = null;

2084

2085

$params =& $this->_prepareAssociationQuery($this->Model, $queryData, $binding);

2086

2087

$result = $this->testDb->generateAssociationQuery($this->Model, $params['linkModel'], $params['type'], $params['assoc'], $params['assocData'], $queryData, $params['external'], $resultSet);

2088

$this->assertPattern('/^SELECT\s+`TestModel7`\.`id`, `TestModel7`\.`name`, `TestModel7`\.`created`, `TestModel7`\.`updated`, `TestModel4TestModel7`\.`test_model4_id`, `TestModel4TestModel7`\.`test_model7_id`\s+/', $result);

2089

$this->assertPattern('/\s+FROM\s+`test_model7` AS `TestModel7`\s+JOIN\s+`' . $this->testDb->fullTableName('test_model4_test_model7', false) . '`/', $result);

2090

$this->assertPattern('/\s+ON\s+\(`TestModel4TestModel7`\.`test_model4_id`\s+=\s+{\$__cakeID__\$}\s+AND/', $result);

2091

$this->assertPattern('/\s+AND\s+`TestModel4TestModel7`\.`test_model7_id`\s+=\s+`TestModel7`\.`id`\)/', $result);

2092

$this->assertPattern('/WHERE\s+(?:$)?1 = 1(?:$)?\s*$/', $result);

2093

2094

$result = $this->testDb->generateAssociationQuery($this->Model, $null, null, null, null, $queryData, false, $null);

2095

$this->assertPattern('/^SELECT\s+`TestModel4`\.`id`, `TestModel4`\.`name`, `TestModel4`\.`created`, `TestModel4`\.`updated`\s+/', $result);

2096

$this->assertPattern('/\s+FROM\s+`test_model4` AS `TestModel4`\s+WHERE/', $result);

2097

$this->assertPattern('/\s+WHERE\s+(?:$)?1 = 1(?:$)?\s*$/', $result);

2098

}

2099

2100

/**

2101

* testGenerateAssociationQueryHasAndBelongsToManyWithConditions method

2102

2103

* @access public

2104

* @return void

2105

2106

function testGenerateAssociationQueryHasAndBelongsToManyWithConditions() {

2107

$this->Model =& new TestModel4();

2108

$this->Model->schema();

2109

$this->_buildRelatedModels($this->Model);

2110

2111

$binding = array('type'=>'hasAndBelongsToMany', 'model'=>'TestModel7');

2112

$queryData = array('conditions' => array('TestModel4.name !=' => 'mariano'));

2113

$resultSet = null;

2114

$null = null;

2115

2116

$params =& $this->_prepareAssociationQuery($this->Model, $queryData, $binding);

2117

2118

$result = $this->testDb->generateAssociationQuery($this->Model, $params['linkModel'], $params['type'], $params['assoc'], $params['assocData'], $queryData, $params['external'], $resultSet);

2119

2120

$this->assertPattern('/\s+FROM\s+`test_model7`\s+AS\s+`TestModel7`\s+JOIN\s+`test_model4_test_model7`\s+AS\s+`TestModel4TestModel7`/', $result);

2121

$this->assertPattern('/\s+ON\s+\(`TestModel4TestModel7`\.`test_model4_id`\s+=\s+{\$__cakeID__\$}/', $result);

2122

$this->assertPattern('/\s+AND\s+`TestModel4TestModel7`\.`test_model7_id`\s+=\s+`TestModel7`\.`id`\)\s+WHERE\s+/', $result);

2123

2124

$result = $this->testDb->generateAssociationQuery($this->Model, $null, null, null, null, $queryData, false, $null);

2125

$this->assertPattern('/^SELECT\s+`TestModel4`\.`id`, `TestModel4`\.`name`, `TestModel4`\.`created`, `TestModel4`\.`updated`\s+/', $result);

2126

$this->assertPattern('/\s+FROM\s+`test_model4` AS `TestModel4`\s+WHERE\s+(?:$)?`TestModel4`.`name`\s+!=\s+\'mariano\'(?:$)?\s*$/', $result);

2127

}

2128

2129

/**

2130

* testGenerateAssociationQueryHasAndBelongsToManyWithOffsetAndLimit method

2131

2132

* @access public

2133

* @return void

2134

2135

function testGenerateAssociationQueryHasAndBelongsToManyWithOffsetAndLimit() {

2136

$this->Model =& new TestModel4();

2137

$this->Model->schema();

2138

$this->_buildRelatedModels($this->Model);

2139

2140

$__backup = $this->Model->hasAndBelongsToMany['TestModel7'];

2141

2142

$this->Model->hasAndBelongsToMany['TestModel7']['offset'] = 2;

2143

$this->Model->hasAndBelongsToMany['TestModel7']['limit'] = 5;

2144

2145

$binding = array('type'=>'hasAndBelongsToMany', 'model'=>'TestModel7');

2146

$queryData = array();

2147

$resultSet = null;

2148

$null = null;

2149

2150

$params = &$this->_prepareAssociationQuery($this->Model, $queryData, $binding);

2151

2152

$result = $this->testDb->generateAssociationQuery($this->Model, $params['linkModel'], $params['type'], $params['assoc'], $params['assocData'], $queryData, $params['external'], $resultSet);

2153

2154

$this->assertPattern('/\s+FROM\s+`test_model7`\s+AS\s+`TestModel7`\s+JOIN\s+`test_model4_test_model7`\s+AS\s+`TestModel4TestModel7`/', $result);

2155

$this->assertPattern('/\s+ON\s+\(`TestModel4TestModel7`\.`test_model4_id`\s+=\s+{\$__cakeID__\$}\s+/', $result);

2156

$this->assertPattern('/\s+AND\s+`TestModel4TestModel7`\.`test_model7_id`\s+=\s+`TestModel7`\.`id`\)\s+WHERE\s+/', $result);

2157

$this->assertPattern('/\s+(?:$)?1\s+=\s+1(?:$)?\s*\s+LIMIT 2,\s*5\s*$/', $result);

2158

2159

$result = $this->testDb->generateAssociationQuery($this->Model, $null, null, null, null, $queryData, false, $null);

2160

$this->assertPattern('/^SELECT\s+`TestModel4`\.`id`, `TestModel4`\.`name`, `TestModel4`\.`created`, `TestModel4`\.`updated`\s+/', $result);

2161

$this->assertPattern('/\s+FROM\s+`test_model4` AS `TestModel4`\s+WHERE\s+(?:$)?1\s+=\s+1(?:$)?\s*$/', $result);

2162

2163

$this->Model->hasAndBelongsToMany['TestModel7'] = $__backup;

2164

}

2165

2166

/**

2167

* testGenerateAssociationQueryHasAndBelongsToManyWithPageAndLimit method

2168

2169

* @access public

2170

* @return void

2171

2172

function testGenerateAssociationQueryHasAndBelongsToManyWithPageAndLimit() {

2173

$this->Model =& new TestModel4();

2174

$this->Model->schema();

2175

$this->_buildRelatedModels($this->Model);

2176

2177

$__backup = $this->Model->hasAndBelongsToMany['TestModel7'];

2178

2179

$this->Model->hasAndBelongsToMany['TestModel7']['page'] = 2;

2180

$this->Model->hasAndBelongsToMany['TestModel7']['limit'] = 5;

2181

2182

$binding = array('type'=>'hasAndBelongsToMany', 'model'=>'TestModel7');

2183

$queryData = array();

2184

$resultSet = null;

2185

$null = null;

2186

2187

$params = &$this->_prepareAssociationQuery($this->Model, $queryData, $binding);

2188

2189

$result = $this->testDb->generateAssociationQuery($this->Model, $params['linkModel'], $params['type'], $params['assoc'], $params['assocData'], $queryData, $params['external'], $resultSet);

2190

2191

$this->assertPattern('/\s+FROM\s+`test_model7`\s+AS\s+`TestModel7`\s+JOIN\s+`test_model4_test_model7`\s+AS\s+`TestModel4TestModel7`/', $result);

2192

$this->assertPattern('/\s+ON\s+\(`TestModel4TestModel7`\.`test_model4_id`\s+=\s+{\$__cakeID__\$}/', $result);

2193

$this->assertPattern('/\s+AND\s+`TestModel4TestModel7`\.`test_model7_id`\s+=\s+`TestModel7`\.`id`\)\s+WHERE\s+/', $result);

2194

$this->assertPattern('/\s+(?:$)?1\s+=\s+1(?:$)?\s*\s+LIMIT 5,\s*5\s*$/', $result);

2195

2196

$result = $this->testDb->generateAssociationQuery($this->Model, $null, null, null, null, $queryData, false, $null);

2197

$this->assertPattern('/^SELECT\s+`TestModel4`\.`id`, `TestModel4`\.`name`, `TestModel4`\.`created`, `TestModel4`\.`updated`\s+/', $result);

2198

$this->assertPattern('/\s+FROM\s+`test_model4` AS `TestModel4`\s+WHERE\s+(?:$)?1\s+=\s+1(?:$)?\s*$/', $result);

2199

2200

$this->Model->hasAndBelongsToMany['TestModel7'] = $__backup;

2201

}

2202

2203

/**

2204

* buildRelatedModels method

2205

2206

* @param mixed $model

2207

* @access protected

2208

* @return void

2209

2210

function _buildRelatedModels(&$model) {

2211

foreach ($model->__associations as $type) {

2212

foreach ($model->{$type} as $assoc => $assocData) {

2213

if (is_string($assocData)) {

2214

$className = $assocData;

2215

} elseif (isset($assocData['className'])) {

2216

$className = $assocData['className'];

2217

}

2218

$model->$className =& new $className();

2219

$model->$className->schema();

2220

}

2221

}

2222

}

2223

2224

/**

2225

* &_prepareAssociationQuery method

2226

2227

* @param mixed $model

2228

* @param mixed $queryData

2229

* @param mixed $binding

2230

* @access public

2231

* @return void

2232

2233

function &_prepareAssociationQuery(&$model, &$queryData, $binding) {

2234

$type = $binding['type'];

2235

$assoc = $binding['model'];

2236

$assocData = $model->{$type}[$assoc];

2237

$className = $assocData['className'];

2238

2239

$linkModel =& $model->{$className};

2240

$external = isset($assocData['external']);

2241

$queryData = $this->testDb->__scrubQueryData($queryData);

2242

2243

$result = array_merge(array('linkModel' => &$linkModel), compact('type', 'assoc', 'assocData', 'external'));

2244

return $result;

2245

}

2246

2247

/**

2248

* testSelectDistict method

2249

2250

* @access public

2251

* @return void

2252

2253

function testSelectDistict() {

2254

$result = $this->testDb->fields($this->Model, 'Vendor', "DISTINCT Vendor.id, Vendor.name");

2255

$expected = array('DISTINCT `Vendor`.`id`', '`Vendor`.`name`');

2256

$this->assertEqual($result, $expected);

2257

}

2258

2259

/**

2260

* test that booleans and null make logical condition strings.

2261

2262

* @return void

2263

2264

function testBooleanNullConditionsParsing() {

2265

$result = $this->testDb->conditions(true);

2266

$this->assertEqual($result, ' WHERE 1 = 1', 'true conditions failed %s');

2267

2268

$result = $this->testDb->conditions(false);

2269

$this->assertEqual($result, ' WHERE 0 = 1', 'false conditions failed %s');

2270

2271

$result = $this->testDb->conditions(null);

2272

$this->assertEqual($result, ' WHERE 1 = 1', 'null conditions failed %s');

2273

2274

$result = $this->testDb->conditions(array());

2275

$this->assertEqual($result, ' WHERE 1 = 1', 'array() conditions failed %s');

2276

2277

$result = $this->testDb->conditions('');

2278

$this->assertEqual($result, ' WHERE 1 = 1', '"" conditions failed %s');

2279

2280

$result = $this->testDb->conditions(' ', '" " conditions failed %s');

2281

$this->assertEqual($result, ' WHERE 1 = 1');

2282

}

2283

/**

2284

* testStringConditionsParsing method

2285

2286

* @access public

2287

* @return void

2288

2289

function testStringConditionsParsing() {

2290

$result = $this->testDb->conditions("ProjectBid.project_id = Project.id");

2291

$expected = " WHERE `ProjectBid`.`project_id` = `Project`.`id`";

2292

$this->assertEqual($result, $expected);

2293

2294

$result = $this->testDb->conditions("Candy.name LIKE 'a' AND HardCandy.name LIKE 'c'");

2295

$expected = " WHERE `Candy`.`name` LIKE 'a' AND `HardCandy`.`name` LIKE 'c'";

2296

$this->assertEqual($result, $expected);

2297

2298

$result = $this->testDb->conditions("HardCandy.name LIKE 'a' AND Candy.name LIKE 'c'");

2299

$expected = " WHERE `HardCandy`.`name` LIKE 'a' AND `Candy`.`name` LIKE 'c'";

2300

$this->assertEqual($result, $expected);

2301

2302

$result = $this->testDb->conditions("Post.title = '1.1'");

2303

$expected = " WHERE `Post`.`title` = '1.1'";

2304

$this->assertEqual($result, $expected);

2305

2306

$result = $this->testDb->conditions("User.id != 0 AND User.user LIKE '%arr%'");

2307

$expected = " WHERE `User`.`id` != 0 AND `User`.`user` LIKE '%arr%'";

2308

$this->assertEqual($result, $expected);

2309

2310

$result = $this->testDb->conditions("SUM(Post.comments_count) > 500");

2311

$expected = " WHERE SUM(`Post`.`comments_count`) > 500";

2312

$this->assertEqual($result, $expected);

2313

2314

$result = $this->testDb->conditions("(Post.created < '" . date('Y-m-d H:i:s') . "') GROUP BY YEAR(Post.created), MONTH(Post.created)");

2315

$expected = " WHERE (`Post`.`created` < '" . date('Y-m-d H:i:s') . "') GROUP BY YEAR(`Post`.`created`), MONTH(`Post`.`created`)";

2316

$this->assertEqual($result, $expected);

2317

2318

$result = $this->testDb->conditions("score BETWEEN 90.1 AND 95.7");

2319

$expected = " WHERE score BETWEEN 90.1 AND 95.7";

2320

$this->assertEqual($result, $expected);

2321

2322

$result = $this->testDb->conditions(array('score' => array(2=>1, 2, 10)));

2323

$expected = " WHERE score IN (1, 2, 10)";

2324

$this->assertEqual($result, $expected);

2325

2326

$result = $this->testDb->conditions("Aro.rght = Aro.lft + 1.1");

2327

$expected = " WHERE `Aro`.`rght` = `Aro`.`lft` + 1.1";

2328

$this->assertEqual($result, $expected);

2329

2330

$result = $this->testDb->conditions("(Post.created < '" . date('Y-m-d H:i:s') . "') GROUP BY YEAR(Post.created), MONTH(Post.created)");

2331

$expected = " WHERE (`Post`.`created` < '" . date('Y-m-d H:i:s') . "') GROUP BY YEAR(`Post`.`created`), MONTH(`Post`.`created`)";

2332

$this->assertEqual($result, $expected);

2333

2334

$result = $this->testDb->conditions('Sportstaette.sportstaette LIKE "%ru%" AND Sportstaette.sportstaettenart_id = 2');

2335

$expected = ' WHERE `Sportstaette`.`sportstaette` LIKE "%ru%" AND `Sportstaette`.`sportstaettenart_id` = 2';

2336

$this->assertPattern('/\s*WHERE\s+`Sportstaette`\.`sportstaette`\s+LIKE\s+"%ru%"\s+AND\s+`Sports/', $result);

2337

$this->assertEqual($result, $expected);

2338

2339

$result = $this->testDb->conditions('Sportstaette.sportstaettenart_id = 2 AND Sportstaette.sportstaette LIKE "%ru%"');

2340

$expected = ' WHERE `Sportstaette`.`sportstaettenart_id` = 2 AND `Sportstaette`.`sportstaette` LIKE "%ru%"';

2341

$this->assertEqual($result, $expected);

2342

2343

$result = $this->testDb->conditions('SUM(Post.comments_count) > 500 AND NOT Post.title IS NULL AND NOT Post.extended_title IS NULL');

2344

$expected = ' WHERE SUM(`Post`.`comments_count`) > 500 AND NOT `Post`.`title` IS NULL AND NOT `Post`.`extended_title` IS NULL';

2345

$this->assertEqual($result, $expected);

2346

2347

$result = $this->testDb->conditions('NOT Post.title IS NULL AND NOT Post.extended_title IS NULL AND SUM(Post.comments_count) > 500');

2348

$expected = ' WHERE NOT `Post`.`title` IS NULL AND NOT `Post`.`extended_title` IS NULL AND SUM(`Post`.`comments_count`) > 500';

2349

$this->assertEqual($result, $expected);

2350

2351

$result = $this->testDb->conditions('NOT Post.extended_title IS NULL AND NOT Post.title IS NULL AND Post.title != "" AND SPOON(SUM(Post.comments_count) + 1.1) > 500');

2352

$expected = ' WHERE NOT `Post`.`extended_title` IS NULL AND NOT `Post`.`title` IS NULL AND `Post`.`title` != "" AND SPOON(SUM(`Post`.`comments_count`) + 1.1) > 500';

2353

$this->assertEqual($result, $expected);

2354

2355

$result = $this->testDb->conditions('NOT Post.title_extended IS NULL AND NOT Post.title IS NULL AND Post.title_extended != Post.title');

2356

$expected = ' WHERE NOT `Post`.`title_extended` IS NULL AND NOT `Post`.`title` IS NULL AND `Post`.`title_extended` != `Post`.`title`';

2357

$this->assertEqual($result, $expected);

2358

2359

$result = $this->testDb->conditions("Comment.id = 'a'");

2360

$expected = " WHERE `Comment`.`id` = 'a'";

2361

$this->assertEqual($result, $expected);

2362

2363

$result = $this->testDb->conditions("lower(Article.title) LIKE 'a%'");

2364

$expected = " WHERE lower(`Article`.`title`) LIKE 'a%'";

2365

$this->assertEqual($result, $expected);

2366

2367

$result = $this->testDb->conditions('((MATCH(Video.title) AGAINST(\'My Search*\' IN BOOLEAN MODE) * 2) + (MATCH(Video.description) AGAINST(\'My Search*\' IN BOOLEAN MODE) * 0.4) + (MATCH(Video.tags) AGAINST(\'My Search*\' IN BOOLEAN MODE) * 1.5))');

2368

$expected = ' WHERE ((MATCH(`Video`.`title`) AGAINST(\'My Search*\' IN BOOLEAN MODE) * 2) + (MATCH(`Video`.`description`) AGAINST(\'My Search*\' IN BOOLEAN MODE) * 0.4) + (MATCH(`Video`.`tags`) AGAINST(\'My Search*\' IN BOOLEAN MODE) * 1.5))';

2369

$this->assertEqual($result, $expected);

2370

2371

$result = $this->testDb->conditions('DATEDIFF(NOW(),Article.published) < 1 && Article.live=1');

2372

$expected = " WHERE DATEDIFF(NOW(),`Article`.`published`) < 1 && `Article`.`live`=1";

2373

$this->assertEqual($result, $expected);

2374

2375

$result = $this->testDb->conditions('file = "index.html"');

2376

$expected = ' WHERE file = "index.html"';

2377

$this->assertEqual($result, $expected);

2378

2379

$result = $this->testDb->conditions("file = 'index.html'");

2380

$expected = " WHERE file = 'index.html'";

2381

$this->assertEqual($result, $expected);

2382

2383

$letter = $letter = 'd.a';

2384

$conditions = array('Company.name like ' => $letter . '%');

2385

$result = $this->testDb->conditions($conditions);

2386

$expected = " WHERE `Company`.`name` like 'd.a%'";

2387

$this->assertEqual($result, $expected);

2388

2389

$conditions = array('Artist.name' => 'JUDY and MARY');

2390

$result = $this->testDb->conditions($conditions);

2391

$expected = " WHERE `Artist`.`name` = 'JUDY and MARY'";

2392

$this->assertEqual($result, $expected);

2393

2394

$conditions = array('Artist.name' => 'JUDY AND MARY');

2395

$result = $this->testDb->conditions($conditions);

2396

$expected = " WHERE `Artist`.`name` = 'JUDY AND MARY'";

2397

$this->assertEqual($result, $expected);

2398

}

2399

2400

/**

2401

* testQuotesInStringConditions method

2402

2403

* @access public

2404

* @return void

2405

2406

function testQuotesInStringConditions() {

2407

$result = $this->testDb->conditions('Member.email = \'mariano@cricava.com\'');

2408

$expected = ' WHERE `Member`.`email` = \'mariano@cricava.com\'';

2409

$this->assertEqual($result, $expected);

2410

2411

$result = $this->testDb->conditions('Member.email = "mariano@cricava.com"');

2412

$expected = ' WHERE `Member`.`email` = "mariano@cricava.com"';

2413

$this->assertEqual($result, $expected);

2414

2415

$result = $this->testDb->conditions('Member.email = \'mariano@cricava.com\' AND Member.user LIKE \'mariano.iglesias%\'');

2416

$expected = ' WHERE `Member`.`email` = \'mariano@cricava.com\' AND `Member`.`user` LIKE \'mariano.iglesias%\'';

2417

$this->assertEqual($result, $expected);

2418

2419

2420

$result = $this->testDb->conditions('Member.email = "mariano@cricava.com" AND Member.user LIKE "mariano.iglesias%"');

2421

$expected = ' WHERE `Member`.`email` = "mariano@cricava.com" AND `Member`.`user` LIKE "mariano.iglesias%"';

2422

$this->assertEqual($result, $expected);

2423

}

2424

2425

/**

2426

* testParenthesisInStringConditions method

2427

2428

* @access public

2429

* @return void

2430

2431

function testParenthesisInStringConditions() {

2432

$result = $this->testDb->conditions('Member.name = \'(lu\'');

2433

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'\(lu\'$/', $result);

2434

2435

$result = $this->testDb->conditions('Member.name = \')lu\'');

2436

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'\)lu\'$/', $result);

2437

2438

$result = $this->testDb->conditions('Member.name = \'va(lu\'');

2439

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'va\(lu\'$/', $result);

2440

2441

$result = $this->testDb->conditions('Member.name = \'va)lu\'');

2442

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'va\)lu\'$/', $result);

2443

2444

$result = $this->testDb->conditions('Member.name = \'va(lu)\'');

2445

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'va$lu$\'$/', $result);

2446

2447

$result = $this->testDb->conditions('Member.name = \'va(lu)e\'');

2448

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'va$lu$e\'$/', $result);

2449

2450

$result = $this->testDb->conditions('Member.name = \'(mariano)\'');

2451

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'$mariano$\'$/', $result);

2452

2453

$result = $this->testDb->conditions('Member.name = \'(mariano)iglesias\'');

2454

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'$mariano$iglesias\'$/', $result);

2455

2456

$result = $this->testDb->conditions('Member.name = \'(mariano) iglesias\'');

2457

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'$mariano$ iglesias\'$/', $result);

2458

2459

$result = $this->testDb->conditions('Member.name = \'(mariano word) iglesias\'');

2460

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'$mariano word$ iglesias\'$/', $result);

2461

2462

$result = $this->testDb->conditions('Member.name = \'(mariano.iglesias)\'');

2463

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'$mariano.iglesias$\'$/', $result);

2464

2465

$result = $this->testDb->conditions('Member.name = \'Mariano Iglesias (mariano.iglesias)\'');

2466

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'Mariano Iglesias $mariano.iglesias$\'$/', $result);

2467

2468

$result = $this->testDb->conditions('Member.name = \'Mariano Iglesias (mariano.iglesias) CakePHP\'');

2469

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'Mariano Iglesias $mariano.iglesias$ CakePHP\'$/', $result);

2470

2471

$result = $this->testDb->conditions('Member.name = \'(mariano.iglesias) CakePHP\'');

2472

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'$mariano.iglesias$ CakePHP\'$/', $result);

2473

}

2474

2475

/**

2476

* testParenthesisInArrayConditions method

2477

2478

* @access public

2479

* @return void

2480

2481

function testParenthesisInArrayConditions() {

2482

$result = $this->testDb->conditions(array('Member.name' => '(lu'));

2483

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'\(lu\'$/', $result);

2484

2485

$result = $this->testDb->conditions(array('Member.name' => ')lu'));

2486

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'\)lu\'$/', $result);

2487

2488

$result = $this->testDb->conditions(array('Member.name' => 'va(lu'));

2489

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'va\(lu\'$/', $result);

2490

2491

$result = $this->testDb->conditions(array('Member.name' => 'va)lu'));

2492

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'va\)lu\'$/', $result);

2493

2494

$result = $this->testDb->conditions(array('Member.name' => 'va(lu)'));

2495

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'va$lu$\'$/', $result);

2496

2497

$result = $this->testDb->conditions(array('Member.name' => 'va(lu)e'));

2498

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'va$lu$e\'$/', $result);

2499

2500

$result = $this->testDb->conditions(array('Member.name' => '(mariano)'));

2501

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'$mariano$\'$/', $result);

2502

2503

$result = $this->testDb->conditions(array('Member.name' => '(mariano)iglesias'));

2504

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'$mariano$iglesias\'$/', $result);

2505

2506

$result = $this->testDb->conditions(array('Member.name' => '(mariano) iglesias'));

2507

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'$mariano$ iglesias\'$/', $result);

2508

2509

$result = $this->testDb->conditions(array('Member.name' => '(mariano word) iglesias'));

2510

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'$mariano word$ iglesias\'$/', $result);

2511

2512

$result = $this->testDb->conditions(array('Member.name' => '(mariano.iglesias)'));

2513

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'$mariano.iglesias$\'$/', $result);

2514

2515

$result = $this->testDb->conditions(array('Member.name' => 'Mariano Iglesias (mariano.iglesias)'));

2516

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'Mariano Iglesias $mariano.iglesias$\'$/', $result);

2517

2518

$result = $this->testDb->conditions(array('Member.name' => 'Mariano Iglesias (mariano.iglesias) CakePHP'));

2519

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'Mariano Iglesias $mariano.iglesias$ CakePHP\'$/', $result);

2520

2521

$result = $this->testDb->conditions(array('Member.name' => '(mariano.iglesias) CakePHP'));

2522

$this->assertPattern('/^\s+WHERE\s+`Member`.`name`\s+=\s+\'$mariano.iglesias$ CakePHP\'$/', $result);

2523

}

2524

2525

/**

2526

* testArrayConditionsParsing method

2527

2528

* @access public

2529

* @return void

2530

2531

function testArrayConditionsParsing() {

2532

$result = $this->testDb->conditions(array('Stereo.type' => 'in dash speakers'));

2533

$this->assertPattern("/^\s+WHERE\s+`Stereo`.`type`\s+=\s+'in dash speakers'/", $result);

2534

2535

$result = $this->testDb->conditions(array('Candy.name LIKE' => 'a', 'HardCandy.name LIKE' => 'c'));

2536

$this->assertPattern("/^\s+WHERE\s+`Candy`.`name` LIKE\s+'a'\s+AND\s+`HardCandy`.`name`\s+LIKE\s+'c'/", $result);

2537

2538

$result = $this->testDb->conditions(array('HardCandy.name LIKE' => 'a', 'Candy.name LIKE' => 'c'));

2539

$expected = " WHERE `HardCandy`.`name` LIKE 'a' AND `Candy`.`name` LIKE 'c'";

2540

$this->assertEqual($result, $expected);

2541

2542

$result = $this->testDb->conditions(array('HardCandy.name LIKE' => 'a%', 'Candy.name LIKE' => '%c%'));

2543

$expected = " WHERE `HardCandy`.`name` LIKE 'a%' AND `Candy`.`name` LIKE '%c%'";

2544

$this->assertEqual($result, $expected);

2545

2546

$result = $this->testDb->conditions(array('HardCandy.name LIKE' => 'to be or%', 'Candy.name LIKE' => '%not to be%'));

2547

$expected = " WHERE `HardCandy`.`name` LIKE 'to be or%' AND `Candy`.`name` LIKE '%not to be%'";

2548

$this->assertEqual($result, $expected);

2549

2550

$result = $this->testDb->conditions(array('score BETWEEN ? AND ?' => array(90.1, 95.7)));

2551

$expected = " WHERE `score` BETWEEN 90.100000 AND 95.700000";

2552

$this->assertEqual($result, $expected);

2553

2554

$result = $this->testDb->conditions(array('Post.title' => 1.1));

2555

$expected = " WHERE `Post`.`title` = 1.100000";

2556

$this->assertEqual($result, $expected);

2557

2558

$result = $this->testDb->conditions(array('Post.title' => 1.1), true, true, new Post());

2559

$expected = " WHERE `Post`.`title` = '1.1'";

2560

$this->assertEqual($result, $expected);

2561

2562

$result = $this->testDb->conditions(array('SUM(Post.comments_count) >' => '500'));

2563

$expected = " WHERE SUM(`Post`.`comments_count`) > '500'";

2564

$this->assertEqual($result, $expected);

2565

2566

$result = $this->testDb->conditions(array('MAX(Post.rating) >' => '50'));

2567

$expected = " WHERE MAX(`Post`.`rating`) > '50'";

2568

$this->assertEqual($result, $expected);

2569

2570

$result = $this->testDb->conditions(array('title LIKE' => '%hello'));

2571

$expected = " WHERE `title` LIKE '%hello'";

2572

$this->assertEqual($result, $expected);

2573

2574

$result = $this->testDb->conditions(array('Post.name' => 'mad(g)ik'));

2575

$expected = " WHERE `Post`.`name` = 'mad(g)ik'";

2576

$this->assertEqual($result, $expected);

2577

2578

$result = $this->testDb->conditions(array('score' => array(1, 2, 10)));

2579

$expected = " WHERE score IN (1, 2, 10)";

2580

$this->assertEqual($result, $expected);

2581

2582

$result = $this->testDb->conditions(array('score' => array()));

2583

$expected = " WHERE `score` IS NULL";

2584

$this->assertEqual($result, $expected);

2585

2586

$result = $this->testDb->conditions(array('score !=' => array()));

2587

$expected = " WHERE `score` IS NOT NULL";

2588

$this->assertEqual($result, $expected);

2589

2590

$result = $this->testDb->conditions(array('score !=' => '20'));

2591

$expected = " WHERE `score` != '20'";

2592

$this->assertEqual($result, $expected);

2593

2594

$result = $this->testDb->conditions(array('score >' => '20'));

2595

$expected = " WHERE `score` > '20'";

2596

$this->assertEqual($result, $expected);

2597

2598

$result = $this->testDb->conditions(array('client_id >' => '20'), true, true, new TestModel());

2599

$expected = " WHERE `client_id` > 20";

2600

$this->assertEqual($result, $expected);

2601

2602

$result = $this->testDb->conditions(array('OR' => array(

2603

array('User.user' => 'mariano'),

2604

array('User.user' => 'nate')

2605

)));

2606

2607

$expected = " WHERE ((`User`.`user` = 'mariano') OR (`User`.`user` = 'nate'))";

2608

$this->assertEqual($result, $expected);

2609

2610

$result = $this->testDb->conditions(array('or' => array(

2611

'score BETWEEN ? AND ?' => array('4', '5'), 'rating >' => '20'

2612

)));

2613

$expected = " WHERE ((`score` BETWEEN '4' AND '5') OR (`rating` > '20'))";

2614

$this->assertEqual($result, $expected);

2615

2616

$result = $this->testDb->conditions(array('or' => array(

2617

'score BETWEEN ? AND ?' => array('4', '5'), array('score >' => '20')

2618

)));

2619

$expected = " WHERE ((`score` BETWEEN '4' AND '5') OR (`score` > '20'))";

2620

$this->assertEqual($result, $expected);

2621

2622

$result = $this->testDb->conditions(array('and' => array(

2623

'score BETWEEN ? AND ?' => array('4', '5'), array('score >' => '20')

2624

)));

2625

$expected = " WHERE ((`score` BETWEEN '4' AND '5') AND (`score` > '20'))";

2626

$this->assertEqual($result, $expected);

2627

2628

$result = $this->testDb->conditions(array(

2629

'published' => 1, 'or' => array('score >' => '2', array('score >' => '20'))

2630

));

2631

$expected = " WHERE `published` = 1 AND ((`score` > '2') OR (`score` > '20'))";

2632

$this->assertEqual($result, $expected);

2633

2634

$result = $this->testDb->conditions(array(array('Project.removed' => false)));

2635

$expected = " WHERE `Project`.`removed` = 0";

2636

$this->assertEqual($result, $expected);

2637

2638

$result = $this->testDb->conditions(array(array('Project.removed' => true)));

2639

$expected = " WHERE `Project`.`removed` = 1";

2640

$this->assertEqual($result, $expected);

2641

2642

$result = $this->testDb->conditions(array(array('Project.removed' => null)));

2643

$expected = " WHERE `Project`.`removed` IS NULL";

2644

$this->assertEqual($result, $expected);

2645

2646

$result = $this->testDb->conditions(array(array('Project.removed !=' => null)));

2647

$expected = " WHERE `Project`.`removed` IS NOT NULL";

2648

$this->assertEqual($result, $expected);

2649

2650

$result = $this->testDb->conditions(array('(Usergroup.permissions) & 4' => 4));

2651

$expected = " WHERE (`Usergroup`.`permissions`) & 4 = 4";

2652

$this->assertEqual($result, $expected);

2653

2654

$result = $this->testDb->conditions(array('((Usergroup.permissions) & 4)' => 4));

2655

$expected = " WHERE ((`Usergroup`.`permissions`) & 4) = 4";

2656

$this->assertEqual($result, $expected);

2657

2658

$result = $this->testDb->conditions(array('Post.modified >=' => 'DATE_SUB(NOW(), INTERVAL 7 DAY)'));

2659

$expected = " WHERE `Post`.`modified` >= 'DATE_SUB(NOW(), INTERVAL 7 DAY)'";

2660

$this->assertEqual($result, $expected);

2661

2662

$result = $this->testDb->conditions(array('Post.modified >= DATE_SUB(NOW(), INTERVAL 7 DAY)'));

2663

$expected = " WHERE `Post`.`modified` >= DATE_SUB(NOW(), INTERVAL 7 DAY)";

2664

$this->assertEqual($result, $expected);

2665

2666

$result = $this->testDb->conditions(array(

2667

'NOT' => array('Course.id' => null, 'Course.vet' => 'N', 'level_of_education_id' => array(912,999)),

2668

'Enrollment.yearcompleted >' => '0')

2669

);

2670

$this->assertPattern('/^\s*WHERE\s+$NOT\s+\(`Course`\.`id` IS NULL$\s+AND NOT\s+$`Course`\.`vet`\s+=\s+\'N\'$\s+AND NOT\s+$level_of_education_id IN \(912, 999$\)\)\s+AND\s+`Enrollment`\.`yearcompleted`\s+>\s+\'0\'\s*$/', $result);

2671

2672

$result = $this->testDb->conditions(array('id <>' => '8'));

2673

$this->assertPattern('/^\s*WHERE\s+`id`\s+<>\s+\'8\'\s*$/', $result);

2674

2675

$result = $this->testDb->conditions(array('TestModel.field =' => 'gribe$@()lu'));

2676

$expected = " WHERE `TestModel`.`field` = 'gribe$@()lu'";

2677

$this->assertEqual($result, $expected);

2678

2679

$conditions['NOT'] = array('Listing.expiration BETWEEN ? AND ?' => array("1", "100"));

2680

$conditions[0]['OR'] = array(

2681

"Listing.title LIKE" => "%term%",

2682

"Listing.description LIKE" => "%term%"

2683

);

2684

$conditions[1]['OR'] = array(

2685

"Listing.title LIKE" => "%term_2%",

2686

"Listing.description LIKE" => "%term_2%"

2687

);

2688

$result = $this->testDb->conditions($conditions);

2689

$expected = " WHERE NOT (`Listing`.`expiration` BETWEEN '1' AND '100') AND" .

2690

" ((`Listing`.`title` LIKE '%term%') OR (`Listing`.`description` LIKE '%term%')) AND" .

2691

" ((`Listing`.`title` LIKE '%term_2%') OR (`Listing`.`description` LIKE '%term_2%'))";

2692

$this->assertEqual($result, $expected);

2693

2694

$result = $this->testDb->conditions(array('MD5(CONCAT(Reg.email,Reg.id))' => 'blah'));

2695

$expected = " WHERE MD5(CONCAT(`Reg`.`email`,`Reg`.`id`)) = 'blah'";

2696

$this->assertEqual($result, $expected);

2697

2698

$result = $this->testDb->conditions(array(

2699

'MD5(CONCAT(Reg.email,Reg.id))' => array('blah', 'blahblah')

2700

));

2701

$expected = " WHERE MD5(CONCAT(`Reg`.`email`,`Reg`.`id`)) IN ('blah', 'blahblah')";

2702

$this->assertEqual($result, $expected);

2703

2704

$conditions = array('id' => array(2, 5, 6, 9, 12, 45, 78, 43, 76));

2705

$result = $this->testDb->conditions($conditions);

2706

$expected = " WHERE id IN (2, 5, 6, 9, 12, 45, 78, 43, 76)";

2707

$this->assertEqual($result, $expected);

2708

2709

$conditions = array('title' => 'user(s)');

2710

$result = $this->testDb->conditions($conditions);

2711

$expected = " WHERE `title` = 'user(s)'";

2712

$this->assertEqual($result, $expected);

2713

2714

$conditions = array('title' => 'user(s) data');

2715

$result = $this->testDb->conditions($conditions);

2716

$expected = " WHERE `title` = 'user(s) data'";

2717

$this->assertEqual($result, $expected);

2718

2719

$conditions = array('title' => 'user(s,arg) data');

2720

$result = $this->testDb->conditions($conditions);

2721

$expected = " WHERE `title` = 'user(s,arg) data'";

2722

$this->assertEqual($result, $expected);

2723

2724

$result = $this->testDb->conditions(array("Book.book_name" => 'Java(TM)'));

2725

$expected = " WHERE `Book`.`book_name` = 'Java(TM)'";

2726

$this->assertEqual($result, $expected);

2727

2728

$result = $this->testDb->conditions(array("Book.book_name" => 'Java(TM) '));

2729

$expected = " WHERE `Book`.`book_name` = 'Java(TM) '";

2730

$this->assertEqual($result, $expected);

2731

2732

$result = $this->testDb->conditions(array("Book.id" => 0));

2733

$expected = " WHERE `Book`.`id` = 0";

2734

$this->assertEqual($result, $expected);

2735

2736

$result = $this->testDb->conditions(array("Book.id" => NULL));

2737

$expected = " WHERE `Book`.`id` IS NULL";

2738

$this->assertEqual($result, $expected);

2739

2740

$result = $this->testDb->conditions(array('Listing.beds >=' => 0));

2741

$expected = " WHERE `Listing`.`beds` >= 0";

2742

$this->assertEqual($result, $expected);

2743

2744

$result = $this->testDb->conditions(array(

2745

'ASCII(SUBSTRING(keyword, 1, 1)) BETWEEN ? AND ?' => array(65, 90)

2746

));

2747

$expected = ' WHERE ASCII(SUBSTRING(keyword, 1, 1)) BETWEEN 65 AND 90';

2748

$this->assertEqual($result, $expected);

2749

2750

$result = $this->testDb->conditions(array('or' => array(

2751

'? BETWEEN Model.field1 AND Model.field2' => '2009-03-04'

2752

)));

2753

$expected = " WHERE '2009-03-04' BETWEEN Model.field1 AND Model.field2";

2754

$this->assertEqual($result, $expected);

2755

}

2756

2757

/**

2758

* testArrayConditionsParsingComplexKeys method

2759

2760

* @access public

2761

* @return void

2762

2763

function testArrayConditionsParsingComplexKeys() {

2764

$result = $this->testDb->conditions(array(

2765

'CAST(Book.created AS DATE)' => '2008-08-02'

2766

));

2767

$expected = " WHERE CAST(`Book`.`created` AS DATE) = '2008-08-02'";

2768

$this->assertEqual($result, $expected);

2769

2770

$result = $this->testDb->conditions(array(

2771

'CAST(Book.created AS DATE) <=' => '2008-08-02'

2772

));

2773

$expected = " WHERE CAST(`Book`.`created` AS DATE) <= '2008-08-02'";

2774

$this->assertEqual($result, $expected);

2775

2776

$result = $this->testDb->conditions(array(

2777

'(Stats.clicks * 100) / Stats.views >' => 50

2778

));

2779

$expected = " WHERE (`Stats`.`clicks` * 100) / `Stats`.`views` > 50";

2780

$this->assertEqual($result, $expected);

2781

}

2782

2783

/**

2784

* testMixedConditionsParsing method

2785

2786

* @access public

2787

* @return void

2788

2789

function testMixedConditionsParsing() {

2790

$conditions[] = 'User.first_name = \'Firstname\'';

2791

$conditions[] = array('User.last_name' => 'Lastname');

2792

$result = $this->testDb->conditions($conditions);

2793

$expected = " WHERE `User`.`first_name` = 'Firstname' AND `User`.`last_name` = 'Lastname'";

2794

$this->assertEqual($result, $expected);

2795

2796

$conditions = array(

2797

'Thread.project_id' => 5,

2798

'Thread.buyer_id' => 14,

2799

'1=1 GROUP BY Thread.project_id'

2800

);

2801

$result = $this->testDb->conditions($conditions);

2802

$this->assertPattern('/^\s*WHERE\s+`Thread`.`project_id`\s*=\s*5\s+AND\s+`Thread`.`buyer_id`\s*=\s*14\s+AND\s+1\s*=\s*1\s+GROUP BY `Thread`.`project_id`$/', $result);

2803

}

2804

2805

/**

2806

* testConditionsOptionalArguments method

2807

2808

* @access public

2809

* @return void

2810

2811

function testConditionsOptionalArguments() {

2812

$result = $this->testDb->conditions( array('Member.name' => 'Mariano'), true, false);

2813

$this->assertPattern('/^\s*`Member`.`name`\s*=\s*\'Mariano\'\s*$/', $result);

2814

2815

$result = $this->testDb->conditions( array(), true, false);

2816

$this->assertPattern('/^\s*1\s*=\s*1\s*$/', $result);

2817

}

2818

2819

/**

2820

* testConditionsWithModel

2821

2822

* @access public

2823

* @return void

2824

2825

function testConditionsWithModel() {

2826

$this->Model =& new Article2();

2827

2828

$result = $this->testDb->conditions(array('Article2.viewed >=' => 0), true, true, $this->Model);

2829

$expected = " WHERE `Article2`.`viewed` >= 0";

2830

$this->assertEqual($result, $expected);

2831

2832

$result = $this->testDb->conditions(array('Article2.viewed >=' => '0'), true, true, $this->Model);

2833

$expected = " WHERE `Article2`.`viewed` >= 0";

2834

$this->assertEqual($result, $expected);

2835

2836

$result = $this->testDb->conditions(array('Article2.viewed >=' => '1'), true, true, $this->Model);

2837

$expected = " WHERE `Article2`.`viewed` >= 1";

2838

$this->assertEqual($result, $expected);

2839

2840

$result = $this->testDb->conditions(array('Article2.rate_sum BETWEEN ? AND ?' => array(0, 10)), true, true, $this->Model);

2841

$expected = " WHERE `Article2`.`rate_sum` BETWEEN 0 AND 10";

2842

$this->assertEqual($result, $expected);

2843

2844

$result = $this->testDb->conditions(array('Article2.rate_sum BETWEEN ? AND ?' => array('0', '10')), true, true, $this->Model);

2845

$expected = " WHERE `Article2`.`rate_sum` BETWEEN 0 AND 10";

2846

$this->assertEqual($result, $expected);

2847

2848

$result = $this->testDb->conditions(array('Article2.rate_sum BETWEEN ? AND ?' => array('1', '10')), true, true, $this->Model);

2849

$expected = " WHERE `Article2`.`rate_sum` BETWEEN 1 AND 10";

2850

$this->assertEqual($result, $expected);

2851

}

2852

2853

/**

2854

* testFieldParsing method

2855

2856

* @access public

2857

* @return void

2858

2859

function testFieldParsing() {

2860

$result = $this->testDb->fields($this->Model, 'Vendor', "Vendor.id, COUNT(Model.vendor_id) AS `Vendor`.`count`");

2861

$expected = array('`Vendor`.`id`', 'COUNT(`Model`.`vendor_id`) AS `Vendor`.`count`');

2862

$this->assertEqual($result, $expected);

2863

2864

$result = $this->testDb->fields($this->Model, 'Vendor', "`Vendor`.`id`, COUNT(`Model`.`vendor_id`) AS `Vendor`.`count`");

2865

$expected = array('`Vendor`.`id`', 'COUNT(`Model`.`vendor_id`) AS `Vendor`.`count`');

2866

$this->assertEqual($result, $expected);

2867

2868

$result = $this->testDb->fields($this->Model, 'Post', "CONCAT(REPEAT(' ', COUNT(Parent.name) - 1), Node.name) AS name, Node.created");

2869

$expected = array("CONCAT(REPEAT(' ', COUNT(`Parent`.`name`) - 1), Node.name) AS name", "`Node`.`created`");

2870

$this->assertEqual($result, $expected);

2871

2872

$result = $this->testDb->fields($this->Model, null, 'round( (3.55441 * fooField), 3 ) AS test');

2873

$this->assertEqual($result, array('round( (3.55441 * fooField), 3 ) AS test'));

2874

2875

$result = $this->testDb->fields($this->Model, null, 'ROUND(`Rating`.`rate_total` / `Rating`.`rate_count`,2) AS rating');

2876

$this->assertEqual($result, array('ROUND(`Rating`.`rate_total` / `Rating`.`rate_count`,2) AS rating'));

2877

2878

$result = $this->testDb->fields($this->Model, null, 'ROUND(Rating.rate_total / Rating.rate_count,2) AS rating');

2879

$this->assertEqual($result, array('ROUND(Rating.rate_total / Rating.rate_count,2) AS rating'));

2880

2881

$result = $this->testDb->fields($this->Model, 'Post', "Node.created, CONCAT(REPEAT(' ', COUNT(Parent.name) - 1), Node.name) AS name");

2882

$expected = array("`Node`.`created`", "CONCAT(REPEAT(' ', COUNT(`Parent`.`name`) - 1), Node.name) AS name");

2883

$this->assertEqual($result, $expected);

2884

2885

$result = $this->testDb->fields($this->Model, 'Post', "2.2,COUNT(*), SUM(Something.else) as sum, Node.created, CONCAT(REPEAT(' ', COUNT(Parent.name) - 1), Node.name) AS name,Post.title,Post.1,1.1");

2886

$expected = array(

2887

'2.2', 'COUNT(*)', 'SUM(`Something`.`else`) as sum', '`Node`.`created`',

2888

"CONCAT(REPEAT(' ', COUNT(`Parent`.`name`) - 1), Node.name) AS name", '`Post`.`title`', '`Post`.`1`', '1.1'

2889

);

2890

$this->assertEqual($result, $expected);

2891

2892

$result = $this->testDb->fields($this->Model, null, "(`Provider`.`star_total` / `Provider`.`total_ratings`) as `rating`");

2893

$expected = array("(`Provider`.`star_total` / `Provider`.`total_ratings`) as `rating`");

2894

$this->assertEqual($result, $expected);

2895

2896

$result = $this->testDb->fields($this->Model, 'Post');

2897

$expected = array(

2898

'`Post`.`id`', '`Post`.`client_id`', '`Post`.`name`', '`Post`.`login`',

2899

'`Post`.`passwd`', '`Post`.`addr_1`', '`Post`.`addr_2`', '`Post`.`zip_code`',

2900

'`Post`.`city`', '`Post`.`country`', '`Post`.`phone`', '`Post`.`fax`',

2901

'`Post`.`url`', '`Post`.`email`', '`Post`.`comments`', '`Post`.`last_login`',

2902

'`Post`.`created`', '`Post`.`updated`'

2903

);

2904

$this->assertEqual($result, $expected);

2905

2906

$result = $this->testDb->fields($this->Model, 'Other');

2907

$expected = array(

2908

'`Other`.`id`', '`Other`.`client_id`', '`Other`.`name`', '`Other`.`login`',

2909

'`Other`.`passwd`', '`Other`.`addr_1`', '`Other`.`addr_2`', '`Other`.`zip_code`',

2910

'`Other`.`city`', '`Other`.`country`', '`Other`.`phone`', '`Other`.`fax`',

2911

'`Other`.`url`', '`Other`.`email`', '`Other`.`comments`', '`Other`.`last_login`',

2912

'`Other`.`created`', '`Other`.`updated`'

2913

);

2914

$this->assertEqual($result, $expected);

2915

2916

$result = $this->testDb->fields($this->Model, null, array(), false);

2917

$expected = array('id', 'client_id', 'name', 'login', 'passwd', 'addr_1', 'addr_2', 'zip_code', 'city', 'country', 'phone', 'fax', 'url', 'email', 'comments', 'last_login', 'created', 'updated');

2918

$this->assertEqual($result, $expected);

2919

2920

$result = $this->testDb->fields($this->Model, null, 'COUNT(*)');

2921

$expected = array('COUNT(*)');

2922

$this->assertEqual($result, $expected);

2923

2924

$result = $this->testDb->fields($this->Model, null, 'SUM(Thread.unread_buyer) AS ' . $this->testDb->name('sum_unread_buyer'));

2925

$expected = array('SUM(`Thread`.`unread_buyer`) AS `sum_unread_buyer`');

2926

$this->assertEqual($result, $expected);

2927

2928

$result = $this->testDb->fields($this->Model, null, 'name, count(*)');

2929

$expected = array('`TestModel`.`name`', 'count(*)');

2930

$this->assertEqual($result, $expected);

2931

2932

$result = $this->testDb->fields($this->Model, null, 'count(*), name');

2933

$expected = array('count(*)', '`TestModel`.`name`');

2934

$this->assertEqual($result, $expected);

2935

2936

$result = $this->testDb->fields(

2937

$this->Model, null, 'field1, field2, field3, count(*), name'

2938

);

2939

$expected = array(

2940

'`TestModel`.`field1`', '`TestModel`.`field2`',

2941

'`TestModel`.`field3`', 'count(*)', '`TestModel`.`name`'

2942

);

2943

$this->assertEqual($result, $expected);

2944

2945

$result = $this->testDb->fields($this->Model, null, array('dayofyear(now())'));

2946

$expected = array('dayofyear(now())');

2947

$this->assertEqual($result, $expected);

2948

2949

$result = $this->testDb->fields($this->Model, null, array('MAX(Model.field) As Max'));

2950

$expected = array('MAX(`Model`.`field`) As Max');

2951

$this->assertEqual($result, $expected);

2952

2953

$result = $this->testDb->fields($this->Model, null, array('Model.field AS AnotherName'));

2954

$expected = array('`Model`.`field` AS `AnotherName`');

2955

$this->assertEqual($result, $expected);

2956

2957

$result = $this->testDb->fields($this->Model, null, array('field AS AnotherName'));

2958

$expected = array('`field` AS `AnotherName`');

2959

$this->assertEqual($result, $expected);

2960

2961

$result = $this->testDb->fields($this->Model, null, array(

2962

'TestModel.field AS AnotherName'

2963

));

2964

$expected = array('`TestModel`.`field` AS `AnotherName`');

2965

$this->assertEqual($result, $expected);

2966

2967

$result = $this->testDb->fields($this->Model, 'Foo', array(

2968

'id', 'title', '(user_count + discussion_count + post_count) AS score'

2969

));

2970

$expected = array(

2971

'`Foo`.`id`',

2972

'`Foo`.`title`',

2973

'(user_count + discussion_count + post_count) AS score'

2974

);

2975

$this->assertEqual($result, $expected);

2976

}

2977

2978

/**

2979

* test that fields() will accept objects made from DboSource::expression

2980

2981

* @return void

2982

2983

function testFieldsWithExpression() {

2984

$expression = $this->testDb->expression("CASE Sample.id WHEN 1 THEN 'Id One' ELSE 'Other Id' END AS case_col");

2985

$result = $this->testDb->fields($this->Model, null, array("id", $expression));

2986

$expected = array(

2987

'`TestModel`.`id`',

2988

"CASE Sample.id WHEN 1 THEN 'Id One' ELSE 'Other Id' END AS case_col"

2989

);

2990

$this->assertEqual($result, $expected);

2991

}

2992

2993

/**

2994

* test that order() will accept objects made from DboSource::expression

2995

2996

* @return void

2997

2998

function testOrderWithExpression() {

2999

$expression = $this->testDb->expression("CASE Sample.id WHEN 1 THEN 'Id One' ELSE 'Other Id' END AS case_col");

3000

$result = $this->testDb->order($expression);

3001

$expected = " ORDER BY CASE Sample.id WHEN 1 THEN 'Id One' ELSE 'Other Id' END AS case_col";

3002

$this->assertEqual($result, $expected);

3003

}

3004

3005

/**

3006

* testMergeAssociations method

3007

3008

* @access public

3009

* @return void

3010

3011

function testMergeAssociations() {

3012

$data = array('Article2' => array(

3013

'id' => '1', 'user_id' => '1', 'title' => 'First Article',

3014

'body' => 'First Article Body', 'published' => 'Y',

3015

'created' => '2007-03-18 10:39:23', 'updated' => '2007-03-18 10:41:31'

3016

));

3017

$merge = array('Topic' => array(array(

3018

'id' => '1', 'topic' => 'Topic', 'created' => '2007-03-17 01:16:23',

3019

'updated' => '2007-03-17 01:18:31'

3020

)));

3021

$expected = array(

3022

'Article2' => array(

3023

'id' => '1', 'user_id' => '1', 'title' => 'First Article',

3024

'body' => 'First Article Body', 'published' => 'Y',

3025

'created' => '2007-03-18 10:39:23', 'updated' => '2007-03-18 10:41:31'

3026

3027

'Topic' => array(

3028

'id' => '1', 'topic' => 'Topic', 'created' => '2007-03-17 01:16:23',

3029

'updated' => '2007-03-17 01:18:31'

3030

)

3031

);

3032

$this->testDb->__mergeAssociation($data, $merge, 'Topic', 'hasOne');

3033

$this->assertEqual($data, $expected);

3034

3035

$data = array('Article2' => array(

3036

'id' => '1', 'user_id' => '1', 'title' => 'First Article',

3037

'body' => 'First Article Body', 'published' => 'Y',

3038

'created' => '2007-03-18 10:39:23', 'updated' => '2007-03-18 10:41:31'

3039

));

3040

$merge = array('User2' => array(array(

3041

'id' => '1', 'user' => 'mariano', 'password' => '5f4dcc3b5aa765d61d8327deb882cf99',

3042

'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3043

)));

3044

3045

$expected = array(

3046

'Article2' => array(

3047

'id' => '1', 'user_id' => '1', 'title' => 'First Article',

3048

'body' => 'First Article Body', 'published' => 'Y',

3049

'created' => '2007-03-18 10:39:23', 'updated' => '2007-03-18 10:41:31'

3050

3051

'User2' => array(

3052

'id' => '1', 'user' => 'mariano', 'password' => '5f4dcc3b5aa765d61d8327deb882cf99', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3053

)

3054

);

3055

$this->testDb->__mergeAssociation($data, $merge, 'User2', 'belongsTo');

3056

$this->assertEqual($data, $expected);

3057

3058

$data = array(

3059

'Article2' => array(

3060

'id' => '1', 'user_id' => '1', 'title' => 'First Article', 'body' => 'First Article Body', 'published' => 'Y', 'created' => '2007-03-18 10:39:23', 'updated' => '2007-03-18 10:41:31'

3061

)

3062

);

3063

$merge = array(array('Comment' => false));

3064

$expected = array(

3065

'Article2' => array(

3066

'id' => '1', 'user_id' => '1', 'title' => 'First Article', 'body' => 'First Article Body', 'published' => 'Y', 'created' => '2007-03-18 10:39:23', 'updated' => '2007-03-18 10:41:31'

3067

3068

'Comment' => array()

3069

);

3070

$this->testDb->__mergeAssociation($data, $merge, 'Comment', 'hasMany');

3071

$this->assertEqual($data, $expected);

3072

3073

$data = array(

3074

'Article' => array(

3075

'id' => '1', 'user_id' => '1', 'title' => 'First Article', 'body' => 'First Article Body', 'published' => 'Y', 'created' => '2007-03-18 10:39:23', 'updated' => '2007-03-18 10:41:31'

3076

)

3077

);

3078

$merge = array(

3079

array(

3080

'Comment' => array(

3081

'id' => '1', 'comment' => 'Comment 1', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3082

)

3083

3084

array(

3085

'Comment' => array(

3086

'id' => '2', 'comment' => 'Comment 2', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3087

)

3088

)

3089

);

3090

$expected = array(

3091

'Article' => array(

3092

'id' => '1', 'user_id' => '1', 'title' => 'First Article', 'body' => 'First Article Body', 'published' => 'Y', 'created' => '2007-03-18 10:39:23', 'updated' => '2007-03-18 10:41:31'

3093

3094

'Comment' => array(

3095

array(

3096

'id' => '1', 'comment' => 'Comment 1', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3097

3098

array(

3099

'id' => '2', 'comment' => 'Comment 2', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3100

)

3101

)

3102

);

3103

$this->testDb->__mergeAssociation($data, $merge, 'Comment', 'hasMany');

3104

$this->assertEqual($data, $expected);

3105

3106

$data = array(

3107

'Article' => array(

3108

'id' => '1', 'user_id' => '1', 'title' => 'First Article', 'body' => 'First Article Body', 'published' => 'Y', 'created' => '2007-03-18 10:39:23', 'updated' => '2007-03-18 10:41:31'

3109

)

3110

);

3111

$merge = array(

3112

array(

3113

'Comment' => array(

3114

'id' => '1', 'comment' => 'Comment 1', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3115

3116

'User2' => array(

3117

'id' => '1', 'user' => 'mariano', 'password' => '5f4dcc3b5aa765d61d8327deb882cf99', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3118

)

3119

3120

array(

3121

'Comment' => array(

3122

'id' => '2', 'comment' => 'Comment 2', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3123

3124

'User2' => array(

3125

'id' => '1', 'user' => 'mariano', 'password' => '5f4dcc3b5aa765d61d8327deb882cf99', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3126

)

3127

)

3128

);

3129

$expected = array(

3130

'Article' => array(

3131

'id' => '1', 'user_id' => '1', 'title' => 'First Article', 'body' => 'First Article Body', 'published' => 'Y', 'created' => '2007-03-18 10:39:23', 'updated' => '2007-03-18 10:41:31'

3132

3133

'Comment' => array(

3134

array(

3135

'id' => '1', 'comment' => 'Comment 1', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31',

3136

'User2' => array(

3137

'id' => '1', 'user' => 'mariano', 'password' => '5f4dcc3b5aa765d61d8327deb882cf99', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3138

)

3139

3140

array(

3141

'id' => '2', 'comment' => 'Comment 2', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31',

3142

'User2' => array(

3143

'id' => '1', 'user' => 'mariano', 'password' => '5f4dcc3b5aa765d61d8327deb882cf99', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3144

)

3145

)

3146

)

3147

);

3148

$this->testDb->__mergeAssociation($data, $merge, 'Comment', 'hasMany');

3149

$this->assertEqual($data, $expected);

3150

3151

$data = array(

3152

'Article' => array(

3153

'id' => '1', 'user_id' => '1', 'title' => 'First Article', 'body' => 'First Article Body', 'published' => 'Y', 'created' => '2007-03-18 10:39:23', 'updated' => '2007-03-18 10:41:31'

3154

)

3155

);

3156

$merge = array(

3157

array(

3158

'Comment' => array(

3159

'id' => '1', 'comment' => 'Comment 1', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3160

3161

'User2' => array(

3162

'id' => '1', 'user' => 'mariano', 'password' => '5f4dcc3b5aa765d61d8327deb882cf99', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3163

3164

'Tag' => array(

3165

array('id' => 1, 'tag' => 'Tag 1'),

3166

array('id' => 2, 'tag' => 'Tag 2')

3167

)

3168

3169

array(

3170

'Comment' => array(

3171

'id' => '2', 'comment' => 'Comment 2', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3172

3173

'User2' => array(

3174

'id' => '1', 'user' => 'mariano', 'password' => '5f4dcc3b5aa765d61d8327deb882cf99', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3175

3176

'Tag' => array()

3177

)

3178

);

3179

$expected = array(

3180

'Article' => array(

3181

'id' => '1', 'user_id' => '1', 'title' => 'First Article', 'body' => 'First Article Body', 'published' => 'Y', 'created' => '2007-03-18 10:39:23', 'updated' => '2007-03-18 10:41:31'

3182

3183

'Comment' => array(

3184

array(

3185

'id' => '1', 'comment' => 'Comment 1', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31',

3186

'User2' => array(

3187

'id' => '1', 'user' => 'mariano', 'password' => '5f4dcc3b5aa765d61d8327deb882cf99', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3188

3189

'Tag' => array(

3190

array('id' => 1, 'tag' => 'Tag 1'),

3191

array('id' => 2, 'tag' => 'Tag 2')

3192

)

3193

3194

array(

3195

'id' => '2', 'comment' => 'Comment 2', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31',

3196

'User2' => array(

3197

'id' => '1', 'user' => 'mariano', 'password' => '5f4dcc3b5aa765d61d8327deb882cf99', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3198

3199

'Tag' => array()

3200

)

3201

)

3202

);

3203

$this->testDb->__mergeAssociation($data, $merge, 'Comment', 'hasMany');

3204

$this->assertEqual($data, $expected);

3205

3206

$data = array(

3207

'Article' => array(

3208

'id' => '1', 'user_id' => '1', 'title' => 'First Article', 'body' => 'First Article Body', 'published' => 'Y', 'created' => '2007-03-18 10:39:23', 'updated' => '2007-03-18 10:41:31'

3209

)

3210

);

3211

$merge = array(

3212

array(

3213

'Tag' => array(

3214

'id' => '1', 'tag' => 'Tag 1', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3215

)

3216

3217

array(

3218

'Tag' => array(

3219

'id' => '2', 'tag' => 'Tag 2', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3220

)

3221

3222

array(

3223

'Tag' => array(

3224

'id' => '3', 'tag' => 'Tag 3', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3225

)

3226

)

3227

);

3228

$expected = array(

3229

'Article' => array(

3230

'id' => '1', 'user_id' => '1', 'title' => 'First Article', 'body' => 'First Article Body', 'published' => 'Y', 'created' => '2007-03-18 10:39:23', 'updated' => '2007-03-18 10:41:31'

3231

3232

'Tag' => array(

3233

array(

3234

'id' => '1', 'tag' => 'Tag 1', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3235

3236

array(

3237

'id' => '2', 'tag' => 'Tag 2', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3238

3239

array(

3240

'id' => '3', 'tag' => 'Tag 3', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3241

)

3242

)

3243

);

3244

$this->testDb->__mergeAssociation($data, $merge, 'Tag', 'hasAndBelongsToMany');

3245

$this->assertEqual($data, $expected);

3246

3247

$data = array(

3248

'Article' => array(

3249

'id' => '1', 'user_id' => '1', 'title' => 'First Article', 'body' => 'First Article Body', 'published' => 'Y', 'created' => '2007-03-18 10:39:23', 'updated' => '2007-03-18 10:41:31'

3250

)

3251

);

3252

$merge = array(

3253

array(

3254

'Tag' => array(

3255

'id' => '1', 'tag' => 'Tag 1', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3256

)

3257

3258

array(

3259

'Tag' => array(

3260

'id' => '2', 'tag' => 'Tag 2', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3261

)

3262

3263

array(

3264

'Tag' => array(

3265

'id' => '3', 'tag' => 'Tag 3', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31'

3266

)

3267

)

3268

);

3269

$expected = array(

3270

'Article' => array(

3271

'id' => '1', 'user_id' => '1', 'title' => 'First Article', 'body' => 'First Article Body', 'published' => 'Y', 'created' => '2007-03-18 10:39:23', 'updated' => '2007-03-18 10:41:31'

3272

3273

'Tag' => array('id' => '1', 'tag' => 'Tag 1', 'created' => '2007-03-17 01:16:23', 'updated' => '2007-03-17 01:18:31')

3274

);

3275

$this->testDb->__mergeAssociation($data, $merge, 'Tag', 'hasOne');

3276

$this->assertEqual($data, $expected);

3277

}

3278

3279

/**

3280

* testRenderStatement method

3281

3282

* @access public

3283

* @return void

3284

3285

function testRenderStatement() {

3286

$result = $this->testDb->renderStatement('select', array(

3287

'fields' => 'id', 'table' => 'table', 'conditions' => 'WHERE 1=1',

3288

'alias' => '', 'joins' => '', 'order' => '', 'limit' => '', 'group' => ''

3289

));

3290

$this->assertPattern('/^\s*SELECT\s+id\s+FROM\s+table\s+WHERE\s+1=1\s*$/', $result);

3291

3292

$result = $this->testDb->renderStatement('update', array('fields' => 'value=2', 'table' => 'table', 'conditions' => 'WHERE 1=1', 'alias' => ''));

3293

$this->assertPattern('/^\s*UPDATE\s+table\s+SET\s+value=2\s+WHERE\s+1=1\s*$/', $result);

3294

3295

$result = $this->testDb->renderStatement('update', array('fields' => 'value=2', 'table' => 'table', 'conditions' => 'WHERE 1=1', 'alias' => 'alias', 'joins' => ''));

3296

$this->assertPattern('/^\s*UPDATE\s+table\s+AS\s+alias\s+SET\s+value=2\s+WHERE\s+1=1\s*$/', $result);

3297

3298

$result = $this->testDb->renderStatement('delete', array('fields' => 'value=2', 'table' => 'table', 'conditions' => 'WHERE 1=1', 'alias' => ''));

3299

$this->assertPattern('/^\s*DELETE\s+FROM\s+table\s+WHERE\s+1=1\s*$/', $result);

3300

3301

$result = $this->testDb->renderStatement('delete', array('fields' => 'value=2', 'table' => 'table', 'conditions' => 'WHERE 1=1', 'alias' => 'alias', 'joins' => ''));

3302

$this->assertPattern('/^\s*DELETE\s+alias\s+FROM\s+table\s+AS\s+alias\s+WHERE\s+1=1\s*$/', $result);

3303

}

3304

3305

/**

3306

* testStatements method

3307

3308

* @access public

3309

* @return void

3310

3311

function testStatements() {

3312

$Article =& ClassRegistry::init('Article');

3313

3314

$result = $this->testDb->update($Article, array('field1'), array('value1'));

3315

$this->assertFalse($result);

3316

$result = $this->testDb->getLastQuery();

3317

$this->assertPattern('/^\s*UPDATE\s+' . $this->testDb->fullTableName('articles') . '\s+SET\s+`field1`\s*=\s*\'value1\'\s+WHERE\s+1 = 1\s*$/', $result);

3318

3319

$result = $this->testDb->update($Article, array('field1'), array('2'), '2=2');

3320

$this->assertFalse($result);

3321

$result = $this->testDb->getLastQuery();

3322

$this->assertPattern('/^\s*UPDATE\s+' . $this->testDb->fullTableName('articles') . ' AS `Article`\s+LEFT JOIN\s+' . $this->testDb->fullTableName('users') . ' AS `User` ON $`Article`.`user_id` = `User`.`id`$\s+SET\s+`Article`\.`field1`\s*=\s*2\s+WHERE\s+2\s*=\s*2\s*$/', $result);

3323

3324

$result = $this->testDb->delete($Article);

3325

$this->assertTrue($result);

3326

$result = $this->testDb->getLastQuery();

3327

$this->assertPattern('/^\s*DELETE\s+FROM\s+' . $this->testDb->fullTableName('articles') . '\s+WHERE\s+1 = 1\s*$/', $result);

3328

3329

$result = $this->testDb->delete($Article, true);

3330

$this->assertTrue($result);

3331

$result = $this->testDb->getLastQuery();

3332

$this->assertPattern('/^\s*DELETE\s+`Article`\s+FROM\s+' . $this->testDb->fullTableName('articles') . '\s+AS `Article`\s+LEFT JOIN\s+' . $this->testDb->fullTableName('users') . ' AS `User` ON $`Article`.`user_id` = `User`.`id`$\s+WHERE\s+1\s*=\s*1\s*$/', $result);

3333

3334

$result = $this->testDb->delete($Article, '2=2');

3335

$this->assertTrue($result);

3336

$result = $this->testDb->getLastQuery();

3337

3338

3339

$result = $this->testDb->hasAny($Article, '1=2');

3340

$this->assertFalse($result);

3341

3342

$result = $this->testDb->insertMulti('articles', array('field'), array('(1)', '(2)'));

3343

$this->assertFalse($result);

3344

$result = $this->testDb->getLastQuery();

3345

$this->assertPattern('/^\s*INSERT INTO\s+' . $this->testDb->fullTableName('articles') . '\s+$`field`$\s+VALUES\s+$1$,\s*$2$\s*$/', $result);

3346

}

3347

3348

/**

3349

* testSchema method

3350

3351

* @access public

3352

* @return void

3353

3354

function testSchema() {

3355

$Schema =& new CakeSchema();

3356

$Schema->tables = array('table' => array(), 'anotherTable' => array());

3357

3358

$this->expectError();

3359

$result = $this->testDb->dropSchema(null);

3360

$this->assertTrue($result === null);

3361

3362

$result = $this->testDb->dropSchema($Schema, 'non_existing');

3363

$this->assertTrue(empty($result));

3364

3365

$result = $this->testDb->dropSchema($Schema, 'table');

3366

$this->assertPattern('/^\s*DROP TABLE IF EXISTS\s+' . $this->testDb->fullTableName('table') . ';\s*$/s', $result);

3367

}

3368

3369

/**

3370

* testMagicMethodQuerying method

3371

3372

* @access public

3373

* @return void

3374

3375

function testMagicMethodQuerying() {

3376

$result = $this->testDb->query('findByFieldName', array('value'), $this->Model);

3377

$expected = array('first', array(

3378

'conditions' => array('TestModel.field_name' => 'value'),

3379

'fields' => null, 'order' => null, 'recursive' => null

3380

));

3381

$this->assertEqual($result, $expected);

3382

3383

$result = $this->testDb->query('findByFindBy', array('value'), $this->Model);

3384

$expected = array('first', array(

3385

'conditions' => array('TestModel.find_by' => 'value'),

3386

'fields' => null, 'order' => null, 'recursive' => null

3387

));

3388

$this->assertEqual($result, $expected);

3389

3390

$result = $this->testDb->query('findAllByFieldName', array('value'), $this->Model);

3391

$expected = array('all', array(

3392

'conditions' => array('TestModel.field_name' => 'value'),

3393

'fields' => null, 'order' => null, 'limit' => null,

3394

'page' => null, 'recursive' => null

3395

));

3396

$this->assertEqual($result, $expected);

3397

3398

$result = $this->testDb->query('findAllById', array('a'), $this->Model);

3399

$expected = array('all', array(

3400

'conditions' => array('TestModel.id' => 'a'),

3401

'fields' => null, 'order' => null, 'limit' => null,

3402

'page' => null, 'recursive' => null

3403

));

3404

$this->assertEqual($result, $expected);

3405

3406

$result = $this->testDb->query('findByFieldName', array(array('value1', 'value2', 'value3')), $this->Model);

3407

$expected = array('first', array(

3408

'conditions' => array('TestModel.field_name' => array('value1', 'value2', 'value3')),

3409

'fields' => null, 'order' => null, 'recursive' => null

3410

));

3411

$this->assertEqual($result, $expected);

3412

3413

$result = $this->testDb->query('findByFieldName', array(null), $this->Model);

3414

$expected = array('first', array(

3415

'conditions' => array('TestModel.field_name' => null),

3416

'fields' => null, 'order' => null, 'recursive' => null

3417

));

3418

$this->assertEqual($result, $expected);

3419

3420

$result = $this->testDb->query('findByFieldName', array('= a'), $this->Model);

3421

$expected = array('first', array(

3422

'conditions' => array('TestModel.field_name' => '= a'),

3423

'fields' => null, 'order' => null, 'recursive' => null

3424

));

3425

$this->assertEqual($result, $expected);

3426

3427

$result = $this->testDb->query('findByFieldName', array(), $this->Model);

3428

$expected = false;

3429

$this->assertEqual($result, $expected);

3430

3431

$result = $this->testDb->query('directCall', array(), $this->Model);

3432

$this->assertFalse($result);

3433

3434

$result = $this->testDb->query('directCall', true, $this->Model);

3435

$this->assertFalse($result);

3436

3437

$result = $this->testDb->query('directCall', false, $this->Model);

3438

$this->assertFalse($result);

3439

}

3440

3441

/**

3442

* testOrderParsing method

3443

3444

* @access public

3445

* @return void

3446

3447

function testOrderParsing() {

3448

$result = $this->testDb->order("ADDTIME(Event.time_begin, '-06:00:00') ASC");

3449

$expected = " ORDER BY ADDTIME(`Event`.`time_begin`, '-06:00:00') ASC";

3450

$this->assertEqual($result, $expected);

3451

3452

$result = $this->testDb->order("title, id");

3453

$this->assertPattern('/^\s*ORDER BY\s+`title`\s+ASC,\s+`id`\s+ASC\s*$/', $result);

3454

3455

$result = $this->testDb->order("title desc, id desc");

3456

$this->assertPattern('/^\s*ORDER BY\s+`title`\s+desc,\s+`id`\s+desc\s*$/', $result);

3457

3458

$result = $this->testDb->order(array("title desc, id desc"));

3459

$this->assertPattern('/^\s*ORDER BY\s+`title`\s+desc,\s+`id`\s+desc\s*$/', $result);

3460

3461

$result = $this->testDb->order(array("title", "id"));

3462

$this->assertPattern('/^\s*ORDER BY\s+`title`\s+ASC,\s+`id`\s+ASC\s*$/', $result);

3463

3464

$result = $this->testDb->order(array(array('title'), array('id')));

3465

$this->assertPattern('/^\s*ORDER BY\s+`title`\s+ASC,\s+`id`\s+ASC\s*$/', $result);

3466

3467

$result = $this->testDb->order(array("Post.title" => 'asc', "Post.id" => 'desc'));

3468

$this->assertPattern('/^\s*ORDER BY\s+`Post`.`title`\s+asc,\s+`Post`.`id`\s+desc\s*$/', $result);

3469

3470

$result = $this->testDb->order(array(array("Post.title" => 'asc', "Post.id" => 'desc')));

3471

$this->assertPattern('/^\s*ORDER BY\s+`Post`.`title`\s+asc,\s+`Post`.`id`\s+desc\s*$/', $result);

3472

3473

$result = $this->testDb->order(array("title"));

3474

$this->assertPattern('/^\s*ORDER BY\s+`title`\s+ASC\s*$/', $result);

3475

3476

$result = $this->testDb->order(array(array("title")));

3477

$this->assertPattern('/^\s*ORDER BY\s+`title`\s+ASC\s*$/', $result);

3478

3479

$result = $this->testDb->order("Dealer.id = 7 desc, Dealer.id = 3 desc, Dealer.title asc");

3480

$expected = " ORDER BY `Dealer`.`id` = 7 desc, `Dealer`.`id` = 3 desc, `Dealer`.`title` asc";

3481

$this->assertEqual($result, $expected);

3482

3483

$result = $this->testDb->order(array("Page.name" => "='test' DESC"));

3484

$this->assertPattern("/^\s*ORDER BY\s+`Page`\.`name`\s*='test'\s+DESC\s*$/", $result);

3485

3486

$result = $this->testDb->order("Page.name = 'view' DESC");

3487

$this->assertPattern("/^\s*ORDER BY\s+`Page`\.`name`\s*=\s*'view'\s+DESC\s*$/", $result);

3488

3489

$result = $this->testDb->order("(Post.views)");

3490

$this->assertPattern("/^\s*ORDER BY\s+$`Post`\.`views`$\s+ASC\s*$/", $result);

3491

3492

$result = $this->testDb->order("(Post.views)*Post.views");

3493

$this->assertPattern("/^\s*ORDER BY\s+$`Post`\.`views`$\*`Post`\.`views`\s+ASC\s*$/", $result);

3494

3495

$result = $this->testDb->order("(Post.views) * Post.views");

3496

$this->assertPattern("/^\s*ORDER BY\s+$`Post`\.`views`$ \* `Post`\.`views`\s+ASC\s*$/", $result);

3497

3498

$result = $this->testDb->order("(Model.field1 + Model.field2) * Model.field3");

3499

$this->assertPattern("/^\s*ORDER BY\s+$`Model`\.`field1` \+ `Model`\.`field2`$ \* `Model`\.`field3`\s+ASC\s*$/", $result);

3500

3501

$result = $this->testDb->order("Model.name+0 ASC");

3502

$this->assertPattern("/^\s*ORDER BY\s+`Model`\.`name`\+0\s+ASC\s*$/", $result);

3503

3504

$result = $this->testDb->order("Anuncio.destaque & 2 DESC");

3505

$expected = ' ORDER BY `Anuncio`.`destaque` & 2 DESC';

3506

$this->assertEqual($result, $expected);

3507

3508

$result = $this->testDb->order("3963.191 * id");

3509

$expected = ' ORDER BY 3963.191 * id ASC';

3510

$this->assertEqual($result, $expected);

3511

3512

$result = $this->testDb->order(array('Property.sale_price IS NULL'));

3513

$expected = ' ORDER BY `Property`.`sale_price` IS NULL ASC';

3514

$this->assertEqual($result, $expected);

3515

}

3516

3517

/**

3518

* testComplexSortExpression method

3519

3520

* @return void

3521

* @access public

3522

3523

function testComplexSortExpression() {

3524

$result = $this->testDb->order(array('(Model.field > 100) DESC', 'Model.field ASC'));

3525

$this->assertPattern("/^\s*ORDER BY\s+$`Model`\.`field`\s+>\s+100$\s+DESC,\s+`Model`\.`field`\s+ASC\s*$/", $result);

3526

}

3527

3528

/**

3529

* testCalculations method

3530

3531

* @access public

3532

* @return void

3533

3534

function testCalculations() {

3535

$result = $this->testDb->calculate($this->Model, 'count');

3536

$this->assertEqual($result, 'COUNT(*) AS `count`');

3537

3538

$result = $this->testDb->calculate($this->Model, 'count', array('id'));

3539

$this->assertEqual($result, 'COUNT(`id`) AS `count`');

3540

3541

$result = $this->testDb->calculate(

3542

$this->Model,

3543

'count',

3544

array($this->testDb->expression('DISTINCT id'))

3545

);

3546

$this->assertEqual($result, 'COUNT(DISTINCT id) AS `count`');

3547

3548

$result = $this->testDb->calculate($this->Model, 'count', array('id', 'id_count'));

3549

$this->assertEqual($result, 'COUNT(`id`) AS `id_count`');

3550

3551

$result = $this->testDb->calculate($this->Model, 'count', array('Model.id', 'id_count'));

3552

$this->assertEqual($result, 'COUNT(`Model`.`id`) AS `id_count`');

3553

3554

$result = $this->testDb->calculate($this->Model, 'max', array('id'));

3555

$this->assertEqual($result, 'MAX(`id`) AS `id`');

3556

3557

$result = $this->testDb->calculate($this->Model, 'max', array('Model.id', 'id'));

3558

$this->assertEqual($result, 'MAX(`Model`.`id`) AS `id`');

3559

3560

$result = $this->testDb->calculate($this->Model, 'max', array('`Model`.`id`', 'id'));

3561

$this->assertEqual($result, 'MAX(`Model`.`id`) AS `id`');

3562

3563

$result = $this->testDb->calculate($this->Model, 'min', array('`Model`.`id`', 'id'));

3564

$this->assertEqual($result, 'MIN(`Model`.`id`) AS `id`');

3565

3566

$result = $this->testDb->calculate($this->Model, 'min', 'left');

3567

$this->assertEqual($result, 'MIN(`left`) AS `left`');

3568

}

3569

3570

/**

3571

* testLength method

3572

3573

* @access public

3574

* @return void

3575

3576

function testLength() {

3577

$result = $this->testDb->length('varchar(255)');

3578

$expected = 255;

3579

$this->assertIdentical($result, $expected);

3580

3581

$result = $this->testDb->length('int(11)');

3582

$expected = 11;

3583

$this->assertIdentical($result, $expected);

3584

3585

$result = $this->testDb->length('float(5,3)');

3586

$expected = '5,3';

3587

$this->assertIdentical($result, $expected);

3588

3589

$result = $this->testDb->length('decimal(5,2)');

3590

$expected = '5,2';

3591

$this->assertIdentical($result, $expected);

3592

3593

$result = $this->testDb->length("enum('test','me','now')");

3594

$expected = 4;

3595

$this->assertIdentical($result, $expected);

3596

3597

$result = $this->testDb->length("set('a','b','cd')");

3598

$expected = 2;

3599

$this->assertIdentical($result, $expected);

3600

3601

$this->expectError();

3602

$result = $this->testDb->length(false);

3603

$this->assertTrue($result === null);

3604

3605

$result = $this->testDb->length('datetime');

3606

$expected = null;

3607

$this->assertIdentical($result, $expected);

3608

3609

$result = $this->testDb->length('text');

3610

$expected = null;

3611

$this->assertIdentical($result, $expected);

3612

}

3613

3614

/**

3615

* testBuildIndex method

3616

3617

* @access public

3618

* @return void

3619

3620

function testBuildIndex() {

3621

$data = array(

3622

'PRIMARY' => array('column' => 'id')

3623

);

3624

$result = $this->testDb->buildIndex($data);

3625

$expected = array('PRIMARY KEY (`id`)');

3626

$this->assertIdentical($result, $expected);

3627

3628

$data = array(

3629

'MyIndex' => array('column' => 'id', 'unique' => true)

3630

);

3631

$result = $this->testDb->buildIndex($data);

3632

$expected = array('UNIQUE KEY `MyIndex` (`id`)');

3633

$this->assertEqual($result, $expected);

3634

3635

$data = array(

3636

'MyIndex' => array('column' => array('id', 'name'), 'unique' => true)

3637

);

3638

$result = $this->testDb->buildIndex($data);

3639

$expected = array('UNIQUE KEY `MyIndex` (`id`, `name`)');

3640

$this->assertEqual($result, $expected);

3641

}

3642

3643

/**

3644

* testBuildColumn method

3645

3646

* @access public

3647

* @return void

3648

3649

function testBuildColumn() {

3650

$this->expectError();

3651

$data = array(

3652

'name' => 'testName',

3653

'type' => 'varchar(255)',

3654

'default',

3655

'null' => true,

3656

'key'

3657

);

3658

$this->testDb->buildColumn($data);

3659

3660

$data = array(

3661

'name' => 'testName',

3662

'type' => 'string',

3663

'length' => 255,

3664

'default',

3665

'null' => true,

3666

'key'

3667

);

3668

$result = $this->testDb->buildColumn($data);

3669

$expected = '`testName` varchar(255) DEFAULT NULL';

3670

$this->assertEqual($result, $expected);

3671

3672

$data = array(

3673

'name' => 'int_field',

3674

'type' => 'integer',

3675

'default' => '',

3676

'null' => false,

3677

);

3678

$restore = $this->testDb->columns;

3679

3680

$this->testDb->columns = array('integer' => array('name' => 'int', 'limit' => '11', 'formatter' => 'intval'), );

3681

$result = $this->testDb->buildColumn($data);

3682

$expected = '`int_field` int(11) NOT NULL';

3683

$this->assertEqual($result, $expected);

3684

3685

$this->testDb->fieldParameters['param'] = array(

3686

'value' => 'COLLATE',

3687

'quote' => false,

3688

'join' => ' ',

3689

'column' => 'Collate',

3690

'position' => 'beforeDefault',

3691

'options' => array('GOOD', 'OK')

3692

);

3693

$data = array(

3694

'name' => 'int_field',

3695

'type' => 'integer',

3696

'default' => '',

3697

'null' => false,

3698

'param' => 'BAD'

3699

);

3700

$result = $this->testDb->buildColumn($data);

3701

$expected = '`int_field` int(11) NOT NULL';

3702

$this->assertEqual($result, $expected);

3703

3704

$data = array(

3705

'name' => 'int_field',

3706

'type' => 'integer',

3707

'default' => '',

3708

'null' => false,

3709

'param' => 'GOOD'

3710

);

3711

$result = $this->testDb->buildColumn($data);

3712

$expected = '`int_field` int(11) COLLATE GOOD NOT NULL';

3713

$this->assertEqual($result, $expected);

3714

3715

$this->testDb->columns = $restore;

3716

3717

$data = array(

3718

'name' => 'created',

3719

'type' => 'timestamp',

3720

'default' => 'current_timestamp',

3721

'null' => false,

3722

);

3723

$result = $this->db->buildColumn($data);

3724

$expected = '`created` timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL';

3725

$this->assertEqual($result, $expected);

3726

3727

$data = array(

3728

'name' => 'created',

3729

'type' => 'timestamp',

3730

'default' => 'CURRENT_TIMESTAMP',

3731

'null' => true,

3732

);

3733

$result = $this->db->buildColumn($data);

3734

$expected = '`created` timestamp DEFAULT CURRENT_TIMESTAMP';

3735

$this->assertEqual($result, $expected);

3736

3737

$data = array(

3738

'name' => 'modified',

3739

'type' => 'timestamp',

3740

'null' => true,

3741

);

3742

$result = $this->db->buildColumn($data);

3743

$expected = '`modified` timestamp NULL';

3744

$this->assertEqual($result, $expected);

3745

3746

$data = array(

3747

'name' => 'modified',

3748

'type' => 'timestamp',

3749

'default' => null,

3750

'null' => true,

3751

);

3752

$result = $this->db->buildColumn($data);

3753

$expected = '`modified` timestamp NULL';

3754

$this->assertEqual($result, $expected);

3755

}

3756

3757

/**

3758

* test hasAny()

3759

3760

* @return void

3761

3762

function testHasAny() {

3763

$this->testDb->hasAny($this->Model, array());

3764

$expected = 'SELECT COUNT(`TestModel`.`id`) AS count FROM `test_models` AS `TestModel` WHERE 1 = 1';

3765

$this->assertEqual(end($this->testDb->simulated), $expected);

3766

3767

$this->testDb->hasAny($this->Model, array('TestModel.name' => 'harry'));

3768

$expected = "SELECT COUNT(`TestModel`.`id`) AS count FROM `test_models` AS `TestModel` WHERE `TestModel`.`name` = 'harry'";

3769

$this->assertEqual(end($this->testDb->simulated), $expected);

3770

}

3771

3772

/**

3773

* testIntrospectType method

3774

3775

* @access public

3776

* @return void

3777

3778

function testIntrospectType() {

3779

$this->assertEqual($this->testDb->introspectType(0), 'integer');

3780

$this->assertEqual($this->testDb->introspectType(2), 'integer');

3781

$this->assertEqual($this->testDb->introspectType('2'), 'string');

3782

$this->assertEqual($this->testDb->introspectType('2.2'), 'string');

3783

$this->assertEqual($this->testDb->introspectType(2.2), 'float');

3784

$this->assertEqual($this->testDb->introspectType('stringme'), 'string');

3785

$this->assertEqual($this->testDb->introspectType('0stringme'), 'string');

3786

3787

$data = array(2.2);

3788

$this->assertEqual($this->testDb->introspectType($data), 'float');

3789

3790

$data = array('2.2');

3791

$this->assertEqual($this->testDb->introspectType($data), 'float');

3792

3793

$data = array(2);

3794

$this->assertEqual($this->testDb->introspectType($data), 'integer');

3795

3796

$data = array('2');

3797

$this->assertEqual($this->testDb->introspectType($data), 'integer');

3798

3799

$data = array('string');

3800

$this->assertEqual($this->testDb->introspectType($data), 'string');

3801

3802

$data = array(2.2, '2.2');

3803

$this->assertEqual($this->testDb->introspectType($data), 'float');

3804

3805

$data = array(2, '2');

3806

$this->assertEqual($this->testDb->introspectType($data), 'integer');

3807

3808

$data = array('string one', 'string two');

3809

$this->assertEqual($this->testDb->introspectType($data), 'string');

3810

3811

$data = array('2.2', 3);

3812

$this->assertEqual($this->testDb->introspectType($data), 'integer');

3813

3814

$data = array('2.2', '0stringme');

3815

$this->assertEqual($this->testDb->introspectType($data), 'string');

3816

3817

$data = array(2.2, 3);

3818

$this->assertEqual($this->testDb->introspectType($data), 'integer');

3819

3820

$data = array(2.2, '0stringme');

3821

$this->assertEqual($this->testDb->introspectType($data), 'string');

3822

3823

$data = array(2, 'stringme');

3824

$this->assertEqual($this->testDb->introspectType($data), 'string');

3825

3826

$data = array(2, '2.2', 'stringgme');

3827

$this->assertEqual($this->testDb->introspectType($data), 'string');

3828

3829

$data = array(2, '2.2');

3830

$this->assertEqual($this->testDb->introspectType($data), 'integer');

3831

3832

$data = array(2, 2.2);

3833

$this->assertEqual($this->testDb->introspectType($data), 'integer');

3834

3835

3836

// NULL

3837

$result = $this->testDb->value(null, 'boolean');

3838

$this->assertEqual($result, 'NULL');

3839

3840

// EMPTY STRING

3841

$result = $this->testDb->value('', 'boolean');

3842

$this->assertEqual($result, "NULL");

3843

3844

3845

// BOOLEAN

3846

$result = $this->testDb->value('true', 'boolean');

3847

$this->assertEqual($result, 1);

3848

3849

$result = $this->testDb->value('false', 'boolean');

3850

$this->assertEqual($result, 1);

3851

3852

$result = $this->testDb->value(true, 'boolean');

3853

$this->assertEqual($result, 1);

3854

3855

$result = $this->testDb->value(false, 'boolean');

3856

$this->assertEqual($result, 0);

3857

3858

$result = $this->testDb->value(1, 'boolean');

3859

$this->assertEqual($result, 1);

3860

3861

$result = $this->testDb->value(0, 'boolean');

3862

$this->assertEqual($result, 0);

3863

3864

$result = $this->testDb->value('abc', 'boolean');

3865

$this->assertEqual($result, 1);

3866

3867

$result = $this->testDb->value(1.234, 'boolean');

3868

$this->assertEqual($result, 1);

3869

3870

$result = $this->testDb->value('1.234e05', 'boolean');

3871

$this->assertEqual($result, 1);

3872

3873

// NUMBERS

3874

$result = $this->testDb->value(123, 'integer');

3875

$this->assertEqual($result, 123);

3876

3877

$result = $this->testDb->value('123', 'integer');

3878

$this->assertEqual($result, '123');

3879

3880

$result = $this->testDb->value('0123', 'integer');

3881

$this->assertEqual($result, "'0123'");

3882

3883

$result = $this->testDb->value('0x123ABC', 'integer');

3884

$this->assertEqual($result, "'0x123ABC'");

3885

3886

$result = $this->testDb->value('0x123', 'integer');

3887

$this->assertEqual($result, "'0x123'");

3888

3889

$result = $this->testDb->value(1.234, 'float');

3890

$this->assertEqual($result, 1.234);

3891

3892

$result = $this->testDb->value('1.234', 'float');

3893

$this->assertEqual($result, '1.234');

3894

3895

$result = $this->testDb->value(' 1.234 ', 'float');

3896

$this->assertEqual($result, "' 1.234 '");

3897

3898

$result = $this->testDb->value('1.234e05', 'float');

3899

$this->assertEqual($result, "'1.234e05'");

3900

3901

$result = $this->testDb->value('1.234e+5', 'float');

3902

$this->assertEqual($result, "'1.234e+5'");

3903

3904

$result = $this->testDb->value('1,234', 'float');

3905

$this->assertEqual($result, "'1,234'");

3906

3907

$result = $this->testDb->value('FFF', 'integer');

3908

$this->assertEqual($result, "'FFF'");

3909

3910

$result = $this->testDb->value('abc', 'integer');

3911

$this->assertEqual($result, "'abc'");

3912

3913

// STRINGS

3914

$result = $this->testDb->value('123', 'string');

3915

$this->assertEqual($result, "'123'");

3916

3917

$result = $this->testDb->value(123, 'string');

3918

$this->assertEqual($result, "'123'");

3919

3920

$result = $this->testDb->value(1.234, 'string');

3921

$this->assertEqual($result, "'1.234'");

3922

3923

$result = $this->testDb->value('abc', 'string');

3924

$this->assertEqual($result, "'abc'");

3925

3926

$result = $this->testDb->value(' abc ', 'string');

3927

$this->assertEqual($result, "' abc '");

3928

3929

$result = $this->testDb->value('a bc', 'string');

3930

$this->assertEqual($result, "'a bc'");

3931

}

3932

3933

/**

3934

* testValue method

3935

3936

* @access public

3937

* @return void

3938

3939

function testValue() {

3940

$result = $this->testDb->value('{$__cakeForeignKey__$}');

3941

$this->assertEqual($result, '{$__cakeForeignKey__$}');

3942

3943

$result = $this->testDb->value(array('first', 2, 'third'));

3944

$expected = array('\'first\'', 2, '\'third\'');

3945

$this->assertEqual($result, $expected);

3946

}

3947

3948

/**

3949

* testReconnect method

3950

3951

* @access public

3952

* @return void

3953

3954

function testReconnect() {

3955

$this->testDb->reconnect(array('prefix' => 'foo'));

3956

$this->assertTrue($this->testDb->connected);

3957

$this->assertEqual($this->testDb->config['prefix'], 'foo');

3958

}

3959

3960

/**

3961

* testRealQueries method

3962

3963

* @access public

3964

* @return void

3965

3966

function testRealQueries() {

3967

$this->loadFixtures('Apple', 'Article', 'User', 'Comment', 'Tag');

3968

3969

$Apple =& ClassRegistry::init('Apple');

3970

$Article =& ClassRegistry::init('Article');

3971

3972

$result = $this->db->rawQuery('SELECT color, name FROM ' . $this->db->fullTableName('apples'));

3973

$this->assertTrue(!empty($result));

3974

3975

$result = $this->db->fetchRow($result);

3976

$expected = array($this->db->fullTableName('apples', false) => array(

3977

'color' => 'Red 1',

3978

'name' => 'Red Apple 1'

3979

));

3980

$this->assertEqual($result, $expected);

3981

3982

$result = $this->db->fetchAll('SELECT name FROM ' . $this->testDb->fullTableName('apples') . ' ORDER BY id');

3983

$expected = array(

3984

array($this->db->fullTableName('apples', false) => array('name' => 'Red Apple 1')),

3985

array($this->db->fullTableName('apples', false) => array('name' => 'Bright Red Apple')),

3986

array($this->db->fullTableName('apples', false) => array('name' => 'green blue')),

3987

array($this->db->fullTableName('apples', false) => array('name' => 'Test Name')),

3988

array($this->db->fullTableName('apples', false) => array('name' => 'Blue Green')),

3989

array($this->db->fullTableName('apples', false) => array('name' => 'My new apple')),

3990

array($this->db->fullTableName('apples', false) => array('name' => 'Some odd color'))

3991

);

3992

$this->assertEqual($result, $expected);

3993

3994

$result = $this->db->field($this->testDb->fullTableName('apples', false), 'SELECT color, name FROM ' . $this->testDb->fullTableName('apples') . ' ORDER BY id');

3995

$expected = array(

3996

'color' => 'Red 1',

3997

'name' => 'Red Apple 1'

3998

);

3999

$this->assertEqual($result, $expected);

4000

4001

$Apple->unbindModel(array(), false);

4002

$result = $this->db->read($Apple, array(

4003

'fields' => array($Apple->escapeField('name')),

4004

'conditions' => null,

4005

'recursive' => -1

4006

));

4007

$expected = array(

4008

array('Apple' => array('name' => 'Red Apple 1')),

4009

array('Apple' => array('name' => 'Bright Red Apple')),

4010

array('Apple' => array('name' => 'green blue')),

4011

array('Apple' => array('name' => 'Test Name')),

4012

array('Apple' => array('name' => 'Blue Green')),

4013

array('Apple' => array('name' => 'My new apple')),

4014

array('Apple' => array('name' => 'Some odd color'))

4015

);

4016

$this->assertEqual($result, $expected);

4017

4018

$result = $this->db->read($Article, array(

4019

'fields' => array('id', 'user_id', 'title'),

4020

'conditions' => null,

4021

'recursive' => 1

4022

));

4023

4024

$this->assertTrue(Set::matches('/Article[id=1]', $result));

4025

$this->assertTrue(Set::matches('/Comment[id=1]', $result));

4026

$this->assertTrue(Set::matches('/Comment[id=2]', $result));

4027

$this->assertFalse(Set::matches('/Comment[id=10]', $result));

4028

}

4029

4030

/**

4031

* testName method

4032

4033

* @access public

4034

* @return void

4035

4036

function testName() {

4037

$result = $this->testDb->name('name');

4038

$expected = '`name`';

4039

$this->assertEqual($result, $expected);

4040

4041

$result = $this->testDb->name(array('name', 'Model.*'));

4042

$expected = array('`name`', '`Model`.*');

4043

$this->assertEqual($result, $expected);

4044

4045

$result = $this->testDb->name('MTD()');

4046

$expected = 'MTD()';

4047

$this->assertEqual($result, $expected);

4048

4049

$result = $this->testDb->name('(sm)');

4050

$expected = '(sm)';

4051

$this->assertEqual($result, $expected);

4052

4053

$result = $this->testDb->name('name AS x');

4054

$expected = '`name` AS `x`';

4055

$this->assertEqual($result, $expected);

4056

4057

$result = $this->testDb->name('Model.name AS x');

4058

$expected = '`Model`.`name` AS `x`';

4059

$this->assertEqual($result, $expected);

4060

4061

$result = $this->testDb->name('Function(Something.foo)');

4062

$expected = 'Function(`Something`.`foo`)';

4063

$this->assertEqual($result, $expected);

4064

4065

$result = $this->testDb->name('Function(SubFunction(Something.foo))');

4066

$expected = 'Function(SubFunction(`Something`.`foo`))';

4067

$this->assertEqual($result, $expected);

4068

4069

$result = $this->testDb->name('Function(Something.foo) AS x');

4070

$expected = 'Function(`Something`.`foo`) AS `x`';

4071

$this->assertEqual($result, $expected);

4072

4073

$result = $this->testDb->name('name-with-minus');

4074

$expected = '`name-with-minus`';

4075

$this->assertEqual($result, $expected);

4076

4077

$result = $this->testDb->name(array('my-name', 'Foo-Model.*'));

4078

$expected = array('`my-name`', '`Foo-Model`.*');

4079

$this->assertEqual($result, $expected);

4080

}

4081

4082

/**

4083

* test that cacheMethod works as exepected

4084

4085

* @return void

4086

4087

function testCacheMethod() {

4088

$this->testDb->cacheMethods = true;

4089

$result = $this->testDb->cacheMethod('name', 'some-key', 'stuff');

4090

$this->assertEqual($result, 'stuff');

4091

4092

$result = $this->testDb->cacheMethod('name', 'some-key');

4093

$this->assertEqual($result, 'stuff');

4094

4095

$result = $this->testDb->cacheMethod('conditions', 'some-key');

4096

$this->assertNull($result);

4097

4098

$result = $this->testDb->cacheMethod('name', 'other-key');

4099

$this->assertNull($result);

4100

4101

$this->testDb->cacheMethods = false;

4102

$result = $this->testDb->cacheMethod('name', 'some-key', 'stuff');

4103

$this->assertEqual($result, 'stuff');

4104

4105

$result = $this->testDb->cacheMethod('name', 'some-key');

4106

$this->assertNull($result);

4107

}

4108

4109

/**

4110

* testLog method

4111

4112

* @access public

4113

* @return void

4114

4115

function testLog() {

4116

$this->testDb->logQuery('Query 1');

4117

$this->testDb->logQuery('Query 2');

4118

4119

$log = $this->testDb->getLog(false, false);

4120

$result = Set::extract($log['log'], '/query');

4121

$expected = array('Query 1', 'Query 2');

4122

$this->assertEqual($result, $expected);

4123

4124

$oldError = $this->testDb->error;

4125

$this->testDb->error = true;

4126

$result = $this->testDb->logQuery('Error 1');

4127

$this->assertFalse($result);

4128

$this->testDb->error = $oldError;

4129

4130

$log = $this->testDb->getLog(false, false);

4131

$result = Set::combine($log['log'], '/query', '/error');

4132

$expected = array('Query 1' => false, 'Query 2' => false, 'Error 1' => true);

4133

$this->assertEqual($result, $expected);

4134

4135

Configure::write('debug', 2);

4136

ob_start();

4137

$this->testDb->showLog();

4138

$contents = ob_get_clean();

4139

4140

$this->assertPattern('/Query 1/s', $contents);

4141

$this->assertPattern('/Query 2/s', $contents);

4142

$this->assertPattern('/Error 1/s', $contents);

4143

4144

ob_start();

4145

$this->testDb->showLog(true);

4146

$contents = ob_get_clean();

4147

4148

$this->assertPattern('/Query 1/s', $contents);

4149

$this->assertPattern('/Query 2/s', $contents);

4150

$this->assertPattern('/Error 1/s', $contents);

4151

4152

$oldError = $this->testDb->error;

4153

$oldDebug = Configure::read('debug');

4154

Configure::write('debug', 2);

4155

4156

$this->testDb->error = true;

4157

$this->expectError();

4158

ob_start();

4159

$this->testDb->showQuery('Error 2');

4160

$contents = ob_get_clean();

4161

4162

$this->assertPattern('/Error 2/s', $contents);

4163

4164

$this->testDb->error = $oldError;

4165

Configure::write('debug', $oldDebug);

4166

}

4167

4168

/**

4169

* test getting the query log as an array.

4170

4171

* @return void

4172

4173

function testGetLog() {

4174

$this->testDb->logQuery('Query 1');

4175

$this->testDb->logQuery('Query 2');

4176

4177

$oldError = $this->testDb->error;

4178

$this->testDb->error = true;

4179

$result = $this->testDb->logQuery('Error 1');

4180

$this->assertFalse($result);

4181

$this->testDb->error = $oldError;

4182

4183

$log = $this->testDb->getLog();

4184

$expected = array('query' => 'Query 1', 'error' => '', 'affected' => '', 'numRows' => '', 'took' => '');

4185

$this->assertEqual($log['log'][0], $expected);

4186

$expected = array('query' => 'Query 2', 'error' => '', 'affected' => '', 'numRows' => '', 'took' => '');

4187

$this->assertEqual($log['log'][1], $expected);

4188

$expected = array('query' => 'Error 1', 'error' => true, 'affected' => '', 'numRows' => '', 'took' => '');

4189

$this->assertEqual($log['log'][2], $expected);

4190

}

4191

4192

/**

4193

* test that execute runs queries.

4194

4195

* @return void

4196

4197

function testExecute() {

4198

$query = 'SELECT * FROM ' . $this->testDb->fullTableName('articles') . ' WHERE 1 = 1';

4199

4200

$this->db->_result = null;

4201

$this->db->took = null;

4202

$this->db->affected = null;

4203

$result = $this->db->execute($query, array('stats' => false));

4204

$this->assertNotNull($result, 'No query performed! %s');

4205

$this->assertNull($this->db->took, 'Stats were set %s');

4206

$this->assertNull($this->db->affected, 'Stats were set %s');

4207

4208

$result = $this->db->execute($query);

4209

$this->assertNotNull($result, 'No query performed! %s');

4210

$this->assertNotNull($this->db->took, 'Stats were not set %s');

4211

$this->assertNotNull($this->db->affected, 'Stats were not set %s');

4212

}

4213

4214

/**

4215

* test that query() returns boolean values from operations like CREATE TABLE

4216

4217

* @return void

4218

4219

function testFetchAllBooleanReturns() {

4220

$name = $this->db->fullTableName('test_query');

4221

$query = "CREATE TABLE {$name} (name varchar(10));";

4222

$result = $this->db->query($query);

4223

$this->assertTrue($result, 'Query did not return a boolean. %s');

4224

4225

$query = "DROP TABLE {$name};";

4226

$result = $this->db->fetchAll($query);

4227

$this->assertTrue($result, 'Query did not return a boolean. %s');

4228

}

4229

4230

/**

4231

* test ShowQuery generation of regular and error messages

4232

4233

* @return void

4234

4235

function testShowQuery() {

4236

$this->testDb->error = false;

4237

ob_start();

4238

$this->testDb->showQuery('Some Query');

4239

$contents = ob_get_clean();

4240

$this->assertPattern('/Some Query/s', $contents);

4241

$this->assertPattern('/Aff:/s', $contents);

4242

$this->assertPattern('/Num:/s', $contents);

4243

$this->assertPattern('/Took:/s', $contents);

4244

4245

$this->expectError();

4246

$this->testDb->error = true;

4247

ob_start();

4248

$this->testDb->showQuery('Another Query');

4249

$contents = ob_get_clean();

4250

$this->assertPattern('/Another Query/s', $contents);

4251

$this->assertNoPattern('/Aff:/s', $contents);

4252

$this->assertNoPattern('/Num:/s', $contents);

4253

$this->assertNoPattern('/Took:/s', $contents);

4254

}

4255

4256

/**

4257

* test fields generating usable virtual fields to use in query

4258

4259

* @return void

4260

4261

function testVirtualFields() {

4262

$this->loadFixtures('Article');

4263

4264

$Article =& ClassRegistry::init('Article');

4265

$Article->virtualFields = array(

4266

'this_moment' => 'NOW()',

4267

'two' => '1 + 1',

4268

'comment_count' => 'SELECT COUNT(*) FROM ' . $this->db->fullTableName('comments') .

4269

' WHERE Article.id = ' . $this->db->fullTableName('comments') . '.article_id'

4270

);

4271

$result = $this->db->fields($Article);

4272

$expected = array(

4273

'`Article`.`id`',

4274

'`Article`.`user_id`',

4275

'`Article`.`title`',

4276

'`Article`.`body`',

4277

'`Article`.`published`',

4278

'`Article`.`created`',

4279

'`Article`.`updated`',

4280

'(NOW()) AS `Article__this_moment`',

4281

'(1 + 1) AS `Article__two`',

4282

'(SELECT COUNT(*) FROM comments WHERE `Article`.`id` = `comments`.`article_id`) AS `Article__comment_count`'

4283

);

4284

$this->assertEqual($expected, $result);

4285

4286

$result = $this->db->fields($Article, null, array('this_moment', 'title'));

4287

$expected = array(

4288

'`Article`.`title`',

4289

'(NOW()) AS `Article__this_moment`',

4290

);

4291

$this->assertEqual($expected, $result);

4292

4293

$result = $this->db->fields($Article, null, array('Article.title', 'Article.this_moment'));

4294

$expected = array(

4295

'`Article`.`title`',

4296

'(NOW()) AS `Article__this_moment`',

4297

);

4298

$this->assertEqual($expected, $result);

4299

4300

$result = $this->db->fields($Article, null, array('Article.this_moment', 'Article.title'));

4301

$expected = array(

4302

'`Article`.`title`',

4303

'(NOW()) AS `Article__this_moment`',

4304

);

4305

$this->assertEqual($expected, $result);

4306

4307

$result = $this->db->fields($Article, null, array('Article.*'));

4308

$expected = array(

4309

'`Article`.*',

4310

'(NOW()) AS `Article__this_moment`',

4311

'(1 + 1) AS `Article__two`',

4312

'(SELECT COUNT(*) FROM comments WHERE `Article`.`id` = `comments`.`article_id`) AS `Article__comment_count`'

4313

);

4314

$this->assertEqual($expected, $result);

4315

4316

$result = $this->db->fields($Article, null, array('*'));

4317

$expected = array(

4318

'*',

4319

'(NOW()) AS `Article__this_moment`',

4320

'(1 + 1) AS `Article__two`',

4321

'(SELECT COUNT(*) FROM comments WHERE `Article`.`id` = `comments`.`article_id`) AS `Article__comment_count`'

4322

);

4323

$this->assertEqual($expected, $result);

4324

}

4325

4326

/**

4327

* test conditions to generate query conditions for virtual fields

4328

4329

* @return void

4330

4331

function testVirtualFieldsInConditions() {

4332

$Article =& ClassRegistry::init('Article');

4333

$Article->virtualFields = array(

4334

'this_moment' => 'NOW()',

4335

'two' => '1 + 1',

4336

'comment_count' => 'SELECT COUNT(*) FROM ' . $this->db->fullTableName('comments') .

4337

' WHERE Article.id = ' . $this->db->fullTableName('comments') . '.article_id'

4338

);

4339

$conditions = array('two' => 2);

4340

$result = $this->db->conditions($conditions, true, false, $Article);

4341

$expected = '(1 + 1) = 2';

4342

$this->assertEqual($expected, $result);

4343

4344

$conditions = array('this_moment BETWEEN ? AND ?' => array(1,2));

4345

$expected = 'NOW() BETWEEN 1 AND 2';

4346

$result = $this->db->conditions($conditions, true, false, $Article);

4347

$this->assertEqual($expected, $result);

4348

4349

$conditions = array('comment_count >' => 5);

4350

$expected = '(SELECT COUNT(*) FROM comments WHERE `Article`.`id` = `comments`.`article_id`) > 5';

4351

$result = $this->db->conditions($conditions, true, false, $Article);

4352

$this->assertEqual($expected, $result);

4353

4354

$conditions = array('NOT' => array('two' => 2));

4355

$result = $this->db->conditions($conditions, true, false, $Article);

4356

$expected = 'NOT ((1 + 1) = 2)';

4357

$this->assertEqual($expected, $result);

4358

}

4359

4360

/**

4361

* test that virtualFields with complex functions and aliases work.

4362

4363

* @return void

4364

4365

function testConditionsWithComplexVirtualFields() {

4366

$Article =& ClassRegistry::init('Article');

4367

$Article->virtualFields = array(

4368

'distance' => 'ACOS(SIN(20 * PI() / 180)

4369

* SIN(Article.latitude * PI() / 180)

4370

+ COS(20 * PI() / 180)

4371

* COS(Article.latitude * PI() / 180)

4372

* COS((50 - Article.longitude) * PI() / 180)

4373

) * 180 / PI() * 60 * 1.1515 * 1.609344'

4374

);

4375

$conditions = array('distance >=' => 20);

4376

$result = $this->db->conditions($conditions, true, true, $Article);

4377

4378

$this->assertPattern('/\) >= 20/', $result);

4379

$this->assertPattern('/[`\'"]Article[`\'"].[`\'"]latitude[`\'"]/', $result);

4380

$this->assertPattern('/[`\'"]Article[`\'"].[`\'"]longitude[`\'"]/', $result);

4381

}

4382

4383

/**

4384

* test order to generate query order clause for virtual fields

4385

4386

* @return void

4387

4388

function testVirtualFieldsInOrder() {

4389

$Article =& ClassRegistry::init('Article');

4390

$Article->virtualFields = array(

4391

'this_moment' => 'NOW()',

4392

'two' => '1 + 1',

4393

);

4394

$order = array('two', 'this_moment');

4395

$result = $this->db->order($order, 'ASC', $Article);

4396

$expected = ' ORDER BY (1 + 1) ASC, (NOW()) ASC';

4397

$this->assertEqual($expected, $result);

4398

4399

$order = array('Article.two', 'Article.this_moment');

4400

$result = $this->db->order($order, 'ASC', $Article);

4401

$expected = ' ORDER BY (1 + 1) ASC, (NOW()) ASC';

4402

$this->assertEqual($expected, $result);

4403

}

4404

4405

/**

4406

* test calculate to generate claculate statements on virtual fields

4407

4408

* @return void

4409

4410

function testVirtualFieldsInCalculate() {

4411

$Article =& ClassRegistry::init('Article');

4412

$Article->virtualFields = array(

4413

'this_moment' => 'NOW()',

4414

'two' => '1 + 1',

4415

'comment_count' => 'SELECT COUNT(*) FROM ' . $this->db->fullTableName('comments') .

4416

' WHERE Article.id = ' . $this->db->fullTableName('comments'). '.article_id'

4417

);

4418

4419

$result = $this->db->calculate($Article, 'count', array('this_moment'));

4420

$expected = 'COUNT(NOW()) AS `count`';

4421

$this->assertEqual($expected, $result);

4422

4423

$result = $this->db->calculate($Article, 'max', array('comment_count'));

4424

$expected = 'MAX(SELECT COUNT(*) FROM comments WHERE `Article`.`id` = `comments`.`article_id`) AS `comment_count`';

4425

$this->assertEqual($expected, $result);

4426

}

4427

4428

/**

4429

* test a full example of using virtual fields

4430

4431

* @return void

4432

4433

function testVirtualFieldsFetch() {

4434

$this->loadFixtures('Article', 'Comment');

4435

4436

$Article =& ClassRegistry::init('Article');

4437

$Article->virtualFields = array(

4438

'comment_count' => 'SELECT COUNT(*) FROM ' . $this->db->fullTableName('comments') .

4439

' WHERE Article.id = ' . $this->db->fullTableName('comments') . '.article_id'

4440

);

4441

4442

$conditions = array('comment_count >' => 2);

4443

$query = 'SELECT ' . join(',',$this->db->fields($Article, null, array('id', 'comment_count'))) .

4444

' FROM ' . $this->db->fullTableName($Article) . ' Article ' . $this->db->conditions($conditions, true, true, $Article);

4445

$result = $this->db->fetchAll($query);

4446

$expected = array(array(

4447

'Article' => array('id' => 1, 'comment_count' => 4)

4448

));

4449

$this->assertEqual($expected, $result);

4450

}

4451

4452

/**

4453

* test reading complex virtualFields with subqueries.

4454

4455

* @return void

4456

4457

function testVirtualFieldsComplexRead() {

4458

$this->loadFixtures('DataTest', 'Article', 'Comment');

4459

4460

$Article =& ClassRegistry::init('Article');

4461

$commentTable = $this->db->fullTableName('comments');

4462

$Article =& ClassRegistry::init('Article');

4463

$Article->virtualFields = array(

4464

'comment_count' => 'SELECT COUNT(*) FROM ' . $commentTable .

4465

' AS Comment WHERE Article.id = Comment.article_id'

4466

);

4467

$result = $Article->find('all');

4468

$this->assertTrue(count($result) > 0);

4469

$this->assertTrue($result[0]['Article']['comment_count'] > 0);

4470

4471

$DataTest =& ClassRegistry::init('DataTest');

4472

$DataTest->virtualFields = array(

4473

'complicated' => 'ACOS(SIN(20 * PI() / 180)

4474

* SIN(DataTest.float * PI() / 180)

4475

+ COS(20 * PI() / 180)

4476

* COS(DataTest.count * PI() / 180)

4477

* COS((50 - DataTest.float) * PI() / 180)

4478

) * 180 / PI() * 60 * 1.1515 * 1.609344'

4479

);

4480

$result = $DataTest->find('all');

4481

$this->assertTrue(count($result) > 0);

4482

$this->assertTrue($result[0]['DataTest']['complicated'] > 0);

4483

}

4484

4485

/**

4486

* test that virtualFields with complex functions and aliases work.

4487

4488

* @return void

4489

4490

function testFieldsWithComplexVirtualFields() {

4491

$Article =& new Article();

4492

$Article->virtualFields = array(

4493

'distance' => 'ACOS(SIN(20 * PI() / 180)

4494

* SIN(Article.latitude * PI() / 180)

4495

+ COS(20 * PI() / 180)

4496

* COS(Article.latitude * PI() / 180)

4497

* COS((50 - Article.longitude) * PI() / 180)

4498

) * 180 / PI() * 60 * 1.1515 * 1.609344'

4499

);

4500

4501

$fields = array('id', 'distance');

4502

$result = $this->db->fields($Article, null, $fields);

4503

$qs = $this->db->startQuote;

4504

$qe = $this->db->endQuote;

4505

4506

$this->assertEqual($result[0], "{$qs}Article{$qe}.{$qs}id{$qe}");

4507

$this->assertPattern('/Article__distance/', $result[1]);

4508

$this->assertPattern('/[`\'"]Article[`\'"].[`\'"]latitude[`\'"]/', $result[1]);

4509

$this->assertPattern('/[`\'"]Article[`\'"].[`\'"]longitude[`\'"]/', $result[1]);

4510

}

4511

4512

/**

4513

* test reading virtual fields containing newlines when recursive > 0

4514

4515

* @return void

4516

4517

function testReadVirtualFieldsWithNewLines() {

4518

$Article =& new Article();

4519

$Article->recursive = 1;

4520

$Article->virtualFields = array(

4521

'test' => '

4522

User.id + User.id

4523

4524

);

4525

$result = $this->db->fields($Article, null, array());

4526

$result = $this->db->fields($Article, $Article->alias, $result);

4527

$this->assertPattern('/[`\"]User[`\"]\.[`\"]id[`\"] \+ [`\"]User[`\"]\.[`\"]id[`\"]/', $result[7]);

4528

}

4529

4530

/**

4531

* test group to generate GROUP BY statements on virtual fields

4532

4533

* @return void

4534

4535

function testVirtualFieldsInGroup() {

4536

$Article =& ClassRegistry::init('Article');

4537

$Article->virtualFields = array(

4538

'this_year' => 'YEAR(Article.created)'

4539

);

4540

4541

$result = $this->db->group('this_year',$Article);

4542

$expected = " GROUP BY (YEAR(`Article`.`created`))";

4543

$this->assertEqual($expected, $result);

4544

}

4545

4546

/**

4547

* test the permutations of fullTableName()

4548

4549

* @return void

4550

4551

function testFullTablePermutations() {

4552

$Article =& ClassRegistry::init('Article');

4553

$result = $this->testDb->fullTableName($Article, false);

4554

$this->assertEqual($result, 'articles');

4555

4556

$Article->tablePrefix = 'tbl_';

4557

$result = $this->testDb->fullTableName($Article, false);

4558

$this->assertEqual($result, 'tbl_articles');

4559

4560

$Article->useTable = $Article->table = 'with spaces';

4561

$Article->tablePrefix = '';

4562

$result = $this->testDb->fullTableName($Article);

4563

$this->assertEqual($result, '`with spaces`');

4564

}

4565

4566

/**

4567

* test that read() only calls queryAssociation on db objects when the method is defined.

4568

4569

* @return void

4570

4571

function testReadOnlyCallingQueryAssociationWhenDefined() {

4572

ConnectionManager::create('test_no_queryAssociation', array(

4573

'datasource' => 'data'

4574

));

4575

$Article =& ClassRegistry::init('Article');

4576

$Article->Comment->useDbConfig = 'test_no_queryAssociation';

4577

$result = $Article->find('all');

4578

$this->assertTrue(is_array($result));

4579

}

4580

4581

/**

4582

* test that fields() is using methodCache()

4583

4584

* @return void

4585

4586

function testFieldsUsingMethodCache() {

4587

$this->testDb->cacheMethods = false;

4588

$this->assertTrue(empty($this->testDb->methodCache['fields']), 'Cache not empty');

4589

4590

$Article =& ClassRegistry::init('Article');

4591

$this->testDb->fields($Article, null, array('title', 'body', 'published'));

4592

$this->assertTrue(empty($this->testDb->methodCache['fields']), 'Cache not empty');

4593

}

4594

}

Older »