first commit

modules/psaddonsconnect/vendor/guzzlehttp/guzzle/tests/Event/AbstractEventTest.php

@@ -0,0 +1,14 @@
+<?php
+namespace GuzzleHttp\Tests\Event;
+
+class AbstractEventTest extends \PHPUnit_Framework_TestCase
+{
+    public function testStopsPropagation()
+    {
+        $e = $this->getMockBuilder('GuzzleHttp\Event\AbstractEvent')
+            ->getMockForAbstractClass();
+        $this->assertFalse($e->isPropagationStopped());
+        $e->stopPropagation();
+        $this->assertTrue($e->isPropagationStopped());
+    }
+}

modules/psaddonsconnect/vendor/guzzlehttp/guzzle/tests/Event/AbstractRequestEventTest.php

@@ -0,0 +1,33 @@
+<?php
+namespace GuzzleHttp\Tests\Event;
+
+use GuzzleHttp\Client;
+use GuzzleHttp\Transaction;
+use GuzzleHttp\Message\Request;
+
+/**
+ * @covers GuzzleHttp\Event\AbstractRequestEvent
+ */
+class AbstractRequestEventTest extends \PHPUnit_Framework_TestCase
+{
+    public function testHasTransactionMethods()
+    {
+        $t = new Transaction(new Client(), new Request('GET', '/'));
+        $e = $this->getMockBuilder('GuzzleHttp\Event\AbstractRequestEvent')
+            ->setConstructorArgs([$t])
+            ->getMockForAbstractClass();
+        $this->assertSame($t->client, $e->getClient());
+        $this->assertSame($t->request, $e->getRequest());
+    }
+
+    public function testHasTransaction()
+    {
+        $t = new Transaction(new Client(), new Request('GET', '/'));
+        $e = $this->getMockBuilder('GuzzleHttp\Event\AbstractRequestEvent')
+            ->setConstructorArgs([$t])
+            ->getMockForAbstractClass();
+        $r = new \ReflectionMethod($e, 'getTransaction');
+        $r->setAccessible(true);
+        $this->assertSame($t, $r->invoke($e));
+    }
+}

modules/psaddonsconnect/vendor/guzzlehttp/guzzle/tests/Event/AbstractRetryableEventTest.php

@@ -0,0 +1,37 @@
+<?php
+namespace GuzzleHttp\Tests\Event;
+
+use GuzzleHttp\Client;
+use GuzzleHttp\Transaction;
+use GuzzleHttp\Message\Request;
+
+/**
+ * @covers GuzzleHttp\Event\AbstractRetryableEvent
+ */
+class AbstractRetryableEventTest extends \PHPUnit_Framework_TestCase
+{
+    public function testCanRetry()
+    {
+        $t = new Transaction(new Client(), new Request('GET', '/'));
+        $t->transferInfo = ['foo' => 'bar'];
+        $e = $this->getMockBuilder('GuzzleHttp\Event\AbstractRetryableEvent')
+            ->setConstructorArgs([$t])
+            ->getMockForAbstractClass();
+        $e->retry();
+        $this->assertTrue($e->isPropagationStopped());
+        $this->assertEquals('retry', $t->state);
+    }
+
+    public function testCanRetryAfterDelay()
+    {
+        $t = new Transaction(new Client(), new Request('GET', '/'));
+        $t->transferInfo = ['foo' => 'bar'];
+        $e = $this->getMockBuilder('GuzzleHttp\Event\AbstractRetryableEvent')
+            ->setConstructorArgs([$t])
+            ->getMockForAbstractClass();
+        $e->retry(10);
+        $this->assertTrue($e->isPropagationStopped());
+        $this->assertEquals('retry', $t->state);
+        $this->assertEquals(10, $t->request->getConfig()->get('delay'));
+    }
+}

modules/psaddonsconnect/vendor/guzzlehttp/guzzle/tests/Event/AbstractTransferEventTest.php

