ldc-crm/tests/Client/CrmClientCustomerTest.php

<?php

namespace Tests\Client;

use App\Models\Brand;
use App\Models\Customer as ModelsCustomer;
use App\Models\SingleOptin;
use Illuminate\Support\Str;
use LDC\LDCCRM\CrmApiV4;
use LDC\LDCCRM\Enums\ApiError;
use LDC\LDCCRM\Enums\Country;
use LDC\LDCCRM\Exceptions\AccessError;
use LDC\LDCCRM\Exceptions\ApiErrorException;
use LDC\LDCCRM\Exceptions\ValidationException;
use LDC\LDCCRM\Models\Customer;

class CrmClientCustomerTest extends CrmClientTester
{
    /**
     * Test get customer prop.
     *
     * @return void
     */
    public function testGetter(): void
    {
        $this->expectNotToPerformAssertions();
        $client = new Customer();
        $client->email;
    }

    /**
     * Test set customer prop.
     *
     * @return void
     */
    public function testSetter(): void
    {
        $this->expectNotToPerformAssertions();
        $client = new Customer();

        $client->firstname = 'toto';
        $client->firstname;
    }

    /**
     * Test client wrong type.
     *
     * @return void
     */
    public function testSetterFailWrongType(): void
    {
        $this->expectException(ValidationException::class);
        $client = new Customer();

        $client->opt_in = 'toto';
    }

    /**
     * Test country validation.
     *
     * @return void
     */
    public function testSetterFailWrongTypeCountry(): void
    {
        $this->expectException(ValidationException::class);
        $client = new Customer();

        $client->country = 'toto';
    }

    /**
     * Test set all props ok.
     *
     * @return void
     */
    public function testPropsAllSetOk(): void
    {
        $this->expectNotToPerformAssertions();
        $client = new Customer();

        $propTypes = [
            'hashcode'   => (string) Str::uuid(),
            'email'      => 'toto@gmail.com',
            'firstname'  => 'string',
            'lastname'   => 'string',
            'password'   => 'StrongPassword!7',
            'birth_date' => '1992-02-03',
            'phone'      => '0673891630',
            'address'    => 'string',
            'address2'   => 'string',
            'city'       => 'string',
            'postcode'   => 'string',
            'country'    => Country::afghanistan->value(),
            'opt_in'     => 1,
            'status'     => 1,
        ];

        foreach ($propTypes as $prop => $type) {
            $client->{$prop} = $type;
        }
    }

    /**
     * Test customer is json serializable.
     *
     * @return void
     */
    public function testJsonSerialize(): void
    {
        $client = new Customer();

        $propTypes = [
            'hashcode'   => (string) Str::uuid(),
            'email'      => 'toto@gmail.com',
            'firstname'  => 'string',
            'lastname'   => 'string',
            'password'   => 'StrongPassword!7',
            'birth_date' => '1992-02-03',
            'phone'      => '0673891630',
            'address'    => 'string',
            'address2'   => 'string',
            'city'       => 'string',
            'postcode'   => 'string',
            'country'    => Country::afghanistan->value(),
            'opt_in'     => true,
            'status'     => true,
        ];

        foreach ($propTypes as $prop => $type) {
            $client->{$prop} = $type;
        }
        $jsonDecoded = \json_decode(\json_encode($client), true);
        $this->assertIsArray($jsonDecoded);
        unset($propTypes['password']);
        $propTypes['country'] = Country::afghanistan->value();
        foreach ($propTypes as $key => $value) {
            $this->assertArrayHasKey($key, $jsonDecoded);
            $this->assertEquals($value, $jsonDecoded[$key]);
        }
    }

    /**
     * Test set all props fail.
     *
     * @return void
     */
    public function testPropsAllSetNotOk(): void
    {
        $this->expectException(ValidationException::class);
        $client = new Customer();

        $propTypes = [
            'hashcode'   => (string) Str::uuid(),
            'email'      => 'toto@gmail.com',
            'firstname'  => 'string',
            'lastname'   => 'string',
            'password'   => 'StrongPassword!7',
            'birth_date' => '1992-02-03',
            'phone'      => '0673891630',
            'address'    => 'string',
            'address2'   => 'string',
            'city'       => 18,
            'postcode'   => 'string',
            'country'    => Country::afghanistan->value(),
            'opt_in'     => true,
            'status'     => true,
        ];

        foreach ($propTypes as $prop => $type) {
            $client->{$prop} = $type;
        }
    }

