route4me / route4me-php-sdk

UnitTestFiles/Test/TerritoryTests.php

Indentation +299 added lines, -299 removed lines

@@ -9,303 +9,303 @@
 
 class TerritoryTests extends \PHPUnit\Framework\TestCase
 {
-    public static $createdTerritories = [];
-
-    public static function setUpBeforeClass()
-    {
-        Route4Me::setApiKey(Constants::API_KEY);
-
-        $territory = new Territory();
-
-        $territoryParams['type'] = TerritoryTypes::CIRCLE;
-        $territoryParams['data'] = [
-            '37.569752822786455,-77.47833251953125',
-            '5000',
-        ];
-
-        $TerritoryParameters = Territory::fromArray([
-            'territory_name' => 'Test Territory '.strval(rand(10000, 99999)),
-            'territory_color' => 'ff7700',
-            'territory' => $territoryParams,
-        ]);
-
-        $territory = new Territory();
-
-        $response = $territory->addTerritory($TerritoryParameters);
-
-        self::assertNotNull($response);
-        self::assertTrue(is_array($response));
-        self::assertInstanceOf(Territory::class, Territory::fromArray($response));
-        self::assertTrue(isset($response['territory_id']));
-
-        self::$createdTerritories[] = $response['territory_id'];
-    }
-
-    public function testFromArray()
-    {
-        $terrName = 'Test Territory '.strval(rand(10000, 99999));
-
-        $territory = Territory::fromArray([
-            'territory_name'    => $terrName,
-            'territory_color'   => 'ff7700',
-            'territory'         => [
-                'type' => TerritoryTypes::CIRCLE,
-                'data' => [
-                    '37.569752822786455,-77.47833251953125',
-                    '5000',
-                ]
-            ],
-        ]);
-
-        $this->assertEquals($terrName, $territory->territory_name);
-        $this->assertEquals('ff7700', $territory->territory_color);
-        $this->assertEquals(
-            [
-                'type' => TerritoryTypes::CIRCLE,
-                'data' => [
-                    '37.569752822786455,-77.47833251953125',
-                    '5000',
-                ]
-            ],
-            $territory->territory);
-    }
-
-    public function testToArray()
-    {
-        $terrName = 'Test Territory '.strval(rand(10000, 99999));
-
-        $territory = Territory::fromArray([
-            'territory_name'    => $terrName,
-            'territory_color'   => 'ff7700',
-            'territory'         => [
-                'type' => TerritoryTypes::CIRCLE,
-                'data' => [
-                    '37.569752822786455,-77.47833251953125',
-                    '5000',
-                ]
-            ],
-        ]);
-
-        $this->assertEquals(
-            $territory->toArray(),
-            [
-                'territory_name'    => $terrName,
-                'territory_color'   => 'ff7700',
-                'territory'         => [
-                    'type' => TerritoryTypes::CIRCLE,
-                    'data' => [
-                        '37.569752822786455,-77.47833251953125',
-                        '5000',
-                    ]
-                ],
-            ]
-        );
-    }
-
-    public function testGetTerritories()
-    {
-        $territory = new Territory();
-
-        $queryParameters = [
-            'offset' => 0,
-            'limit'  => 20,
-        ];
-
-        $response = $territory->getTerritories($queryParameters);
-
-        $this->assertNotNull($response);
-        $this->assertTrue(is_array($response));
-        $this->assertTrue(sizeof($response)>0);
-        $this->assertInstanceOf(Territory::class, Territory::fromArray($response[0]));
-    }
-
-    public function testGetTerritory(){
-        $territory = new Territory();
-
-        $params = [
-            'territory_id' => self::$createdTerritories[0],
-        ];
-
-        $response = $territory->getTerritory($params);
-
-        $this->assertNotNull($response);
-        $this->assertTrue(is_array($response));
-        $this->assertInstanceOf(Territory::class, Territory::fromArray($response));
-        $this->assertTrue(isset($response['territory_id']));
-        $this->assertEquals(self::$createdTerritories[0],$response['territory_id']);
-    }
-
-    public function testCreateCircleTerritory()
-    {
-        $territoryParams['type'] = TerritoryTypes::CIRCLE;
-        $territoryParams['data'] = [
-            '37.569752822786455,-77.47833251953125',
-            '5100',
-        ];
-
-        $TerritoryParameters = Territory::fromArray([
-            'territory_name'    => 'Test Circle Territory '.strval(rand(10000, 99999)),
-            'territory_color'   => 'ff7700',
-            'territory' => $territoryParams,
-        ]);
-
-        $territory = new Territory();
-
-        $response = $territory->addTerritory($TerritoryParameters);
-
-        $this->assertNotNull($response);
-        $this->assertTrue(is_array($response));
-        $this->assertInstanceOf(Territory::class, Territory::fromArray($response));
-        $this->assertTrue(isset($response['territory']));
-        $this->assertTrue(isset($response['territory']['type']));
-
-        $this->assertEquals(
-            TerritoryTypes::CIRCLE,
-            $response['territory']['type']
-        );
-
-        self::$createdTerritories[] = $response['territory_id'];
-    }
-
-    public function testCreateRectangularTerritory()
-    {
-        $territoryParams['type'] = TerritoryTypes::RECT;
-        $territoryParams['data'] = [
-            '43.51668853502909,-109.3798828125',
-            '46.98025235521883,-101.865234375',
-        ];
-
-        $TerritoryParameters = Territory::fromArray([
-            'territory_name'    => 'Test Rectangular Territory '.strval(rand(10000, 99999)),
-            'territory_color'   => 'ff7705',
-            'territory' => $territoryParams,
-        ]);
-
-        $territory = new Territory();
-
-        $response = $territory->addTerritory($TerritoryParameters);
-
-        $this->assertNotNull($response);
-        $this->assertTrue(is_array($response));
-        $this->assertInstanceOf(Territory::class, Territory::fromArray($response));
-        $this->assertTrue(isset($response['territory']));
-        $this->assertTrue(isset($response['territory']['type']));
-
-        $this->assertEquals(
-            TerritoryTypes::RECT,
-            $response['territory']['type']
-        );
-
-        self::$createdTerritories[] = $response['territory_id'];
-    }
-
-    public function testCreatePolygonTerritory()
-    {
-        $territoryParams['type'] = TerritoryTypes::POLY;
-        $territoryParams['data'] = [
-            '37.769752822786455,-77.67833251953125',
-            '37.75886716305343,-77.68974800109863',
-            '37.74763966054455,-77.6917221069336',
-            '37.74655084306813,-77.68863220214844',
-            '37.7502255383101,-77.68125076293945',
-            '37.74797991274437,-77.67498512268066',
-            '37.73327960206065,-77.6411678314209',
-            '37.74430510679532,-77.63172645568848',
-            '37.76641925847049,-77.66846199035645',
-        ];
-
-        $TerritoryParameters = Territory::fromArray([
-            'territory_name'    => 'Test Polygon Territory '.strval(rand(10000, 99999)),
-            'territory_color'   => 'ff7707',
-            'territory' => $territoryParams,
-        ]);
-
-        $territory = new Territory();
-
-        $response = $territory->addTerritory($TerritoryParameters);
-
-        $this->assertNotNull($response);
-        $this->assertTrue(is_array($response));
-        $this->assertInstanceOf(Territory::class, Territory::fromArray($response));
-        $this->assertTrue(isset($response['territory']));
-        $this->assertTrue(isset($response['territory']['type']));
-
-        $this->assertEquals(
-            TerritoryTypes::POLY,
-            $response['territory']['type']
-        );
-
-        self::$createdTerritories[] = $response['territory_id'];
-    }
-
-    public function testUpdateTerritory()
-    {
-        $territory = new Territory();
-
-        // Update territory
-        $territoryParameters = [
-            'type' => TerritoryTypes::RECT,
-            'data' => [
-                '29.6600127358956,-95.6593322753906',
-                '29.8966150753098,-95.3146362304688',
-            ],
-        ];
-
-        $TerritoryParameters = Territory::fromArray([
-            'territory_id'      => self::$createdTerritories[0],
-            'territory_name'    => 'Test Territory Updated as rectangle',
-            'territory_color'   => 'ff5500',
-            'territory'         => $territoryParameters,
-        ]);
-
-        $response = $territory->updateTerritory($TerritoryParameters);
-
-        $this->assertNotNull($response);
-        $this->assertTrue(is_array($response));
-        $this->assertInstanceOf(Territory::class, Territory::fromArray($response));
-        $this->assertTrue(isset($response['territory']));
-        $this->assertTrue(isset($response['territory']['type']));
-
-        $this->assertEquals(
-            TerritoryTypes::RECT,
-            $response['territory']['type']
-        );
-
-        $this->assertEquals(
-            'Test Territory Updated as rectangle',
-            $response['territory_name']
-        );
-    }
-
-    public function testRemoveTerritory()
-    {
-        $territory = new Territory();
-
-        $territoryId = self::$createdTerritories[sizeof(self::$createdTerritories)-1];
-
-        $response = $territory->deleteTerritory($territoryId);
-
-        $this->assertNotNull($response);
-        $this->assertTrue(isset($response['status']));
-        $this->assertTrue($response['status']);
-
-        self::$createdTerritories[] = array_pop(self::$createdTerritories);
-    }
-
-    public static function tearDownAfterClass()
-    {
-        if (sizeof(self::$createdTerritories)<1) return;
-
-        $territory = new Territory();
-
-        foreach (self::$createdTerritories as $createdTerritoryId) {
-            $result1 = $territory->deleteTerritory($createdTerritoryId);
-
-            if (!is_null($result1) && isset($result1['status']) && $result1['status']) {
-                echo "Removed the territory ".$createdTerritoryId." <br>";
-            } else {
-                echo "Cannot removed the territory ".$createdTerritoryId." <br>";
-            }
-        }
-    }
+	public static $createdTerritories = [];
+
+	public static function setUpBeforeClass()
+	{
+		Route4Me::setApiKey(Constants::API_KEY);
+
+		$territory = new Territory();
+
+		$territoryParams['type'] = TerritoryTypes::CIRCLE;
+		$territoryParams['data'] = [
+			'37.569752822786455,-77.47833251953125',
+			'5000',
+		];
+
+		$TerritoryParameters = Territory::fromArray([
+			'territory_name' => 'Test Territory '.strval(rand(10000, 99999)),
+			'territory_color' => 'ff7700',
+			'territory' => $territoryParams,
+		]);
+
+		$territory = new Territory();
+
+		$response = $territory->addTerritory($TerritoryParameters);
+
+		self::assertNotNull($response);
+		self::assertTrue(is_array($response));
+		self::assertInstanceOf(Territory::class, Territory::fromArray($response));
+		self::assertTrue(isset($response['territory_id']));
+
+		self::$createdTerritories[] = $response['territory_id'];
+	}
+
+	public function testFromArray()
+	{
+		$terrName = 'Test Territory '.strval(rand(10000, 99999));
+
+		$territory = Territory::fromArray([
+			'territory_name'    => $terrName,
+			'territory_color'   => 'ff7700',
+			'territory'         => [
+				'type' => TerritoryTypes::CIRCLE,
+				'data' => [
+					'37.569752822786455,-77.47833251953125',
+					'5000',
+				]
+			],
+		]);
+
+		$this->assertEquals($terrName, $territory->territory_name);
+		$this->assertEquals('ff7700', $territory->territory_color);
+		$this->assertEquals(
+			[
+				'type' => TerritoryTypes::CIRCLE,
+				'data' => [
+					'37.569752822786455,-77.47833251953125',
+					'5000',
+				]
+			],
+			$territory->territory);
+	}
+
+	public function testToArray()
+	{
+		$terrName = 'Test Territory '.strval(rand(10000, 99999));
+
+		$territory = Territory::fromArray([
+			'territory_name'    => $terrName,
+			'territory_color'   => 'ff7700',
+			'territory'         => [
+				'type' => TerritoryTypes::CIRCLE,
+				'data' => [
+					'37.569752822786455,-77.47833251953125',
+					'5000',
+				]
+			],
+		]);
+
+		$this->assertEquals(
+			$territory->toArray(),
+			[
+				'territory_name'    => $terrName,
+				'territory_color'   => 'ff7700',
+				'territory'         => [
+					'type' => TerritoryTypes::CIRCLE,
+					'data' => [
+						'37.569752822786455,-77.47833251953125',
+						'5000',
+					]
+				],
+			]
+		);
+	}
+
+	public function testGetTerritories()
+	{
+		$territory = new Territory();
+
+		$queryParameters = [
+			'offset' => 0,
+			'limit'  => 20,
+		];
+
+		$response = $territory->getTerritories($queryParameters);
+
+		$this->assertNotNull($response);
+		$this->assertTrue(is_array($response));
+		$this->assertTrue(sizeof($response)>0);
+		$this->assertInstanceOf(Territory::class, Territory::fromArray($response[0]));
+	}
+
+	public function testGetTerritory(){
+		$territory = new Territory();
+
+		$params = [
+			'territory_id' => self::$createdTerritories[0],
+		];
+
+		$response = $territory->getTerritory($params);
+
+		$this->assertNotNull($response);
+		$this->assertTrue(is_array($response));
+		$this->assertInstanceOf(Territory::class, Territory::fromArray($response));
+		$this->assertTrue(isset($response['territory_id']));
+		$this->assertEquals(self::$createdTerritories[0],$response['territory_id']);
+	}
+
+	public function testCreateCircleTerritory()
+	{
+		$territoryParams['type'] = TerritoryTypes::CIRCLE;
+		$territoryParams['data'] = [
+			'37.569752822786455,-77.47833251953125',
+			'5100',
+		];
+
+		$TerritoryParameters = Territory::fromArray([
+			'territory_name'    => 'Test Circle Territory '.strval(rand(10000, 99999)),
+			'territory_color'   => 'ff7700',
+			'territory' => $territoryParams,
+		]);
+
+		$territory = new Territory();
+
+		$response = $territory->addTerritory($TerritoryParameters);
+
+		$this->assertNotNull($response);
+		$this->assertTrue(is_array($response));
+		$this->assertInstanceOf(Territory::class, Territory::fromArray($response));
+		$this->assertTrue(isset($response['territory']));
+		$this->assertTrue(isset($response['territory']['type']));
+
+		$this->assertEquals(
+			TerritoryTypes::CIRCLE,
+			$response['territory']['type']
+		);
+
+		self::$createdTerritories[] = $response['territory_id'];
+	}
+
+	public function testCreateRectangularTerritory()
+	{
+		$territoryParams['type'] = TerritoryTypes::RECT;
+		$territoryParams['data'] = [
+			'43.51668853502909,-109.3798828125',
+			'46.98025235521883,-101.865234375',
+		];
+
+		$TerritoryParameters = Territory::fromArray([
+			'territory_name'    => 'Test Rectangular Territory '.strval(rand(10000, 99999)),
+			'territory_color'   => 'ff7705',
+			'territory' => $territoryParams,
+		]);
+
+		$territory = new Territory();
+
+		$response = $territory->addTerritory($TerritoryParameters);
+
+		$this->assertNotNull($response);
+		$this->assertTrue(is_array($response));
+		$this->assertInstanceOf(Territory::class, Territory::fromArray($response));
+		$this->assertTrue(isset($response['territory']));
+		$this->assertTrue(isset($response['territory']['type']));
+
+		$this->assertEquals(
+			TerritoryTypes::RECT,
+			$response['territory']['type']
+		);
+
+		self::$createdTerritories[] = $response['territory_id'];
+	}
+
+	public function testCreatePolygonTerritory()
+	{
+		$territoryParams['type'] = TerritoryTypes::POLY;
+		$territoryParams['data'] = [
+			'37.769752822786455,-77.67833251953125',
+			'37.75886716305343,-77.68974800109863',
+			'37.74763966054455,-77.6917221069336',
+			'37.74655084306813,-77.68863220214844',
+			'37.7502255383101,-77.68125076293945',
+			'37.74797991274437,-77.67498512268066',
+			'37.73327960206065,-77.6411678314209',
+			'37.74430510679532,-77.63172645568848',
+			'37.76641925847049,-77.66846199035645',
+		];
+
+		$TerritoryParameters = Territory::fromArray([
+			'territory_name'    => 'Test Polygon Territory '.strval(rand(10000, 99999)),
+			'territory_color'   => 'ff7707',
+			'territory' => $territoryParams,
+		]);
+
+		$territory = new Territory();
+
+		$response = $territory->addTerritory($TerritoryParameters);
+
+		$this->assertNotNull($response);
+		$this->assertTrue(is_array($response));
+		$this->assertInstanceOf(Territory::class, Territory::fromArray($response));
+		$this->assertTrue(isset($response['territory']));
+		$this->assertTrue(isset($response['territory']['type']));
+
+		$this->assertEquals(
+			TerritoryTypes::POLY,
+			$response['territory']['type']
+		);
+
+		self::$createdTerritories[] = $response['territory_id'];
+	}
+
+	public function testUpdateTerritory()
+	{
+		$territory = new Territory();
+
+		// Update territory
+		$territoryParameters = [
+			'type' => TerritoryTypes::RECT,
+			'data' => [
+				'29.6600127358956,-95.6593322753906',
+				'29.8966150753098,-95.3146362304688',
+			],
+		];
+
+		$TerritoryParameters = Territory::fromArray([
+			'territory_id'      => self::$createdTerritories[0],
+			'territory_name'    => 'Test Territory Updated as rectangle',
+			'territory_color'   => 'ff5500',
+			'territory'         => $territoryParameters,
+		]);
+
+		$response = $territory->updateTerritory($TerritoryParameters);
+
+		$this->assertNotNull($response);
+		$this->assertTrue(is_array($response));
+		$this->assertInstanceOf(Territory::class, Territory::fromArray($response));
+		$this->assertTrue(isset($response['territory']));
+		$this->assertTrue(isset($response['territory']['type']));
+
+		$this->assertEquals(
+			TerritoryTypes::RECT,
+			$response['territory']['type']
+		);
+
+		$this->assertEquals(
+			'Test Territory Updated as rectangle',
+			$response['territory_name']
+		);
+	}
+
+	public function testRemoveTerritory()
+	{
+		$territory = new Territory();
+
+		$territoryId = self::$createdTerritories[sizeof(self::$createdTerritories)-1];
+
+		$response = $territory->deleteTerritory($territoryId);
+
+		$this->assertNotNull($response);
+		$this->assertTrue(isset($response['status']));
+		$this->assertTrue($response['status']);
+
+		self::$createdTerritories[] = array_pop(self::$createdTerritories);
+	}
+
+	public static function tearDownAfterClass()
+	{
+		if (sizeof(self::$createdTerritories)<1) return;
+
+		$territory = new Territory();
+
+		foreach (self::$createdTerritories as $createdTerritoryId) {
+			$result1 = $territory->deleteTerritory($createdTerritoryId);
+
+			if (!is_null($result1) && isset($result1['status']) && $result1['status']) {
+				echo "Removed the territory ".$createdTerritoryId." <br>";
+			} else {
+				echo "Cannot removed the territory ".$createdTerritoryId." <br>";
+			}
+		}
+	}
 }
\ No newline at end of file

UnitTestFiles/Test/AddressNoteUnitTests.php

Indentation +386 added lines, -386 removed lines