@@ -0,0 +1,59 @@
+<?php
+namespace GuzzleHttp\Tests\Event;
+
+use GuzzleHttp\Client;
+use GuzzleHttp\Message\Response;
+use GuzzleHttp\Transaction;
+use GuzzleHttp\Message\Request;
+
+/**
+ * @covers GuzzleHttp\Event\AbstractTransferEvent
+ */
+class AbstractTransferEventTest extends \PHPUnit_Framework_TestCase
+{
+    public function testHasStats()
+    {
+        $t = new Transaction(new Client(), new Request('GET', '/'));
+        $t->transferInfo = ['foo' => 'bar'];
+        $e = $this->getMockBuilder('GuzzleHttp\Event\AbstractTransferEvent')
+            ->setConstructorArgs([$t])
+            ->getMockForAbstractClass();
+        $this->assertNull($e->getTransferInfo('baz'));
+        $this->assertEquals('bar', $e->getTransferInfo('foo'));
+        $this->assertEquals($t->transferInfo, $e->getTransferInfo());
+    }
+
+    public function testHasResponse()
+    {
+        $t = new Transaction(new Client(), new Request('GET', '/'));
+        $t->response = new Response(200);
+        $e = $this->getMockBuilder('GuzzleHttp\Event\AbstractTransferEvent')
+            ->setConstructorArgs([$t])
+            ->getMockForAbstractClass();
+        $this->assertTrue($e->hasResponse());
+        $this->assertSame($t->response, $e->getResponse());
+    }
+
+    public function testCanInterceptWithResponse()
+    {
+        $t = new Transaction(new Client(), new Request('GET', '/'));
+        $r = new Response(200);
+        $e = $this->getMockBuilder('GuzzleHttp\Event\AbstractTransferEvent')
+            ->setConstructorArgs([$t])
+            ->getMockForAbstractClass();
+        $e->intercept($r);
+        $this->assertSame($t->response, $r);
+        $this->assertSame($t->response, $e->getResponse());
+        $this->assertTrue($e->isPropagationStopped());
+    }
+
+    public function testReturnsNumberOfRetries()
+    {
+        $t = new Transaction(new Client(), new Request('GET', '/'));
+        $t->retries = 2;
+        $e = $this->getMockBuilder('GuzzleHttp\Event\AbstractTransferEvent')
+            ->setConstructorArgs([$t])
+            ->getMockForAbstractClass();
+        $this->assertEquals(2, $e->getRetryCount());
+    }
+}

modules/psaddonsconnect/vendor/guzzlehttp/guzzle/tests/Event/BeforeEventTest.php

@@ -0,0 +1,26 @@
+<?php
+namespace GuzzleHttp\Tests\Event;
+
+use GuzzleHttp\Transaction;
+use GuzzleHttp\Client;
+use GuzzleHttp\Event\BeforeEvent;
+use GuzzleHttp\Message\Request;
+use GuzzleHttp\Message\Response;
+
+/**
+ * @covers GuzzleHttp\Event\BeforeEvent
+ */
+class BeforeEventTest extends \PHPUnit_Framework_TestCase
+{
+    public function testInterceptsWithEvent()
+    {
+        $t = new Transaction(new Client(), new Request('GET', '/'));
+        $t->exception = new \Exception('foo');
+        $e = new BeforeEvent($t);
+        $response = new Response(200);
+        $e->intercept($response);
+        $this->assertTrue($e->isPropagationStopped());
+        $this->assertSame($t->response, $response);
+        $this->assertNull($t->exception);
+    }
+}

modules/psaddonsconnect/vendor/guzzlehttp/guzzle/tests/Event/EmitterTest.php

