WorkflowEmbargoExpiryTest::setUp() - Code Metrics - Inspection of "Converted to PSR-2" - silverstripe-australia/advancedworkflow - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#230)

by Helpful

created 2015-12-17 06:52 UTC

WorkflowEmbargoExpiryTest::setUp() A

↳ Parent: WorkflowEmbargoExpiryTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	6
rs	9.4286
cc	1
eloc	3
nc	1
nop	0

<?php

/**
 * @author [email protected]
 * @license BSD License http://silverstripe.org/bsd-license/
 */
class WorkflowEmbargoExpiryTest extends SapphireTest
namespace YourVendor;

class YourClass { }
{

    public function setUp()
    {
        parent::setUp();

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

    public function tearDown()
    {
        SS_Datetime::clear_mock_now();
        parent::tearDown();
    }

    /**
     * @var array
     */
    protected $requiredExtensions = array(
        'SiteTree' => array(
            'WorkflowEmbargoExpiryExtension',
            'Versioned',
        )
    );

    /**
     * @var array
     */
    protected $illegalExtensions = array(
        'SiteTree' => array(
            "Translatable",
        )
    );

    public function __construct()
    {
        if (!class_exists('AbstractQueuedJob')) {
            $this->skipTest = true;
        }
        parent::__construct();
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
    }

    public function testFutureDatesJobs()
    {
        $page = new Page();

        $page->PublishOnDate = '2020-01-01 00:00:00';
        $page->UnPublishOnDate = '2020-01-01 01:00:00';

        // Two writes are necessary for this to work on new objects
        $page->write();
        $page->write();

        $this->assertTrue($page->PublishJobID > 0);

        $this->assertTrue($page->UnPublishJobID > 0);


        // Check date ranges
        $now = strtotime(SS_Datetime::now()->getValue());
        $publish = strtotime($page->PublishJob()->StartAfter);
        $unPublish = strtotime($page->UnPublishJob()->StartAfter);

        $this->assertGreaterThan($now, $publish);

        $this->assertGreaterThan($now, $unPublish);

        $this->assertGreaterThan($publish, $unPublish);

    }

    public function testDesiredRemovesJobs()
    {
        $page = new Page();

        $page->PublishOnDate = '2020-01-01 00:00:00';
        $page->UnPublishOnDate = '2020-01-01 01:00:00';

        // Two writes are necessary for this to work on new objects
        $page->write();
        $page->write();

        $this->assertTrue($page->PublishJobID > 0);

        $this->assertTrue($page->UnPublishJobID > 0);


        // Check date ranges
        $now = strtotime(SS_Datetime::now()->getValue());
        $publish = strtotime($page->PublishJob()->StartAfter);
        $unPublish = strtotime($page->UnPublishJob()->StartAfter);

        $this->assertGreaterThan($now, $publish);

        $this->assertGreaterThan($now, $unPublish);

        $this->assertGreaterThan($publish, $unPublish);


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

        $page->write();

        $this->assertTrue($page->PublishJobID == 0);

        $this->assertTrue($page->UnPublishJobID == 0);

    }

    public function testPublishActionWithFutureDates()
    {
        $action = new PublishItemWorkflowAction();
        $instance = new WorkflowInstance();

        $page = new Page();
        $page->Title = 'stuff';
        $page->DesiredPublishDate = '2020-02-01 00:00:00';
        $page->DesiredUnPublishDate = '2020-02-01 02:00:00';

        $page->write();

        $instance->TargetClass = $page->ClassName;
<?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.");
        }
    }

}
        $instance->TargetID = $page->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.");
        }
    }

}

        $action->execute($instance);

        $page = DataObject::get_by_id('Page', $page->ID);
        $this->assertTrue($page->PublishJobID > 0);

        $this->assertTrue($page->UnPublishJobID > 0);


        // Check date ranges
        $now = strtotime(SS_Datetime::now()->getValue());
        $publish = strtotime($page->PublishJob()->StartAfter);
        $unPublish = strtotime($page->UnPublishJob()->StartAfter);

        $this->assertGreaterThan($now, $publish);

        $this->assertGreaterThan($now, $unPublish);

        $this->assertGreaterThan($publish, $unPublish);

    }

    /**
     * Test that a page with a past publish date creates the correct jobs
     */
    public function testPastPublishThenUnpublish()

    {
        $page = new Page();
        $page->Title = 'My Page';
        $page->write();

        // No publish
        $this->assertEmpty($page->PublishJobID);

        $this->assertEmpty($page->UnPublishJobID);


        // Set a past publish date
        $page->PublishOnDate = '2010-01-01 00:00:00';
        $page->write();

        // We should still have a job to publish this page, but not unpublish
        $this->assertNotEmpty($page->PublishJobID);

        $this->assertEmpty($page->UnPublishJobID);


        // Check that this job is set for immediate run
        $publish = strtotime($page->PublishJob()->StartAfter);
        $this->assertEmpty($publish);


        // Now add an expiry date in the past, but after the current publish job,
        // and ensure that this correctly overrides the open publish request
        $page->UnPublishOnDate = '2010-01-02 00:00:00';
        $page->write();

        // Now we should have an unpublish job, but the publish job is noticably absent
        $this->assertEmpty($page->PublishJobID);

        $this->assertNotEmpty($page->UnPublishJobID);


        // Check that this unpublish job is set for immediate run
        $unpublish = strtotime($page->UnPublishJob()->StartAfter);
        $this->assertEmpty($unpublish);


        // Now add an expiry date in the future, and ensure that we get the correct combination of
        // publish and unpublish jobs
        $page->UnPublishOnDate = '2015-01-01 12:00:00';
        $page->write();

        // Both jobs exist
        $this->assertNotEmpty($page->PublishJobID);

        $this->assertNotEmpty($page->UnPublishJobID);


        // Check that this unpublish job is set for immediate run and the unpublish for future
        $publish = strtotime($page->PublishJob()->StartAfter);
        $unpublish = strtotime($page->UnPublishJob()->StartAfter);
        $this->assertEmpty($publish); // for immediate run

        $this->assertGreaterThan(strtotime(SS_Datetime::now()->getValue()), $unpublish); // for later run

    }

    /**
     * Test that a page with a past unpublish date creates the correct jobs
     */
    public function testPastUnPublishThenPublish()

    {
        $page = new Page();
        $page->Title = 'My Page';
        $page->write();

        // No publish
        $this->assertEmpty($page->PublishJobID);

        $this->assertEmpty($page->UnPublishJobID);


        // Set a past unpublish date
        $page->UnPublishOnDate = '2010-01-01 00:00:00';
        $page->write();

        // We should still have a job to unpublish this page, but not publish
        $this->assertEmpty($page->PublishJobID);

        $this->assertNotEmpty($page->UnPublishJobID);


        // Check that this job is set for immediate run
        $unpublish = strtotime($page->UnPublishJob()->StartAfter);
        $this->assertEmpty($unpublish);


        // Now add an publish date in the past, but after the unpublish job,
        // and ensure that this correctly overrides the open unpublish request
        $page->PublishOnDate = '2010-01-02 00:00:00';
        $page->write();

        // Now we should have an publish job, but the unpublish job is noticably absent
        $this->assertNotEmpty($page->PublishJobID);

        $this->assertEmpty($page->UnPublishJobID);


        // Check that this publish job is set for immediate run
        $publish = strtotime($page->PublishJob()->StartAfter);
        $this->assertEmpty($publish);


        // Now add a publish date in the future, and ensure that we get the correct combination of
        // publish and unpublish jobs
        $page->PublishOnDate = '2015-01-01 12:00:00';
        $page->write();

        // Both jobs exist
        $this->assertNotEmpty($page->PublishJobID);

        $this->assertNotEmpty($page->UnPublishJobID);


        // Check that this unpublish job is set for immediate run and the unpublish for future
        $publish = strtotime($page->PublishJob()->StartAfter);
        $unpublish = strtotime($page->UnPublishJob()->StartAfter);
        $this->assertEmpty($unpublish); // for immediate run

        $this->assertGreaterThan(strtotime(SS_Datetime::now()->getValue()), $publish); // for later run

    }

    public function testPastPublishWithWorkflowInEffect()
    {
        $definition = $this->createDefinition();

        $page = new Page();
        $page->Title = 'My page';
        $page->WorkflowDefinitionID = $definition->ID;
        $page->write();

        // No publish
        $this->assertEmpty($page->PublishJobID);

        $this->assertEmpty($page->UnPublishJobID);


        // Set a past publish date
        $page->DesiredPublishDate = '2010-01-01 00:00:00';
        $page->write();

        // Workflow is in effect. No jobs have been created yet as it's not approved.
        $this->assertEmpty($page->PublishJobID);

        $this->assertEmpty($page->UnPublishJobID);


        // Advance the workflow so we can see what happens
        $instance = new WorkflowInstance();
        $instance->beginWorkflow($definition, $page);
        $instance->execute();

        // execute the "publish" workflow action
        $action = new PublishItemWorkflowAction();
        $action->execute($instance);

        // re-fetch the Page again.
        $page = Page::get()->byId($page->ID);

        // We now have a PublishOnDate field set
        $this->assertEquals('2010-01-01 00:00:00', $page->PublishOnDate);

        $this->assertEmpty($page->DesiredPublishDate);


        // Publish job has been setup
        $this->assertNotEmpty($page->PublishJobID);

        $this->assertEmpty($page->UnPublishJobID);


        // Check that this publish job is set for immediate run
        $publish = strtotime($page->PublishJob()->StartAfter);
        $this->assertEmpty($publish);

    }

    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;
    }
}


