WorkflowEmbargoExpiryTest::createDefinition() - Code Metrics - symbiote/silverstripe-advancedworkflow - Measure and Improve Code Quality continuously with Scrutinizer

WorkflowEmbargoExpiryTest::createDefinition() A
last analyzed 2019-12-18 23:33 UTC

↳ Parent: WorkflowEmbargoExpiryTest
Complexity

Conditions	1
Paths	1
Size

Total Lines
Duplication

Lines	24
Ratio	100 %
Importance

Changes
Metric	Value
dl	24
loc	24
rs	9.536
c	0
b	0
f	0
cc	1
nc	1
nop	0
<?php

namespace Symbiote\AdvancedWorkflow\Tests;

use SilverStripe\CMS\Model\SiteTree;
use SilverStripe\Core\Config\Config;
use SilverStripe\Dev\SapphireTest;
use SilverStripe\ORM\DataObject;
use SilverStripe\ORM\FieldType\DBDatetime;
use SilverStripe\Translatable\Model\Translatable;
use SilverStripe\Security\Member;
use SilverStripe\Subsites\Extensions\SiteTreeSubsites;
use SilverStripe\Versioned\Versioned;
use Symbiote\AdvancedWorkflow\DataObjects\WorkflowAction;
use Symbiote\AdvancedWorkflow\DataObjects\WorkflowDefinition;
use Symbiote\AdvancedWorkflow\DataObjects\WorkflowTransition;
use Symbiote\AdvancedWorkflow\Extensions\WorkflowEmbargoExpiryExtension;
use Symbiote\AdvancedWorkflow\Services\WorkflowService;
use Symbiote\QueuedJobs\Services\AbstractQueuedJob;
use Symbiote\QueuedJobs\Services\QueuedJobService;

/**
 * @author [email protected]
 * @license BSD License http://silverstripe.org/bsd-license/
 */
class WorkflowEmbargoExpiryTest extends SapphireTest
{
    protected static $fixture_file = 'WorkflowEmbargoExpiry.yml';

    protected function setUp()
    {
        // Prevent failure if queuedjobs module isn't installed.
        if (!class_exists(AbstractQueuedJob::class)) {
            static::$fixture_file = '';
            parent::setUp();
            $this->markTestSkipped("This test requires queuedjobs");
        }
        parent::setUp();

        DBDatetime::set_mock_now('2014-01-05 12:00:00');

        // This doesn't play nicely with PHPUnit
        Config::modify()->set(QueuedJobService::class, 'use_shutdown_function', false);
    }

    protected function tearDown()
    {
        DBDatetime::clear_mock_now();
        parent::tearDown();
    }

    /**
     * @var array
     */
    protected static $required_extensions = array(
        SiteTree::class => array(
            WorkflowEmbargoExpiryExtension::class,
            Versioned::class,
        ),
    );

    /**
     * @var array
     */
    protected static $illegal_extensions = array(
        SiteTree::class => array(
            Translatable::class,
            SiteTreeSubsites::class,
        ),
    );

    /**
     * Start a workflow for a page,
     * this will set it into a state where a workflow is currently being processes
     *
     * @param DataObject $obj
     * @return DataObject
     */
    private function startWorkflow($obj)
    {
        $workflow = $this->objFromFixture(WorkflowDefinition::class, 'requestPublication');
        $obj->WorkflowDefinitionID = $workflow->ID;
        $obj->write();

        $svc = singleton(WorkflowService::class);
        $svc->startWorkflow($obj, $obj->WorkflowDefinitionID);
        return $obj;
    }

    /**
     * Start and finish a workflow which will publish the page immediately basically.
     *
     * @param DataObject $obj
     * @return DataObject
     */
    private function finishWorkflow($obj)
    {
        $workflow = $this->objFromFixture(WorkflowDefinition::class, 'approvePublication');
        $obj->WorkflowDefinitionID = $workflow->ID;
        $obj->write();

        $svc = singleton(WorkflowService::class);
        $svc->startWorkflow($obj, $obj->WorkflowDefinitionID);

        $obj = DataObject::get($obj->ClassName)->byID($obj->ID);
        return $obj;
    }

