~tsep-dev/tsep/0.9-beta

if (isset($this->_fixtures) && isset($this->db) && !in_array(strtolower($method), array('start', 'end')) && $this->__truncated && $this->autoFixtures == true) {

415

foreach ($this->_fixtures as $fixture) {

416

$inserts = $fixture->insert($this->db);

417

}

418

}

419

420

if (!in_array(strtolower($method), $this->methods)) {

421

$this->startTest($method);

422

}

423

}

424

425

/**

426

* Runs as first test to create tables.

427

428

* @return void

429

* @access public

430

431

function start() {

432

if (isset($this->_fixtures) && isset($this->db)) {

433

Configure::write('Cache.disable', true);

434

$cacheSources = $this->db->cacheSources;

435

$this->db->cacheSources = false;

436

$sources = $this->db->listSources();

437

$this->db->cacheSources = $cacheSources;

438

439

if (!$this->dropTables) {

440

return;

441

}

442

foreach ($this->_fixtures as $fixture) {

443

$table = $this->db->config['prefix'] . $fixture->table;

444

if (in_array($table, $sources)) {

445

$fixture->drop($this->db);

446

$fixture->create($this->db);

447

} elseif (!in_array($table, $sources)) {

448

$fixture->create($this->db);

449

}

450

}

451

}

452

}

453

454

/**

455

* Runs as last test to drop tables.

456

457

* @return void

458

* @access public

459

460

function end() {

461

if (isset($this->_fixtures) && isset($this->db)) {

462

if ($this->dropTables) {

463

foreach (array_reverse($this->_fixtures) as $fixture) {

464

$fixture->drop($this->db);

465

}

466

}

467

$this->db->sources(true);

468

Configure::write('Cache.disable', false);

469

}

470

471

if (class_exists('ClassRegistry')) {

472

ClassRegistry::flush();

473

}

474

}

475

476

/**

477

* Announces the end of a test.

478

479

* @param string $method Test method just finished.

480

* @return void

481

* @access public

482

483

function after($method) {

484

$isTestMethod = !in_array(strtolower($method), array('start', 'end'));

485

486

if (isset($this->_fixtures) && isset($this->db) && $isTestMethod) {

487

foreach ($this->_fixtures as $fixture) {

488

$fixture->truncate($this->db);

489

}

490

$this->__truncated = true;

491

} else {

492

$this->__truncated = false;

493

}

494

495

if (!in_array(strtolower($method), $this->methods)) {

496

$this->endTest($method);

497

}

498

$this->_should_skip = false;

499

500

parent::after($method);

501

}

502

503

/**

504

* Gets a list of test names. Normally that will be all internal methods that start with the

505

* name "test". This method should be overridden if you want a different rule.

506

507

* @return array List of test names.

508

* @access public

509

510

function getTests() {

511

return array_merge(

512

array('start', 'startCase'),

513

array_diff(parent::getTests(), array('testAction', 'testaction')),

514

array('endCase', 'end')

515

);

516

}

517

518

/**

519

* Chooses which fixtures to load for a given test

520

521

* @param string $fixture Each parameter is a model name that corresponds to a

522

* fixture, i.e. 'Post', 'Author', etc.

523

* @return void

524

* @access public

525

* @see CakeTestCase::$autoFixtures

526

527

function loadFixtures() {

528

$args = func_get_args();

529

foreach ($args as $class) {

530

if (isset($this->_fixtureClassMap[$class])) {

531

$fixture = $this->_fixtures[$this->_fixtureClassMap[$class]];

532

533

$fixture->truncate($this->db);

534

$fixture->insert($this->db);

535

} else {

536

trigger_error(sprintf(__('Referenced fixture class %s not found', true), $class), E_USER_WARNING);

537

}

538

}

539

}

540

541

/**

542

* Takes an array $expected and generates a regex from it to match the provided $string.

543

* Samples for $expected:

544

545

* Checks for an input tag with a name attribute (contains any non-empty value) and an id

546

* attribute that contains 'my-input':

547

* array('input' => array('name', 'id' => 'my-input'))

548

549

* Checks for two p elements with some text in them:

550

* array(

551

* array('p' => true),

552

* 'textA',

553

* '/p',

554

* array('p' => true),

555

* 'textB',

556

* '/p'

557

* )

558

559

* You can also specify a pattern expression as part of the attribute values, or the tag

560

* being defined, if you prepend the value with preg: and enclose it with slashes, like so:

561

* array(

562

* array('input' => array('name', 'id' => 'preg:/FieldName\d+/')),

563

* 'preg:/My\s+field/'

564

* )

565

566

* Important: This function is very forgiving about whitespace and also accepts any

567

* permutation of attribute order. It will also allow whitespaces between specified tags.

568

569

* @param string $string An HTML/XHTML/XML string

570

* @param array $expected An array, see above

571

* @param string $message SimpleTest failure output string

572

* @return boolean

573

* @access public

574

575

function assertTags($string, $expected, $fullDebug = false) {

576

$regex = array();

577

$normalized = array();

578

foreach ((array) $expected as $key => $val) {

579

if (!is_numeric($key)) {

580

$normalized[] = array($key => $val);

581

} else {

582

$normalized[] = $val;

583

}

584

}

585

$i = 0;

586

foreach ($normalized as $tags) {

587

if (!is_array($tags)) {

588

$tags = (string)$tags;

589

}

590

$i++;

591

if (is_string($tags) && $tags{0} == '<') {

592

$tags = array(substr($tags, 1) => array());

593

} elseif (is_string($tags)) {

594

$tagsTrimmed = preg_replace('/\s+/m', '', $tags);

595

596

if (preg_match('/^\*?\//', $tags, $match) && $tagsTrimmed !== '//') {

597

$prefix = array(null, null);

598

599

if ($match[0] == '*/') {

