vendor and env first commit

vendor/akaunting/laravel-setting/tests/functional/AbstractFunctionalTest.php

@@ -0,0 +1,118 @@
+<?php
+
+use Akaunting\Setting\Drivers\Database;
+
+abstract class AbstractFunctionalTest extends PHPUnit_Framework_TestCase
+{
+    abstract protected function createStore(array $data = []);
+
+    protected function assertStoreEquals($store, $expected, $message = null)
+    {
+        $this->assertEquals($expected, $store->all(), $message);
+        $store->save();
+        $store = $this->createStore();
+        $this->assertEquals($expected, $store->all(), $message);
+    }
+
+    protected function assertStoreKeyEquals($store, $key, $expected, $message = null)
+    {
+        $this->assertEquals($expected, $store->get($key), $message);
+        $store->save();
+        $store = $this->createStore();
+        $this->assertEquals($expected, $store->get($key), $message);
+    }
+
+    /** @test */
+    public function store_is_initially_empty()
+    {
+        $store = $this->createStore();
+        $this->assertEquals([], $store->all());
+    }
+
+    /** @test */
+    public function written_changes_are_saved()
+    {
+        $store = $this->createStore();
+        $store->set('foo', 'bar');
+        $this->assertStoreKeyEquals($store, 'foo', 'bar');
+    }
+
+    /** @test */
+    public function nested_keys_are_nested()
+    {
+        $store = $this->createStore();
+        $store->set('foo.bar', 'baz');
+        $this->assertStoreEquals($store, ['foo' => ['bar' => 'baz']]);
+    }
+
+    /** @test */
+    public function cannot_set_nested_key_on_non_array_member()
+    {
+        $store = $this->createStore();
+        $store->set('foo', 'bar');
+        $this->setExpectedException('UnexpectedValueException', 'Non-array segment encountered');
+        $store->set('foo.bar', 'baz');
+    }
+
+    /** @test */
+    public function can_forget_key()
+    {
+        $store = $this->createStore();
+        $store->set('foo', 'bar');
+        $store->set('bar', 'baz');
+        $this->assertStoreEquals($store, ['foo' => 'bar', 'bar' => 'baz']);
+
+        $store->forget('foo');
+        $this->assertStoreEquals($store, ['bar' => 'baz']);
+    }
+
+    /** @test */
+    public function can_forget_nested_key()
+    {
+        $store = $this->createStore();
+        $store->set('foo.bar', 'baz');
+        $store->set('foo.baz', 'bar');
+        $store->set('bar.foo', 'baz');
+        $this->assertStoreEquals($store, [
+            'foo' => [
+                'bar' => 'baz',
+                'baz' => 'bar',
+            ],
+            'bar' => [
+                'foo' => 'baz',
+            ],
+        ]);
+
+        $store->forget('foo.bar');
+        $this->assertStoreEquals($store, [
+            'foo' => [
+                'baz' => 'bar',
+            ],
+            'bar' => [
+                'foo' => 'baz',
+            ],
+        ]);
+
+        $store->forget('bar.foo');
+        $expected = [
+            'foo' => [
+                'baz' => 'bar',
+            ],
+            'bar' => [
+            ],
+        ];
+        if ($store instanceof Database) {
+            unset($expected['bar']);
+        }
+        $this->assertStoreEquals($store, $expected);
+    }
+
+    /** @test */
+    public function can_forget_all()
+    {
+        $store = $this->createStore(['foo' => 'bar']);
+        $this->assertStoreEquals($store, ['foo' => 'bar']);
+        $store->forgetAll();
+        $this->assertStoreEquals($store, []);
+    }
+}

vendor/akaunting/laravel-setting/tests/functional/DatabaseTest.php

@@ -0,0 +1,43 @@
+<?php
+
+class DatabaseTest extends AbstractFunctionalTest
+{
+    public function setUp()
+    {
+        $this->container = new \Illuminate\Container\Container();
+        $this->capsule = new \Illuminate\Database\Capsule\Manager($this->container);
+        $this->capsule->setAsGlobal();
+        $this->container['db'] = $this->capsule;
+        $this->capsule->addConnection([
+            'driver'   => 'sqlite',
+            'database' => ':memory:',
+            'prefix'   => '',
+        ]);
+
+        $this->capsule->schema()->create('settings', function ($t) {
+            $t->string('key', 64)->unique();
+            $t->string('value', 4096);
+        });
+    }
+
+    public function tearDown()
+    {
+        $this->capsule->schema()->drop('settings');
+        unset($this->capsule);
+        unset($this->container);
+    }
+
+    protected function createStore(array $data = [])
+    {
+        if ($data) {
+            $store = $this->createStore();
+            $store->set($data);
+            $store->save();
+            unset($store);
+        }
+
+        return new \Akaunting\Setting\Drivers\Database(
+            $this->capsule->getConnection()
+        );
+    }
+}