    /**
     * Retrieves the live version for an object
     *
     * @param DataObject $obj
     * @return DataObject
     */
    private function getLive($obj)
    {
        $oldMode = Versioned::get_reading_mode();
        Versioned::set_reading_mode(Versioned::LIVE);
        $live = DataObject::get($obj->ClassName)->byID($obj->ID);
        Versioned::set_reading_mode($oldMode);

        return $live;
    }

    /**
     * Test when embargo and expiry are both empty.
     *
     * No jobs should be created, but page is published by the workflow action.
     */
    public function testEmptyEmbargoExpiry()
    {
        $page = $this->objFromFixture(SiteTree::class, 'emptyEmbargoExpiry');
        $page->Content = 'Content to go live';

        $live = $this->getLive($page);

        $this->assertEmpty($live->Content);
        $this->assertEquals(0, $page->PublishJobID);
        $this->assertEquals(0, $page->UnPublishJobID);

        $page = $this->finishWorkflow($page);

        $live = $this->getLive($page);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}

        $this->assertNotEmpty($live->Content);
        $this->assertEquals(0, $page->PublishJobID);
        $this->assertEquals(0, $page->UnPublishJobID);
    }

    /**
     * Test for embargo in the past
     *
     * Creates a publish job which is queued for immediately
     */
    public function testPastEmbargo()

    {
        $page = $this->objFromFixture(SiteTree::class, 'pastEmbargo');

        $page = $this->finishWorkflow($page);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}

        $this->assertNotEquals(0, $page->PublishJobID);
        $this->assertEquals(0, $page->UnPublishJobID);

        $publish = strtotime($page->PublishJob()->StartAfter);
        $this->assertFalse($publish);
    }

    /**
     * Test for expiry in the past
     *
     * Creates an unpublish job which is queued for immediately
     */
    public function testPastExpiry()

    {
        $page = $this->objFromFixture(SiteTree::class, 'pastExpiry');

        $page = $this->finishWorkflow($page);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}

        $this->assertEquals(0, $page->PublishJobID);
        $this->assertNotEquals(0, $page->UnPublishJobID);

        $unpublish = strtotime($page->UnPublishJob()->StartAfter);

        $this->assertFalse($unpublish);
    }

    /**
     * Test for embargo and expiry in the past
     *
     * Creates an unpublish job which is queued for immediately
     */
    public function testPastEmbargoExpiry()

    {
        $page = $this->objFromFixture(SiteTree::class, 'pastEmbargoExpiry');

        $page = $this->finishWorkflow($page);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}

        $this->assertEquals(0, $page->PublishJobID);
        $this->assertNotEquals(0, $page->UnPublishJobID);

        $unpublish = strtotime($page->UnPublishJob()->StartAfter);

        $this->assertFalse($unpublish);
    }

    /**
     * Test for embargo in the past and expiry in the future
     *
     * Creates a publish job which is queued for immediately and an unpublish job which is queued for later
     */
    public function testPastEmbargoFutureExpiry()

    {
        $page = $this->objFromFixture(SiteTree::class, 'pastEmbargoFutureExpiry');

        $page = $this->finishWorkflow($page);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}

        $this->assertNotEquals(0, $page->PublishJobID);
        $this->assertNotEquals(0, $page->UnPublishJobID);

        $publish = strtotime($page->PublishJob()->StartAfter);
        $unpublish = strtotime($page->UnPublishJob()->StartAfter);

        $this->assertFalse($publish);
        $this->assertNotFalse($unpublish);
    }

    /**
     * Test for embargo and expiry in the future
     *
     * Creates a publish and unpublish job which are queued for immediately
     */
    public function testFutureEmbargoExpiry()

    {
        $page = $this->objFromFixture(SiteTree::class, 'futureEmbargoExpiry');

        $page = $this->finishWorkflow($page);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}

        $this->assertNotEquals(0, $page->PublishJobID);
        $this->assertNotEquals(0, $page->UnPublishJobID);

        $publish = strtotime($page->PublishJob()->StartAfter);
        $unpublish = strtotime($page->UnPublishJob()->StartAfter);

        $this->assertNotFalse($publish);
        $this->assertNotFalse($unpublish);
    }

    /**
     * Test for embargo after expiry in the past
     *
     * No jobs should be created, invalid option
     */
    public function testPastEmbargoAfterExpiry()

    {
        $page = $this->objFromFixture(SiteTree::class, 'pastEmbargoAfterExpiry');

        $page = $this->finishWorkflow($page);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}

        $this->assertEquals(0, $page->PublishJobID);
        $this->assertEquals(0, $page->UnPublishJobID);
    }

    /**
     * Test for embargo after expiry in the future
     *
     * No jobs should be created, invalid option
     */
    public function testFutureEmbargoAfterExpiry()

    {
        $page = $this->objFromFixture(SiteTree::class, 'futureEmbargoAfterExpiry');

        $page = $this->finishWorkflow($page);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}

        $this->assertEquals(0, $page->PublishJobID);
        $this->assertEquals(0, $page->UnPublishJobID);
    }

    /**
     * Test for embargo and expiry in the past, both have the same value
     *
     * No jobs should be created, invalid option
     */
    public function testPastSameEmbargoExpiry()

    {
        $page = $this->objFromFixture(SiteTree::class, 'pastSameEmbargoExpiry');

        $page = $this->finishWorkflow($page);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}

        $this->assertEquals(0, $page->PublishJobID);
        $this->assertEquals(0, $page->UnPublishJobID);
    }

    /**
     * Test for embargo and expiry in the future, both have the same value
     *
     * No jobs should be created, invalid option
     */
    public function testFutureSameEmbargoExpiry()

    {
        $page = $this->objFromFixture(SiteTree::class, 'futureSameEmbargoExpiry');

        $page = $this->finishWorkflow($page);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}

        $this->assertEquals(0, $page->PublishJobID);
        $this->assertEquals(0, $page->UnPublishJobID);
    }

    /**
     * When an item is queued for publishing or unpublishing and new dates are entered
     *
     * The existing queued jobs should be cleared
     */
    public function testDesiredRemovesJobs()
    {
        $page = $this->objFromFixture(SiteTree::class, 'futureEmbargoExpiry');

        $page = $this->finishWorkflow($page);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}

        $this->assertNotEquals(0, $page->PublishJobID);
        $this->assertNotEquals(0, $page->UnPublishJobID);

        $page->DesiredPublishDate = '2020-02-01 00:00:00';
        $page->DesiredUnPublishDate = '2020-02-01 02:00:00';

        $page->write();

        $this->assertEquals(0, $page->PublishJobID);
        $this->assertEquals(0, $page->UnPublishJobID);
    }

    /**
     * Tests that checking for publishing scheduled state is working
     */
    public function testIsPublishScheduled()

    {
        $page = SiteTree::create();
        $page->Title = 'My page';
        $page->PublishOnDate = '2010-01-01 00:00:00';
        $page->AllowEmbargoedEditing = false;
        $page->write();

        $this->assertFalse($page->getIsPublishScheduled());

        $page->PublishOnDate = '2016-02-01 00:00:00';
        DBDatetime::set_mock_now('2016-01-16 00:00:00');
        $this->assertTrue($page->getIsPublishScheduled());

        DBDatetime::set_mock_now('2016-02-16 00:00:00');
        $this->assertFalse($page->getIsPublishScheduled());
    }

    /**
     * Tests that checking for un-publishing scheduled state is working
     */
    public function testIsUnPublishScheduled()

    {
        $page = SiteTree::create();
        $page->Title = 'My page';
        $page->PublishOnDate = '2010-01-01 00:00:00';
        $page->AllowEmbargoedEditing = false;
        $page->write();

        $this->assertFalse($page->getIsUnPublishScheduled());

        $page->UnPublishOnDate = '2016-02-01 00:00:00';
        DBDatetime::set_mock_now('2016-01-16 00:00:00');
        $this->assertTrue($page->getIsUnPublishScheduled());

        DBDatetime::set_mock_now('2016-02-16 00:00:00');
        $this->assertFalse($page->getIsUnPublishScheduled());
    }

    /**
     * Tests that status flags (badges) are added properly for a page
     */
    public function testStatusFlags()
    {
        $page = SiteTree::create();
        $page->Title = 'stuff';
        DBDatetime::set_mock_now('2016-01-16 00:00:00');

        $flags = $page->getStatusFlags(false);
        $this->assertNotContains('embargo_expiry', array_keys($flags));
        $this->assertNotContains('embargo', array_keys($flags));
        $this->assertNotContains('expiry', array_keys($flags));

        $page->PublishOnDate = '2016-02-01 00:00:00';
        $page->UnPublishOnDate = null;
        $flags = $page->getStatusFlags(false);
        $this->assertNotContains('embargo_expiry', array_keys($flags));
        $this->assertContains('embargo', array_keys($flags));
        $this->assertNotContains('expiry', array_keys($flags));

        $page->PublishOnDate = null;
        $page->UnPublishOnDate = '2016-02-01 00:00:00';
        $flags = $page->getStatusFlags(false);
        $this->assertNotContains('embargo_expiry', array_keys($flags));
        $this->assertNotContains('embargo', array_keys($flags));
        $this->assertContains('expiry', array_keys($flags));

        $page->PublishOnDate = '2016-02-01 00:00:00';
        $page->UnPublishOnDate = '2016-02-08 00:00:00';
        $flags = $page->getStatusFlags(false);
        $this->assertContains('embargo_expiry', array_keys($flags));
        $this->assertNotContains('embargo', array_keys($flags));
        $this->assertNotContains('expiry', array_keys($flags));
    }

    /**
     * Test workflow definition "Can disable edits during embargo"
     * Make sure page cannot be edited when an embargo is in place
     */
    public function testCanEditConfig()
    {
        $this->logOut();

        $page = SiteTree::create();
        $page->Title = 'My page';
        $page->PublishOnDate = '2010-01-01 00:00:00';
        $page->write();

        $memberID = $this->logInWithPermission('SITETREE_EDIT_ALL');
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $this->assertTrue($page->canEdit(), 'Can edit page without embargo and no permission');

        $page->PublishOnDate = '2020-01-01 00:00:00';
        $page->AllowEmbargoedEditing = false;
        $page->write();
        $this->assertFalse($page->canEdit(), 'Cannot edit page with embargo and no permission');

        $this->logOut();
        $memberID = $this->logInWithPermission('ADMIN');
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $this->assertTrue($page->canEdit(), 'Can edit page with embargo as Admin');

        $this->logOut();
        $memberID = $this->logInWithPermission(array('SITETREE_EDIT_ALL', 'EDIT_EMBARGOED_WORKFLOW'));
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $this->assertTrue($page->canEdit(), 'Can edit page with embargo and permission');

        $page->PublishOnDate = '2010-01-01 00:00:00';
        $page->write();
        $this->assertTrue($page->canEdit(), 'Can edit page without embargo and permission');
    }

    protected function createDefinition()

    {
        $definition = new WorkflowDefinition();
        $definition->Title = 'Dummy Workflow Definition';
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $definition->write();

        $stepOne = new WorkflowAction();
        $stepOne->Title = 'Step One';
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $stepOne->WorkflowDefID = $definition->ID;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $stepOne->write();

        $stepTwo = new WorkflowAction();
        $stepTwo->Title = 'Step Two';
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $stepTwo->WorkflowDefID = $definition->ID;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $stepTwo->write();

        $transitionOne = new WorkflowTransition();
        $transitionOne->Title = 'Step One T1';
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $transitionOne->ActionID = $stepOne->ID;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $transitionOne->NextActionID = $stepTwo->ID;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $transitionOne->write();

        return $definition;
    }

    /**
     * Make sure that publish and unpublish dates are not carried over to the duplicates.
     */
    public function testDuplicateRemoveEmbargoExpiry()
    {
        $page = $this->objFromFixture(SiteTree::class, 'futureEmbargoExpiry');

        // fake publish jobs
        $page = $this->finishWorkflow($page);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}

        $dupe = $page->duplicate();
        $this->assertNotNull($page->PublishOnDate, 'Not blank publish on date');
        $this->assertNotNull($page->UnPublishOnDate, 'Not blank unpublish on date');
        $this->assertNotEquals($page->PublishJobID, 0, 'Publish job ID still set');
        $this->assertNotEquals($page->UnPublishJobID, 0, 'Unpublish job ID still set');
        $this->assertNull($dupe->PublishOnDate, 'Blank publish on date');
        $this->assertNull($dupe->UnPublishOnDate, 'Blank unpublish on date');
        $this->assertEquals($dupe->PublishJobID, 0, 'Publish job ID unset');
        $this->assertEquals($dupe->UnPublishJobID, 0, 'Unpublish job ID unset');
    }
}