@@ -16,418 +16,418 @@
 
 class AddressNoteUnitTests extends \PHPUnit\Framework\TestCase
 {
-    protected $addressNote;
-
-    public static $problem;
-
-    public static $route_id = null;
-    public static $address_id = null;
-    public static $address_lat = null;
-    public static $address_lng = null;
-    public static $address_is_depot = null;
-    public static $noteAddressId = null;
-    public static $noteFileAddressId = null;
-
-    public static $addresIdMarkedAsVisited;
-
-    public static $afterAddressId;
-    public static $route_id_dest;
-
-    public static $createdCustomNotes;
-
-    public static function setUpBeforeClass()
-    {
-        if (Constants::API_KEY == Constants::DEMO_API_KEY) {
-            $className = str_replace('UnitTestFiles\\Test\\','',get_class());
-            self::markTestSkipped( 'PHPUnit will skip '. $className ." class - it impossible run with demo API key" );
-        }
-
-        Route4Me::setApiKey(Constants::API_KEY);
-
-        //<editor-fold desc="Prepare Addresses">
-        $addresses = [];
-        $addresses[] = Address::fromArray([
-            'address'           => '11497 Columbia Park Dr W, Jacksonville, FL 32258',
-            'is_depot'          => true,
-            'lat'               => 30.159341812134,
-            'lng'               => -81.538619995117,
-            'time'              => 300,
-            'time_window_start' => 28800,
-            'time_window_end'   => 32400,
-        ]);
-
-        $addresses[] = Address::fromArray([
-            'address'           => '214 Edgewater Branch Drive 32259',
-            'lat'               => 30.103567123413,
-            'lng'               => -81.595352172852,
-            'time'              => 300,
-            'time_window_start' => 36000,
-            'time_window_end'   => 37200,
-        ]);
-
-        $addresses[] = Address::fromArray([
-            'address'           => '756 eagle point dr 32092',
-            'lat'               => 30.046422958374,
-            'lng'               => -81.508758544922,
-            'time'              => 300,
-            'time_window_start' => 39600,
-            'time_window_end'   => 41400,
-        ]);
-
-        $addresses[] = Address::fromArray([
-            'address'           => '63 Stone Creek Cir St Johns, FL 32259, USA',
-            'lat'               => 30.048496,
-            'lng'               => -81.558716,
-            'time'              => 300,
-            'time_window_start' => 43200,
-            'time_window_end'   => 45000,
-        ]);
-
-        $addresses[] = Address::fromArray([
-            'address'           => 'St Johns Florida 32259, USA',
-            'lat'               => 30.099642,
-            'lng'               => -81.547201,
-            'time'              => 300,
-            'time_window_start' => 46800,
-            'time_window_end'   => 48600,
-        ]);
-
-        $parameters = RouteParameters::fromArray([
-            'device_type'           => DeviceType::IPAD,
-            'disable_optimization'  => false,
-            'route_name'            => 'phpunit test '.date('Y-m-d H:i'),
-        ]);
-        //</editor-fold>
-
-        $optimizationParameters = new OptimizationProblemParams();
-        $optimizationParameters->setAddresses($addresses);
-        $optimizationParameters->setParameters($parameters);
-
-        self::$problem = OptimizationProblem::optimize($optimizationParameters);
-        $routes = self::$problem->getRoutes();
-        self::$route_id = $routes[0]->route_id;
-        self::$noteAddressId = $routes[0]->addresses[2]->route_destination_id;
-        self::$noteFileAddressId = $routes[0]->addresses[3]->route_destination_id;
-
-        $addresses = self::$problem->addresses;
-        self::$address_id = $addresses[1]->getAddressId();
-        //self::$address_address = $addresses[1]->address;
-        self::$address_lat = $addresses[1]->lat;
-        self::$address_lng = $addresses[1]->lng;
-        self::$address_is_depot = $addresses[1]->is_depot;
-
-        $noteParameters = [
-            'route_id'          => self::$route_id,
-            'address_id'        => self::$address_id,
-            'dev_lat'           => self::$address_lat,
-            'dev_lng'           => self::$address_lng,
-            'device_type'       => 'web',
-            'strUpdateType'     => 'dropoff',
-            'strNoteContents'   => 'Test Address Note',
-        ];
-
-        $addressNote = new AddressNote();
-
-        $addresses[1] = $addressNote->AddAddressNote($noteParameters);
-
-        self::$createdCustomNotes = [];
-
-        $customNoteTypes = $addressNote->getAllCustomNoteTypes();
-
-        foreach ($customNoteTypes as $custNote) {
-            if ($custNote['note_custom_type'] == 'Unit Test To Do') {
-                self::$createdCustomNotes[]='Unit Test To Do';
-            }
-        }
-
-        if (sizeof(self::$createdCustomNotes)<1) {
-            $customNoteTypeParameters = [
-                'type'   => 'Unit Test To Do',
-                'values' => [
-                    'Pass a package',
-                    'Pickup package',
-                    'Do a service',
-                ],
-            ];
-
-            $customNoteTypeResult = $addressNote->createCustomNoteType($customNoteTypeParameters);
-
-            if ($customNoteTypeResult!=null
-                && $customNoteTypeResult['result']!=null
-                && $customNoteTypeResult['result']=='OK'
-                && $customNoteTypeResult['affected']!=null
-                && $customNoteTypeResult['affected']==1
-            ) {
-                self::$createdCustomNotes[]='Unit Test To Do';
-            }
-        }
-    }
-
-    public function testFromArray()
-    {
-        $addressNote = AddressNote::fromArray([
-            'note_id'               => 539264,
-            'route_id'              => '5555E83A4BE0055551537955558D5555',
-            'route_destination_id'  => 162916895,
-            'ts_added'              => 1466515325,
-            'activity_type'         => 'dropoff',
-            'upload_id'             => '1a499993c63d68d1a5d26045a1763d16',
-            'upload_extension'      => 'csv',
-            'upload_url'            => 'http:\/\/adb6def9928467589ebb-f540d5a8d53c2e76ad581b6e5c346ad6.\/1a499113c63d68d1a5d26045a1763d16.csv',
-            'upload_type'           => 'ANY_FILE',
-            'contents'              => 'Some text',
-            'lat'                   => 33.132675,
-            'lng'                   => -83.244743,
-            'device_type'           => 'web'
-        ]);
-
-        $this->assertEquals(539264, $addressNote->note_id);
-        $this->assertEquals('5555E83A4BE0055551537955558D5555', $addressNote->route_id);
-        $this->assertEquals(162916895, $addressNote->route_destination_id);
-        $this->assertEquals(1466515325, $addressNote->ts_added);
-        $this->assertEquals('dropoff', $addressNote->activity_type);
-        $this->assertEquals('1a499993c63d68d1a5d26045a1763d16', $addressNote->upload_id);
-        $this->assertEquals('csv', $addressNote->upload_extension);
-        $this->assertEquals('http:\/\/adb6def9928467589ebb-f540d5a8d53c2e76ad581b6e5c346ad6.\/1a499113c63d68d1a5d26045a1763d16.csv', $addressNote->upload_url);
-        $this->assertEquals('ANY_FILE', $addressNote->upload_type);
-        $this->assertEquals('Some text', $addressNote->contents);
-        $this->assertEquals(33.132675, $addressNote->lat);
-        $this->assertEquals(-83.244743, $addressNote->lng);
-        $this->assertEquals('web', $addressNote->device_type);
-    }
-
-    public function testGetAddressesNotes()
-    {
-        $noteParameters = [
-            'route_id'              => self::$route_id,
-            'route_destination_id'  => self::$address_id,
-        ];
-
-        $addressNote = new AddressNote();
-
-        $addressWithNotes = Address::fromArray(
-             $addressNote->GetAddressesNotes($noteParameters)
-        );
-
-        $firstNote = AddressNote::fromArray(
-            $addressWithNotes->notes[0]
-        );
-
-        $this->assertNotNull($addressWithNotes);
-        $this->assertTrue(sizeof( $addressWithNotes->notes)>0);
-        $this->assertContainsOnlyInstancesOf(AddressNote::class, [$firstNote]);
-        $this->assertEquals('Test Address Note', $firstNote->contents);
-        $this->assertEquals('dropoff',$firstNote->activity_type);
-    }
-
-    public function testAddAddressNote()
-    {
-        $noteParameters = [
-            'strFilename'       => 'notes.csv',
-            'route_id'          => self::$route_id,
-            'address_id'        => self::$noteAddressId,
-            'dev_lat'           => 33.132675170898,
-            'dev_lng'           => -83.244743347168,
-            'device_type'       => 'web',
-            'strUpdateType'     => 'dropoff',
-            'strNoteContents'   => 'Test Add Note To Route Address',
-        ];
-
-        $addressNote = new AddressNote();
-
-        $response = AddressNoteResponse::fromArray(
-            $addressNote->AddAddressNote($noteParameters)
-        );
-
-        $this->assertNotNull($response);
-        $this->assertContainsOnlyInstancesOf(AddressNoteResponse::class, [$response]);
-
-        $firstNote = AddressNote::fromArray(
-            $response->note
-        );
-
-        $this->assertContainsOnlyInstancesOf(AddressNote::class, [$firstNote]);
-        $this->assertEquals('Test Add Note To Route Address', $firstNote->contents);
-        $this->assertNotNull($firstNote->upload_id);
-    }
-
-    public function testAddNoteFile()
-    {
-        //$this->markTestSkipped('must be revisited.');
-
-        $noteParameters = [
-            'strFilename'   => dirname(__FILE__).'\data\notes.csv',
-            'route_id'      => self::$route_id,
-            'address_id'    => self::$noteFileAddressId,
-            'dev_lat'       => 33.132675170898,
-            'dev_lng'       => -83.244743347168,
-            'device_type'   => 'web',
-            'strUpdateType' => 'dropoff',
-        ];
-
-        $addressNote = new AddressNote();
-
-        $result = $addressNote->AddNoteFile($noteParameters);
-
-        $response = AddressNoteResponse::fromArray(
-            $result
-        );
-
-        sleep(5);
-
-        $this->assertNotNull($response);
-        $this->assertNotNull($response->status);
-        $this->assertTrue($response->status);
-        $this->assertContainsOnlyInstancesOf(AddressNoteResponse::class, [$response]);
-
-        $firstNote = AddressNote::fromArray(
-            $response->note
-        );
-
-        $this->assertContainsOnlyInstancesOf(AddressNote::class, [$firstNote]);
-        $this->assertNotNull($firstNote->upload_id);
-        $this->assertNotNull($firstNote->upload_url);
-        $this->assertEquals('csv', $firstNote->upload_extension);
-    }
-
-    public function testGetCustomNoteTypeByKey()
-    {
-        $addressNote = new AddressNote();
-
-        $customNoteType = $addressNote->getCustomNoteTypeByKey(self::$createdCustomNotes[0]);
-
-        $this->assertEquals(self::$createdCustomNotes[0],$customNoteType['note_custom_type']);
-    }
-
-    public function testGetAllCustomNoteTypes()
-    {
-        $addressNote = new AddressNote();
-
-        $customNoteTypes =  $addressNote->getAllCustomNoteTypes();
-
-        $firstCustomNoteType = CustomNoteTypeResponse::fromArray($customNoteTypes[0]);
-
-        $this->assertNotNull($customNoteTypes);
-        $this->assertTrue(sizeof($customNoteTypes)>0);
-        $this->assertContainsOnlyInstancesOf(CustomNoteTypeResponse::class, [$firstCustomNoteType]);
-    }
-
-    public function testCreateCustomNoteType()
-    {
-        $customNoteTypeKey = 'cnt'.date('yMdHi');
-
-        $noteParameters = [
-            'type'   => $customNoteTypeKey,
-            'values' => [
-                'First value',
-                'Second value',
-                'Third value',
-            ],
-        ];
+	protected $addressNote;
+
+	public static $problem;
+
+	public static $route_id = null;
+	public static $address_id = null;
+	public static $address_lat = null;
+	public static $address_lng = null;
+	public static $address_is_depot = null;
+	public static $noteAddressId = null;
+	public static $noteFileAddressId = null;
+
+	public static $addresIdMarkedAsVisited;
+
+	public static $afterAddressId;
+	public static $route_id_dest;
+
+	public static $createdCustomNotes;
+
+	public static function setUpBeforeClass()
+	{
+		if (Constants::API_KEY == Constants::DEMO_API_KEY) {
+			$className = str_replace('UnitTestFiles\\Test\\','',get_class());
+			self::markTestSkipped( 'PHPUnit will skip '. $className ." class - it impossible run with demo API key" );
+		}
+
+		Route4Me::setApiKey(Constants::API_KEY);
+
+		//<editor-fold desc="Prepare Addresses">
+		$addresses = [];
+		$addresses[] = Address::fromArray([
+			'address'           => '11497 Columbia Park Dr W, Jacksonville, FL 32258',
+			'is_depot'          => true,
+			'lat'               => 30.159341812134,
+			'lng'               => -81.538619995117,
+			'time'              => 300,
+			'time_window_start' => 28800,
+			'time_window_end'   => 32400,
+		]);
+
+		$addresses[] = Address::fromArray([
+			'address'           => '214 Edgewater Branch Drive 32259',
+			'lat'               => 30.103567123413,
+			'lng'               => -81.595352172852,
+			'time'              => 300,
+			'time_window_start' => 36000,
+			'time_window_end'   => 37200,
+		]);
+
+		$addresses[] = Address::fromArray([
+			'address'           => '756 eagle point dr 32092',
+			'lat'               => 30.046422958374,
+			'lng'               => -81.508758544922,
+			'time'              => 300,
+			'time_window_start' => 39600,
+			'time_window_end'   => 41400,
+		]);
+
+		$addresses[] = Address::fromArray([
+			'address'           => '63 Stone Creek Cir St Johns, FL 32259, USA',
+			'lat'               => 30.048496,
+			'lng'               => -81.558716,
+			'time'              => 300,
+			'time_window_start' => 43200,
+			'time_window_end'   => 45000,
+		]);
+
+		$addresses[] = Address::fromArray([
+			'address'           => 'St Johns Florida 32259, USA',
+			'lat'               => 30.099642,
+			'lng'               => -81.547201,
+			'time'              => 300,
+			'time_window_start' => 46800,
+			'time_window_end'   => 48600,
+		]);
+
+		$parameters = RouteParameters::fromArray([
+			'device_type'           => DeviceType::IPAD,
+			'disable_optimization'  => false,
+			'route_name'            => 'phpunit test '.date('Y-m-d H:i'),
+		]);
+		//</editor-fold>
+
+		$optimizationParameters = new OptimizationProblemParams();
+		$optimizationParameters->setAddresses($addresses);
+		$optimizationParameters->setParameters($parameters);
+
+		self::$problem = OptimizationProblem::optimize($optimizationParameters);
+		$routes = self::$problem->getRoutes();
+		self::$route_id = $routes[0]->route_id;
+		self::$noteAddressId = $routes[0]->addresses[2]->route_destination_id;
+		self::$noteFileAddressId = $routes[0]->addresses[3]->route_destination_id;
+
+		$addresses = self::$problem->addresses;
+		self::$address_id = $addresses[1]->getAddressId();
+		//self::$address_address = $addresses[1]->address;
+		self::$address_lat = $addresses[1]->lat;
+		self::$address_lng = $addresses[1]->lng;
+		self::$address_is_depot = $addresses[1]->is_depot;
+
+		$noteParameters = [
+			'route_id'          => self::$route_id,
+			'address_id'        => self::$address_id,
+			'dev_lat'           => self::$address_lat,
+			'dev_lng'           => self::$address_lng,
+			'device_type'       => 'web',
+			'strUpdateType'     => 'dropoff',
+			'strNoteContents'   => 'Test Address Note',
+		];
+
+		$addressNote = new AddressNote();
+
+		$addresses[1] = $addressNote->AddAddressNote($noteParameters);
+
+		self::$createdCustomNotes = [];
+
+		$customNoteTypes = $addressNote->getAllCustomNoteTypes();
+
+		foreach ($customNoteTypes as $custNote) {
+			if ($custNote['note_custom_type'] == 'Unit Test To Do') {
+				self::$createdCustomNotes[]='Unit Test To Do';
+			}
+		}
+
+		if (sizeof(self::$createdCustomNotes)<1) {
+			$customNoteTypeParameters = [
+				'type'   => 'Unit Test To Do',
+				'values' => [
+					'Pass a package',
+					'Pickup package',
+					'Do a service',
+				],
+			];
+
+			$customNoteTypeResult = $addressNote->createCustomNoteType($customNoteTypeParameters);
+
+			if ($customNoteTypeResult!=null
+				&& $customNoteTypeResult['result']!=null
+				&& $customNoteTypeResult['result']=='OK'
+				&& $customNoteTypeResult['affected']!=null
+				&& $customNoteTypeResult['affected']==1
+			) {
+				self::$createdCustomNotes[]='Unit Test To Do';
+			}
+		}
+	}
+
+	public function testFromArray()
+	{
+		$addressNote = AddressNote::fromArray([
+			'note_id'               => 539264,
+			'route_id'              => '5555E83A4BE0055551537955558D5555',
+			'route_destination_id'  => 162916895,
+			'ts_added'              => 1466515325,
+			'activity_type'         => 'dropoff',
+			'upload_id'             => '1a499993c63d68d1a5d26045a1763d16',
+			'upload_extension'      => 'csv',
+			'upload_url'            => 'http:\/\/adb6def9928467589ebb-f540d5a8d53c2e76ad581b6e5c346ad6.\/1a499113c63d68d1a5d26045a1763d16.csv',
+			'upload_type'           => 'ANY_FILE',
+			'contents'              => 'Some text',
+			'lat'                   => 33.132675,
+			'lng'                   => -83.244743,
+			'device_type'           => 'web'
+		]);
+
+		$this->assertEquals(539264, $addressNote->note_id);
+		$this->assertEquals('5555E83A4BE0055551537955558D5555', $addressNote->route_id);
+		$this->assertEquals(162916895, $addressNote->route_destination_id);
+		$this->assertEquals(1466515325, $addressNote->ts_added);
+		$this->assertEquals('dropoff', $addressNote->activity_type);
+		$this->assertEquals('1a499993c63d68d1a5d26045a1763d16', $addressNote->upload_id);
+		$this->assertEquals('csv', $addressNote->upload_extension);
+		$this->assertEquals('http:\/\/adb6def9928467589ebb-f540d5a8d53c2e76ad581b6e5c346ad6.\/1a499113c63d68d1a5d26045a1763d16.csv', $addressNote->upload_url);
+		$this->assertEquals('ANY_FILE', $addressNote->upload_type);
+		$this->assertEquals('Some text', $addressNote->contents);
+		$this->assertEquals(33.132675, $addressNote->lat);
+		$this->assertEquals(-83.244743, $addressNote->lng);
+		$this->assertEquals('web', $addressNote->device_type);
+	}
+
+	public function testGetAddressesNotes()
+	{
+		$noteParameters = [
+			'route_id'              => self::$route_id,
+			'route_destination_id'  => self::$address_id,
+		];
+
+		$addressNote = new AddressNote();
+
+		$addressWithNotes = Address::fromArray(
+			 $addressNote->GetAddressesNotes($noteParameters)
+		);
+
+		$firstNote = AddressNote::fromArray(
+			$addressWithNotes->notes[0]
+		);
+
+		$this->assertNotNull($addressWithNotes);
+		$this->assertTrue(sizeof( $addressWithNotes->notes)>0);
+		$this->assertContainsOnlyInstancesOf(AddressNote::class, [$firstNote]);
+		$this->assertEquals('Test Address Note', $firstNote->contents);
+		$this->assertEquals('dropoff',$firstNote->activity_type);
+	}
+
+	public function testAddAddressNote()
+	{
+		$noteParameters = [
+			'strFilename'       => 'notes.csv',
+			'route_id'          => self::$route_id,
+			'address_id'        => self::$noteAddressId,
+			'dev_lat'           => 33.132675170898,
+			'dev_lng'           => -83.244743347168,
+			'device_type'       => 'web',
+			'strUpdateType'     => 'dropoff',
+			'strNoteContents'   => 'Test Add Note To Route Address',
+		];
+
+		$addressNote = new AddressNote();
+
+		$response = AddressNoteResponse::fromArray(
+			$addressNote->AddAddressNote($noteParameters)
+		);
+
+		$this->assertNotNull($response);
+		$this->assertContainsOnlyInstancesOf(AddressNoteResponse::class, [$response]);
+
+		$firstNote = AddressNote::fromArray(
+			$response->note
+		);
+
+		$this->assertContainsOnlyInstancesOf(AddressNote::class, [$firstNote]);
+		$this->assertEquals('Test Add Note To Route Address', $firstNote->contents);
+		$this->assertNotNull($firstNote->upload_id);
+	}
+
+	public function testAddNoteFile()
+	{
+		//$this->markTestSkipped('must be revisited.');
+
+		$noteParameters = [
+			'strFilename'   => dirname(__FILE__).'\data\notes.csv',
+			'route_id'      => self::$route_id,
+			'address_id'    => self::$noteFileAddressId,
+			'dev_lat'       => 33.132675170898,
+			'dev_lng'       => -83.244743347168,
+			'device_type'   => 'web',
+			'strUpdateType' => 'dropoff',
+		];
+
+		$addressNote = new AddressNote();
+
+		$result = $addressNote->AddNoteFile($noteParameters);
+
+		$response = AddressNoteResponse::fromArray(
+			$result
+		);
+
+		sleep(5);
+
+		$this->assertNotNull($response);
+		$this->assertNotNull($response->status);
+		$this->assertTrue($response->status);
+		$this->assertContainsOnlyInstancesOf(AddressNoteResponse::class, [$response]);
+
+		$firstNote = AddressNote::fromArray(
+			$response->note
+		);
+
+		$this->assertContainsOnlyInstancesOf(AddressNote::class, [$firstNote]);
+		$this->assertNotNull($firstNote->upload_id);
+		$this->assertNotNull($firstNote->upload_url);
+		$this->assertEquals('csv', $firstNote->upload_extension);
+	}
+
+	public function testGetCustomNoteTypeByKey()
+	{
+		$addressNote = new AddressNote();
+
+		$customNoteType = $addressNote->getCustomNoteTypeByKey(self::$createdCustomNotes[0]);
+
+		$this->assertEquals(self::$createdCustomNotes[0],$customNoteType['note_custom_type']);
+	}
+
+	public function testGetAllCustomNoteTypes()
+	{
+		$addressNote = new AddressNote();
+
+		$customNoteTypes =  $addressNote->getAllCustomNoteTypes();
+
+		$firstCustomNoteType = CustomNoteTypeResponse::fromArray($customNoteTypes[0]);
+
+		$this->assertNotNull($customNoteTypes);
+		$this->assertTrue(sizeof($customNoteTypes)>0);
+		$this->assertContainsOnlyInstancesOf(CustomNoteTypeResponse::class, [$firstCustomNoteType]);
+	}
+
+	public function testCreateCustomNoteType()
+	{
+		$customNoteTypeKey = 'cnt'.date('yMdHi');
+
+		$noteParameters = [
+			'type'   => $customNoteTypeKey,
+			'values' => [
+				'First value',
+				'Second value',
+				'Third value',
+			],
+		];
 
-        $addressNote = new AddressNote();
+		$addressNote = new AddressNote();
 
-        $response = $addressNote->createCustomNoteType($noteParameters);
+		$response = $addressNote->createCustomNoteType($noteParameters);
 
-        $this->assertNotNull($response);
-        $this->assertNotNull($response['result']);
-        $this->assertEquals('OK', $response['result']);
-        $this->assertNotNull($response['affected']);
-        $this->assertEquals(1, $response['affected']);
+		$this->assertNotNull($response);
+		$this->assertNotNull($response['result']);
+		$this->assertEquals('OK', $response['result']);
+		$this->assertNotNull($response['affected']);
+		$this->assertEquals(1, $response['affected']);
 
-        self::$createdCustomNotes[] = $customNoteTypeKey;
-    }
+		self::$createdCustomNotes[] = $customNoteTypeKey;
+	}
 
-    public function testAddCustomNoteToRoute()
-    {
-        $addressNote = new AddressNote();
+	public function testAddCustomNoteToRoute()
+	{
+		$addressNote = new AddressNote();
 
-        $customNoteType = $addressNote->getCustomNoteTypeByKey(self::$createdCustomNotes[0]);
+		$customNoteType = $addressNote->getCustomNoteTypeByKey(self::$createdCustomNotes[0]);
 
-        $noteParameters = [
-            'route_id'          => self::$route_id,
-            'address_id'        => self::$address_id,
-            'format'            => 'json',
-            'dev_lat'           => 33.132675170898,
-            'dev_lng'           => -83.244743347168,
-            'custom_note_type['.$customNoteType["note_custom_type_id"].']' => 'Pickup package',
-            'strUpdateType'     => 'dropoff',
-            'strNoteContents'   => 'php test 1111',
-        ];
+		$noteParameters = [
+			'route_id'          => self::$route_id,
+			'address_id'        => self::$address_id,
+			'format'            => 'json',
+			'dev_lat'           => 33.132675170898,
+			'dev_lng'           => -83.244743347168,
+			'custom_note_type['.$customNoteType["note_custom_type_id"].']' => 'Pickup package',
+			'strUpdateType'     => 'dropoff',
+			'strNoteContents'   => 'php test 1111',
+		];
 
-        $response = AddressNoteResponse::fromArray(
-            $addressNote->addCustomNoteToRoute($noteParameters)
-        );
+		$response = AddressNoteResponse::fromArray(
+			$addressNote->addCustomNoteToRoute($noteParameters)
+		);
 
-        $this->assertNotNull($response);
-        $this->assertContainsOnlyInstancesOf(AddressNoteResponse::class, [$response]);
+		$this->assertNotNull($response);
+		$this->assertContainsOnlyInstancesOf(AddressNoteResponse::class, [$response]);
 
-        $note = AddressNote::fromArray($response->note);
-        $this->assertNotNull($note);
-        $this->assertNotNull($note->custom_types);
-        $this->assertTrue(sizeof($note->custom_types)>0);
+		$note = AddressNote::fromArray($response->note);
+		$this->assertNotNull($note);
+		$this->assertNotNull($note->custom_types);
+		$this->assertTrue(sizeof($note->custom_types)>0);
 
-        $customNote = CustomNoteType::fromArray($note->custom_types[0]);
+		$customNote = CustomNoteType::fromArray($note->custom_types[0]);
 
-        $this->assertContainsOnlyInstancesOf(CustomNoteType::class, [$customNote]);
-        $this->assertEquals('Pickup package',$customNote->note_custom_value);
-    }
+		$this->assertContainsOnlyInstancesOf(CustomNoteType::class, [$customNote]);
+		$this->assertEquals('Pickup package',$customNote->note_custom_value);
+	}
 
-    public function testRemoveCustomNoteType()
-    {
-        $addressNote = new AddressNote();
+	public function testRemoveCustomNoteType()
+	{
+		$addressNote = new AddressNote();
 
-        $customNoteType = $addressNote->getCustomNoteTypeByKey(self::$createdCustomNotes[0]);
+		$customNoteType = $addressNote->getCustomNoteTypeByKey(self::$createdCustomNotes[0]);
 
-        $customNoteTypeParameters = [
-            'id' => $customNoteType["note_custom_type_id"],
-        ];
+		$customNoteTypeParameters = [
+			'id' => $customNoteType["note_custom_type_id"],
+		];
 
-        $response = $addressNote->removeCustomNoteType($customNoteTypeParameters);
+		$response = $addressNote->removeCustomNoteType($customNoteTypeParameters);
 
-        $this->assertNotNull($response);
-        $this->assertNotNull($response['result']);
-        $this->assertEquals('OK', $response['result']);
-        $this->assertNotNull($response['affected']);
-        $this->assertEquals(1, $response['affected']);
+		$this->assertNotNull($response);
+		$this->assertNotNull($response['result']);
+		$this->assertEquals('OK', $response['result']);
+		$this->assertNotNull($response['affected']);
+		$this->assertEquals(1, $response['affected']);
 
-        array_shift(self::$createdCustomNotes);
-    }
+		array_shift(self::$createdCustomNotes);
+	}
 
-    public static function tearDownAfterClass()
-    {
-        $optimizationProblemId = self:: $problem->optimization_problem_id;
+	public static function tearDownAfterClass()
+	{
+		$optimizationProblemId = self:: $problem->optimization_problem_id;
 
-        $params = [
-            'optimization_problem_ids' => [
-                '0' => $optimizationProblemId
-            ],
-            'redirect' => 0,
-        ];
+		$params = [
+			'optimization_problem_ids' => [
+				'0' => $optimizationProblemId
+			],
+			'redirect' => 0,
+		];
 
-        $result = self:: $problem->removeOptimization($params);
+		$result = self:: $problem->removeOptimization($params);
 
-        if ($result!=null && $result['status']==true) {
-            echo "The test optimization was removed <br>";
-        } else {
-            echo "Cannot remove the test optimization <br>";
-        }
+		if ($result!=null && $result['status']==true) {
+			echo "The test optimization was removed <br>";
+		} else {
+			echo "Cannot remove the test optimization <br>";
+		}
 
-        $addressNote = new AddressNote();
+		$addressNote = new AddressNote();
 
-        foreach (self::$createdCustomNotes as $createdCustomNote) {
-            $customNoteId = $addressNote->getCustomNoteTypeByKey($createdCustomNote)["note_custom_type_id"];
+		foreach (self::$createdCustomNotes as $createdCustomNote) {
+			$customNoteId = $addressNote->getCustomNoteTypeByKey($createdCustomNote)["note_custom_type_id"];
 
-            $customNoteTypeParameters = [
-                'id' => $customNoteId,
-            ];
+			$customNoteTypeParameters = [
+				'id' => $customNoteId,
+			];
 
-            $response = $addressNote->removeCustomNoteType($customNoteTypeParameters);
+			$response = $addressNote->removeCustomNoteType($customNoteTypeParameters);
 
-            if ($response!=null && $response['result']!=null && $response['result']=='OK') {
-                echo "Removed the custom note type ".$createdCustomNote.'<br>';
-            }
-        }
+			if ($response!=null && $response['result']!=null && $response['result']=='OK') {
+				echo "Removed the custom note type ".$createdCustomNote.'<br>';
+			}
+		}
 
-    }
+	}
 }
