NewsletterTest::it_exposes_the_api() - Code Metrics - Inspection of "Feature mailjet driver (#1)" - dansmaculotte/laravel-newsletter - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 6f1f11...46af25 )

by Gaël
created 2019-11-21 13:05 UTC
NewsletterTest::it_exposes_the_api() A

↳ Parent: NewsletterTest
Complexity

Conditions	1
Paths	1
Size

Total Lines
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
dl	0
loc	6
c	0
b	0
f	0
rs	10
cc	1
nc	1
nop	0
<?php

namespace DansMaCulotte\Newsletter\Test\Mailjet;

use Mailjet\Client;
use Mailjet\Resources;
use Mailjet\Response;
use Mockery;
use Mockery\Mock;
use PHPUnit\Framework\TestCase;
use DansMaCulotte\Newsletter\Drivers\MailjetDriver;
use DansMaCulotte\Newsletter\Exceptions\ApiError;
use DansMaCulotte\Newsletter\Newsletter;

class NewsletterTest extends TestCase
{
    /** @var MailjetDriver */
    protected $driver;

    /** @var Mockery\Mock */
    protected $client;

    /** @var \DansMaCulotte\Newsletter\Newsletter */
    protected $newsletter;

    /** @var Mock */
    protected $response;


    public function setUp() : void
    {
        $this->client = Mockery::mock(Client::class);

        $this->driver = new MailjetDriver([
            'key' => 'apikey',
            'secret' => 'apisecret',
        ], [
            'lists' => [
                'list1' => ['id' => 123],
                'list2' => ['id' => 456],
            ],
            'defaultList' => 'list1',
        ]);

        $this->driver->client = $this->client;



        $this->response = Mockery::mock(Response::class);
        $this->response->shouldReceive('getData')->andReturn([]);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $this->response->shouldReceive('getReasonPhrase')->andReturn('Error');
        $this->response->shouldReceive('getStatus')->andReturn('400');

        $this->newsletter = new Newsletter($this->driver);
    }

    public function tearDown() : void
    {
        parent::tearDown();

        if ($container = Mockery::getContainer()) {
            $this->addToAssertionCount($container->mockery_getExpectationCount());
        }

        Mockery::close();
    }

    /** @test */
    public function it_can_subscribe_someone()

    {
        $this->response->shouldReceive('success')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $this->client->shouldReceive('post')->withArgs([
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            Resources::$ContactslistManagecontact,[
                'id' => '123',
                'body' => [
                    'Email' => "[email protected]",
                    'Action' => "addnoforce",
                    'Name' => 'Martin',
                ]
            ]

        ])->andReturn($this->response);

        $this->newsletter->subscribe('[email protected]', ['Name' => 'Martin']);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
    }

    /** @test */
    public function it_can_subscribe_or_update_someone()

    {
        $this->response->shouldReceive('success')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $this->client->shouldReceive('post')->withArgs([
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            Resources::$ContactslistManagecontact,[
                'id' => '123',
                'body' => [
                    'Email' => "[email protected]",
                    'Action' => "addnoforce",
                    'Name' => 'Martin',
                ]
            ]

        ])->andReturn($this->response);

        $this->newsletter->subscribeOrUpdate('[email protected]', ['Name' => 'Martin']);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
    }

    /** @test */
    public function it_will_trow_an_exception_when_subscribe_with_an_invalid_email()
    {
        $this->response->shouldReceive('success')->andReturn(false);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $this->client->shouldReceive('post')->withArgs([
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            Resources::$ContactslistManagecontact,[
                'id' => '123',
                'body' => [
                    'Email' => "testtest.fr",
                    'Action' => "addnoforce",
                    'Name' => 'Martin',
                ]
            ]
        ])->andReturn($this->response);

        $this->expectExceptionObject(ApiError::responseError('Error', 'mailjet', 400));
        $this->newsletter->subscribe('testtest.fr', ['Name' => 'Martin']);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
    }

    /** @test */
    public function it_can_get_the_list_members()
    {
        $this->response->shouldReceive('success')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $this->client->shouldReceive('get')->withArgs([
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            Resources::$Contact,
            [
                'ContactsList' => "123"
            ]
        ])->andReturn($this->response);

        $this->newsletter->getMembers();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
    }