600

$prefix = array('Anything, ', '.*?');

601

}

602

$regex[] = array(

603

sprintf('%sClose %s tag', $prefix[0], substr($tags, strlen($match[0]))),

604

sprintf('%s<[\s]*\/[\s]*%s[\s]*>[\n\r]*', $prefix[1], substr($tags, strlen($match[0]))),

605

$i,

606

);

607

continue;

608

}

609

if (!empty($tags) && preg_match('/^preg\:\/(.+)\/$/i', $tags, $matches)) {

610

$tags = $matches[1];

611

$type = 'Regex matches';

612

} else {

613

$tags = preg_quote($tags, '/');

614

$type = 'Text equals';

615

}

616

$regex[] = array(

617

sprintf('%s "%s"', $type, $tags),

618

$tags,

619

$i,

620

);

621

continue;

622

}

623

foreach ($tags as $tag => $attributes) {

624

$regex[] = array(

625

sprintf('Open %s tag', $tag),

626

sprintf('[\s]*<%s', preg_quote($tag, '/')),

627

$i,

628

);

629

if ($attributes === true) {

630

$attributes = array();

631

}

632

$attrs = array();

633

$explanations = array();

634

$i = 1;

635

foreach ($attributes as $attr => $val) {

636

if (is_numeric($attr) && preg_match('/^preg\:\/(.+)\/$/i', $val, $matches)) {

637

$attrs[] = $matches[1];

638

$explanations[] = sprintf('Regex "%s" matches', $matches[1]);

639

continue;

640

} else {

641

$quotes = '["\']';

642

if (is_numeric($attr)) {

643

$attr = $val;

644

$val = '.+?';

645

$explanations[] = sprintf('Attribute "%s" present', $attr);

646

} elseif (!empty($val) && preg_match('/^preg\:\/(.+)\/$/i', $val, $matches)) {

647

$quotes = '["\']?';

648

$val = $matches[1];

649

$explanations[] = sprintf('Attribute "%s" matches "%s"', $attr, $val);

650

} else {

651

$explanations[] = sprintf('Attribute "%s" == "%s"', $attr, $val);

652

$val = preg_quote($val, '/');

653

}

654

$attrs[] = '[\s]+' . preg_quote($attr, '/') . '=' . $quotes . $val . $quotes;

655

}

656

$i++;

657

}

658

if ($attrs) {

659

$permutations = $this->__array_permute($attrs);

660

661

$permutationTokens = array();

662

foreach ($permutations as $permutation) {

663

$permutationTokens[] = implode('', $permutation);

664

}

665

$regex[] = array(

666

sprintf('%s', implode(', ', $explanations)),

667

$permutationTokens,

668

$i,

669

);

670

}

671

$regex[] = array(

672

sprintf('End %s tag', $tag),

673

'[\s]*\/?[\s]*>[\n\r]*',

674

$i,

675

);

676

}

677

}

678

foreach ($regex as $i => $assertation) {

679

list($description, $expressions, $itemNum) = $assertation;

680

$matches = false;

681

foreach ((array)$expressions as $expression) {

682

if (preg_match(sprintf('/^%s/s', $expression), $string, $match)) {

683

$matches = true;

684

$string = substr($string, strlen($match[0]));

685

break;

686

}

687

}

688

if (!$matches) {

689

$this->assert(new TrueExpectation(), false, sprintf('Item #%d / regex #%d failed: %s', $itemNum, $i, $description));

690

if ($fullDebug) {

691

debug($string, true);

692

debug($regex, true);

693

}

694

return false;

695

}

696

}