\ No newline at end of file

UnitTestFiles/Test/ActivityParametersUntTests.php

Indentation +201 added lines, -201 removed lines

@@ -14,205 +14,205 @@
 
 class ActivityParametersUntTests extends \PHPUnit\Framework\TestCase
 {
-    public static $route_id = null;
-    public static $problem = null;
-
-    public static function setUpBeforeClass()
-    {
-        if (Constants::API_KEY == Constants::DEMO_API_KEY) {
-            $className = str_replace('UnitTestFiles\\Test\\','',get_class());
-            self::markTestSkipped( 'PHPUnit will skip '. $className ." class - it impossible run with demo API key" );
-        }
-
-        Route4Me::setApiKey(Constants::API_KEY);
-
-        $addresses = [];
-        $addresses[] = Address::fromArray([
-            'address'           => '11497 Columbia Park Dr W, Jacksonville, FL 32258',
-            'is_depot'          => true,
-            'lat'               => 30.159341812134,
-            'lng'               => -81.538619995117,
-            'time'              => 300,
-            'time_window_start' => 28800,
-            'time_window_end'   => 32400,
-        ]);
-
-        $addresses[] = Address::fromArray([
-            'address'           => '214 Edgewater Branch Drive 32259',
-            'lat'               => 30.103567123413,
-            'lng'               => -81.595352172852,
-            'time'              => 300,
-            'time_window_start' => 36000,
-            'time_window_end'   => 37200,
-        ]);
-
-        $addresses[] = Address::fromArray([
-            'address'           => '756 eagle point dr 32092',
-            'lat'               => 30.046422958374,
-            'lng'               => -81.508758544922,
-            'time'              => 300,
-            'time_window_start' => 39600,
-            'time_window_end'   => 41400,
-        ]);
-
-        $addresses[] = Address::fromArray([
-            'address'           => '63 Stone Creek Cir St Johns, FL 32259, USA',
-            'lat'               => 30.048496,
-            'lng'               => -81.558716,
-            'time'              => 300,
-            'time_window_start' => 43200,
-            'time_window_end'   => 45000,
-        ]);
-
-        $parameters = RouteParameters::fromArray([
-            'device_type'           => DeviceType::IPAD,
-            'disable_optimization'  => false,
-            'route_name'            => 'phpunit test '.date('Y-m-d H:i'),
-        ]);
-
-        $optimizationParameters = new OptimizationProblemParams();
-        $optimizationParameters->setAddresses($addresses);
-        $optimizationParameters->setParameters($parameters);
-
-        self::$problem = OptimizationProblem::optimize($optimizationParameters);
-        $routes = self::$problem->getRoutes();
-        self::$route_id = $routes[0]->route_id;
-    }
-
-    public function testFromArray()
-    {
-        $activityParameters = ActivityParameters::fromArray([
-            "activity_id"           => "77BBB5F38723CCCCCCCCCCCCCCCCDD88",
-            "member_id"             => 444333,
-            "activity_timestamp"    => 1595418362,
-            "activity_type"         => "note-insert",
-            "activity_message"      => "A note was added to address '63 Stone Creek Cir St Johns, FL 32259, USA' from Web Interface",
-            "route_id"              => "38777FFFE274A1F970A3CA8D96F32222",
-            "route_destination_id"  => 535455583,
-            "note_id"               => 9933366,
-            "note_type"             => "Drop Off Occurred",
-            "note_contents"         => "Test Add Note To Route Address",
-            "route_name"            => "phpunit test 2020-07-22 13:45",
-            "note_file"             => "file.ext",
-            "destination_name"      => "63 Stone Creek Cir St Johns, FL 32259, USA",
-            "destination_alias"     => "Dest Alias",
-            "member" => [
-                "member_id"         => "444333",
-                "member_first_name" => "Olbay",
-                "member_last_name"  => "Gustavson",
-                "member_email"      => "aaaa1111@gmail.com"
-            ]
-        ]);
-
-        $this->assertEquals('77BBB5F38723CCCCCCCCCCCCCCCCDD88', $activityParameters->activity_id);
-
-        $this->assertEquals(444333, $activityParameters->member_id);
-        $this->assertEquals(1595418362, $activityParameters->activity_timestamp);
-        $this->assertEquals('note-insert', $activityParameters->activity_type);
-        $this->assertEquals('A note was added to address \'63 Stone Creek Cir St Johns, FL 32259, USA\' from Web Interface', $activityParameters->activity_message);
-        $this->assertEquals('38777FFFE274A1F970A3CA8D96F32222', $activityParameters->route_id);
-        $this->assertEquals(535455583, $activityParameters->route_destination_id);
-        $this->assertEquals(9933366, $activityParameters->note_id);
-        $this->assertEquals('Drop Off Occurred', $activityParameters->note_type);
-        $this->assertEquals('Test Add Note To Route Address', $activityParameters->note_contents);
-        $this->assertEquals('phpunit test 2020-07-22 13:45', $activityParameters->route_name);
-        $this->assertEquals('file.ext', $activityParameters->note_file);
-        $this->assertEquals('63 Stone Creek Cir St Johns, FL 32259, USA', $activityParameters->destination_name);
-        $this->assertEquals('Dest Alias', $activityParameters->destination_alias);
-        $this->assertEquals([
-            "member_id"         => "444333",
-            "member_first_name" => "Olbay",
-            "member_last_name"  => "Gustavson",
-            "member_email"      => "aaaa1111@gmail.com"
-        ], $activityParameters->member);
-    }
-
-    public function testGetActivities()
-    {
-        $activities = new ActivityParameters();
-
-        $activityParameters = ActivityParameters::fromArray([
-            'limit'  => 10,
-            'offset' => 0,
-        ]);
-
-        $result = $activities->getActivities($activityParameters);
-
-        $this->assertNotNull($result);
-        $this->assertNotNull(isset($result['results']));
-
-        $firstActivity = ActivityParameters::fromArray(
-            $result['results'][0]
-        );
-
-        $this->assertContainsOnlyInstancesOf(ActivityParameters::class, [$firstActivity]);
-    }
-
-    public function testSearchActivities()
-    {
-        $activities = new ActivityParameters();
-
-        $activityTypes = new ActivityTypes();
-
-        foreach ($activityTypes->getConstants() as $prop => $value) {
-            $activityParameters = ActivityParameters::fromArray([
-                'activity_type' => $value,
-                'limit'         => 2,
-                'offset'        => 0,
-            ]);
-
-            $activities = new ActivityParameters();
-            $result = $activities->searchActivities($activityParameters);
-
-            $this->assertNotNull($result);
-            $this->assertNotNull(isset($result['results']));
-
-            if (sizeof($result['results'])>0) {
-                $firstActivity = ActivityParameters::fromArray(
-                    $result['results'][0]
-                );
-
-                $this->assertContainsOnlyInstancesOf(ActivityParameters::class, [$firstActivity]);
-            }
-        }
-    }
-
-    public function testSendUserMessage()
-    {
-        $activities = new ActivityParameters();
-
-        $postParameters = ActivityParameters::fromArray([
-            'activity_type'     => 'user_message',
-            'activity_message'  => 'Hello - php!',
-            'route_id'          => self::$route_id,
-        ]);
-
-        $result = $activities->sendUserMessage($postParameters);
-
-        $this->assertNotNull($result);
-        $this->assertNotNull(isset($result['status']));
-        $this->assertTrue(isset($result['status']));
-    }
-
-    public static function tearDownAfterClass()
-    {
-        $optimizationProblemId = self:: $problem->optimization_problem_id;
-
-        $params = [
-            'optimization_problem_ids' => [
-                '0' => $optimizationProblemId
-            ],
-            'redirect' => 0,
-        ];
-
-        $optimizationProblem = new OptimizationProblem();
-
-        $result = $optimizationProblem->removeOptimization($params);
-
-        if ($result!=null && $result['status']==true) {
-            echo "The test optimization was removed <br>";
-        } else {
-            echo "Cannot remove the test optimization <br>";
-        }
-    }
+	public static $route_id = null;
+	public static $problem = null;
+
+	public static function setUpBeforeClass()
+	{
+		if (Constants::API_KEY == Constants::DEMO_API_KEY) {
+			$className = str_replace('UnitTestFiles\\Test\\','',get_class());
+			self::markTestSkipped( 'PHPUnit will skip '. $className ." class - it impossible run with demo API key" );
+		}
+
+		Route4Me::setApiKey(Constants::API_KEY);
+
+		$addresses = [];
+		$addresses[] = Address::fromArray([
+			'address'           => '11497 Columbia Park Dr W, Jacksonville, FL 32258',
+			'is_depot'          => true,
+			'lat'               => 30.159341812134,
+			'lng'               => -81.538619995117,
+			'time'              => 300,
+			'time_window_start' => 28800,
+			'time_window_end'   => 32400,
+		]);
+
+		$addresses[] = Address::fromArray([
+			'address'           => '214 Edgewater Branch Drive 32259',
+			'lat'               => 30.103567123413,
+			'lng'               => -81.595352172852,
+			'time'              => 300,
+			'time_window_start' => 36000,
+			'time_window_end'   => 37200,
+		]);
+
+		$addresses[] = Address::fromArray([
+			'address'           => '756 eagle point dr 32092',
+			'lat'               => 30.046422958374,
+			'lng'               => -81.508758544922,
+			'time'              => 300,
+			'time_window_start' => 39600,
+			'time_window_end'   => 41400,
+		]);
+
+		$addresses[] = Address::fromArray([
+			'address'           => '63 Stone Creek Cir St Johns, FL 32259, USA',
+			'lat'               => 30.048496,
+			'lng'               => -81.558716,
+			'time'              => 300,
+			'time_window_start' => 43200,
+			'time_window_end'   => 45000,
+		]);
+
+		$parameters = RouteParameters::fromArray([
+			'device_type'           => DeviceType::IPAD,
+			'disable_optimization'  => false,
+			'route_name'            => 'phpunit test '.date('Y-m-d H:i'),
+		]);
+
+		$optimizationParameters = new OptimizationProblemParams();
+		$optimizationParameters->setAddresses($addresses);
+		$optimizationParameters->setParameters($parameters);
+
+		self::$problem = OptimizationProblem::optimize($optimizationParameters);
+		$routes = self::$problem->getRoutes();
+		self::$route_id = $routes[0]->route_id;
+	}
+
+	public function testFromArray()
+	{
+		$activityParameters = ActivityParameters::fromArray([
+			"activity_id"           => "77BBB5F38723CCCCCCCCCCCCCCCCDD88",
+			"member_id"             => 444333,
+			"activity_timestamp"    => 1595418362,
+			"activity_type"         => "note-insert",
+			"activity_message"      => "A note was added to address '63 Stone Creek Cir St Johns, FL 32259, USA' from Web Interface",
+			"route_id"              => "38777FFFE274A1F970A3CA8D96F32222",
+			"route_destination_id"  => 535455583,
+			"note_id"               => 9933366,
+			"note_type"             => "Drop Off Occurred",
+			"note_contents"         => "Test Add Note To Route Address",
+			"route_name"            => "phpunit test 2020-07-22 13:45",
+			"note_file"             => "file.ext",
+			"destination_name"      => "63 Stone Creek Cir St Johns, FL 32259, USA",
+			"destination_alias"     => "Dest Alias",
+			"member" => [
+				"member_id"         => "444333",
+				"member_first_name" => "Olbay",
+				"member_last_name"  => "Gustavson",
+				"member_email"      => "aaaa1111@gmail.com"
+			]
+		]);
+
+		$this->assertEquals('77BBB5F38723CCCCCCCCCCCCCCCCDD88', $activityParameters->activity_id);
+
+		$this->assertEquals(444333, $activityParameters->member_id);
+		$this->assertEquals(1595418362, $activityParameters->activity_timestamp);
+		$this->assertEquals('note-insert', $activityParameters->activity_type);
+		$this->assertEquals('A note was added to address \'63 Stone Creek Cir St Johns, FL 32259, USA\' from Web Interface', $activityParameters->activity_message);
+		$this->assertEquals('38777FFFE274A1F970A3CA8D96F32222', $activityParameters->route_id);
+		$this->assertEquals(535455583, $activityParameters->route_destination_id);
+		$this->assertEquals(9933366, $activityParameters->note_id);
+		$this->assertEquals('Drop Off Occurred', $activityParameters->note_type);
+		$this->assertEquals('Test Add Note To Route Address', $activityParameters->note_contents);
+		$this->assertEquals('phpunit test 2020-07-22 13:45', $activityParameters->route_name);
+		$this->assertEquals('file.ext', $activityParameters->note_file);
+		$this->assertEquals('63 Stone Creek Cir St Johns, FL 32259, USA', $activityParameters->destination_name);
+		$this->assertEquals('Dest Alias', $activityParameters->destination_alias);
+		$this->assertEquals([
+			"member_id"         => "444333",
+			"member_first_name" => "Olbay",
+			"member_last_name"  => "Gustavson",
+			"member_email"      => "aaaa1111@gmail.com"
+		], $activityParameters->member);
+	}
+
+	public function testGetActivities()
+	{
+		$activities = new ActivityParameters();
+
+		$activityParameters = ActivityParameters::fromArray([
+			'limit'  => 10,
+			'offset' => 0,
+		]);
+
+		$result = $activities->getActivities($activityParameters);
+
+		$this->assertNotNull($result);
+		$this->assertNotNull(isset($result['results']));
+
+		$firstActivity = ActivityParameters::fromArray(
+			$result['results'][0]
+		);
+
+		$this->assertContainsOnlyInstancesOf(ActivityParameters::class, [$firstActivity]);
+	}
+
+	public function testSearchActivities()
+	{
+		$activities = new ActivityParameters();
+
+		$activityTypes = new ActivityTypes();
+
+		foreach ($activityTypes->getConstants() as $prop => $value) {
+			$activityParameters = ActivityParameters::fromArray([
+				'activity_type' => $value,
+				'limit'         => 2,
+				'offset'        => 0,
+			]);
+
+			$activities = new ActivityParameters();
+			$result = $activities->searchActivities($activityParameters);
+
+			$this->assertNotNull($result);
+			$this->assertNotNull(isset($result['results']));
+
+			if (sizeof($result['results'])>0) {
+				$firstActivity = ActivityParameters::fromArray(
+					$result['results'][0]
+				);
+
+				$this->assertContainsOnlyInstancesOf(ActivityParameters::class, [$firstActivity]);
+			}
+		}
+	}
+
+	public function testSendUserMessage()
+	{
+		$activities = new ActivityParameters();
+
+		$postParameters = ActivityParameters::fromArray([
+			'activity_type'     => 'user_message',
+			'activity_message'  => 'Hello - php!',
+			'route_id'          => self::$route_id,
+		]);
+
+		$result = $activities->sendUserMessage($postParameters);
+
+		$this->assertNotNull($result);
+		$this->assertNotNull(isset($result['status']));
+		$this->assertTrue(isset($result['status']));
+	}
+
+	public static function tearDownAfterClass()
+	{
+		$optimizationProblemId = self:: $problem->optimization_problem_id;
+
+		$params = [
+			'optimization_problem_ids' => [
+				'0' => $optimizationProblemId
+			],
+			'redirect' => 0,
+		];
+
+		$optimizationProblem = new OptimizationProblem();
+
+		$result = $optimizationProblem->removeOptimization($params);
+
+		if ($result!=null && $result['status']==true) {
+			echo "The test optimization was removed <br>";
+		} else {
+			echo "Cannot remove the test optimization <br>";
+		}
+	}
 }