    /**
     * Test set unkown prop fail.
     *
     * @return void
     */
    public function testPropsAssignUnknown(): void
    {
        $this->expectException(AccessError::class);

        $customer = new Customer([
            'hashcode'   => (string) Str::uuid(),
            'email'      => 'toto@gmail.com',
            'firstname'  => 'string',
            'lastname'   => 'string',
            'password'   => 'StrongPassword!7',
            'birth_date' => '1992-02-03',
            'phone'      => '0673891630',
            'address'    => 'string',
            'address2'   => 'string',
            'city'       => 'string',
            'postcode'   => 'string',
            'country'    => Country::afghanistan->value(),
            'opt_in'     => true,
            'status'     => true,
        ]);
        $this->assertNull($customer->unknownProp);
        $customer->unknownProp = 'value';
    }

    /**
     * Test set prop fail wrong type.
     *
     * @return void
     */
    public function testPropsAssignWrongType(): void
    {
        $this->expectException(ValidationException::class);

        $customer = new Customer([
            'hashcode'   => (string) Str::uuid(),
            'email'      => 'toto@gmail.com',
            'firstname'  => 'string',
            'lastname'   => 'string',
            'password'   => 'StrongPassword!7',
            'birth_date' => '1992-02-03',
            'phone'      => '0673891630',
            'address'    => 'string',
            'address2'   => 'string',
            'city'       => 'string',
            'postcode'   => 'string',
            'country'    => Country::afghanistan->value(),
            'opt_in'     => true,
            'status'     => true,
        ]);

        $customer->country = 'value';
    }

    /**
     * Test get customer from hashcode.
     *
     * @return void
     */
    public function testCustomerGet(): void
    {
        $api      = new CrmApiV4();
        $customer = $api->getCustomerOrNew(static::$info->hashcode);

        $this->assertEquals(Customer::class, get_class($customer));
        $this->assertEquals($customer->firstname, static::$info->firstname);
        $this->assertEquals($customer->lastname, static::$info->lastname);
        $this->assertEquals($customer->birth_date, static::$info->birth_date);
        $this->assertEquals($customer->address, static::$info->address);
        $this->assertEquals($customer->address2, static::$info->address2);
        $this->assertEquals($customer->phone, static::$info->phone);
        $this->assertEquals($customer->city, static::$info->city);
        $this->assertEquals($customer->postcode, static::$info->postcode);
        $this->assertEquals($customer->opt_in, static::$info->opt_in);
        $this->assertEquals($customer->hashcode, static::$info->hashcode);
        $this->assertEquals($customer->country->value(), static::$info->country->value());
        $this->assertEquals($customer->country->label(), static::$info->country->label());
    }

    /**
     * Test customer activate.
     *
     * @return void
     */
    public function testCustomerActivate(): void
    {
        // Get non activated customer.
        /** @var \App\Models\Customer */
        $customer = ModelsCustomer::whereHas('logins', function ($q) {
            $q->where('status', 0)->whereHas('brand', function ($q) {
                $q->whereId(static::$brand->id);
            });
        })->firstOrFail();

        $info = $customer->info(static::$brand, ModelsCustomer::FIRST_OR_FAIL);

        $api      = new CrmApiV4();
        $customer = $api->getCustomerOrNew($info->hashcode);

        $this->assertTrue($customer->activate());
        $this->assertTrue($customer->status);

        $this->expectException(ApiErrorException::class);
        $this->expectExceptionMessage(ApiError::customerAlreadyActive->label());
        $this->assertTrue($customer->activate());
    }