697

return $this->assert(new TrueExpectation(), true, '%s');

698

}

699

700

/**

701

* Initialize DB connection.

702

703

* @return void

704

* @access protected

705

706

function _initDb() {

707

$testDbAvailable = in_array('test', array_keys(ConnectionManager::enumConnectionObjects()));

708

709

$_prefix = null;

710

711

if ($testDbAvailable) {

712

// Try for test DB

713

restore_error_handler();

714

@$db =& ConnectionManager::getDataSource('test');

715

set_error_handler('simpleTestErrorHandler');

716

$testDbAvailable = $db->isConnected();

717

}

718

719

// Try for default DB

720

if (!$testDbAvailable) {

721

$db =& ConnectionManager::getDataSource('default');

722

$_prefix = $db->config['prefix'];

723

$db->config['prefix'] = 'test_suite_';

724

}

725

726

ConnectionManager::create('test_suite', $db->config);

727

$db->config['prefix'] = $_prefix;

728

729

// Get db connection

730

$this->db =& ConnectionManager::getDataSource('test_suite');

731

$this->db->cacheSources = false;

732

733

ClassRegistry::config(array('ds' => 'test_suite'));

734

}

735

736

/**

737

* Load fixtures specified in var $fixtures.

738

739

* @return void

740

* @access protected

741

742

function _loadFixtures() {

743

if (!isset($this->fixtures) || empty($this->fixtures)) {

744

return;

745

}

746

747

if (!is_array($this->fixtures)) {

748

$this->fixtures = array_map('trim', explode(',', $this->fixtures));

749

}

750

751

$this->_fixtures = array();

752

753

foreach ($this->fixtures as $index => $fixture) {

754

$fixtureFile = null;

755

756

if (strpos($fixture, 'core.') === 0) {

757

$fixture = substr($fixture, strlen('core.'));

758

foreach (App::core('cake') as $key => $path) {

759

$fixturePaths[] = $path . 'tests' . DS . 'fixtures';

760

}

761

} elseif (strpos($fixture, 'app.') === 0) {

762

$fixture = substr($fixture, strlen('app.'));

763

$fixturePaths = array(

764

TESTS . 'fixtures',

765

VENDORS . 'tests' . DS . 'fixtures'

766

);

767

} elseif (strpos($fixture, 'plugin.') === 0) {

768

$parts = explode('.', $fixture, 3);

769

$pluginName = $parts[1];

770

$fixture = $parts[2];

771

$fixturePaths = array(

772

App::pluginPath($pluginName) . 'tests' . DS . 'fixtures',

773

TESTS . 'fixtures',

774

VENDORS . 'tests' . DS . 'fixtures'

775

);

776

} else {

777

$fixturePaths = array(

778

TESTS . 'fixtures',

779

VENDORS . 'tests' . DS . 'fixtures',

780

TEST_CAKE_CORE_INCLUDE_PATH . DS . 'cake' . DS . 'tests' . DS . 'fixtures'

781

);

782

}

783

784

foreach ($fixturePaths as $path) {

785

if (is_readable($path . DS . $fixture . '_fixture.php')) {

786

$fixtureFile = $path . DS . $fixture . '_fixture.php';

787

break;

788

}

789

}

790

791

if (isset($fixtureFile)) {

792

require_once($fixtureFile);

793

$fixtureClass = Inflector::camelize($fixture) . 'Fixture';

794

$this->_fixtures[$this->fixtures[$index]] =& new $fixtureClass($this->db);

795

$this->_fixtureClassMap[Inflector::camelize($fixture)] = $this->fixtures[$index];

796

}

797

}

798

799

if (empty($this->_fixtures)) {

800

unset($this->_fixtures);

801

}

802

}

803

804

/**

805

* Generates all permutation of an array $items and returns them in a new array.

806

807

* @param array $items An array of items

808

* @return array

809

* @access private

810

811

function __array_permute($items, $perms = array()) {

812

static $permuted;

813

if (empty($perms)) {

814

$permuted = array();

815

}

816

817

if (empty($items)) {

818

$permuted[] = $perms;

819

} else {

820

$numItems = count($items) - 1;

821

for ($i = $numItems; $i >= 0; --$i) {

822

$newItems = $items;

823

$newPerms = $perms;

824

list($tmp) = array_splice($newItems, $i, 1);

825

array_unshift($newPerms, $tmp);

826

$this->__array_permute($newItems, $newPerms);

827

}

828

return $permuted;

829

}

830

}

831

}

Older »