\ No newline at end of file

UnitTestFiles/Test/AddressNoteResponseUnitTests.php

Indentation +46 added lines, -46 removed lines

@@ -7,53 +7,53 @@
 
 class AddressNoteResponseUnitTests extends \PHPUnit\Framework\TestCase
 {
-    public function testFromArray()
-    {
-        $addressNoteResponse = AddressNoteResponse::fromArray([
-            'status'    => true,
-            'note_id'   => '1015289',
-            'upload_id' => '',
-            'note' => [
-                'note_id'               => 1015289,
-                'route_id'              => 'DD376C7148E777736CFABE2BD9998BDD',
-                'route_destination_id'  => 183045812,
-                'ts_added'              => 1480511401,
-                'activity_type'         => '',
-                'upload_id'             => '',
-                'upload_extension'      => null,
-                'upload_url'            => null,
-                'upload_type'           => null,
-                'contents'              => 'Note example for Destination Audit Use Case',
-                'lat'                   => 41.145241,
-                'lng'                   => -81.410248,
-                'device_type'           => 'web'
-            ]
-        ]);
+	public function testFromArray()
+	{
+		$addressNoteResponse = AddressNoteResponse::fromArray([
+			'status'    => true,
+			'note_id'   => '1015289',
+			'upload_id' => '',
+			'note' => [
+				'note_id'               => 1015289,
+				'route_id'              => 'DD376C7148E777736CFABE2BD9998BDD',
+				'route_destination_id'  => 183045812,
+				'ts_added'              => 1480511401,
+				'activity_type'         => '',
+				'upload_id'             => '',
+				'upload_extension'      => null,
+				'upload_url'            => null,
+				'upload_type'           => null,
+				'contents'              => 'Note example for Destination Audit Use Case',
+				'lat'                   => 41.145241,
+				'lng'                   => -81.410248,
+				'device_type'           => 'web'
+			]
+		]);
 
-        $this->assertEquals(true, $addressNoteResponse->status);
-        $this->assertEquals('1015289', $addressNoteResponse->note_id);
-        $this->assertEquals('', $addressNoteResponse->upload_id);
-        $this->assertEquals([
-                'note_id'               => 1015289,
-                'route_id'              => 'DD376C7148E777736CFABE2BD9998BDD',
-                'route_destination_id'  => 183045812,
-                'ts_added'              => 1480511401,
-                'activity_type'         => '',
-                'upload_id'             => '',
-                'upload_extension'      => null,
-                'upload_url'            => null,
-                'upload_type'           => null,
-                'contents'              => 'Note example for Destination Audit Use Case',
-                'lat'                   => 41.145241,
-                'lng'                   => -81.410248,
-                'device_type'           => 'web'
-            ],
-            $addressNoteResponse->note);
+		$this->assertEquals(true, $addressNoteResponse->status);
+		$this->assertEquals('1015289', $addressNoteResponse->note_id);
+		$this->assertEquals('', $addressNoteResponse->upload_id);
+		$this->assertEquals([
+				'note_id'               => 1015289,
+				'route_id'              => 'DD376C7148E777736CFABE2BD9998BDD',
+				'route_destination_id'  => 183045812,
+				'ts_added'              => 1480511401,
+				'activity_type'         => '',
+				'upload_id'             => '',
+				'upload_extension'      => null,
+				'upload_url'            => null,
+				'upload_type'           => null,
+				'contents'              => 'Note example for Destination Audit Use Case',
+				'lat'                   => 41.145241,
+				'lng'                   => -81.410248,
+				'device_type'           => 'web'
+			],
+			$addressNoteResponse->note);
 
-        $note = AddressNote::fromArray(
-            $addressNoteResponse->note
-        );
+		$note = AddressNote::fromArray(
+			$addressNoteResponse->note
+		);
 
-        $this->assertContainsOnlyInstancesOf(AddressNote::class, [$note]);
-    }
+		$this->assertContainsOnlyInstancesOf(AddressNote::class, [$note]);
+	}
 }
\ No newline at end of file

UnitTestFiles/Test/RapidAddressSearchResponseUnitTests.php

Indentation +11 added lines, -11 removed lines

@@ -7,16 +7,16 @@
 
 class RapidAddressSearchResponseUnitTests extends \PHPUnit\Framework\TestCase
 {
-    public function testFromArray()
-    {
-        $rapidAddressSearch = RapidAddressSearchResponse::fromArray([
-            'zipcode'       => '00601',
-            'street_name'   => 'GENERAL DELIVERY',
-            'county_no'     => '103'
-        ]);
+	public function testFromArray()
+	{
+		$rapidAddressSearch = RapidAddressSearchResponse::fromArray([
+			'zipcode'       => '00601',
+			'street_name'   => 'GENERAL DELIVERY',
+			'county_no'     => '103'
+		]);
 
-        $this->assertEquals('00601', $rapidAddressSearch->zipcode);
-        $this->assertEquals('GENERAL DELIVERY', $rapidAddressSearch->street_name);
-        $this->assertEquals('103', $rapidAddressSearch->county_no);
-    }
+		$this->assertEquals('00601', $rapidAddressSearch->zipcode);
+		$this->assertEquals('GENERAL DELIVERY', $rapidAddressSearch->street_name);
+		$this->assertEquals('103', $rapidAddressSearch->county_no);
+	}
 }
\ No newline at end of file

UnitTestFiles/Test/V5/RouteTests.php

Indentation +340 added lines, -340 removed lines

