kahlan / kahlan Goto Github PK

<?php
describe("My test", function () {

    before(function () {
        $this->things = [
            'thing:1',
            'thing:2',
            'thing:3',
        ];
    });

    describe("frontend test", function () {

        for ($this->things as $thing) {
            it("tests the thing {$thing} in frontend", function () use ($thing) {
                expect($thing)->toContain('thing:');
            });
        }

    });

    describe("backend test", function () {

        for ($this->things as $thing) {
            it("tests the thing {$thing} in backend", function () use ($thing) {
                expect($thing)->toContain('thing:');
            });
        }

    });

});
?>

<?php
use kahlan\plugin\Stub;

describe("Pinger", function() {
        beforeEach(function() {
            $this->describer = Stub::create(['class' => 'denzel\services\aws\InstanceDescriber']);
        });

        it("...", function() {
            expect(1)->toBe(1);
        });
});
?>

<?php
use denzel\services\aws\InstanceDescriber;
use kahlan\plugin\Stub;

describe("InstanceDescriber", function() {
    beforeEach(function() {
        $this->client = Stub::create(['class' => 'Aws\Ec2\Ec2Client']);
        $this->sut = new InstanceDescriber($this->client);
    });

    describe('getInstance()', function() {
        it("returns an instance", function() {
            expect(1)->toBe(1);
        });
    });
});
?>

<?php
namespace denzel\services\aws;

use Aws\Ec2\Ec2Client;

class InstanceDescriber {

    protected $_client;

    public function __construct(Ec2Client $client) {
        $this->_client = $client;
    }

    public function getInstance($id) {
        $results = $this->_client->describeInstances(['InstanceIds' => [$id]]);
        return $results['Reservations'][0]['Instances'][0];
    }
}
?>

<?php
namespace denzel\services\aws;

class Pinger {
    protected $_describer;

    public function __construct(InstanceDescriber $describer) {
        $this->_describer = $describer;
    }
    public function ping($instanceId) {
        return false; // TODO
    }
}
?>

Stub::on('Api\Models\AtmLog')->method('create', function($data=null, $whitelist=null) {
    return false;
});

class ApiLog extends \Spec\Helper\BaseModel {
}

<?php
class BaseModel extends \Phalcon\Mvc\Model {

  public static function find($parameters=null){
    return parent::find($parameters);
  }

  public static function findFirst($parameters=null){
    return parent::findFirst($parameters);
  }

  public function save($data=null, $whiteList=null){
    return parent::save($data, $whiteList);
  }

  public function create($data=null, $whiteList=null){
    return parent::create($data, $whiteList);
  }

  public function delete() {
    return parent::delete();
  }
}

if ($parameter->isOptional()) {
    if ($parameter->isDefaultValueAvailable()) {
        $default = var_export($parameter->getDefaultValue(), true);
    } else {
        $default = 'null';
    }
    $default = ' = ' . preg_replace('/\s+/', '', $default);
}

public function writeError($e)
{
    $this->log->errorln(sprintf(
        "FAILED\nReason: %s\nStacktrace:\n%s",
        $e->getMessage(), $e->getTraceAsString()
    ));
}

    describe('->writeError()', function () {

        it('must use message and stack trace of exception', function () {
            /** @var \Exception $e */
            $e = Stub::create(['extends' => '\Exception', 'layer' => true]);
            $this->firstCalled = false;
            Stub::on($e)->method('getMessage', function () {
                $this->firstCalled = true;
                return '';
            });
            $this->secondCalled = false;
            Stub::on($e)->method('getTraceAsString', function () {
                $this->secondCalled = true;
                return '';
            });
            $job = new ExampleCronJob();
            $job->writeError($e);
            expect($this->firstCalled)->toBe(true);
            expect($this->secondCalled)->toBe(true);
        });

    });

public function split($interval)
    {
        $startDate = $this->startDate;
        $interval = static::filterDateInterval($interval);
        do {
            $endDate = $startDate->add($interval);
            if ($endDate > $this->endDate) {
                $endDate = $this->endDate;
            }
            yield new static($startDate, $endDate);

            $startDate = $endDate;
        } while ($startDate < $this->endDate);
    }

it('looks like this', function () {
    expect($this->items)
        ->not->toBeNull()
        ->toBeA('array')
        ->toBeEmpty();
});

it('instead of this', function () {
    expect($this->items)->not->toBeNull();
    expect($this->items)->toBeA('array');
    expect($this->items)->toBeEmpty();
});