@@ -0,0 +1,363 @@
+<?php
+namespace GuzzleHttp\Tests\Event;
+
+use GuzzleHttp\Event\Emitter;
+use GuzzleHttp\Event\EventInterface;
+use GuzzleHttp\Event\SubscriberInterface;
+
+/**
+ * @link https://github.com/symfony/symfony/blob/master/src/Symfony/Component/EventDispatcher/Tests/EventDispatcherTest.php Based on this test.
+ */
+class EmitterTest extends \PHPUnit_Framework_TestCase
+{
+    /* Some pseudo events */
+    const preFoo = 'pre.foo';
+    const postFoo = 'post.foo';
+    const preBar = 'pre.bar';
+    const postBar = 'post.bar';
+
+    /** @var Emitter */
+    private $emitter;
+    private $listener;
+
+    protected function setUp()
+    {
+        $this->emitter = new Emitter();
+        $this->listener = new TestEventListener();
+    }
+
+    protected function tearDown()
+    {
+        $this->emitter = null;
+        $this->listener = null;
+    }
+
+    public function testInitialState()
+    {
+        $this->assertEquals(array(), $this->emitter->listeners());
+    }
+
+    public function testAddListener()
+    {
+        $this->emitter->on('pre.foo', array($this->listener, 'preFoo'));
+        $this->emitter->on('post.foo', array($this->listener, 'postFoo'));
+        $this->assertTrue($this->emitter->hasListeners(self::preFoo));
+        $this->assertTrue($this->emitter->hasListeners(self::preFoo));
+        $this->assertCount(1, $this->emitter->listeners(self::postFoo));
+        $this->assertCount(1, $this->emitter->listeners(self::postFoo));
+        $this->assertCount(2, $this->emitter->listeners());
+    }
+
+    public function testGetListenersSortsByPriority()
+    {
+        $listener1 = new TestEventListener();
+        $listener2 = new TestEventListener();
+        $listener3 = new TestEventListener();
+        $listener1->name = '1';
+        $listener2->name = '2';
+        $listener3->name = '3';
+
+        $this->emitter->on('pre.foo', array($listener1, 'preFoo'), -10);
+        $this->emitter->on('pre.foo', array($listener2, 'preFoo'), 10);
+        $this->emitter->on('pre.foo', array($listener3, 'preFoo'));
+
+        $expected = array(
+            array($listener2, 'preFoo'),
+            array($listener3, 'preFoo'),
+            array($listener1, 'preFoo'),
+        );
+
+        $this->assertSame($expected, $this->emitter->listeners('pre.foo'));
+    }
+
+    public function testGetAllListenersSortsByPriority()
+    {
+        $listener1 = new TestEventListener();
+        $listener2 = new TestEventListener();
+        $listener3 = new TestEventListener();
+        $listener4 = new TestEventListener();
+        $listener5 = new TestEventListener();
+        $listener6 = new TestEventListener();
+
+        $this->emitter->on('pre.foo', [$listener1, 'preFoo'], -10);
+        $this->emitter->on('pre.foo', [$listener2, 'preFoo']);
+        $this->emitter->on('pre.foo', [$listener3, 'preFoo'], 10);
+        $this->emitter->on('post.foo', [$listener4, 'preFoo'], -10);
+        $this->emitter->on('post.foo', [$listener5, 'preFoo']);
+        $this->emitter->on('post.foo', [$listener6, 'preFoo'], 10);
+
+        $expected = [
+            'pre.foo'  => [[$listener3, 'preFoo'], [$listener2, 'preFoo'], [$listener1, 'preFoo']],
+            'post.foo' => [[$listener6, 'preFoo'], [$listener5, 'preFoo'], [$listener4, 'preFoo']],
+        ];
+
+        $this->assertSame($expected, $this->emitter->listeners());
+    }
+
+    public function testDispatch()
+    {
+        $this->emitter->on('pre.foo', array($this->listener, 'preFoo'));
+        $this->emitter->on('post.foo', array($this->listener, 'postFoo'));
+        $this->emitter->emit(self::preFoo, $this->getEvent());
+        $this->assertTrue($this->listener->preFooInvoked);
+        $this->assertFalse($this->listener->postFooInvoked);
+        $this->assertInstanceOf('GuzzleHttp\Event\EventInterface', $this->emitter->emit(self::preFoo, $this->getEvent()));
+        $event = $this->getEvent();
+        $return = $this->emitter->emit(self::preFoo, $event);
+        $this->assertSame($event, $return);
+    }
+
+    public function testDispatchForClosure()
+    {
+        $invoked = 0;
+        $listener = function () use (&$invoked) {
+            $invoked++;
+        };
+        $this->emitter->on('pre.foo', $listener);
+        $this->emitter->on('post.foo', $listener);
+        $this->emitter->emit(self::preFoo, $this->getEvent());
+        $this->assertEquals(1, $invoked);
+    }
+
+    public function testStopEventPropagation()
+    {
+        $otherListener = new TestEventListener();
+
+        // postFoo() stops the propagation, so only one listener should
+        // be executed
+        // Manually set priority to enforce $this->listener to be called first
+        $this->emitter->on('post.foo', array($this->listener, 'postFoo'), 10);
+        $this->emitter->on('post.foo', array($otherListener, 'preFoo'));
+        $this->emitter->emit(self::postFoo, $this->getEvent());
+        $this->assertTrue($this->listener->postFooInvoked);
+        $this->assertFalse($otherListener->postFooInvoked);
+    }
+
+    public function testDispatchByPriority()
+    {
+        $invoked = array();
+        $listener1 = function () use (&$invoked) {
+            $invoked[] = '1';
+        };
+        $listener2 = function () use (&$invoked) {
+            $invoked[] = '2';
+        };
+        $listener3 = function () use (&$invoked) {
+            $invoked[] = '3';
+        };
+        $this->emitter->on('pre.foo', $listener1, -10);
+        $this->emitter->on('pre.foo', $listener2);
+        $this->emitter->on('pre.foo', $listener3, 10);
+        $this->emitter->emit(self::preFoo, $this->getEvent());
+        $this->assertEquals(array('3', '2', '1'), $invoked);
+    }
+
+    public function testRemoveListener()
+    {
+        $this->emitter->on('pre.bar', [$this->listener, 'preFoo']);
+        $this->assertNotEmpty($this->emitter->listeners(self::preBar));
+        $this->emitter->removeListener('pre.bar', [$this->listener, 'preFoo']);
+        $this->assertEmpty($this->emitter->listeners(self::preBar));
+        $this->emitter->removeListener('notExists', [$this->listener, 'preFoo']);
+    }
+
+    public function testAddSubscriber()
+    {
+        $eventSubscriber = new TestEventSubscriber();
+        $this->emitter->attach($eventSubscriber);
+        $this->assertNotEmpty($this->emitter->listeners(self::preFoo));
+        $this->assertNotEmpty($this->emitter->listeners(self::postFoo));
+    }
+
+    public function testAddSubscriberWithMultiple()
+    {
+        $eventSubscriber = new TestEventSubscriberWithMultiple();
+        $this->emitter->attach($eventSubscriber);
+        $listeners = $this->emitter->listeners('pre.foo');
+        $this->assertNotEmpty($this->emitter->listeners(self::preFoo));
+        $this->assertCount(2, $listeners);
+    }
+
+    public function testAddSubscriberWithPriorities()
+    {
+        $eventSubscriber = new TestEventSubscriber();
+        $this->emitter->attach($eventSubscriber);
+
+        $eventSubscriber = new TestEventSubscriberWithPriorities();
+        $this->emitter->attach($eventSubscriber);
+
+        $listeners = $this->emitter->listeners('pre.foo');
+        $this->assertNotEmpty($this->emitter->listeners(self::preFoo));
+        $this->assertCount(2, $listeners);
+        $this->assertInstanceOf('GuzzleHttp\Tests\Event\TestEventSubscriberWithPriorities', $listeners[0][0]);
+    }
+
+    public function testdetach()
+    {
+        $eventSubscriber = new TestEventSubscriber();
+        $this->emitter->attach($eventSubscriber);
+        $this->assertNotEmpty($this->emitter->listeners(self::preFoo));
+        $this->assertNotEmpty($this->emitter->listeners(self::postFoo));
+        $this->emitter->detach($eventSubscriber);
+        $this->assertEmpty($this->emitter->listeners(self::preFoo));
+        $this->assertEmpty($this->emitter->listeners(self::postFoo));
+    }
+
+    public function testdetachWithPriorities()
+    {
+        $eventSubscriber = new TestEventSubscriberWithPriorities();
+        $this->emitter->attach($eventSubscriber);
+        $this->assertNotEmpty($this->emitter->listeners(self::preFoo));
+        $this->assertNotEmpty($this->emitter->listeners(self::postFoo));
+        $this->emitter->detach($eventSubscriber);
+        $this->assertEmpty($this->emitter->listeners(self::preFoo));
+        $this->assertEmpty($this->emitter->listeners(self::postFoo));
+    }
+
+    public function testEventReceivesEventNameAsArgument()
+    {
+        $listener = new TestWithDispatcher();
+        $this->emitter->on('test', array($listener, 'foo'));
+        $this->assertNull($listener->name);
+        $this->emitter->emit('test', $this->getEvent());
+        $this->assertEquals('test', $listener->name);
+    }
+
+    /**
+     * @see https://bugs.php.net/bug.php?id=62976
+     *
+     * This bug affects:
+     *  - The PHP 5.3 branch for versions < 5.3.18
+     *  - The PHP 5.4 branch for versions < 5.4.8
+     *  - The PHP 5.5 branch is not affected
+     */
+    public function testWorkaroundForPhpBug62976()
+    {
+        $dispatcher = new Emitter();
+        $dispatcher->on('bug.62976', new CallableClass());
+        $dispatcher->removeListener('bug.62976', function () {});
+        $this->assertNotEmpty($dispatcher->listeners('bug.62976'));
+    }
+
+    public function testRegistersEventsOnce()
+    {
+        $this->emitter->once('pre.foo', array($this->listener, 'preFoo'));
+        $this->emitter->on('pre.foo', array($this->listener, 'preFoo'));
+        $this->assertCount(2, $this->emitter->listeners(self::preFoo));
+        $this->emitter->emit(self::preFoo, $this->getEvent());
+        $this->assertTrue($this->listener->preFooInvoked);
+        $this->assertCount(1, $this->emitter->listeners(self::preFoo));
+    }
+
+    public function testReturnsEmptyArrayForNonExistentEvent()
+    {
+        $this->assertEquals([], $this->emitter->listeners('doesnotexist'));
+    }
+
+    public function testCanAddFirstAndLastListeners()
+    {
+        $b = '';
+        $this->emitter->on('foo', function () use (&$b) { $b .= 'a'; }, 'first'); // 1
+        $this->emitter->on('foo', function () use (&$b) { $b .= 'b'; }, 'last');  // 0
+        $this->emitter->on('foo', function () use (&$b) { $b .= 'c'; }, 'first'); // 2
+        $this->emitter->on('foo', function () use (&$b) { $b .= 'd'; }, 'first'); // 3
+        $this->emitter->on('foo', function () use (&$b) { $b .= 'e'; }, 'first'); // 4
+        $this->emitter->on('foo', function () use (&$b) { $b .= 'f'; });          // 0
+        $this->emitter->emit('foo', $this->getEvent());
+        $this->assertEquals('edcabf', $b);
+    }
+
+    /**
+     * @return \GuzzleHttp\Event\EventInterface
+     */
+    private function getEvent()
+    {
+        return $this->getMockBuilder('GuzzleHttp\Event\AbstractEvent')
+            ->getMockForAbstractClass();
+    }
+}
+
+class CallableClass
+{
+    public function __invoke()
+    {
+    }
+}
+
+class TestEventListener
+{
+    public $preFooInvoked = false;
+    public $postFooInvoked = false;
+
+    /* Listener methods */
+
+    public function preFoo(EventInterface $e)
+    {
+        $this->preFooInvoked = true;
+    }
+
+    public function postFoo(EventInterface $e)
+    {
+        $this->postFooInvoked = true;
+
+        $e->stopPropagation();
+    }
+
+    /**
+     * @expectedException \PHPUnit_Framework_Error_Deprecated
+     */
+    public function testHasDeprecatedAddListener()
+    {
+        $emitter = new Emitter();
+        $emitter->addListener('foo', function () {});
+    }
+
+    /**
+     * @expectedException \PHPUnit_Framework_Error_Deprecated
+     */
+    public function testHasDeprecatedAddSubscriber()
+    {
+        $emitter = new Emitter();
+        $emitter->addSubscriber('foo', new TestEventSubscriber());
+    }
+}
+
+class TestWithDispatcher
+{
+    public $name;
+
+    public function foo(EventInterface $e, $name)
+    {
+        $this->name = $name;
+    }
+}
+
+class TestEventSubscriber extends TestEventListener implements SubscriberInterface
+{
+    public function getEvents()
+    {
+        return [
+            'pre.foo' => ['preFoo'],
+            'post.foo' => ['postFoo']
+        ];
+    }
+}
+
+class TestEventSubscriberWithPriorities extends TestEventListener implements SubscriberInterface
+{
+    public function getEvents()
+    {
+        return [
+            'pre.foo' => ['preFoo', 10],
+            'post.foo' => ['postFoo']
+        ];
+    }
+}
+
+class TestEventSubscriberWithMultiple extends TestEventListener implements SubscriberInterface
+{
+    public function getEvents()
+    {
+        return ['pre.foo' => [['preFoo', 10],['preFoo', 20]]];
+    }
+}