vendor/akaunting/laravel-setting/tests/functional/JsonTest.php

@@ -0,0 +1,30 @@
+<?php
+
+class JsonTest extends AbstractFunctionalTest
+{
+    protected function createStore(array $data = null)
+    {
+        $path = dirname(__DIR__) . '/tmp/store.json';
+
+        if ($data !== null) {
+            if ($data) {
+                $json = json_encode($data);
+            } else {
+                $json = '{}';
+            }
+
+            file_put_contents($path, $json);
+        }
+
+        return new \Akaunting\Setting\Drivers\Json(
+            new \Illuminate\Filesystem\Filesystem(),
+            $path
+        );
+    }
+
+    public function tearDown()
+    {
+        $path = dirname(__DIR__) . '/tmp/store.json';
+        unlink($path);
+    }
+}

vendor/akaunting/laravel-setting/tests/functional/MemoryTest.php

@@ -0,0 +1,21 @@
+<?php
+
+class MemoryTest extends AbstractFunctionalTest
+{
+    protected function assertStoreEquals($store, $expected, $message = null)
+    {
+        $this->assertEquals($expected, $store->all(), $message);
+        // removed persistance test assertions
+    }
+
+    protected function assertStoreKeyEquals($store, $key, $expected, $message = null)
+    {
+        $this->assertEquals($expected, $store->get($key), $message);
+        // removed persistance test assertions
+    }
+
+    protected function createStore(array $data = null)
+    {
+        return new \Akaunting\Setting\Drivers\Memory($data);
+    }
+}

vendor/akaunting/laravel-setting/tests/unit/ArrayUtilTest.php

@@ -0,0 +1,132 @@
+<?php
+
+use Akaunting\Setting\Support\Arr;
+
+class ArrayUtilityTest extends PHPUnit_Framework_TestCase
+{
+    /**
+     * @test
+     * @dataProvider getGetData
+     */
+    public function getReturnsCorrectValue(array $data, $key, $expected)
+    {
+        $this->assertEquals($expected, Arr::get($data, $key));
+    }
+
+    public function getGetData()
+    {
+        return [
+            [[], 'foo', null],
+            [['foo' => 'bar'], 'foo', 'bar'],
+            [['foo' => 'bar'], 'bar', null],
+            [['foo' => 'bar'], 'foo.bar', null],
+            [['foo' => ['bar' => 'baz']], 'foo.bar', 'baz'],
+            [['foo' => ['bar' => 'baz']], 'foo.baz', null],
+            [['foo' => ['bar' => 'baz']], 'foo', ['bar' => 'baz']],
+            [
+                ['foo' => 'bar', 'bar' => 'baz'],
+                ['foo', 'bar'],
+                ['foo' => 'bar', 'bar' => 'baz'],
+            ],
+            [
+                ['foo' => ['bar' => 'baz'], 'bar' => 'baz'],
+                ['foo.bar', 'bar'],
+                ['foo' => ['bar' => 'baz'], 'bar' => 'baz'],
+            ],
+            [
+                ['foo' => ['bar' => 'baz'], 'bar' => 'baz'],
+                ['foo.bar'],
+                ['foo' => ['bar' => 'baz']],
+            ],
+            [
+                ['foo' => ['bar' => 'baz'], 'bar' => 'baz'],
+                ['foo.bar', 'baz'],
+                ['foo' => ['bar' => 'baz'], 'baz' => null],
+            ],
+        ];
+    }
+
+    /**
+     * @test
+     * @dataProvider getSetData
+     */
+    public function setSetsCorrectKeyToValue(array $input, $key, $value, array $expected)
+    {
+        Arr::set($input, $key, $value);
+        $this->assertEquals($expected, $input);
+    }
+
+    public function getSetData()
+    {
+        return [
+            [
+                ['foo' => 'bar'],
+                'foo',
+                'baz',
+                ['foo' => 'baz'],
+            ],
+            [
+                [],
+                'foo',
+                'bar',
+                ['foo' => 'bar'],
+            ],
+            [
+                [],
+                'foo.bar',
+                'baz',
+                ['foo' => ['bar' => 'baz']],
+            ],
+            [
+                ['foo' => ['bar' => 'baz']],
+                'foo.baz',
+                'foo',
+                ['foo' => ['bar' => 'baz', 'baz' => 'foo']],
+            ],
+            [
+                ['foo' => ['bar' => 'baz']],
+                'foo.baz.bar',
+                'baz',
+                ['foo' => ['bar' => 'baz', 'baz' => ['bar' => 'baz']]],
+            ],
+            [
+                [],
+                'foo.bar.baz',
+                'foo',
+                ['foo' => ['bar' => ['baz' => 'foo']]],
+            ],
+        ];
+    }
+
+    /** @test */
+    public function setThrowsExceptionOnNonArraySegment()
+    {
+        $data = ['foo' => 'bar'];
+        $this->setExpectedException('UnexpectedValueException', 'Non-array segment encountered');
+        Arr::set($data, 'foo.bar', 'baz');
+    }
+
+    /**
+     * @test
+     * @dataProvider getHasData
+     */
+    public function hasReturnsCorrectly(array $input, $key, $expected)
+    {
+        $this->assertEquals($expected, Arr::has($input, $key));
+    }
+
+    public function getHasData()
+    {
+        return [
+            [[], 'foo', false],
+            [['foo' => 'bar'], 'foo', true],
+            [['foo' => 'bar'], 'bar', false],
+            [['foo' => 'bar'], 'foo.bar', false],
+            [['foo' => ['bar' => 'baz']], 'foo.bar', true],
+            [['foo' => ['bar' => 'baz']], 'foo.baz', false],
+            [['foo' => ['bar' => 'baz']], 'foo', true],
+            [['foo' => null], 'foo', true],
+            [['foo' => ['bar' => null]], 'foo.bar', true],
+        ];
+    }
+}

