WorkflowEmbargoExpiryTest - Code Metrics - silverstripe-australia/advancedworkflow - Measure and Improve Code Quality continuously with Scrutinizer

WorkflowEmbargoExpiryTest A
last analyzed 2016-05-03 01:01 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	299
Duplicated Lines	40.47 %

Coupling/Cohesion

Components	0
Dependencies	8

Metric	Value
wmc	11
lcom	0
cbo	8
dl	121
loc	299
rs	10

10 Methods

Rating	Name	Duplication	Size	Complexity
A	tearDown()	0	4	1
A	testFutureDatesJobs()	0	22	1
A	setUp()	0	5	1
A	__construct()	0	6	2
B	testDesiredRemovesJobs()	0	30	1
B	testPublishActionWithFutureDates()	0	29	1
A	testPastPublishThenUnpublish()	49	49	1
A	testPastUnPublishThenPublish()	49	49	1
B	testPastPublishWithWorkflowInEffect()	0	44	1
A	createDefinition()	23	23	1

How to fix Duplicated Code

<?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			public function setUp() {
10			parent::setUp();
11
12			SS_Datetime::set_mock_now('2014-01-05 12:00:00');
13			}
14
15			public function tearDown() {
16			SS_Datetime::clear_mock_now();
17			parent::tearDown();
18			}
19
20			/**
21			* @var array
22			*/
23			protected $requiredExtensions = array(
24			'SiteTree' => array(
25			'WorkflowEmbargoExpiryExtension',
26			'Versioned',
27			)
28			);
29
30			/**
31			* @var array
32			*/
33			protected $illegalExtensions = array(
34			'SiteTree' => array(
35			"Translatable",
36			)
37			);
38
39			public function __construct() {

silverstripe-australia / advancedworkflow

WorkflowEmbargoExpiryTest A last analyzed 2016-05-03 01:01 UTC

Complexity

Size/Duplication

Coupling/Cohesion

10 Methods

How to fix Duplicated Code

Duplicated Code

Available Fixes

Duplication Side-by-Side

Filter issues like

WorkflowEmbargoExpiryTest A
last analyzed 2016-05-03 01:01 UTC