it('falls', function () {
    $pdf = new \mPDF();
});

    if ($this->bodyBackgroundColor) {
        $s .= 'q ' .$this->SetFColor($this->bodyBackgroundColor, true)."\n";
        if ($this->bodyBackgroundColor{}0==5) { // RGBa
            $s .= $this->SetAlpha($__KMONKEY__123($this->bodyBackgroundColor{4})/100, 'Normal', true, 'F')."\n";
        }
        else if ($this->bodyBackgroundColor{}0==6) {    // CMYKa
            $s .= $this->SetAlpha($__KMONKEY__124($this->bodyBackgroundColor{5})/100, 'Normal', true, 'F')."\n";
        }
        $s .= $__KMONKEY__125('%.3F %.3F %.3F %.3F re f Q', ($clx*_MPDFK), ($cly*_MPDFK),$clw*_MPDFK,$clh*_MPDFK)."\n";
    }

if ($this->bodyBackgroundColor{}0==5) { // RGBa

describe('example', function () {
    it('produces notice exception', function () {
        error_reporting(E_ALL ^ E_NOTICE ^ E_STRICT);
        $arr = [];
        expect($arr['some'])->toBe(2);
    });
});

class Foo
{
    public function __construct(Dependency $d)
    {
        $this->d = $d;
    }
}

class Dependency
{
       public function __construct($a, $b, $c) {}
}

// FooSpec.php
describe('Foo', function() {

    before(function() {
        $this->dependency = Stub::create(['class' => Dependency::class]);
        $this->foo = new Foo($this->dependency);
    });

});

describe('Dependency', function() {

    before(function() {
        $this->dependency = new Dependency(1, 2, 3);
    });

});

/* filename: spec/MonologStubbingSpec.php */
use kahlan\plugin\Stub;
describe('MonologStubbing', function () {
    it('has a dummy expectation', function () {
        $stubbed_logger = Stub::create(['class' => 'Monolog\Logger']);
        expect(true)->toBe(true);
    });
});

/* filename: spec/MonologUsingSpec.php */
describe('MonologUsing', function () {
    it('calls addRecord', function () {
        $logger = new Monolog\Logger('test');
        expect($logger)->toReceive('addRecord');
        $logger->addInfo('test message');
    });
});

class Error implements \API\Result
{

    ...

    public function __construct($code, $additional = [])
    {
        $this->code = $code;
        $this->status = self::getStatus($code);
        $this->description = self::getDescription($code);
        $this->additional = $additional;
    }

    ...

    public function writeHeaders()
    {
        http_response_code($this->status);
        if (!empty($this->headers)) {
            foreach ($this->headers as $name => $value) {
                header($name.': '.$value, true);
            }
        }
    }

    ...

}

    describe('new Result\Error(5)', function () {

        $err = new Error(5);

        it('must have code, status and description', function () use ($err) {
            expect($err->code)->not->toBeNull();
            expect($err->status)->not->toBeNull();
            expect($err->description)->not->toBeNull();
        });

        it('must have valid types of code, status and description',
            function () use ($err) {
                expect($err->code)->toBeA('int');
                expect($err->status)->toBeA('int');
                expect($err->description)->toBeA('string');
            }
        );

        it('must have empty additional parameters', function () use ($err) {
            expect($err->additional)->toBe([]);
        });

    });

    describe('->writeHeaders()', function () {

        $printedHeaders = ['Allowed' => ['old header']];
        $printedHttpStatus = null;
        $header =
            function ($str, $rpl = null, $code = null) use (&$printedHeaders) {
                $name = explode(':', $str)[0];
                if ($rpl) {
                    $printedHeaders[$name] = [$str];
                } else {
                    $printedHeaders[$name][] = $str;
                }
            };
        $http_response_code =
            function ($code) use (&$printedHttpStatus) {
                $printedHttpStatus = $code;
                return $code;
            };
        $err = (new Error(5))->setHeaders([
            'Allowed' => 'nothing',
            'SecondHeader' => 'some',
        ]);

        Monkey::patch('header', $header);
        Monkey::patch('http_response_code', $http_response_code);
        $err->writeHeaders();


        it('must set correct response status',
            function () use (
                $err, &$printedHttpStatus
            ) {
                expect($printedHttpStatus)
                    ->not->toBeNull()
                    ->toBe($err->status);
            }
        );

        it('must set headers correctly',
            function () use ($err, &$printedHeaders) {
                expect($printedHeaders)->toHaveLength(2);
                foreach ($err->headers as $name => $val) {
                    expect($printedHeaders[$name][0])->toBe($name.': '.$val);
                }
            }
        );

        it('must overwrite existing headers',
            function () use (&$printedHeaders) {
                expect($printedHeaders['Allowed'])->toHaveLength(1);
            }
        );

    });

    describe('->writeHeaders()', function () {

        $printedHeaders = ['Allowed' => ['old header']];
        $printedHttpStatus = null;
        $header =
            function ($str, $rpl = null, $code = null) use (&$printedHeaders) {
                $name = explode(':', $str)[0];
                if ($rpl) {
                    $printedHeaders[$name] = [$str];
                } else {
                    $printedHeaders[$name][] = $str;
                }
            };
        $http_response_code =
            function ($code) use (&$printedHttpStatus) {
                $printedHttpStatus = $code;
                return $code;
            };
        $err = (new Error(5))->setHeaders([
            'Allowed' => 'nothing',
            'SecondHeader' => 'some',
        ]);

        it('must set correct response status',
            function () use (
                $err, &$printedHttpStatus, $header, $http_response_code
            ) {
                Monkey::patch('header', $header);
                Monkey::patch('http_response_code', $http_response_code);
                $err->writeHeaders();
                expect($printedHttpStatus)
                    ->not->toBeNull()
                    ->toBe($err->status);
            }
        );

        it('must set headers correctly',
            function () use ($err, &$printedHeaders) {
                expect($printedHeaders)->toHaveLength(2);
                foreach ($err->headers as $name => $val) {
                    expect($printedHeaders[$name][0])->toBe($name.': '.$val);
                }
            }
        );

        it('must overwrite existing headers',
            function () use (&$printedHeaders) {
                expect($printedHeaders['Allowed'])->toHaveLength(1);
            }
        );

    });

$a = [1, 2, 3];
expect($a)->toBeA('array');
expect($a)->toContain(2)->toContain(3);

$a = [1, 2, 3];
expect($a)->to->be->a('array')->and->to->contain([2, 3]);

if ('ssl' == $hostinfo[2] $__KMONKEY__100 ('' == $hostinfo[2] and 'ssl' == $this->SMTPSecure)) {

if ('ssl' == $hostinfo[2] or ('' == $hostinfo[2] and 'ssl' == $this->SMTPSecure)) {

if ($qp_mode $__KMONKEY__117 ($__KMONKEY__118($word) > $length)) {

if ($qp_mode and (strlen($word) > $length)) {

it('has required key', function () {
    expect(['name' => 'John', 'email' => '[email protected]'])->toContainKey('name');
});

it('has required key', function () {
    expect(array_keys(['name' => 'John', 'email' => '[email protected]']))->toContain('name');
});

it('has required key', function () {
    $arr = ['name' => 'John', 'email' => '[email protected]'];
    expect(isset($arr['name']))->toBe(true);
});

    it('does not monkey patch curl', function () {
        $curl = curl_init('http://google.com');
        curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
        Monkey::patch('curl_exec', function ($ch) {
            return 'expected';
        });
        expect(curl_exec($curl))->toBe('expected');
    });

expect($some)->toBeAn('int');
expect($some)->toBeAn('array');

$x = array ( 'product' => null);
 // pass, the key exists
expect(array_key_exists('product', $x))->toBe(true);
// fails despite array key exists, despite array_key_exists() returns true
expect($x)->toContainKey('product');

use filter\Filter;

Filter::register('exclude.namespaces', function ($chain) {
    $defaults = ['VCR', 'Assert'];
    $excluded = $this->args()->get('exclude');
    $this->args()->set('exclude', array_unique(array_merge($excluded, $defaults)));
    return $chain->next();
});

Filter::apply($this, 'interceptor', 'exclude.namespaces');

if(($this->FontFamily == $family) AND ($this->FontStyle == $style) AND ($this->FontSizePt == $size) && !$forcewrite) {
    return $family;
}

if(($this->FontFamily == $family) $__KMONKEY__1174 ($this->FontStyle == $style) $__KMONKEY__1174 ($this->FontSizePt == $size) && !$forcewrite) {
    return $family;
}

$client = new Client();

if (!$client->save()) {
    throw new Exception("Some strange exception");
}

if ($client->age > 30) {
    $client->is_overaged = true;
    if (!$client->save()){
         throw new Exception("Some second strange exception");
    }
}

describe("Top level", function() {

    beforeEach(function() {
        $this->a = 10;
    });

    describe("Sub level", function() {

        before(function() {
              $this->b = 100;
        });    

        iit("should do something", function() {
             var_dump($this->a);
        });

    });

});

class AClass
{
         public function __construct($a) {}
}

describe('AClass', function() {

    before(function() {
        $this->object = new AClass();
    });

});

it("passes if $actual has the correct length", function() {
    expect('Hello World!')->toHaveLength(12);
    expect(['a', 'b', 'c'])->toHaveLength(3);
});

it("passes if $actual contain $expected", function() {
    expect([1, 2, 3])->toContain(3);
    expect('Hello World!')->toContain('World');
});

// Config
Filter::register("app.helpers", function() {
   $scope = $this->scope();

   $helper = new \My\Namespace\Helper();
   $scope->inject($helper);
});


// Spec
describe("My Spec", function() {
    before(function() {
        $this->helper->do_some_action();
    });
});