modules/psaddonsconnect/vendor/guzzlehttp/guzzle/tests/Event/ErrorEventTest.php

@@ -0,0 +1,23 @@
+<?php
+namespace GuzzleHttp\Tests\Event;
+
+use GuzzleHttp\Transaction;
+use GuzzleHttp\Client;
+use GuzzleHttp\Event\ErrorEvent;
+use GuzzleHttp\Exception\RequestException;
+use GuzzleHttp\Message\Request;
+
+/**
+ * @covers GuzzleHttp\Event\ErrorEvent
+ */
+class ErrorEventTest extends \PHPUnit_Framework_TestCase
+{
+    public function testInterceptsWithEvent()
+    {
+        $t = new Transaction(new Client(), new Request('GET', '/'));
+        $except = new RequestException('foo', $t->request);
+        $t->exception = $except;
+        $e = new ErrorEvent($t);
+        $this->assertSame($e->getException(), $t->exception);
+    }
+}

modules/psaddonsconnect/vendor/guzzlehttp/guzzle/tests/Event/HasEmitterTraitTest.php

@@ -0,0 +1,27 @@
+<?php
+namespace GuzzleHttp\Tests\Event;
+
+use GuzzleHttp\Event\HasEmitterInterface;
+use GuzzleHttp\Event\HasEmitterTrait;
+
+class AbstractHasEmitter implements HasEmitterInterface
+{
+    use HasEmitterTrait;
+}
+
+/**
+ * @covers GuzzleHttp\Event\HasEmitterTrait
+ */
+class HasEmitterTraitTest extends \PHPUnit_Framework_TestCase
+{
+    public function testHelperAttachesSubscribers()
+    {
+        $mock = $this->getMockBuilder('GuzzleHttp\Tests\Event\AbstractHasEmitter')
+            ->getMockForAbstractClass();
+
+        $result = $mock->getEmitter();
+        $this->assertInstanceOf('GuzzleHttp\Event\EmitterInterface', $result);
+        $result2 = $mock->getEmitter();
+        $this->assertSame($result, $result2);
+    }
+}