@@ -27,391 +27,391 @@
 
 class RouteTests extends \PHPUnit\Framework\TestCase
 {
-    public static $createdProblems = [];
-    public static $testRoutes = [];
-    public static $addresses = [];
-
-    public static $removedOptimizationIDs = [];
-    public static $removedRouteIDs = [];
-
-    public static function setUpBeforeClass()
-    {
-        Route4Me::setApiKey(Constants::API_KEY);
-
-        //region -- Prepae Addresses --
-        $json = json_decode(file_get_contents(dirname(__FILE__).'/data/addresses_md_tw.json'), true);
-
-        $addresses = [];
-        foreach ($json as $address) {
-            $addresses[] = Address::fromArray($address);
-        }
-
-        $parameters = RouteParameters::fromArray([
-            'algorithm_type'            => AlgorithmType::CVRP_TW_MD,
-            'distance_unit'             => DistanceUnit::MILES,
-            'device_type'               => DeviceType::WEB,
-            'optimize'                  => OptimizationType::DISTANCE,
-            'metric'                    => Metric::GEODESIC,
-            'route_max_duration'        => 86400 * 2,
-            'travel_mode'               => TravelMode::DRIVING,
-            'vehicle_capacity'          => 50,
-            'vehicle_max_distance_mi'   => 10000,
-            'parts'                     => 50,
-        ]);
-        //endregion
-
-        $optimizationParameters = new OptimizationProblemParams();
-        $optimizationParameters->setAddresses($addresses);
-        $optimizationParameters->setParameters($parameters);
-
-        self::$createdProblems[] = OptimizationProblem::optimize($optimizationParameters);
-
-        self::$testRoutes = self::$createdProblems[0]->routes;
-
-        //region -- Extra Testing Addresses --
-        $addresses = [];
-        $addresses[] = Address::fromArray([
-            'address'           => '11497 Columbia Park Dr W, Jacksonville, FL 32258',
-            'is_depot'          => true,
-            'lat'               => 30.159341812134,
-            'lng'               => -81.538619995117,
-            'time'              => 300,
-            'time_window_start' => 28800,
-            'time_window_end'   => 32400,
-        ]);
-
-        $addresses[] = Address::fromArray([
-            'address'           => '214 Edgewater Branch Drive 32259',
-            'lat'               => 30.103567123413,
-            'lng'               => -81.595352172852,
-            'time'              => 300,
-            'time_window_start' => 36000,
-            'time_window_end'   => 37200,
-        ]);
-
-        $addresses[] = Address::fromArray([
-            'address'           => '756 eagle point dr 32092',
-            'lat'               => 30.046422958374,
-            'lng'               => -81.508758544922,
-            'time'              => 300,
-            'time_window_start' => 39600,
-            'time_window_end'   => 41400,
-        ]);
-        //endregion
-
-        self::$addresses = $addresses;
-    }
-
-    public function testFromArray()
-    {
-        //region -- Prepare Addresses --
-
-        $addresses = [];
-        $addresses[] = [
-            'address'           => '11497 Columbia Park Dr W, Jacksonville, FL 32258',
-            'is_depot'          => true,
-            'lat'               => 30.159341812134,
-            'lng'               => -81.538619995117,
-            'time'              => 300,
-            'time_window_start' => 28800,
-            'time_window_end'   => 32400,
-        ];
-
-        $addresses[] = [
-            'address'           => '214 Edgewater Branch Drive 32259',
-            'lat'               => 30.103567123413,
-            'lng'               => -81.595352172852,
-            'time'              => 300,
-            'time_window_start' => 36000,
-            'time_window_end'   => 37200,
-        ];
-
-        $addresses[] = [
-            'address'           => '756 eagle point dr 32092',
-            'lat'               => 30.046422958374,
-            'lng'               => -81.508758544922,
-            'time'              => 300,
-            'time_window_start' => 39600,
-            'time_window_end'   => 41400,
-        ];
-
-        $addresses[] = [
-            'address'           => '63 Stone Creek Cir St Johns, FL 32259, USA',
-            'lat'               => 30.048496,
-            'lng'               => -81.558716,
-            'time'              => 300,
-            'time_window_start' => 43200,
-            'time_window_end'   => 45000,
-        ];
-
-        $addresses[] = [
-            'address'           => 'St Johns Florida 32259, USA',
-            'lat'               => 30.099642,
-            'lng'               => -81.547201,
-            'time'              => 300,
-            'time_window_start' => 46800,
-            'time_window_end'   => 48600,
-        ];
-
-        //endregion
-
-        $parameters = [
-            'device_type'           => DeviceType::IPAD,
-            'disable_optimization'  => false,
-            'route_name'            => 'phpunit test '.date('Y-m-d H:i'),
-        ];
-
-        $routeParameters = Route::fromArray([
-            'parameters'    => $parameters,
-            'addresses'     => $addresses
-        ]);
-
-        $this->assertEquals(RouteParameters::fromArray($parameters), $routeParameters->parameters);
-    }
-
-    public function testGetRoutes()
-    {
-        $params = new RouteParametersQuery();
-
-        $params->limit = 10;
-        $params->offset = 0;
-
-        $route = new Route();
-
-        $routeResults = $route->getRoutes($params->toArray());
-
-        $this->assertNotNull($routeResults);
-        $this->assertTrue(is_array($routeResults));
-        $this->assertTrue(sizeof($routeResults)>0);
-        $this->assertInstanceOf(Route::class, Route::fromArray($routeResults));
-    }
-
-    public function testGetAllRoutesWithPagination()
-    {
-        $params = new RouteParametersQuery();
-
-        $params->page = 1;
-        $params->per_page = 10;
-
-        $route = new Route();
-
-        $routeResults = $route->getAllRoutesWithPagination($params->toArray());
-
-        $this->assertNotNull($routeResults);
-        $this->assertTrue(is_array($routeResults));
-        $this->assertTrue(sizeof($routeResults)>0);
-        $this->assertInstanceOf(Route::class, Route::fromArray($routeResults));
-    }
-
-    public function testGetPaginatedRouteListWithoutElasticSearch()
-    {
-        $params = new RouteParametersQuery();
-
-        $params->page = 1;
-        $params->per_page = 10;
-
-        $route = new Route();
-
-        $routeResults = $route->getPaginatedRouteListWithoutElasticSearch($params->toArray());
-
-        $this->assertNotNull($routeResults);
-        $this->assertTrue(is_array($routeResults));
-        $this->assertTrue(sizeof($routeResults)>0);
-        $this->assertInstanceOf(Route::class, Route::fromArray($routeResults));
-    }
-
-    public function testGetRouteDataTableWithoutElasticSearch()
-    {
-        $scheduleFilter = new RouteFilterParametersFilters();
-
-        $scheduleFilter->schedule_date = [
-            date('Y-m-d', strtotime('-2 days')),
-            date('Y-m-d', strtotime('-3 days')),
-            date('Y-m-d', strtotime('-4 days'))
-        ];
-
-        $filterParams = new RouteFilterParameters();
-        $filterParams->page = 1;
-        $filterParams->per_page = 20;
-        $filterParams->filters = $scheduleFilter;
-        $filterParams->order_by = [["route_created_unix", "desc"]];
-        $filterParams->timezone = "UTC";
-
-        $route = new Route();
+	public static $createdProblems = [];
+	public static $testRoutes = [];
+	public static $addresses = [];
+
+	public static $removedOptimizationIDs = [];
+	public static $removedRouteIDs = [];
+
+	public static function setUpBeforeClass()
+	{
+		Route4Me::setApiKey(Constants::API_KEY);
+
+		//region -- Prepae Addresses --
+		$json = json_decode(file_get_contents(dirname(__FILE__).'/data/addresses_md_tw.json'), true);
+
+		$addresses = [];
+		foreach ($json as $address) {
+			$addresses[] = Address::fromArray($address);
+		}
+
+		$parameters = RouteParameters::fromArray([
+			'algorithm_type'            => AlgorithmType::CVRP_TW_MD,
+			'distance_unit'             => DistanceUnit::MILES,
+			'device_type'               => DeviceType::WEB,
+			'optimize'                  => OptimizationType::DISTANCE,
+			'metric'                    => Metric::GEODESIC,
+			'route_max_duration'        => 86400 * 2,
+			'travel_mode'               => TravelMode::DRIVING,
+			'vehicle_capacity'          => 50,
+			'vehicle_max_distance_mi'   => 10000,
+			'parts'                     => 50,
+		]);
+		//endregion
+
+		$optimizationParameters = new OptimizationProblemParams();
+		$optimizationParameters->setAddresses($addresses);
+		$optimizationParameters->setParameters($parameters);
+
+		self::$createdProblems[] = OptimizationProblem::optimize($optimizationParameters);
+
+		self::$testRoutes = self::$createdProblems[0]->routes;
+
+		//region -- Extra Testing Addresses --
+		$addresses = [];
+		$addresses[] = Address::fromArray([
+			'address'           => '11497 Columbia Park Dr W, Jacksonville, FL 32258',
+			'is_depot'          => true,
+			'lat'               => 30.159341812134,
+			'lng'               => -81.538619995117,
+			'time'              => 300,
+			'time_window_start' => 28800,
+			'time_window_end'   => 32400,
+		]);
+
+		$addresses[] = Address::fromArray([
+			'address'           => '214 Edgewater Branch Drive 32259',
+			'lat'               => 30.103567123413,
+			'lng'               => -81.595352172852,
+			'time'              => 300,
+			'time_window_start' => 36000,
+			'time_window_end'   => 37200,
+		]);
+
+		$addresses[] = Address::fromArray([
+			'address'           => '756 eagle point dr 32092',
+			'lat'               => 30.046422958374,
+			'lng'               => -81.508758544922,
+			'time'              => 300,
+			'time_window_start' => 39600,
+			'time_window_end'   => 41400,
+		]);
+		//endregion
+
+		self::$addresses = $addresses;
+	}
+
+	public function testFromArray()
+	{
+		//region -- Prepare Addresses --
+
+		$addresses = [];
+		$addresses[] = [
+			'address'           => '11497 Columbia Park Dr W, Jacksonville, FL 32258',
+			'is_depot'          => true,
+			'lat'               => 30.159341812134,
+			'lng'               => -81.538619995117,
+			'time'              => 300,
+			'time_window_start' => 28800,
+			'time_window_end'   => 32400,
+		];
+
+		$addresses[] = [
+			'address'           => '214 Edgewater Branch Drive 32259',
+			'lat'               => 30.103567123413,
+			'lng'               => -81.595352172852,
+			'time'              => 300,
+			'time_window_start' => 36000,
+			'time_window_end'   => 37200,
+		];
+
+		$addresses[] = [
+			'address'           => '756 eagle point dr 32092',
+			'lat'               => 30.046422958374,
+			'lng'               => -81.508758544922,
+			'time'              => 300,
+			'time_window_start' => 39600,
+			'time_window_end'   => 41400,
+		];
+
+		$addresses[] = [
+			'address'           => '63 Stone Creek Cir St Johns, FL 32259, USA',
+			'lat'               => 30.048496,
+			'lng'               => -81.558716,
+			'time'              => 300,
+			'time_window_start' => 43200,
+			'time_window_end'   => 45000,
+		];
+
+		$addresses[] = [
+			'address'           => 'St Johns Florida 32259, USA',
+			'lat'               => 30.099642,
+			'lng'               => -81.547201,
+			'time'              => 300,
+			'time_window_start' => 46800,
+			'time_window_end'   => 48600,
+		];
+
+		//endregion
+
+		$parameters = [
+			'device_type'           => DeviceType::IPAD,
+			'disable_optimization'  => false,
+			'route_name'            => 'phpunit test '.date('Y-m-d H:i'),
+		];
+
+		$routeParameters = Route::fromArray([
+			'parameters'    => $parameters,
+			'addresses'     => $addresses
+		]);
+
+		$this->assertEquals(RouteParameters::fromArray($parameters), $routeParameters->parameters);
+	}
+
+	public function testGetRoutes()
+	{
+		$params = new RouteParametersQuery();
+
+		$params->limit = 10;
+		$params->offset = 0;
+
+		$route = new Route();
+
+		$routeResults = $route->getRoutes($params->toArray());
+
+		$this->assertNotNull($routeResults);
+		$this->assertTrue(is_array($routeResults));
+		$this->assertTrue(sizeof($routeResults)>0);
+		$this->assertInstanceOf(Route::class, Route::fromArray($routeResults));
+	}
+
+	public function testGetAllRoutesWithPagination()
+	{
+		$params = new RouteParametersQuery();
+
+		$params->page = 1;
+		$params->per_page = 10;
+
+		$route = new Route();
+
+		$routeResults = $route->getAllRoutesWithPagination($params->toArray());
+
+		$this->assertNotNull($routeResults);
+		$this->assertTrue(is_array($routeResults));
+		$this->assertTrue(sizeof($routeResults)>0);
+		$this->assertInstanceOf(Route::class, Route::fromArray($routeResults));
+	}
+
+	public function testGetPaginatedRouteListWithoutElasticSearch()
+	{
+		$params = new RouteParametersQuery();
+
+		$params->page = 1;
+		$params->per_page = 10;
+
+		$route = new Route();
+
+		$routeResults = $route->getPaginatedRouteListWithoutElasticSearch($params->toArray());
+
+		$this->assertNotNull($routeResults);
+		$this->assertTrue(is_array($routeResults));
+		$this->assertTrue(sizeof($routeResults)>0);
+		$this->assertInstanceOf(Route::class, Route::fromArray($routeResults));
+	}
+
+	public function testGetRouteDataTableWithoutElasticSearch()
+	{
+		$scheduleFilter = new RouteFilterParametersFilters();
+
+		$scheduleFilter->schedule_date = [
+			date('Y-m-d', strtotime('-2 days')),
+			date('Y-m-d', strtotime('-3 days')),
+			date('Y-m-d', strtotime('-4 days'))
+		];
+
+		$filterParams = new RouteFilterParameters();
+		$filterParams->page = 1;
+		$filterParams->per_page = 20;
+		$filterParams->filters = $scheduleFilter;
+		$filterParams->order_by = [["route_created_unix", "desc"]];
+		$filterParams->timezone = "UTC";
+
+		$route = new Route();
 
-        $routeResults = $route->getRouteDataTableWithoutElasticSearch($filterParams->toArray());
+		$routeResults = $route->getRouteDataTableWithoutElasticSearch($filterParams->toArray());
 
-        $this->assertNotNull($routeResults);
-        $this->assertTrue(is_array($routeResults));
-        $this->assertTrue(sizeof($routeResults)>0);
-        $this->assertInstanceOf(Route::class, Route::fromArray($routeResults));
-    }
+		$this->assertNotNull($routeResults);
+		$this->assertTrue(is_array($routeResults));
+		$this->assertTrue(sizeof($routeResults)>0);
+		$this->assertInstanceOf(Route::class, Route::fromArray($routeResults));
+	}
 
-    public function testGetRouteDatatableWithElasticSearch()
-    {
-        $scheduleFilter = new RouteFilterParametersFilters();
+	public function testGetRouteDatatableWithElasticSearch()
+	{
+		$scheduleFilter = new RouteFilterParametersFilters();
 
-        $scheduleFilter->schedule_date = [
-            date('Y-m-d', strtotime('-1 days')),
-            date('Y-m-d', strtotime('-2 days')),
-            date('Y-m-d', strtotime('-3 days'))
-        ];
+		$scheduleFilter->schedule_date = [
+			date('Y-m-d', strtotime('-1 days')),
+			date('Y-m-d', strtotime('-2 days')),
+			date('Y-m-d', strtotime('-3 days'))
+		];
 
-        $filterParams = new RouteFilterParameters();
-        $filterParams->page = 1;
-        $filterParams->per_page = 20;
-        $filterParams->filters = $scheduleFilter;
-        $filterParams->order_by = [["route_created_unix", "desc"]];
-        $filterParams->timezone = "UTC";
+		$filterParams = new RouteFilterParameters();
+		$filterParams->page = 1;
+		$filterParams->per_page = 20;
+		$filterParams->filters = $scheduleFilter;
+		$filterParams->order_by = [["route_created_unix", "desc"]];
+		$filterParams->timezone = "UTC";
 
-        $route = new Route();
+		$route = new Route();
 
-        $routeResults = $route->getRouteDataTableWithElasticSearch($filterParams->toArray());
+		$routeResults = $route->getRouteDataTableWithElasticSearch($filterParams->toArray());
 
-        $this->assertNotNull($routeResults);
-        $this->assertTrue(is_array($routeResults));
-        $this->assertTrue(sizeof($routeResults)>0);
-        $this->assertInstanceOf(Route::class, Route::fromArray($routeResults));
-    }
+		$this->assertNotNull($routeResults);
+		$this->assertTrue(is_array($routeResults));
+		$this->assertTrue(sizeof($routeResults)>0);
+		$this->assertInstanceOf(Route::class, Route::fromArray($routeResults));
+	}
 
-    public function testGetRouteListWithoutElasticSearch()
-    {
-        $params = new RouteParametersQuery();
+	public function testGetRouteListWithoutElasticSearch()
+	{
+		$params = new RouteParametersQuery();
 
-        $params->limit = 10;
-        $params->offset = 0;
+		$params->limit = 10;
+		$params->offset = 0;
 
-        $route = new Route();
+		$route = new Route();
 
-        $routeResults = $route->getRouteListWithoutElasticSearch($params->toArray());
+		$routeResults = $route->getRouteListWithoutElasticSearch($params->toArray());
 
-        $this->assertNotNull($routeResults);
-        $this->assertTrue(is_array($routeResults));
-        $this->assertTrue(sizeof($routeResults)>0);
-        $this->assertInstanceOf(Route::class, Route::fromArray($routeResults));
-    }
+		$this->assertNotNull($routeResults);
+		$this->assertTrue(is_array($routeResults));
+		$this->assertTrue(sizeof($routeResults)>0);
+		$this->assertInstanceOf(Route::class, Route::fromArray($routeResults));
+	}
 
-    public function testDuplicateRoutes()
-    {
-        $routeIDs = [
-            self::$testRoutes[sizeof(self::$testRoutes) - 1]->route_id
-        ];
+	public function testDuplicateRoutes()
+	{
+		$routeIDs = [
+			self::$testRoutes[sizeof(self::$testRoutes) - 1]->route_id
+		];
 
-        $route = new Route();
+		$route = new Route();
 
-        $result = $route->duplicateRoute($routeIDs);
+		$result = $route->duplicateRoute($routeIDs);
 
-        $this->assertNotNull($result);
-        $this->assertInstanceOf(RouteDuplicateResponse::class, RouteDuplicateResponse::fromArray( $result));
-        $this->assertTrue($result['status']);
-    }
+		$this->assertNotNull($result);
+		$this->assertInstanceOf(RouteDuplicateResponse::class, RouteDuplicateResponse::fromArray( $result));
+		$this->assertTrue($result['status']);
+	}
 
-    public function testGetRouteDataTableConfig()
-    {
-        $route = new Route();
+	public function testGetRouteDataTableConfig()
+	{
+		$route = new Route();
 
-        $result = $route->getRouteDataTableConfig();
+		$result = $route->getRouteDataTableConfig();
 
-        $this->assertNotNull($result);
-        $this->assertInstanceOf(  RouteDataTableConfigResponse::class, RouteDataTableConfigResponse::fromArray( $result));
-        $this->assertInstanceOf(  ApiCapabilities::class, ApiCapabilities::fromArray( $result['api_capabilities']));
-        $this->assertInstanceOf(  ApiPreferences::class, ApiPreferences::fromArray( $result['api_preferences']));
-    }
+		$this->assertNotNull($result);
+		$this->assertInstanceOf(  RouteDataTableConfigResponse::class, RouteDataTableConfigResponse::fromArray( $result));
+		$this->assertInstanceOf(  ApiCapabilities::class, ApiCapabilities::fromArray( $result['api_capabilities']));
+		$this->assertInstanceOf(  ApiPreferences::class, ApiPreferences::fromArray( $result['api_preferences']));
+	}
 
-    public function testRouteDataTableFallbackConfig()
-    {
-        $route = new Route();
+	public function testRouteDataTableFallbackConfig()
+	{
+		$route = new Route();
 
-        $result = $route->getRouteDataTableFallbackConfig();
+		$result = $route->getRouteDataTableFallbackConfig();
 
-        $this->assertNotNull($result);
-        $this->assertInstanceOf(  RouteDataTableConfigResponse::class, RouteDataTableConfigResponse::fromArray( $result));
-        $this->assertInstanceOf(  ApiCapabilities::class, ApiCapabilities::fromArray( $result['api_capabilities']));
-        $this->assertInstanceOf(  ApiPreferences::class, ApiPreferences::fromArray( $result['api_preferences']));
-    }
+		$this->assertNotNull($result);
+		$this->assertInstanceOf(  RouteDataTableConfigResponse::class, RouteDataTableConfigResponse::fromArray( $result));
+		$this->assertInstanceOf(  ApiCapabilities::class, ApiCapabilities::fromArray( $result['api_capabilities']));
+		$this->assertInstanceOf(  ApiPreferences::class, ApiPreferences::fromArray( $result['api_preferences']));
+	}
 
-    public function testUpdateRouteParameters()
-    {
-        $routeQueryParams= new RouteParametersQuery();
-        $routeQueryParams->route_id = self::$testRoutes[sizeof(self::$testRoutes) - 1]->route_id;
-        $routeQueryParams->original = 0;
+	public function testUpdateRouteParameters()
+	{
+		$routeQueryParams= new RouteParametersQuery();
+		$routeQueryParams->route_id = self::$testRoutes[sizeof(self::$testRoutes) - 1]->route_id;
+		$routeQueryParams->original = 0;
 
-        $routeParams = new RouteParameters();
+		$routeParams = new RouteParameters();
 
-        $routeParams->disable_optimization = false;
-        $routeParams->vehicle_capacity = 9800;
-        $routeParams->target_duration = 0;
-        $routeParams->target_distance = 100;
-        $routeParams->target_wait_by_tail_size = 0;
+		$routeParams->disable_optimization = false;
+		$routeParams->vehicle_capacity = 9800;
+		$routeParams->target_duration = 0;
+		$routeParams->target_distance = 100;
+		$routeParams->target_wait_by_tail_size = 0;
 
-        $route = new Route();
+		$route = new Route();
 
-        $result = $route->updateRouteParameters($routeQueryParams->toArray(), $routeParams->toArray());
+		$result = $route->updateRouteParameters($routeQueryParams->toArray(), $routeParams->toArray());
 
-        $this->assertNotNull($result);
-        $this->assertInstanceOf(  Route::class, Route::fromArray( $result));
-    }
+		$this->assertNotNull($result);
+		$this->assertInstanceOf(  Route::class, Route::fromArray( $result));
+	}
 
-    public function  testDeleteRoutes()
-    {
-        $routeToDeleteID = self::$testRoutes[sizeof(self::$testRoutes) - 1]->route_id;
+	public function  testDeleteRoutes()
+	{
+		$routeToDeleteID = self::$testRoutes[sizeof(self::$testRoutes) - 1]->route_id;
 
-        $routeIDs = [ $routeToDeleteID ];
+		$routeIDs = [ $routeToDeleteID ];
 
-        $route = new Route();
+		$route = new Route();
 
-        $result = $route->deleteRoutes($routeIDs);
+		$result = $route->deleteRoutes($routeIDs);
 
-        $this->assertNotNull($result);
-        $this->assertInstanceOf(RoutesDeleteResponse::class, RoutesDeleteResponse::fromArray( $result));
-        $this->assertTrue($result['deleted']);
+		$this->assertNotNull($result);
+		$this->assertInstanceOf(RoutesDeleteResponse::class, RoutesDeleteResponse::fromArray( $result));
+		$this->assertTrue($result['deleted']);
 
-        self::$testRoutes = array_pop(self::$testRoutes);
-    }
+		self::$testRoutes = array_pop(self::$testRoutes);
+	}
 
-    public static function tearDownAfterClass()
-    {
-        if (sizeof(self::$createdProblems)>0) {
-            $optimizationProblemIDs = [];
+	public static function tearDownAfterClass()
+	{
+		if (sizeof(self::$createdProblems)>0) {
+			$optimizationProblemIDs = [];
 
-            foreach (self::$createdProblems as $problem) {
-                $optimizationProblemId = $problem->optimization_problem_id;
+			foreach (self::$createdProblems as $problem) {
+				$optimizationProblemId = $problem->optimization_problem_id;
 
-                $optimizationProblemIDs[] = $optimizationProblemId;
-            }
+				$optimizationProblemIDs[] = $optimizationProblemId;
+			}
 
-            if (sizeof(self::$removedOptimizationIDs)>0) {
-                $optimizationProblemIDs = array_merge($optimizationProblemIDs,self::$removedOptimizationIDs);
-            }
+			if (sizeof(self::$removedOptimizationIDs)>0) {
+				$optimizationProblemIDs = array_merge($optimizationProblemIDs,self::$removedOptimizationIDs);
+			}
 
-            $params = [
-                'optimization_problem_ids' => $optimizationProblemIDs,
-                'redirect'                 => 0,
-            ];
+			$params = [
+				'optimization_problem_ids' => $optimizationProblemIDs,
+				'redirect'                 => 0,
+			];
 
-            $problem = new OptimizationProblem();
-            $result = $problem->removeOptimization($params);
+			$problem = new OptimizationProblem();
+			$result = $problem->removeOptimization($params);
 
-            if ($result!=null && $result['status']==true) {
-                echo "The test optimizations were removed <br>";
-            } else {
-                echo "Cannot remove the test optimizations <br>";
-            }
-        }
+			if ($result!=null && $result['status']==true) {
+				echo "The test optimizations were removed <br>";
+			} else {
+				echo "Cannot remove the test optimizations <br>";
+			}
+		}
 
-        if (sizeof(self::$removedRouteIDs)>0) {
-            $route = new Route();
+		if (sizeof(self::$removedRouteIDs)>0) {
+			$route = new Route();
 
-            $route_ids = join(',', self::$removedRouteIDs);
+			$route_ids = join(',', self::$removedRouteIDs);
 
-            $result = $route->deleteRoutes($route_ids);
+			$result = $route->deleteRoutes($route_ids);
 
-            if ($result!=null && $result['deleted']==true) {
-                echo "The test routes were removed <br>";
-            } else {
-                echo "Cannot remove the test routes <br>";
-            }
-        }
-    }
+			if ($result!=null && $result['deleted']==true) {
+				echo "The test routes were removed <br>";
+			} else {
+				echo "Cannot remove the test routes <br>";
+			}
+		}
+	}
 
 }
\ No newline at end of file

UnitTestFiles/Test/CustomNoteTypeUnitTests.php

Indentation +15 added lines, -15 removed lines