1			<?php
2
3			/**
4			* @author [email protected]
5			* @license BSD License http://silverstripe.org/bsd-license/
6			*/
7			class WorkflowEmbargoExpiryTest extends SapphireTest
			0 ignored issues – show Coding Style Compatibility introduced 2015-11-21 06:31 UTC by Report Bug Copy Issue Report PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions. You can fix this by adding a namespace to your class: namespace YourVendor; class YourClass { } When choosing a vendor namespace, try to pick something that is not too generic to avoid conflicts with other libraries. Loading history...
8			{
9
10			public function setUp()
11			{
12			parent::setUp();
13
14			SS_Datetime::set_mock_now('2014-01-05 12:00:00');
15			}
16
17			public function tearDown()
18			{
19			SS_Datetime::clear_mock_now();
20			parent::tearDown();
21			}
22
23			/**
24			* @var array
25			*/
26			protected $requiredExtensions = array(
27			'SiteTree' => array(
28			'WorkflowEmbargoExpiryExtension',
29			'Versioned',
30			)
31			);
32
33			/**
34			* @var array
35			*/
36			protected $illegalExtensions = array(
37			'SiteTree' => array(
38			"Translatable",
39			)

silverstripe-australia / advancedworkflow

Pull Request — master (#230)

WorkflowEmbargoExpiryTest::setUp() A

Complexity

Size

Duplication

Available Fixes

Duplication Side-by-Side

Filter issues like