    /**
     * Test customer update.
     *
     * @return void
     */
    public function testCustomerUpdateProps(): void
    {
        $api      = new CrmApiV4();
        $customer = $api->getCustomerOrNew(static::$info->hashcode);

        $customer->firstname = 'toto';
        $this->assertTrue($customer->save());

        $customer = $api->getCustomerOrNew(static::$info->hashcode);
        $this->assertEquals('Toto', $customer->firstname);

        $customer->lastname = 'pouet';
        $this->assertTrue($customer->save());

        $customer = $api->getCustomerOrNew(static::$info->hashcode);
        $this->assertEquals('Pouet', $customer->lastname);

        $customer->country = Country::belgium->value();
        $customer->save();

        $customer = $api->getCustomerOrNew(static::$info->hashcode);
        $this->assertEquals(Country::belgium, $customer->country);

        $customer->country = Country::france->value();
        $customer->save();

        $customer = $api->getCustomerOrNew(static::$info->hashcode);
        $this->assertEquals(Country::france, $customer->country);

        $customer->email      = 'pouet@gmail.com';
        $customer->birth_date = '1992-03-08';
        $customer->phone      = '0388977213';
        $customer->address    = '30 rue des toto';
        $customer->address2   = 'batiment c';
        $customer->city       = 'toto ville';
        $customer->postcode   = '83160';
        $this->assertTrue($customer->save());

        $customer = $api->getCustomerOrNew(static::$info->hashcode);
        $this->assertEquals('pouet@gmail.com', $customer->email);
        $this->assertEquals('1992-03-08', $customer->birth_date);
        $this->assertEquals('0388977213', $customer->phone);
        $this->assertEquals('30 rue des toto', $customer->address);
        $this->assertEquals('batiment c', $customer->address2);
        $this->assertEquals('toto ville', $customer->city);
        $this->assertEquals('83160', $customer->postcode);
    }

    /**
     * Test customer toggle optin.
     *
     * @return void
     */
    public function testCustomerToggleOptin(): void
    {
        $api      = new CrmApiV4();
        $customer = $api->getCustomerOrNew(static::$info->hashcode);

        $customer->opt_in = false;
        $this->assertTrue($customer->save());

        $this->assertTrue($customer->toggleOptin());
        $this->assertTrue($customer->opt_in);

        $this->assertTrue($customer->toggleOptin());
        $this->assertFalse($customer->opt_in);

        $this->assertTrue($customer->toggleOptin());
        $this->assertTrue($customer->opt_in);
    }

    /**
     * Test customer store.
     *
     * @return void
     */
    public function testCustomerStoreProps(): void
    {
        $customer = new Customer();

        $customer->firstname  = 'toto';
        $customer->lastname   = 'delarogerie';
        $customer->email      = 'toto.delarogerie@gmail.com';
        $customer->password   = 'Complic4tEd!P4assW0rd';
        $customer->birth_date = '1992-03-08';
        $customer->phone      = '0673891160';
        $customer->address    = 'rue des totos';
        $customer->city       = 'Toto ville';
        $customer->postcode   = '72160';
        $customer->country    = Country::france->value();

        $this->assertTrue($customer->save());

        $this->assertEquals('Toto', $customer->firstname);
        $this->assertEquals(null, $customer->password);
    }

    /**
     * Test customer login.
     *
     * @return void
     */
    public function testCustomerLogin(): void
    {
        $api      = new CrmApiV4();
        $customer = $api->getCustomerOrNew('toto.delarogerie@gmail.com');
        $this->assertTrue($customer->activate());
        $this->assertTrue($customer->status);

        $this->assertTrue(Customer::login($customer->email, 'Complic4tEd!P4assW0rd'));
    }

