FlexiBeeROTest::testRawXmlToArray() - Code Metrics - Inspection of "Total Code Coverage 71,67 % reached" - Spoje-NET/FlexiPeeHP - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed
Push — master ( 0e13f3...6d8a3f )

by Vítězslav
created 2018-05-08 19:56 UTC
FlexiBeeROTest::testRawXmlToArray() A

↳ Parent: FlexiBeeROTest
Complexity

Conditions	2
Paths	2
Size

Total Lines	22
Code Lines	11
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	2
eloc	11
nc	2
nop	0
dl	0
loc	22
rs	9.2
c	0
b	0
f	0
<?php

namespace Test\FlexiPeeHP;

use FlexiPeeHP\FlexiBeeRO;

/**
 * Generated by PHPUnit_SkeletonGenerator on 2016-05-04 at 10:08:36.
 */
class FlexiBeeROTest extends \Test\Ease\SandTest
{
    /**
     * @var FlexiBeeRO
     */
    protected $object;

    /**
     * Example JSON 
     * @var string json 
     */
    public $json = '{"winstrom":{"@version":"1.0","adresar":[{"id":"2574","kontakty":[{"id":"299"}]}]}}';

    /**
     * Example XML
     * @var string xml 
     */
    public $xml = '<?xml version="1.0" encoding="utf-8"?>

<winstrom version="1.0">
  <!-- Adresář -->
  <adresar>
    <!-- ID (celé číslo) - -->
    <id>2574</id>
    <kontakty>
      <!-- Kontakty -->
      <kontakt>
        <!-- ID (celé číslo) - -->
        <id>299</id>
      </kontakt>
    </kontakty>
  </adresar>
</winstrom>';

    /**
     * Sets up the fixture, for example, opens a network connection.
     * This method is called before a test is executed.
     * @covers FlexiPeeHP\FlexiBeeRO::__construct
     */
    protected function setUp()
    {
        $this->object                  = new FlexiBeeRO();
        $this->object->prefix          = '/';
        $this->object->debug           = true;
        $this->object->reportRecipient = '[email protected]';
    }