vendor/akaunting/laravel-setting/tests/unit/DatabaseDriverTest.php

@@ -0,0 +1,107 @@
+<?php
+
+use Mockery as m;
+
+class DatabaseDriverTest extends PHPUnit_Framework_TestCase
+{
+    public function tearDown()
+    {
+        m::close();
+    }
+
+    /** @test */
+    public function correct_data_is_inserted_and_updated()
+    {
+        $connection = $this->mockConnection();
+        $query = $this->mockQuery($connection);
+
+        $query->shouldReceive('get')->once()->andReturn([
+            ['key' => 'nest.one', 'value' => 'old'],
+        ]);
+        $query->shouldReceive('lists')->atMost(1)->andReturn(['nest.one']);
+        $query->shouldReceive('pluck')->atMost(1)->andReturn(['nest.one']);
+        $dbData = $this->getDbData();
+        unset($dbData[1]); // remove the nest.one array member
+        $query->shouldReceive('where')->with('key', '=', 'nest.one')->andReturn(m::self())->getMock()
+            ->shouldReceive('update')->with(['value' => 'nestone']);
+        $self = $this; // 5.3 compatibility
+        $query->shouldReceive('insert')->once()->andReturnUsing(function ($arg) use ($dbData, $self) {
+            $self->assertEquals(count($dbData), count($arg));
+            foreach ($dbData as $key => $value) {
+                $self->assertContains($value, $arg);
+            }
+        });
+
+        $store = $this->makeStore($connection);
+        $store->set('foo', 'bar');
+        $store->set('nest.one', 'nestone');
+        $store->set('nest.two', 'nesttwo');
+        $store->set('array', ['one', 'two']);
+        $store->save();
+    }
+
+    /** @test */
+    public function extra_columns_are_queried()
+    {
+        $connection = $this->mockConnection();
+        $query = $this->mockQuery($connection);
+        $query->shouldReceive('where')->once()->with('foo', '=', 'bar')
+            ->andReturn(m::self())->getMock()
+            ->shouldReceive('get')->once()->andReturn([
+                ['key' => 'foo', 'value' => 'bar'],
+            ]);
+
+        $store = $this->makeStore($connection);
+        $store->setExtraColumns(['foo' => 'bar']);
+        $this->assertEquals('bar', $store->get('foo'));
+    }
+
+    /** @test */
+    public function extra_columns_are_inserted()
+    {
+        $connection = $this->mockConnection();
+        $query = $this->mockQuery($connection);
+        $query->shouldReceive('where')->times(2)->with('extracol', '=', 'extradata')
+            ->andReturn(m::self());
+        $query->shouldReceive('get')->once()->andReturn([]);
+        $query->shouldReceive('lists')->atMost(1)->andReturn([]);
+        $query->shouldReceive('pluck')->atMost(1)->andReturn([]);
+        $query->shouldReceive('insert')->once()->with([
+            ['key' => 'foo', 'value' => 'bar', 'extracol' => 'extradata'],
+        ]);
+
+        $store = $this->makeStore($connection);
+        $store->setExtraColumns(['extracol' => 'extradata']);
+        $store->set('foo', 'bar');
+        $store->save();
+    }
+
+    protected function getDbData()
+    {
+        return [
+            ['key' => 'foo', 'value' => 'bar'],
+            ['key' => 'nest.one', 'value' => 'nestone'],
+            ['key' => 'nest.two', 'value' => 'nesttwo'],
+            ['key' => 'array.0', 'value' => 'one'],
+            ['key' => 'array.1', 'value' => 'two'],
+        ];
+    }
+
+    protected function mockConnection()
+    {
+        return m::mock('Illuminate\Database\Connection');
+    }
+
+    protected function mockQuery($connection)
+    {
+        $query = m::mock('Illuminate\Database\Query\Builder');
+        $connection->shouldReceive('table')->andReturn($query);
+
+        return $query;
+    }
+
+    protected function makeStore($connection)
+    {
+        return new Akaunting\Setting\Drivers\Database($connection);
+    }
+}