@@ -6,21 +6,21 @@
 
 class CustomNoteTypeUnitTests extends \PHPUnit\Framework\TestCase
 {
-    public function testFromArray()
-    {
-        $customNoteType = CustomNoteType::fromArray([
-            'note_custom_entry_id'  => 'ABCBA1228FA18888DBEECBFA2DA7777C850E15CA',
-            'note_id'               => '3237302',
-            'note_custom_type_id'   => '10',
-            'note_custom_value'     => 'Backdoor',
-            'note_custom_type'      => 'Dropoff Location'
-        ]);
+	public function testFromArray()
+	{
+		$customNoteType = CustomNoteType::fromArray([
+			'note_custom_entry_id'  => 'ABCBA1228FA18888DBEECBFA2DA7777C850E15CA',
+			'note_id'               => '3237302',
+			'note_custom_type_id'   => '10',
+			'note_custom_value'     => 'Backdoor',
+			'note_custom_type'      => 'Dropoff Location'
+		]);
 
-        $this->assertEquals('ABCBA1228FA18888DBEECBFA2DA7777C850E15CA', $customNoteType->note_custom_entry_id);
-        $this->assertEquals('3237302', $customNoteType->note_id);
-        $this->assertEquals('10', $customNoteType->note_custom_type_id);
-        $this->assertEquals('Backdoor', $customNoteType->note_custom_value);
-        $this->assertEquals('Dropoff Location', $customNoteType->note_custom_type);
-    }
+		$this->assertEquals('ABCBA1228FA18888DBEECBFA2DA7777C850E15CA', $customNoteType->note_custom_entry_id);
+		$this->assertEquals('3237302', $customNoteType->note_id);
+		$this->assertEquals('10', $customNoteType->note_custom_type_id);
+		$this->assertEquals('Backdoor', $customNoteType->note_custom_value);
+		$this->assertEquals('Dropoff Location', $customNoteType->note_custom_type);
+	}
 
 }
\ No newline at end of file

UnitTestFiles/Test/AvoidanceZoneUnitTests.php

Indentation +198 added lines, -198 removed lines

@@ -8,202 +8,202 @@
 use Route4Me\Route4Me;
 
 class AvoidanceZoneUnitTests extends \PHPUnit\Framework\TestCase {
-    protected $avoidanceZone;
-    protected $createdAvoidanceZones;
-
-    public function setUp()
-    {
-        $this->avoidanceZone = new AvoidanceZone();
-
-        Route4Me::setApiKey(Constants::API_KEY);
-
-        $createdAvoidanceZones = [];
-
-        $rectTerritoryParams['type'] = TerritoryTypes::RECT;
-        $rectTerritoryParams['data'] = [
-            '43.51668853502909,-109.3798828125',
-            '46.98025235521883,-101.865234375',
-        ];
-
-        $AvoidanceZoneParameters = AvoidanceZone::fromArray([
-            'territory_name'    => 'Test Rectangular Avoidance Zone '.strval(rand(10000, 99999)),
-            'territory_color'   => 'ff7700',
-            'territory' => $rectTerritoryParams,
-        ]);
-
-        $rectAvoidanceZone = AvoidanceZone::fromArray(
-            AvoidanceZone::addAvoidanceZone($AvoidanceZoneParameters)
-        );
-
-        $this->createdAvoidanceZones[] = $rectAvoidanceZone;
-
-        $circleTerritoryParams['type'] = TerritoryTypes::CIRCLE;
-        $circleTerritoryParams['data'] = [
-            '37.569752822786455,-77.47833251953125',
-            '5000',
-        ];
-
-        $AvoidanceZoneParameters = AvoidanceZone::fromArray([
-            'territory_name'    => 'Test Rectangular Avoidance Zone '.strval(rand(10000, 99999)),
-            'territory_color'   => 'ff7700',
-            'territory' => $circleTerritoryParams,
-        ]);
-
-        $circleAvoidanceZone = AvoidanceZone::fromArray(
-            AvoidanceZone::addAvoidanceZone($AvoidanceZoneParameters)
-        );
-
-        $this->createdAvoidanceZones[] = $circleAvoidanceZone;
-    }
-
-    public function testFromArray()
-    {
-        $circleTerritoryParams['type'] = TerritoryTypes::CIRCLE;
-        $circleTerritoryParams['data'] = [
-            '37.569752822786455,-77.47833251953125',
-            '5000',
-        ];
-
-        $avoidanceZone = AvoidanceZone::fromArray([
-            'territory_name'    => "Rect Territory Name",
-            'territory_color'   => "ff0000",
-            'territory' => $circleTerritoryParams
-        ]);
-
-        $this->assertEquals($avoidanceZone->territory_name, "Rect Territory Name");
-        $this->assertEquals($avoidanceZone->territory_color, "ff0000");
-        $this->assertEquals($avoidanceZone->territory['type'], TerritoryTypes::CIRCLE);
-        $this->assertEquals($avoidanceZone->territory['data'], [
-            '37.569752822786455,-77.47833251953125',
-            '5000',
-        ]);
-    }
-
-    public function testToArray()
-    {
-        $rectTerritoryParams['type'] = TerritoryTypes::RECT;
-        $rectTerritoryParams['data'] = [
-            '43.51668853502909,-109.3798828125',
-            '46.98025235521883,-101.865234375',
-        ];
-
-        $avoidanceZone = AvoidanceZone::fromArray([
-            'territory_name'    => "Rect Territory Name",
-            'territory_color'   => "ff0000",
-            'territory'         => $rectTerritoryParams
-        ]);
-
-        $this->assertEquals($avoidanceZone->toArray(),
-            [
-                'territory_name'    => "Rect Territory Name",
-                'territory_color'   => "ff0000",
-                'territory'         => $rectTerritoryParams
-            ]
-        );
-    }
-
-    public function testGetAvoidanceZones()
-    {
-        $avoidanceZones = AvoidanceZone::getAvoidanceZones([]);
-
-        $this->assertNotNull($avoidanceZones);
-        $this->assertTrue(is_array($avoidanceZones));
-        $first=AvoidanceZone::fromArray($avoidanceZones[0]);
-        $this->assertContainsOnlyInstancesOf('Route4Me\AvoidanceZone', [$first]);
-    }
-
-    public function testGetAvoidanceZone()
-    {
-        $avoidanceZones = AvoidanceZone::getAvoidanceZones([]);
-
-        $avoidanceZoneId = $avoidanceZones[0]['territory_id'];
-        $this->assertNotNull($avoidanceZoneId);
-
-        $avoidanceZone = AvoidanceZone::fromArray(AvoidanceZone::getAvoidanceZone($avoidanceZoneId));
-
-        $this->assertNotNull($avoidanceZone);
-        $this->assertContainsOnlyInstancesOf('Route4Me\AvoidanceZone', [$avoidanceZone]);
-    }
-
-    public function testAddAvoidanceZone()
-    {
-        $polyTerritoryParams['type'] = TerritoryTypes::POLY;
-        $polyTerritoryParams['data'] = [
-            '37.769752822786455,-77.67833251953125',
-            '37.75886716305343,-77.68974800109863',
-            '37.74763966054455,-77.6917221069336',
-            '37.74655084306813,-77.68863220214844',
-            '37.7502255383101,-77.68125076293945',
-            '37.74797991274437,-77.67498512268066',
-            '37.73327960206065,-77.6411678314209',
-            '37.74430510679532,-77.63172645568848',
-            '37.76641925847049,-77.66846199035645',
-        ];
-
-        $AvoidanceZoneParameters = AvoidanceZone::fromArray([
-            'territory_name'    => 'Test Rectangular Avoidance Zone '.strval(rand(10000, 99999)),
-            'territory_color'   => 'ff7700',
-            'territory'         => $polyTerritoryParams,
-        ]);
-
-        $polyAvoidanceZone = AvoidanceZone::fromArray(
-            AvoidanceZone::addAvoidanceZone($AvoidanceZoneParameters)
-        );
-
-        $this->createdAvoidanceZones[] = $polyAvoidanceZone;
-
-        $this->assertNotNull($polyAvoidanceZone);
-        $this->assertContainsOnlyInstancesOf('Route4Me\AvoidanceZone', [$polyAvoidanceZone]);
-        $this->assertEquals(TerritoryTypes::POLY, $polyAvoidanceZone->territory['type']);
-    }
-
-    public function testDeleteAvoidanceZone()
-    {
-        $territoryId = $this->createdAvoidanceZones[sizeof($this->createdAvoidanceZones)-1]->territory_id;
-        $result = $this->avoidanceZone->deleteAvoidanceZone($territoryId);
-        //$result = AvoidanceZone::deleteAvoidanceZone($territoryId);
-
-        $this->assertNotNull($result);
-        $this->assertTrue($result['status']);
-
-        $this->createdAvoidanceZones[] = array_pop($this->createdAvoidanceZones);
-    }
-
-    public function testUpdateAvoidanceZone()
-    {
-        $territoryId = $this->createdAvoidanceZones[0]->territory_id;
-
-        $avoidanceZoneParameters = [
-            'territory_id'      => $territoryId,
-            'territory_name'    => 'Test Territory Updated',
-            'territory_color'   => 'ff5500'
-        ];
-
-        $updatedRoute = AvoidanceZone::fromArray(
-            $this->avoidanceZone->updateAvoidanceZone($avoidanceZoneParameters)
-        );
-
-        $this->assertNotNull($updatedRoute);
-        $this->assertContainsOnlyInstancesOf('Route4Me\AvoidanceZone', [$updatedRoute]);
-        $this->assertEquals('Test Territory Updated',$updatedRoute->territory_name, "The territory name not updated");
-        $this->assertEquals('ff5500',$updatedRoute->territory_color, "The territory color not updated");
-    }
-
-    public function tearDown()
-    {
-        foreach ($this->createdAvoidanceZones as $avZone)
-        {
-            $territoryId = $avZone->territory_id;
-
-            $result = $this->avoidanceZone->deleteAvoidanceZone($territoryId);
-
-            if ($result==true) {
-                echo "The test avoidance zone with territory_id=".$territoryId." removed. <br>";
-            }
-            else {
-                echo "Cannot remove the test avoidance zone with territory_id=".$territoryId."<br>";
-            }
-
-        }
-    }
+	protected $avoidanceZone;
+	protected $createdAvoidanceZones;
+
+	public function setUp()
+	{
+		$this->avoidanceZone = new AvoidanceZone();
+
+		Route4Me::setApiKey(Constants::API_KEY);
+
+		$createdAvoidanceZones = [];
+
+		$rectTerritoryParams['type'] = TerritoryTypes::RECT;
+		$rectTerritoryParams['data'] = [
+			'43.51668853502909,-109.3798828125',
+			'46.98025235521883,-101.865234375',
+		];
+
+		$AvoidanceZoneParameters = AvoidanceZone::fromArray([
+			'territory_name'    => 'Test Rectangular Avoidance Zone '.strval(rand(10000, 99999)),
+			'territory_color'   => 'ff7700',
+			'territory' => $rectTerritoryParams,
+		]);
+
+		$rectAvoidanceZone = AvoidanceZone::fromArray(
+			AvoidanceZone::addAvoidanceZone($AvoidanceZoneParameters)
+		);
+
+		$this->createdAvoidanceZones[] = $rectAvoidanceZone;
+
+		$circleTerritoryParams['type'] = TerritoryTypes::CIRCLE;
+		$circleTerritoryParams['data'] = [
+			'37.569752822786455,-77.47833251953125',
+			'5000',
+		];
+
+		$AvoidanceZoneParameters = AvoidanceZone::fromArray([
+			'territory_name'    => 'Test Rectangular Avoidance Zone '.strval(rand(10000, 99999)),
+			'territory_color'   => 'ff7700',
+			'territory' => $circleTerritoryParams,
+		]);
+
+		$circleAvoidanceZone = AvoidanceZone::fromArray(
+			AvoidanceZone::addAvoidanceZone($AvoidanceZoneParameters)
+		);
+
+		$this->createdAvoidanceZones[] = $circleAvoidanceZone;
+	}
+
+	public function testFromArray()
+	{
+		$circleTerritoryParams['type'] = TerritoryTypes::CIRCLE;
+		$circleTerritoryParams['data'] = [
+			'37.569752822786455,-77.47833251953125',
+			'5000',
+		];
+
+		$avoidanceZone = AvoidanceZone::fromArray([
+			'territory_name'    => "Rect Territory Name",
+			'territory_color'   => "ff0000",
+			'territory' => $circleTerritoryParams
+		]);
+
+		$this->assertEquals($avoidanceZone->territory_name, "Rect Territory Name");
+		$this->assertEquals($avoidanceZone->territory_color, "ff0000");
+		$this->assertEquals($avoidanceZone->territory['type'], TerritoryTypes::CIRCLE);
+		$this->assertEquals($avoidanceZone->territory['data'], [
+			'37.569752822786455,-77.47833251953125',
+			'5000',
+		]);
+	}
+
+	public function testToArray()
+	{
+		$rectTerritoryParams['type'] = TerritoryTypes::RECT;
+		$rectTerritoryParams['data'] = [
+			'43.51668853502909,-109.3798828125',
+			'46.98025235521883,-101.865234375',
+		];
+
+		$avoidanceZone = AvoidanceZone::fromArray([
+			'territory_name'    => "Rect Territory Name",
+			'territory_color'   => "ff0000",
+			'territory'         => $rectTerritoryParams
+		]);
+
+		$this->assertEquals($avoidanceZone->toArray(),
+			[
+				'territory_name'    => "Rect Territory Name",
+				'territory_color'   => "ff0000",
+				'territory'         => $rectTerritoryParams
+			]
+		);
+	}
+
+	public function testGetAvoidanceZones()
+	{
+		$avoidanceZones = AvoidanceZone::getAvoidanceZones([]);
+
+		$this->assertNotNull($avoidanceZones);
+		$this->assertTrue(is_array($avoidanceZones));
+		$first=AvoidanceZone::fromArray($avoidanceZones[0]);
+		$this->assertContainsOnlyInstancesOf('Route4Me\AvoidanceZone', [$first]);
+	}
+
+	public function testGetAvoidanceZone()
+	{
+		$avoidanceZones = AvoidanceZone::getAvoidanceZones([]);
+
+		$avoidanceZoneId = $avoidanceZones[0]['territory_id'];
+		$this->assertNotNull($avoidanceZoneId);
+
+		$avoidanceZone = AvoidanceZone::fromArray(AvoidanceZone::getAvoidanceZone($avoidanceZoneId));
+
+		$this->assertNotNull($avoidanceZone);
+		$this->assertContainsOnlyInstancesOf('Route4Me\AvoidanceZone', [$avoidanceZone]);
+	}
+
+	public function testAddAvoidanceZone()
+	{
+		$polyTerritoryParams['type'] = TerritoryTypes::POLY;
+		$polyTerritoryParams['data'] = [
+			'37.769752822786455,-77.67833251953125',
+			'37.75886716305343,-77.68974800109863',
+			'37.74763966054455,-77.6917221069336',
+			'37.74655084306813,-77.68863220214844',
+			'37.7502255383101,-77.68125076293945',
+			'37.74797991274437,-77.67498512268066',
+			'37.73327960206065,-77.6411678314209',
+			'37.74430510679532,-77.63172645568848',
+			'37.76641925847049,-77.66846199035645',
+		];
+
+		$AvoidanceZoneParameters = AvoidanceZone::fromArray([
+			'territory_name'    => 'Test Rectangular Avoidance Zone '.strval(rand(10000, 99999)),
+			'territory_color'   => 'ff7700',
+			'territory'         => $polyTerritoryParams,
+		]);
+
+		$polyAvoidanceZone = AvoidanceZone::fromArray(
+			AvoidanceZone::addAvoidanceZone($AvoidanceZoneParameters)
+		);
+
+		$this->createdAvoidanceZones[] = $polyAvoidanceZone;
+
+		$this->assertNotNull($polyAvoidanceZone);
+		$this->assertContainsOnlyInstancesOf('Route4Me\AvoidanceZone', [$polyAvoidanceZone]);
+		$this->assertEquals(TerritoryTypes::POLY, $polyAvoidanceZone->territory['type']);
+	}
+
+	public function testDeleteAvoidanceZone()
+	{
+		$territoryId = $this->createdAvoidanceZones[sizeof($this->createdAvoidanceZones)-1]->territory_id;
+		$result = $this->avoidanceZone->deleteAvoidanceZone($territoryId);
+		//$result = AvoidanceZone::deleteAvoidanceZone($territoryId);
+
+		$this->assertNotNull($result);
+		$this->assertTrue($result['status']);
+
+		$this->createdAvoidanceZones[] = array_pop($this->createdAvoidanceZones);
+	}
+
+	public function testUpdateAvoidanceZone()
+	{
+		$territoryId = $this->createdAvoidanceZones[0]->territory_id;
+
+		$avoidanceZoneParameters = [
+			'territory_id'      => $territoryId,
+			'territory_name'    => 'Test Territory Updated',
+			'territory_color'   => 'ff5500'
+		];
+
+		$updatedRoute = AvoidanceZone::fromArray(
+			$this->avoidanceZone->updateAvoidanceZone($avoidanceZoneParameters)
+		);
+
+		$this->assertNotNull($updatedRoute);
+		$this->assertContainsOnlyInstancesOf('Route4Me\AvoidanceZone', [$updatedRoute]);
+		$this->assertEquals('Test Territory Updated',$updatedRoute->territory_name, "The territory name not updated");
+		$this->assertEquals('ff5500',$updatedRoute->territory_color, "The territory color not updated");
+	}
+
+	public function tearDown()
+	{
+		foreach ($this->createdAvoidanceZones as $avZone)
+		{
+			$territoryId = $avZone->territory_id;
+
+			$result = $this->avoidanceZone->deleteAvoidanceZone($territoryId);
+
+			if ($result==true) {
+				echo "The test avoidance zone with territory_id=".$territoryId." removed. <br>";
+			}
+			else {
+				echo "Cannot remove the test avoidance zone with territory_id=".$territoryId."<br>";
+			}
+
+		}
+	}
 }

UnitTestFiles/Test/VehicleTests.php

Indentation +438 added lines, -438 removed lines