    /**
     * Tears down the fixture, for example, closes a network connection.
     * This method is called after a test is executed.
     */
    protected function tearDown()
    {
        
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::logBanner
     */
    public function testLogBanner()
    {
        $this->object->logBanner(addslashes(get_class($this)));
    }

    /**
     * Test Constructor
     *
     * @depends testLogBanner
     * @covers FlexiPeeHP\FlexiBeeRO::__construct
     */
    public function testConstructor()
    {
        $classname = get_class($this->object);
        $evidence  = $this->object->getEvidence();

        // Get mock, without the constructor being called
        $mock = $this->getMockBuilder($classname)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();
        $mock->__construct(1, ['debug' => false]);

        if (!isset(\FlexiPeeHP\EvidenceList::$name[$evidence])) {
            $evidence = 'adresar';
        }

        $mock->__construct('',
            [
                'company' => constant('FLEXIBEE_COMPANY'),
                'url' => constant('FLEXIBEE_URL'),
                'user' => constant('FLEXIBEE_LOGIN'),
                'password' => constant('FLEXIBEE_PASSWORD'),
                'debug' => true,
                'prefix' => 'c',
                'evidence' => $evidence]);
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::curlInit
     */
    public function testSetupProperty()
    {
        $this->object->setupProperty(['test' => 'test'], 'test');
        $properties = ['debug' => true];
        $this->object->setupProperty($properties, 'debug');
        $this->assertTrue($this->object->debug);
        $this->object->setupProperty($properties, 'url', 'FLEXIBEE_URL');
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::curlInit
     */
    public function testCurlInit()
    {
        $this->object->timeout = 120;
        $this->object->curlInit();
        $this->assertTrue(is_resource($this->object->curl));
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::processInit
     */
    public function testProcessInit()
    {
        $this->object->processInit(1);
        $this->object->processInit(['id' => 1]);
        $this->assertEquals(1, $this->object->getDataValue('id'));

        if (!is_null($this->object->evidence) && $this->object->evidence != 'test') {


            $firstID = $this->object->getColumnsFromFlexibee(['id', 'kod'],
                ['limit' => 1]);

            if (count($firstID) && isset($firstID[0]['id'])) {

                $this->object->processInit((int) current($firstID));
                $this->assertNotEmpty($this->object->__toString());

                if (isset($firstID[0]['kod'])) {
                    $this->object->processInit('code:'.$firstID[0]['kod']);
                    $this->assertNotEmpty($this->object->__toString());
                }

                $this->object->processInit($this->object->getEvidenceURL().'/'.$firstID[0]['id'].'.xml');
            } else {
                $this->markTestSkipped(sprintf('Evidence %s doed not contain first record',
                        $this->object->getEvidence()));
            }
        }
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::setUp
     */
    public function testSetUp()
    {
        $this->object->authSessionId = 'XXXtestXXX';
        $this->object->setUp(
            [
                'company' => 'cmp',
                'url' => 'url',
                'user' => 'usr',
                'password' => 'pwd',
                'prefix' => 'c',
                'debug' => true,
                'defaultUrlParams' => ['limit' => 10],
                'evidence' => 'smlouva',
                'detail' => 'summary',
                'filter' => 'testfilter',
                'ignore404' => true,
                'offline' => true
            ]
        );
        $this->assertEquals('cmp', $this->object->company);
        $this->assertEquals('url', $this->object->url);
        $this->assertEquals('usr', $this->object->user);
        $this->assertEquals('/c/', $this->object->prefix);
        $this->assertEquals('pwd', $this->object->password);
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getConnectionOptions
     */
    public function testGetConnectionOptions()
    {
        $options                     = $this->object->getConnectionOptions();
        $this->assertArrayHasKey('url', $options);
        $this->object->timeout       = 120;
        $this->object->authSessionId = 'sessid';
        $this->object->setCompany('test');
        $this->object->getConnectionOptions();
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::setPrefix
     * @expectedException \Exception
     */
    public function testSetPrefix()
    {
        $this->object->setPrefix('c');
        $this->assertEquals('/c/', $this->object->prefix);
        $this->object->setPrefix(null);
        $this->assertEquals('', $this->object->prefix);
        $this->object->setPrefix('fail');
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::setFormat
     */
    public function testSetFormat()
    {
        $this->object->setFormat('xml');
        $this->assertEquals('xml', $this->object->format);
    }

    /**
     * We can set only evidence defined in EvidenceList class
     *
     * @covers FlexiPeeHP\FlexiBeeRO::setEvidence
     * @expectedException \Exception
     */
    public function testSetEvidence()
    {
        $this->object->setEvidence('adresar');
        $this->assertEquals('adresar', $this->object->evidence);
        $this->object->setPrefix('c');
        $this->object->debug = true;
        $this->object->setEvidence('fail');
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::setCompany
     */
    public function testSetCompany()
    {
        $this->object->setCompany('test_s_r_o_');
        $this->assertEquals('test_s_r_o_', $this->object->company);
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::object2array
     */
    public function testObject2array()
    {
        $this->assertNull($this->object->object2array(new \stdClass()));
        $this->assertEquals(
            [
                'item' => 1,
                'arrItem' => ['a', 'b' => 'c']
            ]
            , $this->object->object2array(new \Test\ObjectForTesting()));
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::objectToID
     */
    public function testObjectToID()
    {
        $this->object->setDataValue('kod', 'TEST');
        $this->assertEquals('code:TEST',
            $this->object->objectToID($this->object));

        $this->assertEquals('TEST', $this->object->objectToID('TEST'));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::performRequest
     */
    public function testPerformRequest()
    {
        $evidence = $this->object->getEvidence();
        switch ($evidence) {
            case null:
            case '':
            case 'c':
            case 'test':
            case 'status':
            case 'nastaveni':
                $this->object->performRequest(null, 'GET', 'xml');
                break;

            default:
                $this->object->performRequest(null, 'GET', 'json');
                $this->object->performRequest(null, 'GET', 'xml');
                break;
        }

        //404 Test

        $notFound = $this->object->performRequest('error404.json');
        if(array_key_exists('message', $notFound)){
            $this->assertEquals('false', $notFound['success']);
        } else {
            echo '';
        }
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::rawResponseToArray
     */
    public function testRawResponseToArray()
    {

        $this->assertTrue(is_array(
                $this->object->rawResponseToArray($this->json, 'json')));
        $this->assertTrue(is_array(
                $this->object->rawResponseToArray($this->xml, 'xml')));
        $this->assertTrue(is_array(
                $this->object->rawResponseToArray('simpletext', 'txt')));
        $this->assertTrue(is_array(
                $this->object->rawResponseToArray('othertext', 'other')));
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::rawJsonToArray
     */
    public function testRawJsonToArray()
    {
        $this->assertNull($this->object->rawJsonToArray($this->json.'XXX'));
        $evidence = $this->object->getResponseEvidence() ? $this->object->getResponseEvidence() : 'adresar';
        $arrayWeWant = [
            '@version' => '1.0',
            $evidence  =>
            [
                [
                    'id' => '2574',
                    'kontakty' =>
                    [
                        ['id' => '299']
                    ]
                ]
            ]
        ];
        $this->assertEquals($arrayWeWant,
            $this->object->rawJsonToArray($this->json));
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::rawXmlToArray
     */
    public function testRawXmlToArray()
    {
        $evidence = $this->object->getResponseEvidence() ? $this->object->getResponseEvidence() : 'adresar';
        $arrayWeWant = [
            '@version' => '1.0',
            $evidence =>
            [
                [
                    'id' => '2574',
                    'kontakty' =>
                    [
                        ['kontakt' => [
                                ['id' => '299']
                            ]
                        ]
                    ]
                ]
            ]
        ];
        $this->assertEquals($arrayWeWant,
            $this->object->rawXmlToArray($this->xml));
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::parseResponse
     */
    public function testParseResponse()
    {
        $this->object->parseResponse($this->object->rawJsonToArray($this->json),
            200);
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::doCurlRequest
     */
    public function testDoCurlRequest()
    {
        $this->object->doCurlRequest(constant('FLEXIBEE_URL'), 'GET');
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::setAction
     */
    public function testSetAction()
    {
        switch ($this->object->getEvidence()) {
            case '':
            case 'c':
            case 'hooks':
            case 'status':
            case 'changes':
            case 'nastaveni':
            case 'evidence-list':
                $this->object->setAction('none');
                break;
            default:
                $this->assertTrue($this->object->setAction('new'));
                $this->object->actionsAvailable = [];
                $this->assertFalse($this->object->setAction('none'));
                $this->object->actionsAvailable = ['copy'];
                $this->assertFalse($this->object->setAction('none'));
                break;
        }
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getEvidence
     */
    public function testGetEvidence()
    {
        $this->assertEquals($this->object->evidence,
            $this->object->getEvidence());
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getCompany
     */
    public function testGetCompany()
    {
        $this->assertEquals($this->object->company, $this->object->getCompany());
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getResponseEvidence
     */
    public function testGetResponseEvidence()

    {
        $responseEvidence = $this->object->getResponseEvidence();
        switch ($this->object->getEvidence()) {
            case '':
            case 'c':
            case 'hooks':
            case 'status':
            case 'changes':
            case 'nastaveni':
            case 'evidence-list':
                break;
            default:
                $this->assertEquals($this->object->getEvidence(),
                    $responseEvidence);
                break;
        }
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getLastInsertedId
     * @depends testInsertToFlexiBee
     */
    public function testGetLastInsertedId()
    {
        $this->assertNotEmpty($this->object->getLastInsertedId());
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::xml2array
     */
    public function testXml2array()
    {
        $arrayWeWant = [
            '@version' => '1.0',
            'adresar' =>
            [
                [
                    'id' => '2574',
                    'kontakty' =>
                    [
                        ['kontakt' => [
                                ['id' => '299']
                            ]
                        ]
                    ]
                ]
            ]
        ];

        $this->assertEquals($arrayWeWant, $this->object->xml2array($this->xml));
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::extractUrlParams
     */
    public function testExtractUrlParams()
    {
        $conditions = ['id' => 23, 'limit' => 10];
        $this->object->extractUrlParams($conditions, $urlParams);
        $this->assertEquals(['id' => 23], $conditions);
        $this->assertEquals(['limit' => 10], $urlParams);
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::urlEncode
     */
    public function testUrlEncode()
    {
        $this->assertEquals("stitky%3D'code:VIP'%20or%20stitky%3D'code:DULEZITE'",
            FlexiBeeRO::urlEncode("stitky='code:VIP' or stitky='code:DULEZITE'"));
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getAllFromFlexibee
     */
    public function testGetAllFromFlexibee()
    {
        $this->object->getAllFromFlexibee();
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::disconnect
     *
     * @depends testPerformRequest
     * @depends testLoadFlexiData
     * @depends testGetFlexiRow
     * @depends testGetFlexiData
     * @depends testLoadFromFlexiBee
     * @depends testInsertToFlexiBee
     * @depends testIdExists
     * @depends testRecordExists
     * @depends testGetColumnsFromFlexibee
     * @depends testSearchString
     */
    public function testDisconnect()
    {
        $this->object->disconnect();
        $this->assertNull($this->object->curl);
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::__destruct
     * @depends testDisconnect
     */
    public function testdestruct()
    {
        $this->markTestSkipped();
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getFlexiRow
     */
    public function testGetFlexiRow()
    {
        $this->object->getFlexiRow(0);
        $this->object->getFlexiRow(1);
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getFlexiData
     */
    public function testGetFlexiData()
    {
        $evidence = $this->object->getEvidence();
        switch ($evidence) {
            case null:
                $this->object->getFlexiData();
                break;
            case 'c':
                $this->object->evidence  = 'c';
                $this->object->prefix    = '';
                $this->object->company   = '';
                $this->object->nameSpace = 'companies';
                $flexidata               = $this->object->getFlexiData();
                $this->assertArrayHasKey('company', $flexidata);
                break;
            case 'evidence-list':
                $flexidata               = $this->object->getFlexiData(null,
                    ['detail' => 'id']);
                $this->assertArrayHasKey('evidenceType', $flexidata[0]);
                break;

            default:
                $flexidata = $this->object->getFlexiData(null,
                    ['detail' => 'id']);

                if (is_array($flexidata)) {
                    if (count($flexidata)) {
                        $this->markTestSkipped('Empty evidence');
                    } else {
                        $this->assertArrayHasKey(0, $flexidata);

                        $this->assertArrayHasKey('id', $flexidata[0]);
                        $filtrered = $this->object->getFlexiData(null,
                            ["id = ".$flexidata[0]['id'], 'detail' => 'full']);
                        $this->assertArrayHasKey(0, $filtrered);
                        $this->assertArrayHasKey('id', $filtrered[0]);
                    }
                }
                break;
        }
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::loadFromFlexiBee
     */
    public function testLoadFromFlexiBee()
    {
        $this->object->loadFromFlexiBee();
        $this->object->loadFromFlexiBee(222);
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getJsonizedData
     */
    public function testGetJsonizedData()
    {
        $this->assertEquals('{"'.$this->object->nameSpace.'":{"@version":"1.0","'.$this->object->evidence.'":{"key":"value"}}}',
            $this->object->getJsonizedData(['key' => 'value']));

        switch ($this->object->getEvidence()) {
            case '':
            case 'c':
            case 'hooks':
            case 'status':
            case 'changes':
            case 'nastaveni':
            case 'evidence-list':
                $this->object->getJsonizedData(['key' => 'value']);
                break;
            default:
                $this->object->setAction('copy');
                $this->assertEquals('{"'.$this->object->nameSpace.'":{"@version":"1.0","'.$this->object->evidence.'":{"key":"value"},"'.$this->object->evidence.'@action":"copy"}}',
                    $this->object->getJsonizedData(['key' => 'value']));

                $this->object->action = 'storno';

                $this->object->filter = "stavUhrK = 'stavUhr.uhrazeno'";
                $this->object->getJsonizedData([]);
                break;
        }
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getDataForJSON
     */
    public function testGetDataForJson()
    {
        $this->object->getDataForJSON();
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::idExists
     */
    public function testIdExists()
    {
        $this->assertFalse($this->object->idExists('nonexistent'));
        switch ($this->object->getEvidence()) {
            case '':
            case 'c':
            case 'hooks':
            case 'status':
            case 'changes':
            case 'nastaveni':
            case 'evidence-list':
                break;
            default:
                $first = $this->object->getColumnsFromFlexibee(['id'],
                    ['limit' => 1], 'id');
                if (empty($first)) {
                    $this->markTestSkipped('empty evidence ?');
                } else {
                    $this->object->setData($first);
                    $this->assertTrue($this->object->idExists());
                }
                break;
        }
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getRecordID
     */
    public function testGetRecordID()
    {
        $this->object->setData([$this->object->getKeyColumn() => 10]);
        $this->assertEquals(10, $this->object->getRecordID());
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::recordExists
     */
    public function testRecordExists()
    {
        $evidence = $this->object->getEvidence();

        switch ($evidence) {
            case null:
            case 'c':
            case 'status':
            case 'evidence-list':
                $this->object->recordExists();
                break;

            default:
                $flexidata = $this->object->getFlexiData(null,
                    ['limit' => 1, 'detail' => 'id']);
                if (is_array($flexidata) && !count($flexidata)) {
                    $this->assertFalse($this->object->recordExists(['id' => 1]),
                        'Record ID 1 exists in empty evidence ?');
                } else {
                    if (!is_null($flexidata)) {
                        $this->object->setData(['id' => (int) $flexidata[0]['id']]);
                        $this->assertTrue($this->object->recordExists(),
                            'First record exists test failed');
                        $this->assertFalse($this->object->recordExists(['id' => 0]),
                            'Record ID 0 exists');
                        $this->assertFalse($this->object->recordExists(['unexistent' => 1]),
                            'Unexistent Record exist ?');
                    }
                }
                break;
        }
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getColumnsFromFlexibee
     */
    public function testGetColumnsFromFlexibee()
    {

        switch ($this->object->getEvidence()) {
            case '':
            case 'c':
            case 'hooks':
            case 'status':
            case 'changes':
            case 'nastaveni':
            case 'evidence-list':
                break;
            default:
                $this->object->getColumnsFromFlexibee(['id', 'kod'],
                    ['limit' => 1], 'id');
                $this->object->getColumnsFromFlexibee('summary', ['limit' => 1],
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                    'id');

                break;
        }
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getExternalID
     */
    public function testGetExternalID()
    {
        $this->assertTrue(empty($this->object->getExternalID('ext:test:10'))); //ext: does not exist

        $this->object->setDataValue('external-ids',
            ['ext:doe:22', 'ext:test:10']);

        $this->assertEquals('ext:doe:22', $this->object->getExternalID());
        $this->assertEquals('10', $this->object->getExternalID('test'));
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getGlobalVersion
     */
    public function testGetGlobalVersion()

    {
        switch ($this->object->getEvidence()) {
            case '':
            case 'c':
            case 'hooks':
            case 'status':
            case 'changes':
            case 'nastaveni':
            case 'evidence-list':
                $this->object->getGlobalVersion();
                break;
            default:
                $this->assertInternalType("int",
                    $this->object->getGlobalVersion(),
                    'error obtaining of GlobalVersion');
                break;
        }
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getApiURL
     */
    public function testGetApiUrl()
    {
        $evidence = $this->object->getEvidence();
        if ($evidence) {
            $url = $this->object->url.'/c/'.constant('FLEXIBEE_COMPANY').'/'.$evidence;
        } else {
            $url = $this->object->url.'/c/'.constant('FLEXIBEE_COMPANY');
        }

        $this->assertEquals($url, $this->object->getApiURL());
        $this->assertEquals($url.'.html', $this->object->getApiURL('html'));
        $this->assertEquals($url.'.xml', $this->object->getApiURL('xml'));
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getResponseFormat
     */
    public function testGetResponseFormat()
    {
        $this->object->performRequest(null, 'GET', 'json');
        $this->assertEquals('application/json',
            $this->object->getResponseFormat());
        $this->object->performRequest(null, 'GET', 'xml');
        $this->assertEquals('application/xml',
            $this->object->getResponseFormat());
        unset($this->object->curlInfo['content_type']);
        $this->assertNull($this->object->getResponseFormat());
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getKod
     */
    public function testGetKod()
    {
        $testString = [];
        $this->assertEquals('code:CODE',
            $this->object->getKod([$this->object->keyColumn => 'code']));

        $testString[$this->object->nameColumn] = 'Fish clamp -  Úchytka pro instalaci samonosných kabelů '
            .'(3.5 mm)';
        $code0                                 = $this->object->getKod($testString);
        $this->assertEquals('code:FISHCLAMPUCHYTKAPR', $code0);
        $code1                                 = $this->object->getKod($testString,
            false);
        $this->assertEquals('code:FISHCLAMPUCHYTKAPR', $code1);
        $code2                                 = $this->object->getKod($testString);
        $this->assertEquals('code:FISHCLAMPUCHYTKAPR1', $code2);
        $this->object->setData($testString);
        $code3                                 = $this->object->getKod();
        $this->assertEquals('code:FISHCLAMPUCHYTKAPR2', $code3);

        $this->assertEquals('code:TEST',
            $this->object->getKod([$this->object->nameColumn => 'test']));

        $this->assertEquals('code:TEST1', $this->object->getKod('test'));

        $this->assertEquals('code:TEST2',
            $this->object->getKod(['kod' => 'test']));
        $this->assertEquals('code:NOTSET', $this->object->getKod(['kod' => '']));
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::logResult
     */
    public function testLogResult()
    {
        $this->object->cleanMessages();
        $success = json_decode('{"winstrom":{"@version":"1.0","success":"true",'
            .'"stats":{"created":"0","updated":"1","deleted":"0","skipped":"0"'
            .',"failed":"0"},"results":[{"id":"1","request-id":"ext:SōkoMan.item'
            .':5271","ref":"/c/spoje_net_s_r_o_1/skladovy-pohyb/1.json"}]}}');
        $this->object->logResult(current($this->object->object2array($success)),
            'http://test');

        $this->assertArrayHasKey('info', $this->object->getStatusMessages(true));

        $error                          = json_decode('{"winstrom":{"@version":"1.0","success":"false",'
            .'"stats":{"created":"0","updated":"0","deleted":"0","skipped":"0"'
            .',"failed":"0"},"results":[{"errors":[{"message":"cz.winstrom.'
            .'service.WSBusinessException: Zadaný kód není unikátní.\nZadaný'
            .' kód není unikátní."}]}]}}');
        $this->object->lastResponseCode = 500;
        $this->object->logResult(current($this->object->object2array($error)));
        $this->assertArrayHasKey('error', $this->object->getStatusMessages(true));
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::flexiUrl
     */
    public function testFlexiUrl()
    {
        $this->assertEquals("a eq '1' and b eq 'foo'",
            $this->object->flexiUrl(['a' => 1, 'b' => 'foo'], 'and'));
        $this->assertEquals("a eq '1' or b eq 'bar'",
            $this->object->flexiUrl(['a' => 1, 'b' => 'bar'], 'or'));
        $this->assertEquals("a eq true or b eq false",
            $this->object->flexiUrl(['a' => true, 'b' => false], 'or'));
        $this->assertEquals("a is null and b is not null",
            $this->object->flexiUrl(['a' => null, 'b' => '!null'], 'and'));
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::unifyResponseFormat
     */
    public function testunifyResponseFormat()
    {
        $this->assertNull($this->object->unifyResponseFormat(null));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        //One Row Test

        $responseEvidence = $this->object->getResponseEvidence();
        if (empty($responseEvidence)) {
            $responseEvidence       = $this->object->evidence = 'test';
        }

        $test1raw = [$responseEvidence =>
            ['id' => 1, 'name' => 'value']
        ];

        $test1expected = [$responseEvidence =>
            [
                ['id' => 1, 'name' => 'value']
            ]
        ];

        $this->assertEquals($test1expected,
            $this->object->unifyResponseFormat($test1raw));

        //Two Row Test
        $test2Raw = [$this->object->getResponseEvidence() =>
            [
                ['id' => 1, 'name' => 'value'],
                ['id' => 2, 'name' => 'value2']
            ]
        ];

        $test2expected = [$this->object->getResponseEvidence() =>
            [
                ['id' => 1, 'name' => 'value'],
                ['id' => 2, 'name' => 'value2']
            ]
        ];

        $this->assertEquals($test2expected,
            $this->object->unifyResponseFormat($test2Raw));
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::__toString
     */
    public function testtoString()
    {
        $id = '123';
        $this->object->setMyKey($id);
        $this->assertEquals($id, (string) $this->object);

        $this->object->setDataValue('kod', 'test');
        $this->assertEquals('code:TEST', (string) $this->object);

        $identifer = 'ext:test:123';
        $this->object->setMyKey($identifer);
        $this->assertEquals($identifer, (string) $this->object);

        $this->object->dataReset();
        $this->assertEquals('', $this->object->__toString());
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::draw
     */
    public function testDraw($whatWant = NULL)
    {
        $this->object->setDataValue('kod', 'test');
        $this->assertEquals('code:TEST', $this->object->draw());
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getColumnsInfo
     */
    public function testgetColumnsInfo()
    {
        switch ($this->object->getEvidence()) {
            case '':
            case 'c':
            case 'hooks':
            case 'status':
            case 'changes':
            case 'evidence-list':
                $this->assertNull($this->object->getColumnsInfo());
                break;
            default:
                $this->assertNotEmpty($this->object->getColumnsInfo(),
                    'Cannot obtain structure for '.$this->object->getEvidence());
                break;
        }
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getActionsInfo
     */
    public function testgetActionsInfo()
    {
        switch ($this->object->getEvidence()) {
            case '':
            case 'c':
            case 'hooks':
            case 'status':
            case 'changes':
            case 'nastaveni':
            case 'evidence-list':
                $this->assertNull($this->object->getActionsInfo());
                $this->assertNotEmpty($this->object->getActionsInfo('faktura-vydana'),
                    'Cannot obtain actions for na evidence');
                break;
            default:
                $this->assertNotEmpty($this->object->getActionsInfo(),
                    'Cannot obtain actions for '.$this->object->getEvidence());
                break;
        }
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getRelationsInfo
     */
    public function testgetRelationsInfo()
    {
        switch ($this->object->getEvidence()) {
            case '':
            case 'c':
            case 'hooks':
            case 'status':
            case 'changes':
            case 'nastaveni':
            case 'strom-cenik':
            case 'ucetni-obdobi':
            case 'evidence-list':
                $this->assertNull($this->object->getRelationsInfo());
                break;
            default:
                $this->assertNotEmpty($this->object->getRelationsInfo(),
                    'Cannot obtain relations for '.$this->object->getEvidence());
                break;
        }
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getEvidenceUrl
     */
    public function testgetEvidenceUrl()
    {
        $this->assertNotEmpty($this->object->getEvidenceUrl());
        $this->assertNotEmpty($this->object->getEvidenceUrl('/properties'));

    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::evidenceToClassName
     */
    public function testevidenceToClassName()
    {
        $this->assertEquals('FakturaVydana',
            $this->object->evidenceToClassName('faktura-vydana'));
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getEvidenceInfo
     */
    public function testGetEvidenceInfo()

    {
        $eInfo = $this->object->getEvidenceInfo();
        switch ($this->object->getEvidence()) {
            case '':
            case 'c':
            case 'hooks':
            case 'status':
            case 'changes':
            case 'nastaveni':
            case 'evidence-list':
                break;
            default:
                $this->assertArrayHasKey('evidencePath', $eInfo);
                break;
        }
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getEvidenceName
     */
    public function testGetEvidenceName()

    {
        $evidenceName = $this->object->getEvidenceName();
        switch ($this->object->getEvidence()) {
            case '':
            case 'c':
            case 'hooks':
            case 'status':
            case 'changes':
            case 'nastaveni':
            case 'evidence-list':
                break;
            default:
                $this->assertNotEmpty($evidenceName);
                break;
        }
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::saveResponseToFile
     */
    public function testSaveResponseToFile()
    {
        $tmp = sys_get_temp_dir().'/'.tmpfile();
        $this->object->saveResponseToFile($tmp);
        $this->assertFileExists($tmp);
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getFirstRecordID()
     */
    public function testgetFirstRecordID()

    {
        $this->object->getFirstRecordID();
        switch ($this->object->getEvidence()) {
            case '':
            case 'c':
            case 'hooks':
            case 'status':
            case 'changes':
            case 'nastaveni':
            case 'evidence-list':
                break;
            default:
                break;
        }
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getVazby
     * @expectedException \Exception
     */
    public function testGetVazby()

    {
        switch ($this->object->getEvidence()) {
            case '':
            case 'c':
            case 'hooks':
            case 'status':
            case 'changes':
            case 'nastaveni':
            case 'evidence-list':
                break;
            default:
                $this->object->getVazby($this->object->getMyKey());
                break;
        }
        $this->object->getVazby();
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::evidenceUrlWithSuffix
     */
    public function testEvidenceUrlWithSuffix()
    {
        $urlraw = $this->object->getEvidenceURL();
        $lala   = $this->object->evidenceUrlWithSuffix('lala');
        $this->assertEquals($urlraw.'/lala', $lala);
        $lolo   = $this->object->evidenceUrlWithSuffix('?lele');
        $this->assertEquals($urlraw.'?lele', $lolo);
        $lulu   = $this->object->evidenceUrlWithSuffix(';lulu');
        $this->assertEquals($urlraw.';lulu', $lulu);
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::join
     * @expectedException \Ease\Exception
     */
    public function testJoin()
    {
        $ada = new FlexiBeeRO(['id' => 'A'], ['evidence' => 'adresar']);
        $adb = new FlexiBeeRO(['id' => 'B'], ['evidence' => 'adresar']);
        $this->assertTrue($this->object->join($ada));
        $this->assertTrue($this->object->join($adb));
        $ads = new \stdClass();
        $this->object->join($ads);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::addUrlParams
     */
    public function testAddUrlParams()
    {
        $this->assertEquals('http://vitexsoftware.cz/path?a=b&id=1',
            $this->object->addUrlParams('http://vitexsoftware.cz/path?a=b',
                ['id' => 1], TRUE));
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::addDefaultUrlParams
     */
    public function testAddDefaultUrlParams()
    {
        $this->object->defaultUrlParams       = [];
        $this->assertEquals('http://vitexsoftware.cz?a=b',
            $this->object->addDefaultUrlParams('http://vitexsoftware.cz?a=b'));
        $this->object->defaultUrlParams['id'] = 1;
        $this->assertEquals('http://vitexsoftware.cz/path?id=1&a=b',
            $this->object->addDefaultUrlParams('http://vitexsoftware.cz/path?a=b'));
    }

    public function testFlexiDateToDateTime()
    {
        $this->assertEquals(1495749600,
            FlexiBeeRO::flexiDateToDateTime('2017-05-26+02:00')->getTimestamp());
    }

    public function testFlexiDateTimeToDateTime()
    {
        $this->assertEquals(1506412853,
            FlexiBeeRO::flexiDateTimeToDateTime('2017-09-26T10:00:53.755+02:00')->getTimestamp());
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::setDataValue
     */
    public function testSetDataValue()
    {
        if (!empty($this->object->getColumnsInfo())) {
            $this->object->setDataValue('datVyst', new \DateTime());
        }
        $this->object->setDataValue('test', 'test');
        $this->object->setDataValue('kod', 'code:testKOD');
        $this->assertEquals('testKOD', $this->object->getDataValue('kod'));
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::saveDebugFiles
     */
    public function testSaveDebugFiles()
    {
        $this->object->saveDebugFiles();
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::setPostFields
     * @covers FlexiPeeHP\FlexiBeeRO::getPostFields
     */
    public function testSetPostFields()
    {
        $this->object->setPostFields('test');
        $this->assertEquals($this->object->getPostFields(), 'test');
    }

    /**
     * PHP Date object to FlexiBee date format test
     * 
     * @covers FlexiPeeHP\FlexiBeeRO::dateToFlexiDate
     */
    public function testDateToFlexiDate()
    {
        $dater = new \DateTime();
        $this->assertEquals($dater->format(FlexiBeeRO::$DateFormat),
            FlexiBeeRO::dateToFlexiDate($dater));
    }

    /**
     * PHP Date object to FlexiBee dateTime format test
     * 
     * @covers FlexiPeeHP\FlexiBeeRO::dateToFlexiDateTime
     */
    public function testDateToFlexiDateTime()
    {
        $dater = new \DateTime();
        $this->assertEquals($dater->format(FlexiBeeRO::$DateTimeFormat),
            FlexiBeeRO::dateToFlexiDateTime($dater));
    }

    public function testSetFilter()
    {
        $this->object->setFilter('X');
        $this->object->setFilter(['a' => 'b']);
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getColumnInfo
     */
    public function testGetColumnInfo()
    {
        $this->object->getColumnInfo('id');
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getFlexiBeeURL
     */
    public function testGetFlexiBeeURL()
    {
        $this->object->getFlexiBeeURL();
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::error500Reporter
     */
    public function testError500Reporter()
    {
        $this->object->reportRecipient = '[email protected]';
        $this->object->error500Reporter(['success' => 'false', 'message' => 'test']);
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::setMyKey
     */
    public function testSetMyKey()
    {
        $this->object->setMyKey(1);
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::ignore404
     */
    public function testIgnore404()
    {
        $this->object->ignore404(true);
        $this->assertTrue($this->object->ignore404());
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::sendByMail
     */
    public function testSendByMail()
    {
        $this->object->sendByMail($this->object->reportRecipient, 'test',
            'test body');
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::sendUnsent
     */
    public function testSendUnsent()
    {
        $this->object->sendUnsent();
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::getInFormat
     */
    public function testGetInFormat()
    {
        $this->object->evidence = 'test';
        $this->object->getInFormat('html', 'test');
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::downloadInFormat
     */
    public function testDownloadInFormat()
    {
        $this->object->downloadInFormat('pdf', sys_get_temp_dir().'/');
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::code
     */
    public function testCode()
    {
        $this->assertEquals('code:TEST', FlexiBeeRO::code('test'));
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::uncode
     */
    public function testUncode()
    {
        $this->assertEquals('test', FlexiBeeRO::uncode('code:test'));
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::arrayCleanUP
     */
    public function testArrayCleanUP()
    {
        $this->assertEquals(['a' => 'b'],
            FlexiBeeRO::arrayCleanUP(['a' => 'b', '@a' => 'aaa']));
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::__wakeup
     */
    public function test__wakeup()
    {
        $this->object->__wakeup();
    }

    /**
     * @covers FlexiPeeHP\FlexiBeeRO::__destruct
     */
    public function test_destruct()
    {
        $this->object->__destruct();
    }
}

1			<?php
2
3			namespace Test\FlexiPeeHP;
4
5			use FlexiPeeHP\FlexiBeeRO;
6
7			/**
8			* Generated by PHPUnit_SkeletonGenerator on 2016-05-04 at 10:08:36.
9			*/
10			class FlexiBeeROTest extends \Test\Ease\SandTest
11			{
12			/**
13			* @var FlexiBeeRO
14			*/
15			protected $object;
16
17			/**
18			* Example JSON
19			* @var string json
20			*/
21			public $json = '{"winstrom":{"@version":"1.0","adresar":[{"id":"2574","kontakty":[{"id":"299"}]}]}}';
22
23			/**
24			* Example XML
25			* @var string xml
26			*/
27			public $xml = '<?xml version="1.0" encoding="utf-8"?>
28
29			<winstrom version="1.0">
30			<!-- Adresář -->
31			<adresar>
32			<!-- ID (celé číslo) - -->
33			<id>2574</id>
34			<kontakty>
35			<!-- Kontakty -->
36			<kontakt>
37			<!-- ID (celé číslo) - -->
38			<id>299</id>
39			</kontakt>
40			</kontakty>
Spoje-NET / FlexiPeeHP

Push — master ( 0e13f3...6d8a3f )

FlexiBeeROTest::testRawXmlToArray() A

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like