vendor/akaunting/laravel-setting/tests/unit/HelperTest.php

@@ -0,0 +1,51 @@
+<?php
+
+use Illuminate\Container\Container;
+use Mockery as m;
+
+class HelperTest extends PHPUnit_Framework_TestCase
+{
+    public static $functions;
+
+    public function setUp()
+    {
+        self::$functions = m::mock();
+
+        Container::setInstance(new Container());
+
+        $store = m::mock('Akaunting\Setting\Contracts\Driver');
+
+        app()->bind('setting', function () use ($store) {
+            return $store;
+        });
+    }
+
+    /** @test */
+    public function helper_without_parameters_returns_store()
+    {
+        $this->assertInstanceOf('Akaunting\Setting\Contracts\Driver', setting());
+    }
+
+    /** @test */
+    public function single_parameter_get_a_key_from_store()
+    {
+        app('setting')->shouldReceive('get')->with('foo', null)->once();
+
+        setting('foo');
+    }
+
+    public function two_parameters_return_a_default_value()
+    {
+        app('setting')->shouldReceive('get')->with('foo', 'bar')->once();
+
+        setting('foo', 'bar');
+    }
+
+    /** @test */
+    public function array_parameter_call_set_method_into_store()
+    {
+        app('setting')->shouldReceive('set')->with(['foo', 'bar'])->once();
+
+        setting(['foo', 'bar']);
+    }
+}

vendor/akaunting/laravel-setting/tests/unit/JsonDriverTest.php

@@ -0,0 +1,60 @@
+<?php
+
+use Mockery as m;
+
+class JsonDriverTest extends PHPUnit_Framework_TestCase
+{
+    public function tearDown()
+    {
+        m::close();
+    }
+
+    protected function mockFilesystem()
+    {
+        return m::mock('Illuminate\Filesystem\Filesystem');
+    }
+
+    protected function makeStore($files, $path = 'fakepath')
+    {
+        return new Akaunting\Setting\Drivers\Json($files, $path);
+    }
+
+    /**
+     * @test
+     * @expectedException InvalidArgumentException
+     */
+    public function throws_exception_when_file_not_writeable()
+    {
+        $files = $this->mockFilesystem();
+        $files->shouldReceive('exists')->once()->with('fakepath')->andReturn(true);
+        $files->shouldReceive('isWritable')->once()->with('fakepath')->andReturn(false);
+        $store = $this->makeStore($files);
+    }
+
+    /**
+     * @test
+     * @expectedException InvalidArgumentException
+     */
+    public function throws_exception_when_files_put_fails()
+    {
+        $files = $this->mockFilesystem();
+        $files->shouldReceive('exists')->once()->with('fakepath')->andReturn(false);
+        $files->shouldReceive('put')->once()->with('fakepath', '{}')->andReturn(false);
+        $store = $this->makeStore($files);
+    }
+
+    /**
+     * @test
+     * @expectedException RuntimeException
+     */
+    public function throws_exception_when_file_contains_invalid_json()
+    {
+        $files = $this->mockFilesystem();
+        $files->shouldReceive('exists')->once()->with('fakepath')->andReturn(true);
+        $files->shouldReceive('isWritable')->once()->with('fakepath')->andReturn(true);
+        $files->shouldReceive('get')->once()->with('fakepath')->andReturn('[[!1!11]');
+
+        $store = $this->makeStore($files);
+        $store->get('foo');
+    }
+}