modules/psaddonsconnect/vendor/guzzlehttp/guzzle/tests/Event/ListenerAttacherTraitTest.php

@@ -0,0 +1,92 @@
+<?php
+namespace GuzzleHttp\Tests\Event;
+
+use GuzzleHttp\Event\HasEmitterInterface;
+use GuzzleHttp\Event\HasEmitterTrait;
+use GuzzleHttp\Event\ListenerAttacherTrait;
+
+class ObjectWithEvents implements HasEmitterInterface
+{
+    use HasEmitterTrait, ListenerAttacherTrait;
+
+    public $listeners = [];
+
+    public function __construct(array $args = [])
+    {
+        $this->listeners = $this->prepareListeners($args, ['foo', 'bar']);
+        $this->attachListeners($this, $this->listeners);
+    }
+}
+
+class ListenerAttacherTraitTest extends \PHPUnit_Framework_TestCase
+{
+    public function testRegistersEvents()
+    {
+        $fn = function () {};
+        $o = new ObjectWithEvents([
+            'foo' => $fn,
+            'bar' => $fn,
+        ]);
+
+        $this->assertEquals([
+            ['name' => 'foo', 'fn' => $fn, 'priority' => 0, 'once' => false],
+            ['name' => 'bar', 'fn' => $fn, 'priority' => 0, 'once' => false],
+        ], $o->listeners);
+
+        $this->assertCount(1, $o->getEmitter()->listeners('foo'));
+        $this->assertCount(1, $o->getEmitter()->listeners('bar'));
+    }
+
+    public function testRegistersEventsWithPriorities()
+    {
+        $fn = function () {};
+        $o = new ObjectWithEvents([
+            'foo' => ['fn' => $fn, 'priority' => 99, 'once' => true],
+            'bar' => ['fn' => $fn, 'priority' => 50],
+        ]);
+
+        $this->assertEquals([
+            ['name' => 'foo', 'fn' => $fn, 'priority' => 99, 'once' => true],
+            ['name' => 'bar', 'fn' => $fn, 'priority' => 50, 'once' => false],
+        ], $o->listeners);
+    }
+
+    public function testRegistersMultipleEvents()
+    {
+        $fn = function () {};
+        $eventArray = [['fn' => $fn], ['fn' => $fn]];
+        $o = new ObjectWithEvents([
+            'foo' => $eventArray,
+            'bar' => $eventArray,
+        ]);
+
+        $this->assertEquals([
+            ['name' => 'foo', 'fn' => $fn, 'priority' => 0, 'once' => false],
+            ['name' => 'foo', 'fn' => $fn, 'priority' => 0, 'once' => false],
+            ['name' => 'bar', 'fn' => $fn, 'priority' => 0, 'once' => false],
+            ['name' => 'bar', 'fn' => $fn, 'priority' => 0, 'once' => false],
+        ], $o->listeners);
+
+        $this->assertCount(2, $o->getEmitter()->listeners('foo'));
+        $this->assertCount(2, $o->getEmitter()->listeners('bar'));
+    }
+
+    public function testRegistersEventsWithOnce()
+    {
+        $called = 0;
+        $fn = function () use (&$called) { $called++; };
+        $o = new ObjectWithEvents(['foo' => ['fn' => $fn, 'once' => true]]);
+        $ev = $this->getMock('GuzzleHttp\Event\EventInterface');
+        $o->getEmitter()->emit('foo', $ev);
+        $o->getEmitter()->emit('foo', $ev);
+        $this->assertEquals(1, $called);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testValidatesEvents()
+    {
+        new ObjectWithEvents(['foo' => 'bar']);
+    }
+}

modules/psaddonsconnect/vendor/guzzlehttp/guzzle/tests/Event/ProgressEventTest.php

@@ -0,0 +1,25 @@
+<?php
+namespace GuzzleHttp\Tests\Event;
+
+use GuzzleHttp\Client;
+use GuzzleHttp\Event\ProgressEvent;
+use GuzzleHttp\Message\Request;
+use GuzzleHttp\Transaction;
+
+/**
+ * @covers GuzzleHttp\Event\ProgressEvent
+ */
+class ProgressEventTest extends \PHPUnit_Framework_TestCase
+{
+    public function testContainsNumbers()
+    {
+        $t = new Transaction(new Client(), new Request('GET', 'http://a.com'));
+        $p = new ProgressEvent($t, 2, 1, 3, 0);
+        $this->assertSame($t->request, $p->getRequest());
+        $this->assertSame($t->client, $p->getClient());
+        $this->assertEquals(2, $p->downloadSize);
+        $this->assertEquals(1, $p->downloaded);
+        $this->assertEquals(3, $p->uploadSize);
+        $this->assertEquals(0, $p->uploaded);
+    }
+}

modules/psaddonsconnect/vendor/guzzlehttp/guzzle/tests/Event/RequestEventsTest.php

@@ -0,0 +1,74 @@
+<?php
+namespace GuzzleHttp\Tests\Event;
+
+use GuzzleHttp\Event\RequestEvents;
+
+/**
+ * @covers GuzzleHttp\Event\RequestEvents
+ */
+class RequestEventsTest extends \PHPUnit_Framework_TestCase
+{
+    public function prepareEventProvider()
+    {
+        $cb = function () {};
+
+        return [
+            [[], ['complete'], $cb, ['complete' => [$cb]]],
+            [
+                ['complete' => $cb],
+                ['complete'],
+                $cb,
+                ['complete' => [$cb, $cb]]
+            ],
+            [
+                ['prepare' => []],
+                ['error', 'foo'],
+                $cb,
+                [
+                    'prepare' => [],
+                    'error'   => [$cb],
+                    'foo'     => [$cb]
+                ]
+            ],
+            [
+                ['prepare' => []],
+                ['prepare'],
+                $cb,
+                [
+                    'prepare' => [$cb]
+                ]
+            ],
+            [
+                ['prepare' => ['fn' => $cb]],
+                ['prepare'], $cb,
+                [
+                    'prepare' => [
+                        ['fn' => $cb],
+                        $cb
+                    ]
+                ]
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider prepareEventProvider
+     */
+    public function testConvertsEventArrays(
+        array $in,
+        array $events,
+        $add,
+        array $out
+    ) {
+        $result = RequestEvents::convertEventArray($in, $events, $add);
+        $this->assertEquals($out, $result);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testValidatesEventFormat()
+    {
+        RequestEvents::convertEventArray(['foo' => false], ['foo'], []);
+    }
+}