    /**
     * test customer login does not belong to brand.
     *
     * @return void
     */
    public function testCustomerLoginUsingCustomerfromAnotherBrand(): void
    {
        $this->expectException(ApiErrorException::class);
        $this->expectExceptionCode(ApiError::authFailed->value());
        $email = Str::uuid() . 'loginfromantoherbrand@hotmail.fr';
        $data  = [
            'firstname'  => 'Jean2',
            'lastname'   => 'Bond2',
            'birth_date' => \date('1992-03-09'),
            'address'    => '10 rue des toto',
            'email'      => $email,
            'password'   => '123.Mot.De.P4sseNew',
            'phone'      => '+33654821563',
            'country'    => Country::luxembourg->value(),
            'city'       => 'Connerré2',
            'postcode'   => '72161',
            'opt_in'     => 0
        ];

        $brand = Brand::where('id', '!=', static::$brand->id)->firstOrFail();

        $this->createNewCustomer($data, $brand);

        $api         = new CrmApiV4();
        $crmCustomer = $api->getCustomerOrNew($email);
        $this->assertNull($crmCustomer->hashcode);

        CrmApiV4::login($email, '123.Mot.De.P4sseNew');
    }

    /**
     * Test prop store fail.
     *
     * @return void
     */
    public function testCustomerStorePropsFails(): void
    {
        $this->expectException(ValidationException::class);
        $customer = new Customer();

        $customer->firstname  = 'toto';
        $customer->lastname   = 'delarogerie';
        $customer->email      = 'toto.delarogerie@gmail.com';
        $customer->password   = 'simplepassword';
        $customer->birth_date = '1992-03-08';
        $customer->phone      = '0673891160';
        $customer->address    = 'rue des totos';
        $customer->city       = 'Toto ville';
        $customer->postcode   = '72160';
        $customer->country    = Country::france->value();

        $this->assertTrue($customer->save());

        $this->assertEquals('toto', $customer->firstname);
    }

    /**
     * Create a new customer
     * then save it into crm
     * then deletes it from crm
     * then try again to fetch it
     * check if it exists.
     *
     * @return void
     */
    public function testCustomerDelete(): void
    {
        $customer = new Customer();

        $customer->firstname  = 'toto';
        $customer->lastname   = 'delarogerie';
        $customer->email      = 'delete.delarogerie@gmail.com';
        $customer->password   = 'Complic4tEd!P4assW0rd';
        $customer->birth_date = '1992-03-08';
        $customer->phone      = '0673891160';
        $customer->address    = 'rue des totos';
        $customer->city       = 'Toto ville';
        $customer->postcode   = '72160';
        $customer->country    = Country::france->value();

        $this->assertTrue($customer->save());

        $this->assertTrue($customer->delete());

        $api      = new CrmApiV4();
        $customer = $api->getCustomerOrNew('delete.delarogerie@gmail.com');

        // * If hash code is null then it is a new customer
        $this->assertEquals(null, $customer->hashcode);
    }

    /**
     * Make sute a customer exists and contains data.
     *
     * @param array             $data
     * @param \App\Models\Brand $brand
     * @return void
     */
    private function createNewCustomer(array $data, Brand $brand): void
    {
        $customer = \App\Models\Customer::whereEmail($data['email'])
            ->whereHas('brands', function ($q) use ($brand) {
                $q->where('brands.id', '=', $brand->id);
            })->firstOrNew();
        $customer->fill($data);
        $saved = $customer->save();

        // * Delete Single optin if exists.
        /** @var \App\Models\SingleOptin|null $singleOptin */
        $singleOptin = SingleOptin::query()->where('email', $data['email'])
            ->whereHas('brand', function ($q) use ($brand) {
                $q->where('brands.id', '=', $brand->id);
            })->first();
        if ($singleOptin) {
            $saved = $singleOptin->delete() && $saved;
        }

        /** @var \App\Models\CustomerInfo */
        $customerInfo = $customer->info($brand, \App\Models\Customer::FIRST_OR_NEW);
        $customerInfo->fill($data);
        $customerInfo->brand()->associate($brand);
        $customerInfo->customer()->associate($customer);
        $saved = $customerInfo->save() && $saved;

        /** @var \App\Models\CustomerLogin */
        $customerLogin = $customer->login($brand, \App\Models\Customer::FIRST_OR_NEW);
        $customerLogin->fill($data);
        $customerLogin->brand()->associate($brand);
        $customerLogin->customer()->associate($customer);
        $saved = $customerLogin->save() && $saved;

        $this->assertTrue($saved, 'A new customer should have been created.');
    }
}