EventTest

Complexity

Total Complexity

19

Size/Duplication

Total Lines	232
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	it_can_compile_the_command()	0	6	1
A	it_can_switch_user()	0	7	1
A	it_can_switch_directory()	0	7	1
A	it_can_append_output()	0	7	1
A	it_can_overwrite_output()	0	7	1
A	it_can_run_every_minute()	0	7	1
A	it_can_run_n_minutes()	0	7	1
A	it_can_run_hourly()	0	7	1
A	it_can_run_on_every_hour()	0	7	1
A	it_can_run_daily()	0	7	1
A	it_can_run_daily_at_a_specific_time()	0	9	1
A	it_can_run_on_specific_days()	0	10	1
A	it_can_run_on_weekdays_only()	0	7	1
A	it_can_run_weekly()	0	7	1
A	it_can_run_monthly()	0	7	1
A	it_can_run_quarterly()	0	7	1
A	it_can_run_yearly()	0	7	1
B	it_allows_for_filtering()	0	24	1
A	it_can_prevent_overlapping()	0	7	1

<?php

use Basebuilder\Scheduling\Event;

class EventTest extends \PHPUnit_Framework_TestCase

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

{
    /**
     * @test
     */
    function it_can_compile_the_command()

It is generally recommended to explicitly declare the visibility for methods.

As per coding-style, this function should be in camelCase.

    {
        $event = new Event('php -i');

        $this->assertSame("sh -c 'php -i 1>> '/dev/null' 2>> '/dev/null''", $event->compileCommand());
    }

    /**
     * @test
     */
    function it_can_switch_user()

It is generally recommended to explicitly declare the visibility for methods.

As per coding-style, this function should be in camelCase.

    {
        $event = new Event('php -i');
        $event->asUser('foo');

        $this->assertSame("sudo -u foo -- sh -c 'php -i 1>> '/dev/null' 2>> '/dev/null''", $event->compileCommand());
    }

    /**
     * @test
     */
    function it_can_switch_directory()

It is generally recommended to explicitly declare the visibility for methods.

As per coding-style, this function should be in camelCase.

    {
        $event = new Event('php -i');
        $event->in('/foo/bar');

        $this->assertSame("cd /foo/bar; sh -c 'php -i 1>> '/dev/null' 2>> '/dev/null''", $event->compileCommand());
    }

    /**
     * @test
     */
    function it_can_append_output()

It is generally recommended to explicitly declare the visibility for methods.

As per coding-style, this function should be in camelCase.

    {
        $event = new Event('php -i');
        $event->appendOutput(true);

        $this->assertSame("sh -c 'php -i 1>> '/dev/null' 2>> '/dev/null''", $event->compileCommand());
    }

    /**
     * @test
     */
    function it_can_overwrite_output()

It is generally recommended to explicitly declare the visibility for methods.

As per coding-style, this function should be in camelCase.

    {
        $event = new Event('php -i');
        $event->appendOutput(false);

        $this->assertSame("sh -c 'php -i 1> '/dev/null' 2> '/dev/null''", $event->compileCommand());
    }

    /**
     * @test
     */
    function it_can_run_every_minute()

It is generally recommended to explicitly declare the visibility for methods.

As per coding-style, this function should be in camelCase.

    {
        $event = new Event('php -i');
        $event->everyMinute();

        $this->assertSame('* * * * * *', (string) $event->getCronExpression());
    }

    /**
     * @test
     */
    function it_can_run_n_minutes()

It is generally recommended to explicitly declare the visibility for methods.

As per coding-style, this function should be in camelCase.

    {
        $event = new Event('php -i');
        $event->everyNMinutes(5);

        $this->assertSame("*/5 * * * * *", (string) $event->getCronExpression());

The string literal */5 * * * * * does not require double quotes, as per coding-style, please use single quotes.

    }

    /**
     * @test
     */
    function it_can_run_hourly()

It is generally recommended to explicitly declare the visibility for methods.

As per coding-style, this function should be in camelCase.

    {
        $event = new Event('php -i');
        $event->hourly();

        $this->assertSame('0 * * * * *', (string) $event->getCronExpression());
    }

    /**
     * @test
     */
    function it_can_run_on_every_hour()

It is generally recommended to explicitly declare the visibility for methods.

As per coding-style, this function should be in camelCase.

    {
        $event = new Event('php -i');
        $event->hour(1);

        $this->assertSame('* 1 * * * *', (string) $event->getCronExpression());
    }

    /**
     * @test
     */
    function it_can_run_daily()

It is generally recommended to explicitly declare the visibility for methods.

As per coding-style, this function should be in camelCase.

    {
        $event = new Event('php -i');
        $event->daily();

        $this->assertSame('0 0 * * * *', (string) $event->getCronExpression());
    }

    /**
     * @test
     */
    function it_can_run_daily_at_a_specific_time()

It is generally recommended to explicitly declare the visibility for methods.

As per coding-style, this function should be in camelCase.

    {
        $event = new Event('php -i');
        $event->dailyAt('10:05');
        $this->assertSame('5 10 * * * *', (string) $event->getCronExpression());

        $event->dailyAt('10');
        $this->assertSame('0 10 * * * *', (string) $event->getCronExpression());
    }

    /**
     * @test
     */
    function it_can_run_on_specific_days()

It is generally recommended to explicitly declare the visibility for methods.

As per coding-style, this function should be in camelCase.

    {
        $event = new Event('php -i');

        $event->days([1, 2 ,3 ]);
        $this->assertSame('* * * * 1,2,3 *', (string) $event->getCronExpression());

        $event->days(4, 5, 6);
        $this->assertSame('* * * * 4,5,6 *', (string) $event->getCronExpression());
    }

    /**
     * @test
     */
    function it_can_run_on_weekdays_only()

It is generally recommended to explicitly declare the visibility for methods.

As per coding-style, this function should be in camelCase.

    {
        $event = new Event('php -i');
        $event->weekdays();

        $this->assertSame('* * * * 1-5 *', (string) $event->getCronExpression());
    }

    /**
     * @test
     */
    function it_can_run_weekly()

It is generally recommended to explicitly declare the visibility for methods.

As per coding-style, this function should be in camelCase.

    {
        $event = new Event('php -i');
        $event->weekly();

        $this->assertSame('0 0 * * 0 *', (string) $event->getCronExpression());
    }

    /**
     * @test
     */
    function it_can_run_monthly()

It is generally recommended to explicitly declare the visibility for methods.

As per coding-style, this function should be in camelCase.

    {
        $event = new Event('php -i');
        $event->monthly();

        $this->assertSame('0 0 1 * * *', (string) $event->getCronExpression());
    }

    /**
     * @test
     */
    function it_can_run_quarterly()

It is generally recommended to explicitly declare the visibility for methods.

As per coding-style, this function should be in camelCase.

    {
        $event = new Event('php -i');
        $event->quarterly();

        $this->assertSame('0 0 1 */3 * *', (string) $event->getCronExpression());
    }

    /**
     * @test
     */
    function it_can_run_yearly()

It is generally recommended to explicitly declare the visibility for methods.

As per coding-style, this function should be in camelCase.

    {
        $event = new Event('php -i');
        $event->yearly();

        $this->assertSame('0 0 1 1 * *', (string) $event->getCronExpression());
    }

    /**
     * @test
     */
    function it_allows_for_filtering()

It is generally recommended to explicitly declare the visibility for methods.

As per coding-style, this function should be in camelCase.

    {
        $event = new Event('php -i');
        $event->everyMinute();

        $this->assertTrue($event->isDue());

        $event->skip(function () {
            return true;
        });

        $this->assertFalse($event->isDue());

        $event = new Event('php -i');
        $event->everyMinute();

        $this->assertTrue($event->isDue());

        $event->when(function () {
            return false;
        });

        $this->assertFalse($event->isDue());
    }

    /**
     * @group fix
     */
    function it_can_prevent_overlapping()

It is generally recommended to explicitly declare the visibility for methods.

As per coding-style, this function should be in camelCase.

    {
        $event = new Event('php -i');
        $event->preventOverlapping();

        preg_match('/\(touch \w*; php -i; rm \w*\); 1>> /dev/null 2>> /dev/null/', $event->compileCommand());
    }
}