    /** @test */
    public function it_will_trow_an_exceptions_when_get_members()

    {
        $this->response->shouldReceive('success')->andReturn(false);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $this->client->shouldReceive('get')->withArgs([
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            Resources::$Contact,
            [
                'ContactsList' => "123"
            ]
        ])->andReturn($this->response);


        $this->expectExceptionObject(ApiError::responseError('Error', 'mailjet', 400));
        $this->newsletter->getMembers();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
    }

    /** @test */
    public function it_can_get_the_member()
    {
        $this->response->shouldReceive('success')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $this->client->shouldReceive('get')->withArgs([
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            Resources::$Contact,
            [
                'id' => '[email protected]'
            ]
        ])->andReturn($this->response);

        $this->newsletter->getMember('[email protected]');
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
    }

    /** @test */
    public function it_will_trow_an_exception_when_get_the_member()

    {
        $this->response->shouldReceive('success')->andReturn(false);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $this->client->shouldReceive('get')->withArgs([
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            Resources::$Contact,
            [
                'id' => 'testtest.fr'
            ]
        ])->andReturn($this->response);


        $this->expectExceptionObject(ApiError::responseError('Error', 'mailjet', 400));
        $this->newsletter->getMember('testtest.fr');
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
    }

    /** @test */
    public function it_can_unsubscribe_someone()

    {
        $this->response->shouldReceive('success')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $this->client->shouldReceive('post')->withArgs([
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            Resources::$ContactslistManagecontact,[
                'id' => '123',
                'body' => [
                    'Email' => "[email protected]",
                    'Action' => "unsub",
                ]
            ]

        ])->andReturn($this->response);
        $this->newsletter->unsubscribe('[email protected]');
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
    }

    /** @test */
    public function it_will_trow_an_exception_when_unsubscribe_someone()

    {
        $this->response->shouldReceive('success')->andReturn(false);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $this->client->shouldReceive('post')->withArgs([
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            Resources::$ContactslistManagecontact,[
                'id' => '123',
                'body' => [
                    'Email' => "testtest.fr",
                    'Action' => "unsub",
                ]
            ]

        ])->andReturn($this->response);

        $this->expectExceptionObject(ApiError::responseError('Error', 'mailjet', 400));
        $this->newsletter->unsubscribe('testtest.fr');
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
    }

    /** @test */
    public function it_can_delete_someone()

    {
        $this->response->shouldReceive('success')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $this->client->shouldReceive('post')->withArgs([
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            Resources::$ContactslistManagecontact,[
                'id' => '123',
                'body' => [
                    'Email' => "[email protected]",
                    'Action' => "remove",
                ]
            ]

        ])->andReturn($this->response);

        $this->newsletter->delete('[email protected]');
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
    }

    /** @test */
    public function it_will_trow_an_exception_when_delete_someone()

    {
        $this->response->shouldReceive('success')->andReturn(false);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $this->client->shouldReceive('post')->withArgs([
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            Resources::$ContactslistManagecontact,[
                'id' => '123',
                'body' => [
                    'Email' => "[email protected]",
                    'Action' => "remove",
                ]
            ]

        ])->andReturn($this->response);


        $this->expectExceptionObject(ApiError::responseError('Error', 'mailjet', 400));
        $this->newsletter->delete('[email protected]');
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
    }

    /** @test */
    public function it_exposes_the_api()
    {
        $api = $this->newsletter->getApi();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }

        $this->assertSame($this->client, $api);
    }

    /** @test */
    public function it_can_check_if_member_is_subscribed()

    {
        $this->response->shouldReceive('success')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $response = Mockery::mock(Response::class);
        $response->shouldReceive('success')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $response->shouldReceive('getData')->andReturn([
            [
                'ListID' => '123',
                'IsUnsub' => false
            ]
        ]);

        $this->client->shouldReceive('get')->withArgs([
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            Resources::$ContactGetcontactslists,
            [
                'id' => '[email protected]'
            ]
        ])->andReturn($response);


        $response = $this->newsletter->isSubscribed('[email protected]');
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
        $this->assertTrue($response);
    }

    /** @test */
    public function it_can_check_if_member_is_not_subscribed()

    {
        $this->response->shouldReceive('success')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $response = Mockery::mock(Response::class);
        $response->shouldReceive('success')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $response->shouldReceive('getData')->andReturn([
            [
                'ListID' => '124',
                'IsUnsub' => false
            ]
        ]);

        $this->client->shouldReceive('get')->withArgs([
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            Resources::$ContactGetcontactslists,
            [
                'id' => '[email protected]'
            ]
        ])->andReturn($response);


        $response = $this->newsletter->isSubscribed('[email protected]');
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
        $this->assertFalse($response);
    }

    /** @test */
    public function it_will_trow_an_exception_when_check_if_member_is_subscribed()

    {
        $this->response->shouldReceive('success')->andReturn(false);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $this->client->shouldReceive('get')->withArgs([
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            Resources::$ContactGetcontactslists,
            [
                'id' => 'testtest.fr'
            ]
        ])->andReturn($this->response);

        $this->expectExceptionObject(ApiError::responseError('Error', 'mailjet', 400));
        $this->newsletter->isSubscribed('testtest.fr');
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
    }

    /** @test */
    public function it_can_check_if_list_has_member()

    {
        $this->response->shouldReceive('success')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $response = Mockery::mock(Response::class);
        $response->shouldReceive('success')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $response->shouldReceive('getData')->andReturn([
            [
                'Email' => '[email protected]',
            ]
        ]);

        $this->client->shouldReceive('get')->withArgs([
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            Resources::$Contact,
            [
                'ContactsList' => '123'
            ]
        ])->andReturn($response);

        $response = $this->newsletter->hasMember('[email protected]');
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
        $this->assertTrue($response);
    }


    /** @test */
    public function it_can_check_if_list_does_not_have_member()
    {
        $this->response->shouldReceive('success')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $this->client->shouldReceive('get')->withArgs([
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            Resources::$Contact,
            [
                'ContactsList' => '123'
            ]
        ])->andReturn($this->response);

        $response = $this->newsletter->hasMember('[email protected]');
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
        $this->assertFalse($response);
    }

    /** @test */
    public function it_will_trow_an_exception_when_check_if_list_has_member()

    {
        $this->response->shouldReceive('success')->andReturn(false);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $this->client->shouldReceive('get')->withArgs([
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            Resources::$Contact,
            [
                'ContactsList' => '123'
            ]
        ])->andReturn($this->response);

        $this->expectExceptionObject(ApiError::responseError('Error', 'mailjet', 400));
        $this->newsletter->hasMember('[email protected]');
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
    }
}

1			<?php
2
3			namespace DansMaCulotte\Newsletter\Test\Mailjet;
4
5			use Mailjet\Client;
6			use Mailjet\Resources;
7			use Mailjet\Response;
8			use Mockery;
9			use Mockery\Mock;
10			use PHPUnit\Framework\TestCase;
11			use DansMaCulotte\Newsletter\Drivers\MailjetDriver;
12			use DansMaCulotte\Newsletter\Exceptions\ApiError;
13			use DansMaCulotte\Newsletter\Newsletter;
14
15			class NewsletterTest extends TestCase
16			{
17			/** @var MailjetDriver */
18			protected $driver;
19
20			/** @var Mockery\Mock */
21			protected $client;
22
23			/** @var \DansMaCulotte\Newsletter\Newsletter */
24			protected $newsletter;
25
26			/** @var Mock */
27			protected $response;
28
29
30			public function setUp() : void
31			{
32			$this->client = Mockery::mock(Client::class);
33
34			$this->driver = new MailjetDriver([
35			'key' => 'apikey',
36			'secret' => 'apisecret',
37			], [
38			'lists' => [
39			'list1' => ['id' => 123],
40			'list2' => ['id' => 456],
dansmaculotte / laravel-newsletter

Push — master ( 6f1f11...46af25 )

NewsletterTest::it_exposes_the_api() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like