1			<?php
2
3			namespace Symbiote\AdvancedWorkflow\Tests;
4
5			use SilverStripe\CMS\Model\SiteTree;
6			use SilverStripe\Core\Config\Config;
7			use SilverStripe\Dev\SapphireTest;
8			use SilverStripe\ORM\DataObject;
9			use SilverStripe\ORM\FieldType\DBDatetime;
10			use SilverStripe\Translatable\Model\Translatable;
11			use SilverStripe\Security\Member;
12			use SilverStripe\Subsites\Extensions\SiteTreeSubsites;
13			use SilverStripe\Versioned\Versioned;
14			use Symbiote\AdvancedWorkflow\DataObjects\WorkflowAction;
15			use Symbiote\AdvancedWorkflow\DataObjects\WorkflowDefinition;
16			use Symbiote\AdvancedWorkflow\DataObjects\WorkflowTransition;
17			use Symbiote\AdvancedWorkflow\Extensions\WorkflowEmbargoExpiryExtension;
18			use Symbiote\AdvancedWorkflow\Services\WorkflowService;
19			use Symbiote\QueuedJobs\Services\AbstractQueuedJob;
20			use Symbiote\QueuedJobs\Services\QueuedJobService;
21
22			/**
23			* @author [email protected]
24			* @license BSD License http://silverstripe.org/bsd-license/
25			*/
26			class WorkflowEmbargoExpiryTest extends SapphireTest
27			{
28			protected static $fixture_file = 'WorkflowEmbargoExpiry.yml';
29
30			protected function setUp()
31			{
32			// Prevent failure if queuedjobs module isn't installed.
33			if (!class_exists(AbstractQueuedJob::class)) {
34			static::$fixture_file = '';
35			parent::setUp();
36			$this->markTestSkipped("This test requires queuedjobs");
37			}
38			parent::setUp();
39
40			DBDatetime::set_mock_now('2014-01-05 12:00:00');
symbiote / silverstripe-advancedworkflow

GitHub Access Token became invalid

WorkflowEmbargoExpiryTest::createDefinition() A last analyzed 2019-12-18 23:33 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

WorkflowEmbargoExpiryTest::createDefinition() A
last analyzed 2019-12-18 23:33 UTC