@@ -12,447 +12,447 @@
 
 class VehicleTests extends \PHPUnit\Framework\TestCase
 {
-    public static $createdVehicles=[];
-
-    public static function setUpBeforeClass()
-    {
-        Route4Me::setApiKey(Constants::API_KEY);
-
-        $vehicle = new VehicleV4();
-
-        $vehicleParameters = Vehicle::fromArray([
-            'vehicle_name'              => 'Ford Transit Test 5',
-            'vehicle_alias'             => 'Ford Transit Test 5',
-            'vehicle_vin'               => 'JS3TD62V1Y4107898',
-            'vehicle_reg_country_id'    => '223',
-            'vehicle_make'              => 'Ford',
-            'vehicle_model_year'        => 2013,
-            'vehicle_axle_count'        => 2,
-            'mpg_city'                  => 8,
-            'mpg_highway'               => 14,
-            'fuel_type'                 => 'unleaded 93',
-            'height_inches'             => 72,
-            'weight_lb'                 => 2000,
-        ]);
-
-        $result = $vehicle->createVehicle($vehicleParameters);
-
-        self::assertNotNull($result);
-        self::assertInstanceOf(
-            VehicleV4::class,
-            VehicleV4::fromArray($result)
-        );
-
-        self::$createdVehicles[] = $result['vehicle_id'];
-    }
-
-    public function testFromArray()
-    {
-        $vehicleParameters = VehicleV4::fromArray([
-            'vehicle_id'                        => '43B1DC9C2C4DC3A8FE080A126B12ACBD',
-            'member_id'                         => 18154,
-            'is_deleted'                        => false,
-            'vehicle_alias'                     => 'Ford Transit Test 5',
-            'vehicle_vin'                       => 'JS3TD62V1Y4107898',
-            'vehicle_reg_state_id'              => null,
-            'vehicle_reg_country_id'            => 223,
-            'vehicle_license_plate'             => null,
-            'vehicle_type_id'                   => null,
-            'timestamp_added'                   => '2020-12-20T17:25:14+00:00',
-            'vehicle_make'                      => 'Ford',
-            'vehicle_model_year'                => 2013,
-            'vehicle_model'                     => null,
-            'vehicle_year_acquired'             => null,
-            'vehicle_cost_new'                  => null,
-            'purchased_new'                     => null,
-            'license_start_date'                => '2020-12-20',
-            'license_end_date'                  => '2020-12-20',
-            'is_operational'                    => true,
-            'fuel_type'                         => 'unleaded 93',
-            'external_telematics_vehicle_id'    => null,
-            'timestamp_removed'                 => null,
-            'vehicle_profile_id'                => null,
-            'fuel_consumption_city'             => '8',
-            'fuel_consumption_highway'          => '14',
-            'fuel_consumption_city_unit'        => 'mi\/l',
-            'fuel_consumption_highway_unit'     => 'mi\/l',
-            'mpg_city'                          => 30.28,
-            'mpg_highway'                       => 53,
-            'fuel_consumption_city_uf_value'    => '8 mi\/l',
-            'fuel_consumption_highway_uf_value' => '14 mi\/l'
-        ]);
-
-        $this->assertEquals('43B1DC9C2C4DC3A8FE080A126B12ACBD', $vehicleParameters->vehicle_id);
-        $this->assertEquals(18154, $vehicleParameters->member_id);
-        $this->assertEquals(false, $vehicleParameters->is_deleted);
-        $this->assertEquals('Ford Transit Test 5', $vehicleParameters->vehicle_alias);
-        $this->assertEquals('JS3TD62V1Y4107898', $vehicleParameters->vehicle_vin);
-        $this->assertEquals(null, $vehicleParameters->vehicle_reg_state_id);
-        $this->assertEquals(223, $vehicleParameters->vehicle_reg_country_id);
-        $this->assertEquals(null, $vehicleParameters->vehicle_license_plate);
-        $this->assertEquals(null, $vehicleParameters->vehicle_type_id);
-        $this->assertEquals('2020-12-20T17:25:14+00:00', $vehicleParameters->timestamp_added);
-        $this->assertEquals('Ford', $vehicleParameters->vehicle_make);
-        $this->assertEquals(2013, $vehicleParameters->vehicle_model_year);
-        $this->assertEquals(null, $vehicleParameters->vehicle_model);
-        $this->assertEquals(null, $vehicleParameters->vehicle_year_acquired);
-        $this->assertEquals(null, $vehicleParameters->vehicle_cost_new);
-        $this->assertEquals(null, $vehicleParameters->purchased_new);
-        $this->assertEquals('2020-12-20', $vehicleParameters->license_start_date);
-        $this->assertEquals('2020-12-20', $vehicleParameters->license_end_date);
-        $this->assertEquals(true, $vehicleParameters->is_operational);
-        $this->assertEquals('unleaded 93', $vehicleParameters->fuel_type);
-        $this->assertEquals(null, $vehicleParameters->external_telematics_vehicle_id);
-        $this->assertEquals(null, $vehicleParameters->timestamp_removed);
-        $this->assertEquals(null, $vehicleParameters->vehicle_profile_id);
-        $this->assertEquals('8', $vehicleParameters->fuel_consumption_city);
-        $this->assertEquals('14', $vehicleParameters->fuel_consumption_highway);
-        $this->assertEquals('mi\/l', $vehicleParameters->fuel_consumption_city_unit);
-        $this->assertEquals('mi\/l', $vehicleParameters->fuel_consumption_highway_unit);
-        $this->assertEquals(30.28, $vehicleParameters->mpg_city);
-        $this->assertEquals(53, $vehicleParameters->mpg_highway);
-        $this->assertEquals('8 mi\/l', $vehicleParameters->fuel_consumption_city_uf_value);
-        $this->assertEquals('14 mi\/l', $vehicleParameters->fuel_consumption_highway_uf_value);
-    }
-
-    public function testToArray()
-    {
-        $vehicleParameters = VehicleV4::fromArray([
-            'vehicle_id' => '43B1DC9C2C4DC3A8FE080A126B12ACBD',
-            'member_id' => 18154,
-            'is_deleted' => false,
-            'vehicle_alias' => 'Ford Transit Test 5',
-            'vehicle_vin' => 'JS3TD62V1Y4107898',
-             'vehicle_reg_country_id' => 223,
-            'timestamp_added' => '2020-12-20T17:25:14+00:00',
-            'vehicle_make' => 'Ford',
-            'vehicle_model_year' => 2013,
-            'license_start_date' => '2020-12-20',
-            'license_end_date' => '2020-12-20',
-            'is_operational' => true,
-            'fuel_type' => 'unleaded 93',
-            'fuel_consumption_city' => '8',
-            'fuel_consumption_highway' => '14',
-            'fuel_consumption_city_unit' => 'mi\/l',
-            'fuel_consumption_highway_unit' => 'mi\/l',
-            'mpg_city' => 30.28,
-            'mpg_highway' => 53,
-            'fuel_consumption_city_uf_value' => '8 mi\/l',
-            'fuel_consumption_highway_uf_value' => '14 mi\/l'
-        ]);
-
-        $this->assertEquals($vehicleParameters->toArray(),
-            [
-                'vehicle_id' => '43B1DC9C2C4DC3A8FE080A126B12ACBD',
-                'member_id' => 18154,
-                'is_deleted' => false,
-                'vehicle_alias' => 'Ford Transit Test 5',
-                'vehicle_vin' => 'JS3TD62V1Y4107898',
-                'vehicle_reg_country_id' => 223,
-                'timestamp_added' => '2020-12-20T17:25:14+00:00',
-                'vehicle_make' => 'Ford',
-                'vehicle_model_year' => 2013,
-                'license_start_date' => '2020-12-20',
-                'license_end_date' => '2020-12-20',
-                'is_operational' => true,
-                'fuel_type' => 'unleaded 93',
-                'fuel_consumption_city' => '8',
-                'fuel_consumption_highway' => '14',
-                'fuel_consumption_city_unit' => 'mi\/l',
-                'fuel_consumption_highway_unit' => 'mi\/l',
-                'mpg_city' => 30.28,
-                'mpg_highway' => 53,
-                'fuel_consumption_city_uf_value' => '8 mi\/l',
-                'fuel_consumption_highway_uf_value' => '14 mi\/l'
-            ]
-        );
-    }
-
-    public function testGetVehiclesList()
-    {
-        $vehicle = new Vehicle();
-
-        $vehicleParameters = [
-            'with_pagination' => true,
-            'page' => 2,
-            'perPage' => 10,
-        ];
-
-        $result = $vehicle->getVehicles($vehicleParameters);
-
-        $this->assertNotNull($result);
-        $this->assertTrue(is_array($result));
-        $this->assertInstanceOf(
-            DataVehicle::class,
-            DataVehicle::fromArray($result)
-        );
+	public static $createdVehicles=[];
+
+	public static function setUpBeforeClass()
+	{
+		Route4Me::setApiKey(Constants::API_KEY);
+
+		$vehicle = new VehicleV4();
+
+		$vehicleParameters = Vehicle::fromArray([
+			'vehicle_name'              => 'Ford Transit Test 5',
+			'vehicle_alias'             => 'Ford Transit Test 5',
+			'vehicle_vin'               => 'JS3TD62V1Y4107898',
+			'vehicle_reg_country_id'    => '223',
+			'vehicle_make'              => 'Ford',
+			'vehicle_model_year'        => 2013,
+			'vehicle_axle_count'        => 2,
+			'mpg_city'                  => 8,
+			'mpg_highway'               => 14,
+			'fuel_type'                 => 'unleaded 93',
+			'height_inches'             => 72,
+			'weight_lb'                 => 2000,
+		]);
+
+		$result = $vehicle->createVehicle($vehicleParameters);
+
+		self::assertNotNull($result);
+		self::assertInstanceOf(
+			VehicleV4::class,
+			VehicleV4::fromArray($result)
+		);
+
+		self::$createdVehicles[] = $result['vehicle_id'];
+	}
+
+	public function testFromArray()
+	{
+		$vehicleParameters = VehicleV4::fromArray([
+			'vehicle_id'                        => '43B1DC9C2C4DC3A8FE080A126B12ACBD',
+			'member_id'                         => 18154,
+			'is_deleted'                        => false,
+			'vehicle_alias'                     => 'Ford Transit Test 5',
+			'vehicle_vin'                       => 'JS3TD62V1Y4107898',
+			'vehicle_reg_state_id'              => null,
+			'vehicle_reg_country_id'            => 223,
+			'vehicle_license_plate'             => null,
+			'vehicle_type_id'                   => null,
+			'timestamp_added'                   => '2020-12-20T17:25:14+00:00',
+			'vehicle_make'                      => 'Ford',
+			'vehicle_model_year'                => 2013,
+			'vehicle_model'                     => null,
+			'vehicle_year_acquired'             => null,
+			'vehicle_cost_new'                  => null,
+			'purchased_new'                     => null,
+			'license_start_date'                => '2020-12-20',
+			'license_end_date'                  => '2020-12-20',
+			'is_operational'                    => true,
+			'fuel_type'                         => 'unleaded 93',
+			'external_telematics_vehicle_id'    => null,
+			'timestamp_removed'                 => null,
+			'vehicle_profile_id'                => null,
+			'fuel_consumption_city'             => '8',
+			'fuel_consumption_highway'          => '14',
+			'fuel_consumption_city_unit'        => 'mi\/l',
+			'fuel_consumption_highway_unit'     => 'mi\/l',
+			'mpg_city'                          => 30.28,
+			'mpg_highway'                       => 53,
+			'fuel_consumption_city_uf_value'    => '8 mi\/l',
+			'fuel_consumption_highway_uf_value' => '14 mi\/l'
+		]);
+
+		$this->assertEquals('43B1DC9C2C4DC3A8FE080A126B12ACBD', $vehicleParameters->vehicle_id);
+		$this->assertEquals(18154, $vehicleParameters->member_id);
+		$this->assertEquals(false, $vehicleParameters->is_deleted);
+		$this->assertEquals('Ford Transit Test 5', $vehicleParameters->vehicle_alias);
+		$this->assertEquals('JS3TD62V1Y4107898', $vehicleParameters->vehicle_vin);
+		$this->assertEquals(null, $vehicleParameters->vehicle_reg_state_id);
+		$this->assertEquals(223, $vehicleParameters->vehicle_reg_country_id);
+		$this->assertEquals(null, $vehicleParameters->vehicle_license_plate);
+		$this->assertEquals(null, $vehicleParameters->vehicle_type_id);
+		$this->assertEquals('2020-12-20T17:25:14+00:00', $vehicleParameters->timestamp_added);
+		$this->assertEquals('Ford', $vehicleParameters->vehicle_make);
+		$this->assertEquals(2013, $vehicleParameters->vehicle_model_year);
+		$this->assertEquals(null, $vehicleParameters->vehicle_model);
+		$this->assertEquals(null, $vehicleParameters->vehicle_year_acquired);
+		$this->assertEquals(null, $vehicleParameters->vehicle_cost_new);
+		$this->assertEquals(null, $vehicleParameters->purchased_new);
+		$this->assertEquals('2020-12-20', $vehicleParameters->license_start_date);
+		$this->assertEquals('2020-12-20', $vehicleParameters->license_end_date);
+		$this->assertEquals(true, $vehicleParameters->is_operational);
+		$this->assertEquals('unleaded 93', $vehicleParameters->fuel_type);
+		$this->assertEquals(null, $vehicleParameters->external_telematics_vehicle_id);
+		$this->assertEquals(null, $vehicleParameters->timestamp_removed);
+		$this->assertEquals(null, $vehicleParameters->vehicle_profile_id);
+		$this->assertEquals('8', $vehicleParameters->fuel_consumption_city);
+		$this->assertEquals('14', $vehicleParameters->fuel_consumption_highway);
+		$this->assertEquals('mi\/l', $vehicleParameters->fuel_consumption_city_unit);
+		$this->assertEquals('mi\/l', $vehicleParameters->fuel_consumption_highway_unit);
+		$this->assertEquals(30.28, $vehicleParameters->mpg_city);
+		$this->assertEquals(53, $vehicleParameters->mpg_highway);
+		$this->assertEquals('8 mi\/l', $vehicleParameters->fuel_consumption_city_uf_value);
+		$this->assertEquals('14 mi\/l', $vehicleParameters->fuel_consumption_highway_uf_value);
+	}
+
+	public function testToArray()
+	{
+		$vehicleParameters = VehicleV4::fromArray([
+			'vehicle_id' => '43B1DC9C2C4DC3A8FE080A126B12ACBD',
+			'member_id' => 18154,
+			'is_deleted' => false,
+			'vehicle_alias' => 'Ford Transit Test 5',
+			'vehicle_vin' => 'JS3TD62V1Y4107898',
+			 'vehicle_reg_country_id' => 223,
+			'timestamp_added' => '2020-12-20T17:25:14+00:00',
+			'vehicle_make' => 'Ford',
+			'vehicle_model_year' => 2013,
+			'license_start_date' => '2020-12-20',
+			'license_end_date' => '2020-12-20',
+			'is_operational' => true,
+			'fuel_type' => 'unleaded 93',
+			'fuel_consumption_city' => '8',
+			'fuel_consumption_highway' => '14',
+			'fuel_consumption_city_unit' => 'mi\/l',
+			'fuel_consumption_highway_unit' => 'mi\/l',
+			'mpg_city' => 30.28,
+			'mpg_highway' => 53,
+			'fuel_consumption_city_uf_value' => '8 mi\/l',
+			'fuel_consumption_highway_uf_value' => '14 mi\/l'
+		]);
+
+		$this->assertEquals($vehicleParameters->toArray(),
+			[
+				'vehicle_id' => '43B1DC9C2C4DC3A8FE080A126B12ACBD',
+				'member_id' => 18154,
+				'is_deleted' => false,
+				'vehicle_alias' => 'Ford Transit Test 5',
+				'vehicle_vin' => 'JS3TD62V1Y4107898',
+				'vehicle_reg_country_id' => 223,
+				'timestamp_added' => '2020-12-20T17:25:14+00:00',
+				'vehicle_make' => 'Ford',
+				'vehicle_model_year' => 2013,
+				'license_start_date' => '2020-12-20',
+				'license_end_date' => '2020-12-20',
+				'is_operational' => true,
+				'fuel_type' => 'unleaded 93',
+				'fuel_consumption_city' => '8',
+				'fuel_consumption_highway' => '14',
+				'fuel_consumption_city_unit' => 'mi\/l',
+				'fuel_consumption_highway_unit' => 'mi\/l',
+				'mpg_city' => 30.28,
+				'mpg_highway' => 53,
+				'fuel_consumption_city_uf_value' => '8 mi\/l',
+				'fuel_consumption_highway_uf_value' => '14 mi\/l'
+			]
+		);
+	}
+
+	public function testGetVehiclesList()
+	{
+		$vehicle = new Vehicle();
+
+		$vehicleParameters = [
+			'with_pagination' => true,
+			'page' => 2,
+			'perPage' => 10,
+		];
+
+		$result = $vehicle->getVehicles($vehicleParameters);
+
+		$this->assertNotNull($result);
+		$this->assertTrue(is_array($result));
+		$this->assertInstanceOf(
+			DataVehicle::class,
+			DataVehicle::fromArray($result)
+		);
 
 
 //        $this->assertTrue(isset($result['current_page']));
 //        $this->assertTrue(isset($result['data']));
 //        $this->assertTrue(is_array($result['data']));
-    }
-
-    public function testGetVehicle()
-    {
-        $vehicle = new VehicleV4();
-
-        $randomVehicleID = self::$createdVehicles[0];
-
-        // Get a vehicle by ID
-        $result = $vehicle->getVehicleByID($randomVehicleID);
-
-        $this->assertNotNull($result);
-        $this->assertInstanceOf(
-            VehicleV4::class,
-            VehicleV4::fromArray($result)
-        );
-    }
-
-    public function testUpdateVehicle()
-    {
-        $vehicle = new VehicleV4();
-
-        $randomVehicleID = self::$createdVehicles[0];
-
-        // Update the vehicle
-        $vehicleParameters = Vehicle::fromArray([
-            'vehicle_id' => $randomVehicleID,
-            'vehicle_model_year' => 2013,
-            'vehicle_year_acquired' => 2016,
-            'vehicle_reg_country_id' => '223',
-            'vehicle_make' => 'Ford',
-            'fuel_type' => 'unleaded 93',
-        ]);
-
-        $result = $vehicle->updateVehicle($vehicleParameters);
-
-        $this->assertNotNull($result);
-        $this->assertInstanceOf(
-            VehicleV4::class,
-            VehicleV4::fromArray($result)
-        );
-        $this->assertEquals(2013, $result['vehicle_model_year']);
-        $this->assertEquals(2016, $result['vehicle_year_acquired']);
-        $this->assertEquals('223', $result['vehicle_reg_country_id']);
-        $this->assertEquals('Ford', $result['vehicle_make']);
-        $this->assertEquals('unleaded 93', $result['fuel_type']);
-    }
-
-    public function testCreateVehicle()
-    {
-        $vehicle = new VehicleV4();
-
-        $vehicleParameters = Vehicle::fromArray([
-            'vehicle_alias' => 'Ford Transit Test 5',
-            'vehicle_vin' => 'JS3TD62V1Y4107898',
-            'vehicle_reg_country_id' => '223',
-            'vehicle_make' => 'Ford',
-            'vehicle_model_year' => 2013,
-            'mpg_city' => 8,
-            'mpg_highway' => 14,
-            'fuel_type' => 'unleaded 93',
-        ]);
-
-        $result = $vehicle->createVehicle($vehicleParameters);
-
-        self::assertNotNull($result);
-        self::assertInstanceOf(
-            VehicleV4::class,
-            VehicleV4::fromArray($result)
-        );
-        $this->assertEquals('Ford Transit Test 5', $vehicleParameters->vehicle_alias);
-        $this->assertEquals('JS3TD62V1Y4107898', $vehicleParameters->vehicle_vin);
-
-        self::$createdVehicles[] = $result['vehicle_id'];
-    }
-
-    public function testCreateHazmatTruck()
-    {
-        $vehicle = new VehicleV4();
-
-        $vehicleParameters = Vehicle::fromArray([
-            'vehicle_alias' => 'ISUZU FTR',
-            'vehicle_vin' => '1NP5DB9X93N507873',
-            'vehicle_license_plate' => 'IFT6253',
-            'license_start_date' => '2008-05-14',
-            'license_end_date' => '2020-09-24',
-            'vehicle_model' => 'FTR',
-            'vehicle_model_year' => 2008,
-            'vehicle_year_acquired' => 2008,
-            'vehicle_reg_country_id' => 223,
-            'vehicle_type_id' => 'bigrig',
-            //'has_trailer' => false,
-            'mpg_city' => 5,
-            'mpg_highway' => 15,
-            'fuel_type' => 'diesel',
-            //'height_inches' => 112,
-            //'height_metric' => 280,
-            //'maxWeightPerAxleGroupInPounds' => 19000,
-            //'max_weight_per_axle_group_metric' => 8620,
-            //'widthInInches' => 94,
-            //'width_metric' => 235,
-            //'lengthInInches' => 384,
-            //'length_metric' => 960,
-            //'Use53FootTrailerRouting' => 'NO',
-            //'UseTruckRestrictions' => 'YES',
-            //'DividedHighwayAvoidPreference' => 'NEUTRAL',
-            //'FreewayAvoidPreference' => 'NEUTRAL',
-            //'TollRoadUsage' => 'ALWAYS_AVOID',
-            //'truck_config' => '26_STRAIGHT_TRUCK',
-            //'InternationalBordersOpen' => 'YES',
-            'purchased_new' => true,
-            //'HazmatType' => 'FLAMMABLE',
-        ]);
-
-        $response = $vehicle->createVehicle($vehicleParameters);
-
-        self::assertNotNull($response);
-        self::assertInstanceOf(
-            VehicleCreateResponseV4::class,
-            VehicleCreateResponseV4::fromArray($response)
-        );
-
-        $result =  VehicleCreateResponseV4::fromArray($response);
-
-        $this->assertEquals('ISUZU FTR', $result->vehicle_alias);
-        $this->assertEquals('1NP5DB9X93N507873', $result->vehicle_vin);
-        $this->assertEquals('IFT6253', $result->vehicle_license_plate);
-        $this->assertEquals('2008-05-14', $result->license_start_date);
-        $this->assertEquals('2020-09-24', $result->license_end_date);
-        $this->assertEquals('FTR', $result->vehicle_model);
-        $this->assertEquals(2008, $result->vehicle_model_year);
-        $this->assertEquals(2008, $result->vehicle_year_acquired);
-        $this->assertEquals(223, $result->vehicle_reg_country_id);
-        $this->assertEquals('bigrig', $result->vehicle_type_id);
-        //$this->assertEquals(false, $result->has_trailer);
-        //$this->assertEquals(5, $result->mpg_city);
-        //$this->assertEquals(15, $result->mpg_highway);
-        $this->assertEquals('5', $result->fuel_consumption_city);
-        $this->assertEquals('15', $result->fuel_consumption_highway);
-        $this->assertEquals('diesel', $result->fuel_type);
-        //$this->assertEquals(112, $result->height_inches);
-        //$this->assertEquals(280, $result->height_metric);
-        //$this->assertEquals(19000, $result->maxWeightPerAxleGroupInPounds);
-        //$this->assertEquals(8620, $result->max_weight_per_axle_group_metric);
-        //$this->assertEquals(94, $result->widthInInches);
-        //$this->assertEquals(235, $result->width_metric);
-        //$this->assertEquals(384, $result->lengthInInches);
-        //$this->assertEquals(960, $result->length_metric);
-        //$this->assertEquals('NO', $result->Use53FootTrailerRouting);
-        //$this->assertEquals('YES', $result->UseTruckRestrictions);
-        //$this->assertEquals('NEUTRAL', $result->DividedHighwayAvoidPreference);
-        //$this->assertEquals('NEUTRAL', $result->FreewayAvoidPreference);
-        //$this->assertEquals('ALWAYS_AVOID', $result->TollRoadUsage);
-        //$this->assertEquals('26_STRAIGHT_TRUCK', $result->truck_config);
-        //$this->assertEquals('YES', $result->InternationalBordersOpen);
-        $this->assertEquals(true, $result->purchased_new);
-        //$this->assertEquals('FLAMMABLE', $result->HazmatType);
-
-        self::$createdVehicles[] = $result->vehicle_id;
-    }
-
-    public function testCreateHeavyTruck()
-    {
-        $vehicle = new VehicleV4();
-
-        $vehicleParameters = Vehicle::fromArray([
-            'vehicle_alias' => 'Peterbilt 579',
-            'vehicle_vin' => '1NP5DB9X93N507873',
-            'vehicle_license_plate' => 'PPV7516',
-            'license_start_date' => '2017-06-05',
-            'license_end_date' => '2021-08-14',
-            'vehicle_model' => '579',
-            'vehicle_model_year' => 2015,
-            'vehicle_year_acquired' => 2018,
-            'vehicle_reg_country_id' => 223,
-            'vehicle_type_id' => 'tractor_trailer',
-            //'has_trailer' => true,
-            'mpg_city' => 6,
-            'mpg_highway' => 12,
-            'fuel_type' => 'diesel',
-            //'height_inches' => 114,
-            //'height_metric' => 290,
-            //'maxWeightPerAxleGroupInPounds' => 40000,
-            //'max_weight_per_axle_group_metric' => 18000,
-            //'widthInInches' => 102,
-            //'width_metric' => 258,
-            //'lengthInInches' => 640,
-            //'length_metric' => 1625,
-            //'Use53FootTrailerRouting' => 'YES',
-            //'UseTruckRestrictions' => 'YES',
-            //'DividedHighwayAvoidPreference' => 'STRONG_AVOID',
-            //'FreewayAvoidPreference' => 'STRONG_AVOID',
-            //'truck_config' => '53_SEMI_TRAILER',
-            //'InternationalBordersOpen' => 'YES',
-            'purchased_new' => true,
-        ]);
-
-        $response = $vehicle->createVehicle($vehicleParameters);
-
-        self::assertNotNull($response);
-        self::assertInstanceOf(
-            VehicleCreateResponseV4::class,
-            VehicleCreateResponseV4::fromArray($response)
-        );
-
-        $result =  VehicleCreateResponseV4::fromArray($response);
-
-        $this->assertEquals('Peterbilt 579', $result->vehicle_alias);
-        $this->assertEquals('1NP5DB9X93N507873', $result->vehicle_vin);
-        $this->assertEquals('PPV7516', $result->vehicle_license_plate);
-        $this->assertEquals('2017-06-05', $result->license_start_date);
-        $this->assertEquals('2021-08-14', $result->license_end_date);
-        $this->assertEquals('579', $result->vehicle_model);
-        $this->assertEquals(2015, $result->vehicle_model_year);
-        $this->assertEquals(2018, $result->vehicle_year_acquired);
-        $this->assertEquals(223, $result->vehicle_reg_country_id);
-        $this->assertEquals('tractor_trailer', $result->vehicle_type_id);
-        //$this->assertEquals(true, $result->has_trailer);
-        //'$this->assertEquals(6, $result->mpg_city);
-        //$this->assertEquals(12, $result->mpg_highway);
-        $this->assertEquals('6', $result->fuel_consumption_city);
-        $this->assertEquals('12', $result->fuel_consumption_highway);
-        $this->assertEquals('diesel', $result->fuel_type);
-        //$this->assertEquals(114, $result->height_inches);
-        //$this->assertEquals(290, $result->height_metric);
-        //$this->assertEquals(40000, $result->maxWeightPerAxleGroupInPounds);
-        //$this->assertEquals(18000, $result->max_weight_per_axle_group_metric);
-        //$this->assertEquals(102, $result->widthInInches);
-        //$this->assertEquals(258, $result->width_metric);
-        //$this->assertEquals(640, $result->lengthInInches);
-        //$this->assertEquals(1625, $result->length_metric);
-        //$this->assertEquals('YES', $result->Use53FootTrailerRouting);
-        //$this->assertEquals('YES', $result->UseTruckRestrictions);
-        //$this->assertEquals('STRONG_AVOID', $result->DividedHighwayAvoidPreference);
-        //$this->assertEquals('STRONG_AVOID', $result->FreewayAvoidPreference);
-        //$this->assertEquals('ALWAYS_AVOID', $result->TollRoadUsage);
-        //$this->assertEquals('53_SEMI_TRAILER', $result->truck_config);
-        //$this->assertEquals('YES', $result->InternationalBordersOpen);
-        $this->assertEquals(true, $result->purchased_new);
-
-        self::$createdVehicles[] = $result->vehicle_id;
-    }
-
-    public static function tearDownAfterClass()
-    {
-        if (!is_null(self::$createdVehicles) && sizeof(self::$createdVehicles)>0) {
-            $vehicle = new VehicleV4();
-
-            foreach (self::$createdVehicles as $createdVehicleId) {
-                $vehicleParameters = VehicleV4::fromArray([
-                    'vehicle_id' => $createdVehicleId,
-                ]);
-
-                $result = $vehicle->removeVehicle($vehicleParameters);
-
-                if (!is_null($result) && (VehicleV4::fromArray($result) instanceof VehicleV4)) {
-                    echo "The vehicle ".$result['vehicle_id']." removed <br>";
-                } else {
-                    echo "Cannot remove the vehicle ".$result['vehicle_id']." <br>";
-                };
-
-            }
-        }
-    }
+	}
+
+	public function testGetVehicle()
+	{
+		$vehicle = new VehicleV4();
+
+		$randomVehicleID = self::$createdVehicles[0];
+
+		// Get a vehicle by ID
+		$result = $vehicle->getVehicleByID($randomVehicleID);
+
+		$this->assertNotNull($result);
+		$this->assertInstanceOf(
+			VehicleV4::class,
+			VehicleV4::fromArray($result)
+		);
+	}
+
+	public function testUpdateVehicle()
+	{
+		$vehicle = new VehicleV4();
+
+		$randomVehicleID = self::$createdVehicles[0];
+
+		// Update the vehicle
+		$vehicleParameters = Vehicle::fromArray([
+			'vehicle_id' => $randomVehicleID,
+			'vehicle_model_year' => 2013,
+			'vehicle_year_acquired' => 2016,
+			'vehicle_reg_country_id' => '223',
+			'vehicle_make' => 'Ford',
+			'fuel_type' => 'unleaded 93',
+		]);
+
+		$result = $vehicle->updateVehicle($vehicleParameters);
+
+		$this->assertNotNull($result);
+		$this->assertInstanceOf(
+			VehicleV4::class,
+			VehicleV4::fromArray($result)
+		);
+		$this->assertEquals(2013, $result['vehicle_model_year']);
+		$this->assertEquals(2016, $result['vehicle_year_acquired']);
+		$this->assertEquals('223', $result['vehicle_reg_country_id']);
+		$this->assertEquals('Ford', $result['vehicle_make']);
+		$this->assertEquals('unleaded 93', $result['fuel_type']);
+	}
+
+	public function testCreateVehicle()
+	{
+		$vehicle = new VehicleV4();
+
+		$vehicleParameters = Vehicle::fromArray([
+			'vehicle_alias' => 'Ford Transit Test 5',
+			'vehicle_vin' => 'JS3TD62V1Y4107898',
+			'vehicle_reg_country_id' => '223',
+			'vehicle_make' => 'Ford',
+			'vehicle_model_year' => 2013,
+			'mpg_city' => 8,
+			'mpg_highway' => 14,
+			'fuel_type' => 'unleaded 93',
+		]);
+
+		$result = $vehicle->createVehicle($vehicleParameters);
+
+		self::assertNotNull($result);
+		self::assertInstanceOf(
+			VehicleV4::class,
+			VehicleV4::fromArray($result)
+		);
+		$this->assertEquals('Ford Transit Test 5', $vehicleParameters->vehicle_alias);
+		$this->assertEquals('JS3TD62V1Y4107898', $vehicleParameters->vehicle_vin);
+
+		self::$createdVehicles[] = $result['vehicle_id'];
+	}
+
+	public function testCreateHazmatTruck()
+	{
+		$vehicle = new VehicleV4();
+
+		$vehicleParameters = Vehicle::fromArray([
+			'vehicle_alias' => 'ISUZU FTR',
+			'vehicle_vin' => '1NP5DB9X93N507873',
+			'vehicle_license_plate' => 'IFT6253',
+			'license_start_date' => '2008-05-14',
+			'license_end_date' => '2020-09-24',
+			'vehicle_model' => 'FTR',
+			'vehicle_model_year' => 2008,
+			'vehicle_year_acquired' => 2008,
+			'vehicle_reg_country_id' => 223,
+			'vehicle_type_id' => 'bigrig',
+			//'has_trailer' => false,
+			'mpg_city' => 5,
+			'mpg_highway' => 15,
+			'fuel_type' => 'diesel',
+			//'height_inches' => 112,
+			//'height_metric' => 280,
+			//'maxWeightPerAxleGroupInPounds' => 19000,
+			//'max_weight_per_axle_group_metric' => 8620,
+			//'widthInInches' => 94,
+			//'width_metric' => 235,
+			//'lengthInInches' => 384,
+			//'length_metric' => 960,
+			//'Use53FootTrailerRouting' => 'NO',
+			//'UseTruckRestrictions' => 'YES',
+			//'DividedHighwayAvoidPreference' => 'NEUTRAL',
+			//'FreewayAvoidPreference' => 'NEUTRAL',
+			//'TollRoadUsage' => 'ALWAYS_AVOID',
+			//'truck_config' => '26_STRAIGHT_TRUCK',
+			//'InternationalBordersOpen' => 'YES',
+			'purchased_new' => true,
+			//'HazmatType' => 'FLAMMABLE',
+		]);
+
+		$response = $vehicle->createVehicle($vehicleParameters);
+
+		self::assertNotNull($response);
+		self::assertInstanceOf(
+			VehicleCreateResponseV4::class,
+			VehicleCreateResponseV4::fromArray($response)
+		);
+
+		$result =  VehicleCreateResponseV4::fromArray($response);
+
+		$this->assertEquals('ISUZU FTR', $result->vehicle_alias);
+		$this->assertEquals('1NP5DB9X93N507873', $result->vehicle_vin);
+		$this->assertEquals('IFT6253', $result->vehicle_license_plate);
+		$this->assertEquals('2008-05-14', $result->license_start_date);
+		$this->assertEquals('2020-09-24', $result->license_end_date);
+		$this->assertEquals('FTR', $result->vehicle_model);
+		$this->assertEquals(2008, $result->vehicle_model_year);
+		$this->assertEquals(2008, $result->vehicle_year_acquired);
+		$this->assertEquals(223, $result->vehicle_reg_country_id);
+		$this->assertEquals('bigrig', $result->vehicle_type_id);
+		//$this->assertEquals(false, $result->has_trailer);
+		//$this->assertEquals(5, $result->mpg_city);
+		//$this->assertEquals(15, $result->mpg_highway);
+		$this->assertEquals('5', $result->fuel_consumption_city);
+		$this->assertEquals('15', $result->fuel_consumption_highway);
+		$this->assertEquals('diesel', $result->fuel_type);
+		//$this->assertEquals(112, $result->height_inches);
+		//$this->assertEquals(280, $result->height_metric);
+		//$this->assertEquals(19000, $result->maxWeightPerAxleGroupInPounds);
+		//$this->assertEquals(8620, $result->max_weight_per_axle_group_metric);
+		//$this->assertEquals(94, $result->widthInInches);
+		//$this->assertEquals(235, $result->width_metric);
+		//$this->assertEquals(384, $result->lengthInInches);
+		//$this->assertEquals(960, $result->length_metric);
+		//$this->assertEquals('NO', $result->Use53FootTrailerRouting);
+		//$this->assertEquals('YES', $result->UseTruckRestrictions);
+		//$this->assertEquals('NEUTRAL', $result->DividedHighwayAvoidPreference);
+		//$this->assertEquals('NEUTRAL', $result->FreewayAvoidPreference);
+		//$this->assertEquals('ALWAYS_AVOID', $result->TollRoadUsage);
+		//$this->assertEquals('26_STRAIGHT_TRUCK', $result->truck_config);
+		//$this->assertEquals('YES', $result->InternationalBordersOpen);
+		$this->assertEquals(true, $result->purchased_new);
+		//$this->assertEquals('FLAMMABLE', $result->HazmatType);
+
+		self::$createdVehicles[] = $result->vehicle_id;
+	}
+
+	public function testCreateHeavyTruck()
+	{
+		$vehicle = new VehicleV4();
+
+		$vehicleParameters = Vehicle::fromArray([
+			'vehicle_alias' => 'Peterbilt 579',
+			'vehicle_vin' => '1NP5DB9X93N507873',
+			'vehicle_license_plate' => 'PPV7516',
+			'license_start_date' => '2017-06-05',
+			'license_end_date' => '2021-08-14',
+			'vehicle_model' => '579',
+			'vehicle_model_year' => 2015,
+			'vehicle_year_acquired' => 2018,
+			'vehicle_reg_country_id' => 223,
+			'vehicle_type_id' => 'tractor_trailer',
+			//'has_trailer' => true,
+			'mpg_city' => 6,
+			'mpg_highway' => 12,
+			'fuel_type' => 'diesel',
+			//'height_inches' => 114,
+			//'height_metric' => 290,
+			//'maxWeightPerAxleGroupInPounds' => 40000,
+			//'max_weight_per_axle_group_metric' => 18000,
+			//'widthInInches' => 102,
+			//'width_metric' => 258,
+			//'lengthInInches' => 640,
+			//'length_metric' => 1625,
+			//'Use53FootTrailerRouting' => 'YES',
+			//'UseTruckRestrictions' => 'YES',
+			//'DividedHighwayAvoidPreference' => 'STRONG_AVOID',
+			//'FreewayAvoidPreference' => 'STRONG_AVOID',
+			//'truck_config' => '53_SEMI_TRAILER',
+			//'InternationalBordersOpen' => 'YES',
+			'purchased_new' => true,
+		]);
+
+		$response = $vehicle->createVehicle($vehicleParameters);
+
+		self::assertNotNull($response);
+		self::assertInstanceOf(
+			VehicleCreateResponseV4::class,
+			VehicleCreateResponseV4::fromArray($response)
+		);
+
+		$result =  VehicleCreateResponseV4::fromArray($response);
+
+		$this->assertEquals('Peterbilt 579', $result->vehicle_alias);
+		$this->assertEquals('1NP5DB9X93N507873', $result->vehicle_vin);
+		$this->assertEquals('PPV7516', $result->vehicle_license_plate);
+		$this->assertEquals('2017-06-05', $result->license_start_date);
+		$this->assertEquals('2021-08-14', $result->license_end_date);
+		$this->assertEquals('579', $result->vehicle_model);
+		$this->assertEquals(2015, $result->vehicle_model_year);
+		$this->assertEquals(2018, $result->vehicle_year_acquired);
+		$this->assertEquals(223, $result->vehicle_reg_country_id);
+		$this->assertEquals('tractor_trailer', $result->vehicle_type_id);
+		//$this->assertEquals(true, $result->has_trailer);
+		//'$this->assertEquals(6, $result->mpg_city);
+		//$this->assertEquals(12, $result->mpg_highway);
+		$this->assertEquals('6', $result->fuel_consumption_city);
+		$this->assertEquals('12', $result->fuel_consumption_highway);
+		$this->assertEquals('diesel', $result->fuel_type);
+		//$this->assertEquals(114, $result->height_inches);
+		//$this->assertEquals(290, $result->height_metric);
+		//$this->assertEquals(40000, $result->maxWeightPerAxleGroupInPounds);
+		//$this->assertEquals(18000, $result->max_weight_per_axle_group_metric);
+		//$this->assertEquals(102, $result->widthInInches);
+		//$this->assertEquals(258, $result->width_metric);
+		//$this->assertEquals(640, $result->lengthInInches);
+		//$this->assertEquals(1625, $result->length_metric);
+		//$this->assertEquals('YES', $result->Use53FootTrailerRouting);
+		//$this->assertEquals('YES', $result->UseTruckRestrictions);
+		//$this->assertEquals('STRONG_AVOID', $result->DividedHighwayAvoidPreference);
+		//$this->assertEquals('STRONG_AVOID', $result->FreewayAvoidPreference);
+		//$this->assertEquals('ALWAYS_AVOID', $result->TollRoadUsage);
+		//$this->assertEquals('53_SEMI_TRAILER', $result->truck_config);
+		//$this->assertEquals('YES', $result->InternationalBordersOpen);
+		$this->assertEquals(true, $result->purchased_new);
+
+		self::$createdVehicles[] = $result->vehicle_id;
+	}
+
+	public static function tearDownAfterClass()
+	{
+		if (!is_null(self::$createdVehicles) && sizeof(self::$createdVehicles)>0) {
+			$vehicle = new VehicleV4();
+
+			foreach (self::$createdVehicles as $createdVehicleId) {
+				$vehicleParameters = VehicleV4::fromArray([
+					'vehicle_id' => $createdVehicleId,
+				]);
+
+				$result = $vehicle->removeVehicle($vehicleParameters);
+
+				if (!is_null($result) && (VehicleV4::fromArray($result) instanceof VehicleV4)) {
+					echo "The vehicle ".$result['vehicle_id']." removed <br>";
+				} else {
+					echo "Cannot remove the vehicle ".$result['vehicle_id']." <br>";
+				};
+
+			}
+		}
+	}
 }
\ No newline at end of file