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/V5/VehicleTests.php

Indentation +496 added lines, -496 removed lines

@@ -26,541 +26,541 @@
 
 class VehicleTests extends TestCase
 {
-    public static $createdVehicles = [];
-    public static $createdVehicleProfiles = [];
-
-    public static function setUpBeforeClass()
-    {
-        Route4Me::setApiKey(Constants::API_KEY);
-
-        $vehicle = new Vehicle();
-
-        //region Create Test Vehicles
-
-        $class6TruckParams = Vehicle::fromArray([
-            'vehicle_alias'             => 'GMC TopKick C5500 TST 6',
-            'vehicle_vin'               => 'SAJXA01A06FN08012',
-            'vehicle_license_plate'     => 'CVH4561',
-            'vehicle_model'             => 'TopKick C5500',
-            'vehicle_model_year'        => 1995,
-            'vehicle_year_acquired'     => 2008,
-            'vehicle_reg_country_id'    => 223,
-            'vehicle_reg_state_id'      => 12,
-            'vehicle_make'              => 'GMC',
-            'vehicle_type_id'           => 'pickup_truck',
-            'vehicle_cost_new'          => 60000,
-            'purchased_new'             => true,
-            'mpg_city'                  => 8,
-            'mpg_highway'               => 14,
-            'fuel_type'                 => 'diesel',
-            'license_start_date'        => '2021-01-01',
-            'license_end_date'          => '2031-01-01',
-        ]);
-
-        $result = $vehicle->createVehicle($class6TruckParams);
-
-        self::assertNotNull($result);
-        self::assertInstanceOf(
-            Vehicle::class,
-            Vehicle::fromArray($result)
-        );
-
-        self::$createdVehicles[] = $result;
-
-
-        $class7TruckParams = Vehicle::fromArray([
-            'vehicle_alias'             => 'FORD F750 TST 7',
-            'vehicle_vin'               => '1NPAX6EX2YD550743',
-            'vehicle_license_plate'     => 'FFV9547',
-            'vehicle_model'             => 'F-750',
-            'vehicle_model_year'        => 2010,
-            'vehicle_year_acquired'     => 2018,
-            'vehicle_reg_country_id'    => 223,
-            'vehicle_make'              => 'Ford',
-            'vehicle_type_id'           => 'livestock_carrier',
-            'vehicle_cost_new'          => 60000,
-            'purchased_new'             => true,
-            'mpg_city'                  => 7,
-            'mpg_highway'               => 14,
-            'fuel_consumption_city'     => 7,
-            'fuel_consumption_highway'  => 14,
-            'fuel_type'                 => 'diesel',
-            'license_start_date'        => '2021-01-01',
-            'license_end_date'          => '2031-01-01',
-        ]);
-
-        $result = $vehicle->createVehicle($class7TruckParams);
-
-        self::assertNotNull($result);
-        self::assertInstanceOf(
-            Vehicle::class,
-            Vehicle::fromArray($result)
-        );
-
-        self::$createdVehicles[] = $result;
-
-        //endregion
-
-        #region Create Test Vehicle Profiles
-
-        $profile1 = new VehicleProfile();
-
-        $profile1->name = "Heavy Duty - 28 Double Trailer ".date('Y-m-d H:i');
-        $profile1->height_units = VehicleSizeUnits::METER;
-        $profile1->width_units = VehicleSizeUnits::METER;
-        $profile1->length_units = VehicleSizeUnits::METER;
-        $profile1->height = 4;
-        $profile1->width = 2.44;
-        $profile1->length = 12.2;
-        $profile1->is_predefined = false;
-        $profile1->is_default = false;
-        $profile1->weight_units = VehicleWeightUnits::KILOGRAM;
-        $profile1->weight = 20400;
-        $profile1->max_weight_per_axle = 15400;
-        $profile1->fuel_type = FuelTypes::UNLEADED_91;
-        $profile1->fuel_consumption_city = 6;
-        $profile1->fuel_consumption_highway = 12;
-        $profile1->fuel_consumption_city_unit = FuelConsumptionUnits::MILES_PER_GALLON_US;
-        $profile1->fuel_consumption_highway_unit = FuelConsumptionUnits::MILES_PER_GALLON_US;
-
-        $result1 = $profile1->createVehicleProfile($profile1->toArray());
-
-        self::assertNotNull($result1);
-        self::assertInstanceOf(
-            VehicleProfile::class,
-            VehicleProfile::fromArray($result1)
-        );
-
-        self::$createdVehicleProfiles[] = $result1;
-
-        $profile2 = new VehicleProfile();
-
-        $profile2->name = "Heavy Duty - 40 Straight Truck ".date('Y-m-d H:i');
-        $profile2->height_units = VehicleSizeUnits::METER;
-        $profile2->width_units = VehicleSizeUnits::METER;
-        $profile2->length_units = VehicleSizeUnits::METER;
-        $profile2->height = 4;
-        $profile2->width = 2.44;
-        $profile2->length = 14.6;
-        $profile2->is_predefined = false;
-        $profile2->is_default = false;
-        $profile2->weight_units = VehicleWeightUnits::KILOGRAM;
-        $profile2->weight = 36300;
-        $profile2->max_weight_per_axle = 15400;
-        $profile2->fuel_type = FuelTypes::UNLEADED_87;
-        $profile2->fuel_consumption_city = 5;
-        $profile2->fuel_consumption_highway = 10;
-        $profile2->fuel_consumption_city_unit = FuelConsumptionUnits::MILES_PER_GALLON_US;
-        $profile2->fuel_consumption_highway_unit = FuelConsumptionUnits::MILES_PER_GALLON_US;
-
-        $result2 = $profile2->createVehicleProfile($profile2->toArray());
-
-        self::assertNotNull($result2);
-        self::assertInstanceOf(
-            VehicleProfile::class,
-            VehicleProfile::fromArray($result2)
-        );
-
-        self::$createdVehicleProfiles[] = $result2;
-
-        #endregion
-    }
-
-    public function testFromArray()
-    {
-        $class6TruckParams = Vehicle::fromArray([
-            'vehicle_alias'             => 'GMC TopKick C5500 TST 6',
-            'vehicle_vin'               => 'SAJXA01A06FN08012',
-            'vehicle_license_plate'     => 'CVH4561',
-            'vehicle_model'             => 'TopKick C5500',
-            'vehicle_model_year'        => 1995,
-            'vehicle_year_acquired'     => 2008,
-            'vehicle_reg_country_id'    => 223,
-            'vehicle_reg_state_id'      => 12,
-            'vehicle_make'              => 'GMC',
-            'vehicle_type_id'           => 'pickup_truck',
-            'vehicle_cost_new'          => 60000,
-            'purchased_new'             => true,
-            'mpg_city'                  => 8,
-            'mpg_highway'               => 14,
-            'fuel_type'                 => 'diesel',
-            'license_start_date'        => '2021-01-01',
-            'license_end_date'          => '2031-01-01',
-        ]);
-
-        $this->assertEquals($class6TruckParams->vehicle_alias , 'GMC TopKick C5500 TST 6');
-        $this->assertEquals($class6TruckParams->vehicle_vin , 'SAJXA01A06FN08012');
-        $this->assertEquals($class6TruckParams->vehicle_license_plate , 'CVH4561');
-        $this->assertEquals($class6TruckParams->vehicle_model , 'TopKick C5500');
-        $this->assertEquals($class6TruckParams->vehicle_model_year , 1995);
-        $this->assertEquals($class6TruckParams->vehicle_year_acquired , 2008);
-        $this->assertEquals($class6TruckParams->vehicle_reg_country_id , 223);
-        $this->assertEquals($class6TruckParams->vehicle_reg_state_id , 12);
-        $this->assertEquals($class6TruckParams->vehicle_make , 'GMC');
-        $this->assertEquals($class6TruckParams->vehicle_type_id , 'pickup_truck');
-        $this->assertEquals($class6TruckParams->vehicle_cost_new , 60000);
-        $this->assertEquals($class6TruckParams->purchased_new ,true);
-        $this->assertEquals($class6TruckParams->mpg_city , 8);
-        $this->assertEquals($class6TruckParams->mpg_highway , 14);
-        $this->assertEquals($class6TruckParams->fuel_type , 'diesel');
-        $this->assertEquals($class6TruckParams->license_start_date , '2021-01-01');
-        $this->assertEquals($class6TruckParams->license_end_date , '2031-01-01');
-
-
-    }
-
-    public function testGetVehiclesPaginatedList()
-    {
-        $vehParams = new VehicleParameters();
-
-        $vehParams->with_pagination = true;
-        $vehParams->page = 1;
-        $vehParams->perPage = 10;
-
-        $vehicle = new Vehicle();
-
-        $result = $vehicle->getVehiclesPaginatedList($vehParams->toArray());
-
-        $this->assertNotNull($result);
-        $this->assertTrue(is_array($result));
-        $this->assertTrue(sizeof($result)>0);
-        $this->assertInstanceOf(Vehicle::class, Vehicle::fromArray($result));
-    }
-
-    public function testCreateVehicle()
-    {
-        $vehicle = new Vehicle();
-
-        $class7TruckParams = Vehicle::fromArray([
-            'vehicle_alias'             => 'FORD F750 TST 7',
-            'vehicle_vin'               => '1NPAX6EX2YD550743',
-            'vehicle_license_plate'     => 'FFV9547',
-            'vehicle_model'             => 'F-750',
-            'vehicle_model_year'        => 2010,
-            'vehicle_year_acquired'     => 2018,
-            'vehicle_reg_country_id'    => 223,
-            'vehicle_reg_state_id'      => 12,
-            'vehicle_make'              => 'Ford',
-            'vehicle_type_id'           => 'livestock_carrier',
-            'vehicle_cost_new'          => 70000,
-            'purchased_new'             => false,
-            'mpg_city'                  => 6,
-            'mpg_highway'               => 12,
-            'fuel_consumption_city'     => 6,
-            'fuel_consumption_highway'  => 12,
-            'fuel_type'                 => 'diesel',
-            'license_start_date'        => '2020-03-01',
-            'license_end_date'          => '2028-12-01',
-        ]);
-
-        $result = $vehicle->createVehicle($class7TruckParams);
-
-        self::assertNotNull($result);
-        self::assertInstanceOf(
-            Vehicle::class,
-            Vehicle::fromArray($result)
-        );
-
-        self::$createdVehicles[] = $result;
-    }
-
-    public function testCreateTemporaryVehicle()
-    {
-        $this->markTestSkipped('The endpoint vehicles/assign is enabled for the accounts with the specified features.');
-
-        $vehicle = new Vehicle();
-
-        $tempVehParams = new VehicleTemporary();
-
-        $tempVehParams->assigned_member_id = 1;
-        $tempVehParams->expires_at = '2028-12-20';
-        $tempVehParams->force_assignment = true;
-        $tempVehParams->vehicle_id = self::$createdVehicles[0]['vehicle_id'];
-        $tempVehParams->vehicle_license_plate = self::$createdVehicles[0]['vehicle_license_plate'];
-
-        $result = $vehicle->createTemporaryVehicle($tempVehParams->toArray());
-
-        self::assertNotNull($result);
-        self::assertInstanceOf(
-            VehicleTemporary::class,
-            VehicleTemporary::fromArray($result)
-        );
-    }
-
-    public function testExecuteVehicleOrder()
-    {
-        $this->markTestSkipped('The endpoint vehicles/execute is enabled for the account with the specified features.');
-
-        $vehicle = new Vehicle();
-
-        $orderParams = new VehicleOrderParameters();
-        $orderParams->vehicle_id = self::$createdVehicles[0]['vehicle_id'];
-        $orderParams->lat = 38.247605;
-        $orderParams->lng = -85.746697;
-
-        $result = $vehicle->executeVehicleOrder($orderParams->toArray());
-
-        self::assertNotNull($result);
-        self::assertInstanceOf(
-            VehicleOrderResponse::class,
-            VehicleOrderResponse::fromArray($result)
-        );
-    }
-
-    public function testGetLatestVehicleLocations()
-    {
-        $vehicle = new Vehicle();
-
-        $vehicleIDs = array_column(self::$createdVehicles, 'vehicle_id');
-
-        $vehParams = new VehicleParameters();
-        $vehParams->ids = $vehicleIDs;
-
-        $result = $vehicle->getVehicleLocations($vehParams);
-
-        self::assertNotNull($result);
-        self::assertInstanceOf(
-            VehicleLocationResponse::class,
-            VehicleLocationResponse::fromArray($result)
-        );
-        self::assertTrue(isset($result['data']));
-        self::assertTrue(is_array($result['data']));
-    }
-
-    public function testGetVehicleById()
-    {
-        $vehicle = new Vehicle();
-
-        $vehParams = new VehicleParameters();
-        $vehParams->vehicle_id = self::$createdVehicles[0]['vehicle_id'];
-
-        $result = $vehicle->getVehicleById($vehParams->toArray());
-
-        self::assertNotNull($result);
-        self::assertInstanceOf(
-            Vehicle::class,
-            Vehicle::fromArray($result)
-        );
-        self::assertEquals($vehParams->vehicle_id, $result['vehicle_id']);
-    }
-
-
-    public function testGetVehicleTrack()
-    {
-        $vehicle = new Vehicle();
+	public static $createdVehicles = [];
+	public static $createdVehicleProfiles = [];
+
+	public static function setUpBeforeClass()
+	{
+		Route4Me::setApiKey(Constants::API_KEY);
+
+		$vehicle = new Vehicle();
+
+		//region Create Test Vehicles
+
+		$class6TruckParams = Vehicle::fromArray([
+			'vehicle_alias'             => 'GMC TopKick C5500 TST 6',
+			'vehicle_vin'               => 'SAJXA01A06FN08012',
+			'vehicle_license_plate'     => 'CVH4561',
+			'vehicle_model'             => 'TopKick C5500',
+			'vehicle_model_year'        => 1995,
+			'vehicle_year_acquired'     => 2008,
+			'vehicle_reg_country_id'    => 223,
+			'vehicle_reg_state_id'      => 12,
+			'vehicle_make'              => 'GMC',
+			'vehicle_type_id'           => 'pickup_truck',
+			'vehicle_cost_new'          => 60000,
+			'purchased_new'             => true,
+			'mpg_city'                  => 8,
+			'mpg_highway'               => 14,
+			'fuel_type'                 => 'diesel',
+			'license_start_date'        => '2021-01-01',
+			'license_end_date'          => '2031-01-01',
+		]);
+
+		$result = $vehicle->createVehicle($class6TruckParams);
+
+		self::assertNotNull($result);
+		self::assertInstanceOf(
+			Vehicle::class,
+			Vehicle::fromArray($result)
+		);
+
+		self::$createdVehicles[] = $result;
+
+
+		$class7TruckParams = Vehicle::fromArray([
+			'vehicle_alias'             => 'FORD F750 TST 7',
+			'vehicle_vin'               => '1NPAX6EX2YD550743',
+			'vehicle_license_plate'     => 'FFV9547',
+			'vehicle_model'             => 'F-750',
+			'vehicle_model_year'        => 2010,
+			'vehicle_year_acquired'     => 2018,
+			'vehicle_reg_country_id'    => 223,
+			'vehicle_make'              => 'Ford',
+			'vehicle_type_id'           => 'livestock_carrier',
+			'vehicle_cost_new'          => 60000,
+			'purchased_new'             => true,
+			'mpg_city'                  => 7,
+			'mpg_highway'               => 14,
+			'fuel_consumption_city'     => 7,
+			'fuel_consumption_highway'  => 14,
+			'fuel_type'                 => 'diesel',
+			'license_start_date'        => '2021-01-01',
+			'license_end_date'          => '2031-01-01',
+		]);
+
+		$result = $vehicle->createVehicle($class7TruckParams);
+
+		self::assertNotNull($result);
+		self::assertInstanceOf(
+			Vehicle::class,
+			Vehicle::fromArray($result)
+		);
+
+		self::$createdVehicles[] = $result;
+
+		//endregion
+
+		#region Create Test Vehicle Profiles
+
+		$profile1 = new VehicleProfile();
+
+		$profile1->name = "Heavy Duty - 28 Double Trailer ".date('Y-m-d H:i');
+		$profile1->height_units = VehicleSizeUnits::METER;
+		$profile1->width_units = VehicleSizeUnits::METER;
+		$profile1->length_units = VehicleSizeUnits::METER;
+		$profile1->height = 4;
+		$profile1->width = 2.44;
+		$profile1->length = 12.2;
+		$profile1->is_predefined = false;
+		$profile1->is_default = false;
+		$profile1->weight_units = VehicleWeightUnits::KILOGRAM;
+		$profile1->weight = 20400;
+		$profile1->max_weight_per_axle = 15400;
+		$profile1->fuel_type = FuelTypes::UNLEADED_91;
+		$profile1->fuel_consumption_city = 6;
+		$profile1->fuel_consumption_highway = 12;
+		$profile1->fuel_consumption_city_unit = FuelConsumptionUnits::MILES_PER_GALLON_US;
+		$profile1->fuel_consumption_highway_unit = FuelConsumptionUnits::MILES_PER_GALLON_US;
+
+		$result1 = $profile1->createVehicleProfile($profile1->toArray());
+
+		self::assertNotNull($result1);
+		self::assertInstanceOf(
+			VehicleProfile::class,
+			VehicleProfile::fromArray($result1)
+		);
+
+		self::$createdVehicleProfiles[] = $result1;
+
+		$profile2 = new VehicleProfile();
+
+		$profile2->name = "Heavy Duty - 40 Straight Truck ".date('Y-m-d H:i');
+		$profile2->height_units = VehicleSizeUnits::METER;
+		$profile2->width_units = VehicleSizeUnits::METER;
+		$profile2->length_units = VehicleSizeUnits::METER;
+		$profile2->height = 4;
+		$profile2->width = 2.44;
+		$profile2->length = 14.6;
+		$profile2->is_predefined = false;
+		$profile2->is_default = false;
+		$profile2->weight_units = VehicleWeightUnits::KILOGRAM;
+		$profile2->weight = 36300;
+		$profile2->max_weight_per_axle = 15400;
+		$profile2->fuel_type = FuelTypes::UNLEADED_87;
+		$profile2->fuel_consumption_city = 5;
+		$profile2->fuel_consumption_highway = 10;
+		$profile2->fuel_consumption_city_unit = FuelConsumptionUnits::MILES_PER_GALLON_US;
+		$profile2->fuel_consumption_highway_unit = FuelConsumptionUnits::MILES_PER_GALLON_US;
+
+		$result2 = $profile2->createVehicleProfile($profile2->toArray());
+
+		self::assertNotNull($result2);
+		self::assertInstanceOf(
+			VehicleProfile::class,
+			VehicleProfile::fromArray($result2)
+		);
+
+		self::$createdVehicleProfiles[] = $result2;
+
+		#endregion
+	}
+
+	public function testFromArray()
+	{
+		$class6TruckParams = Vehicle::fromArray([
+			'vehicle_alias'             => 'GMC TopKick C5500 TST 6',
+			'vehicle_vin'               => 'SAJXA01A06FN08012',
+			'vehicle_license_plate'     => 'CVH4561',
+			'vehicle_model'             => 'TopKick C5500',
+			'vehicle_model_year'        => 1995,
+			'vehicle_year_acquired'     => 2008,
+			'vehicle_reg_country_id'    => 223,
+			'vehicle_reg_state_id'      => 12,
+			'vehicle_make'              => 'GMC',
+			'vehicle_type_id'           => 'pickup_truck',
+			'vehicle_cost_new'          => 60000,
+			'purchased_new'             => true,
+			'mpg_city'                  => 8,
+			'mpg_highway'               => 14,
+			'fuel_type'                 => 'diesel',
+			'license_start_date'        => '2021-01-01',
+			'license_end_date'          => '2031-01-01',
+		]);
+
+		$this->assertEquals($class6TruckParams->vehicle_alias , 'GMC TopKick C5500 TST 6');
+		$this->assertEquals($class6TruckParams->vehicle_vin , 'SAJXA01A06FN08012');
+		$this->assertEquals($class6TruckParams->vehicle_license_plate , 'CVH4561');
+		$this->assertEquals($class6TruckParams->vehicle_model , 'TopKick C5500');
+		$this->assertEquals($class6TruckParams->vehicle_model_year , 1995);
+		$this->assertEquals($class6TruckParams->vehicle_year_acquired , 2008);
+		$this->assertEquals($class6TruckParams->vehicle_reg_country_id , 223);
+		$this->assertEquals($class6TruckParams->vehicle_reg_state_id , 12);
+		$this->assertEquals($class6TruckParams->vehicle_make , 'GMC');
+		$this->assertEquals($class6TruckParams->vehicle_type_id , 'pickup_truck');
+		$this->assertEquals($class6TruckParams->vehicle_cost_new , 60000);
+		$this->assertEquals($class6TruckParams->purchased_new ,true);
+		$this->assertEquals($class6TruckParams->mpg_city , 8);
+		$this->assertEquals($class6TruckParams->mpg_highway , 14);
+		$this->assertEquals($class6TruckParams->fuel_type , 'diesel');
+		$this->assertEquals($class6TruckParams->license_start_date , '2021-01-01');
+		$this->assertEquals($class6TruckParams->license_end_date , '2031-01-01');
+
+
+	}
+
+	public function testGetVehiclesPaginatedList()
+	{
+		$vehParams = new VehicleParameters();
+
+		$vehParams->with_pagination = true;
+		$vehParams->page = 1;
+		$vehParams->perPage = 10;
+
+		$vehicle = new Vehicle();
+
+		$result = $vehicle->getVehiclesPaginatedList($vehParams->toArray());
+
+		$this->assertNotNull($result);
+		$this->assertTrue(is_array($result));
+		$this->assertTrue(sizeof($result)>0);
+		$this->assertInstanceOf(Vehicle::class, Vehicle::fromArray($result));
+	}
+
+	public function testCreateVehicle()
+	{
+		$vehicle = new Vehicle();
+
+		$class7TruckParams = Vehicle::fromArray([
+			'vehicle_alias'             => 'FORD F750 TST 7',
+			'vehicle_vin'               => '1NPAX6EX2YD550743',
+			'vehicle_license_plate'     => 'FFV9547',
+			'vehicle_model'             => 'F-750',
+			'vehicle_model_year'        => 2010,
+			'vehicle_year_acquired'     => 2018,
+			'vehicle_reg_country_id'    => 223,
+			'vehicle_reg_state_id'      => 12,
+			'vehicle_make'              => 'Ford',
+			'vehicle_type_id'           => 'livestock_carrier',
+			'vehicle_cost_new'          => 70000,
+			'purchased_new'             => false,
+			'mpg_city'                  => 6,
+			'mpg_highway'               => 12,
+			'fuel_consumption_city'     => 6,
+			'fuel_consumption_highway'  => 12,
+			'fuel_type'                 => 'diesel',
+			'license_start_date'        => '2020-03-01',
+			'license_end_date'          => '2028-12-01',
+		]);
+
+		$result = $vehicle->createVehicle($class7TruckParams);
+
+		self::assertNotNull($result);
+		self::assertInstanceOf(
+			Vehicle::class,
+			Vehicle::fromArray($result)
+		);
+
+		self::$createdVehicles[] = $result;
+	}
+
+	public function testCreateTemporaryVehicle()
+	{
+		$this->markTestSkipped('The endpoint vehicles/assign is enabled for the accounts with the specified features.');
+
+		$vehicle = new Vehicle();
+
+		$tempVehParams = new VehicleTemporary();
+
+		$tempVehParams->assigned_member_id = 1;
+		$tempVehParams->expires_at = '2028-12-20';
+		$tempVehParams->force_assignment = true;
+		$tempVehParams->vehicle_id = self::$createdVehicles[0]['vehicle_id'];
+		$tempVehParams->vehicle_license_plate = self::$createdVehicles[0]['vehicle_license_plate'];
+
+		$result = $vehicle->createTemporaryVehicle($tempVehParams->toArray());
+
+		self::assertNotNull($result);
+		self::assertInstanceOf(
+			VehicleTemporary::class,
+			VehicleTemporary::fromArray($result)
+		);
+	}
+
+	public function testExecuteVehicleOrder()
+	{
+		$this->markTestSkipped('The endpoint vehicles/execute is enabled for the account with the specified features.');
+
+		$vehicle = new Vehicle();
+
+		$orderParams = new VehicleOrderParameters();
+		$orderParams->vehicle_id = self::$createdVehicles[0]['vehicle_id'];
+		$orderParams->lat = 38.247605;
+		$orderParams->lng = -85.746697;
+
+		$result = $vehicle->executeVehicleOrder($orderParams->toArray());
+
+		self::assertNotNull($result);
+		self::assertInstanceOf(
+			VehicleOrderResponse::class,
+			VehicleOrderResponse::fromArray($result)
+		);
+	}
+
+	public function testGetLatestVehicleLocations()
+	{
+		$vehicle = new Vehicle();
+
+		$vehicleIDs = array_column(self::$createdVehicles, 'vehicle_id');
+
+		$vehParams = new VehicleParameters();
+		$vehParams->ids = $vehicleIDs;
+
+		$result = $vehicle->getVehicleLocations($vehParams);
+
+		self::assertNotNull($result);
+		self::assertInstanceOf(
+			VehicleLocationResponse::class,
+			VehicleLocationResponse::fromArray($result)
+		);
+		self::assertTrue(isset($result['data']));
+		self::assertTrue(is_array($result['data']));
+	}
+
+	public function testGetVehicleById()
+	{
+		$vehicle = new Vehicle();
+
+		$vehParams = new VehicleParameters();
+		$vehParams->vehicle_id = self::$createdVehicles[0]['vehicle_id'];
+
+		$result = $vehicle->getVehicleById($vehParams->toArray());
+
+		self::assertNotNull($result);
+		self::assertInstanceOf(
+			Vehicle::class,
+			Vehicle::fromArray($result)
+		);
+		self::assertEquals($vehParams->vehicle_id, $result['vehicle_id']);
+	}
+
+
+	public function testGetVehicleTrack()
+	{
+		$vehicle = new Vehicle();
 
-        $vehParams = new VehicleParameters();
-        $vehParams->vehicle_id = self::$createdVehicles[0]['vehicle_id'];
+		$vehParams = new VehicleParameters();
+		$vehParams->vehicle_id = self::$createdVehicles[0]['vehicle_id'];
 
-        $result = $vehicle->getVehicleTrack($vehParams->toArray());
+		$result = $vehicle->getVehicleTrack($vehParams->toArray());
 
-        self::assertNotNull($result);
-        self::assertInstanceOf(
-            VehicleTrackResponse::class,
-            VehicleTrackResponse::fromArray($result)
-        );
-    }
+		self::assertNotNull($result);
+		self::assertInstanceOf(
+			VehicleTrackResponse::class,
+			VehicleTrackResponse::fromArray($result)
+		);
+	}
 
-    public function testDeleteVehicle()
-    {
-        $vehicle = new Vehicle();
+	public function testDeleteVehicle()
+	{
+		$vehicle = new Vehicle();
 
-        $vehParams = new VehicleParameters();
-        $vehParams->vehicle_id = self::$createdVehicles[sizeof(self::$createdVehicles) - 1]['vehicle_id'];
+		$vehParams = new VehicleParameters();
+		$vehParams->vehicle_id = self::$createdVehicles[sizeof(self::$createdVehicles) - 1]['vehicle_id'];
 
-        $result = $vehicle->removeVehicle($vehParams->toArray());
+		$result = $vehicle->removeVehicle($vehParams->toArray());
 
-        self::assertNotNull($result);
-        self::assertInstanceOf(
-            Vehicle::class,
-            Vehicle::fromArray($result)
-        );
-        self::assertEquals($vehParams->vehicle_id, $result['vehicle_id']);
+		self::assertNotNull($result);
+		self::assertInstanceOf(
+			Vehicle::class,
+			Vehicle::fromArray($result)
+		);
+		self::assertEquals($vehParams->vehicle_id, $result['vehicle_id']);
 
-        array_pop(self::$createdVehicles);
-    }
+		array_pop(self::$createdVehicles);
+	}
 
-    public function testGetVehicleProfiles()
-    {
-        $vehicleProfile = new VehicleProfile();
+	public function testGetVehicleProfiles()
+	{
+		$vehicleProfile = new VehicleProfile();
 
-        $vehProfileParams = new VehicleProfileParameters();
+		$vehProfileParams = new VehicleProfileParameters();
 
-        $vehProfileParams->with_pagination = true;
-        $vehProfileParams->page = 1;
-        $vehProfileParams->perPage = 10;
+		$vehProfileParams->with_pagination = true;
+		$vehProfileParams->page = 1;
+		$vehProfileParams->perPage = 10;
 
-        $result = $vehicleProfile->getVehicleProfiles($vehProfileParams->toArray());
+		$result = $vehicleProfile->getVehicleProfiles($vehProfileParams->toArray());
 
-        self::assertNotNull($result);
-        self::assertInstanceOf(
-            VehicleProfilesResponse::class,
-            VehicleProfilesResponse::fromArray($result)
-        );
-    }
+		self::assertNotNull($result);
+		self::assertInstanceOf(
+			VehicleProfilesResponse::class,
+			VehicleProfilesResponse::fromArray($result)
+		);
+	}
 
-    public function testCreateVehicleProfile()
-    {
-        $vehicleProfile = new VehicleProfile();
+	public function testCreateVehicleProfile()
+	{
+		$vehicleProfile = new VehicleProfile();
 
-        $profile = new VehicleProfile();
+		$profile = new VehicleProfile();
 
-        $profile->name = "Heavy Duty - 48 Semitrailer ".date('Y-m-d H:i');
-        $profile->height_units = VehicleSizeUnits::METER;
-        $profile->width_units = VehicleSizeUnits::METER;
-        $profile->length_units = VehicleSizeUnits::METER;
-        $profile->height = 3.5;
-        $profile->width = 2.5;
-        $profile->length = 16;
-        $profile->is_predefined = false;
-        $profile->is_default = false;
-        $profile->weight_units = VehicleWeightUnits::KILOGRAM;
-        $profile->weight = 35000;
-        $profile->max_weight_per_axle = 17500;
-        $profile->fuel_type = FuelTypes::UNLEADED_87;
-        $profile->fuel_consumption_city = 6;
-        $profile->fuel_consumption_highway = 11;
-        $profile->fuel_consumption_city_unit = FuelConsumptionUnits::MILES_PER_GALLON_US;
-        $profile->fuel_consumption_highway_unit = FuelConsumptionUnits::MILES_PER_GALLON_US;
+		$profile->name = "Heavy Duty - 48 Semitrailer ".date('Y-m-d H:i');
+		$profile->height_units = VehicleSizeUnits::METER;
+		$profile->width_units = VehicleSizeUnits::METER;
+		$profile->length_units = VehicleSizeUnits::METER;
+		$profile->height = 3.5;
+		$profile->width = 2.5;
+		$profile->length = 16;
+		$profile->is_predefined = false;
+		$profile->is_default = false;
+		$profile->weight_units = VehicleWeightUnits::KILOGRAM;
+		$profile->weight = 35000;
+		$profile->max_weight_per_axle = 17500;
+		$profile->fuel_type = FuelTypes::UNLEADED_87;
+		$profile->fuel_consumption_city = 6;
+		$profile->fuel_consumption_highway = 11;
+		$profile->fuel_consumption_city_unit = FuelConsumptionUnits::MILES_PER_GALLON_US;
+		$profile->fuel_consumption_highway_unit = FuelConsumptionUnits::MILES_PER_GALLON_US;
 
 
-        $result = $vehicleProfile->createVehicleProfile($profile->toArray());
+		$result = $vehicleProfile->createVehicleProfile($profile->toArray());
 
-        self::assertNotNull($result);
-        self::assertInstanceOf(
-            VehicleProfile::class,
-            VehicleProfile::fromArray($result)
-        );
+		self::assertNotNull($result);
+		self::assertInstanceOf(
+			VehicleProfile::class,
+			VehicleProfile::fromArray($result)
+		);
 
-        self::$createdVehicleProfiles[] = $result;
-    }
+		self::$createdVehicleProfiles[] = $result;
+	}
 
-    public function testDeleteVehicleProfile()
-    {
-        $vehicleProfile = new VehicleProfile();
+	public function testDeleteVehicleProfile()
+	{
+		$vehicleProfile = new VehicleProfile();
 
-        $vehProfileId = self::$createdVehicleProfiles[sizeof(self::$createdVehicleProfiles)-1]['vehicle_profile_id'];
+		$vehProfileId = self::$createdVehicleProfiles[sizeof(self::$createdVehicleProfiles)-1]['vehicle_profile_id'];
 
-        $result = $vehicleProfile->removeVehicleProfile($vehProfileId);
+		$result = $vehicleProfile->removeVehicleProfile($vehProfileId);
 
-        self::assertNotNull($result);
-        self::assertInstanceOf(
-            VehicleProfile::class,
-            VehicleProfile::fromArray($result)
-        );
+		self::assertNotNull($result);
+		self::assertInstanceOf(
+			VehicleProfile::class,
+			VehicleProfile::fromArray($result)
+		);
 
-        array_pop(self::$createdVehicleProfiles);
-    }
+		array_pop(self::$createdVehicleProfiles);
+	}
 
-    public function testGetVehicleProfileById()
-    {
-        $vehicleProfile = new VehicleProfile();
-
-        $vehProfileId = self::$createdVehicleProfiles[sizeof(self::$createdVehicleProfiles)-1]['vehicle_profile_id'];
+	public function testGetVehicleProfileById()
+	{
+		$vehicleProfile = new VehicleProfile();
+
+		$vehProfileId = self::$createdVehicleProfiles[sizeof(self::$createdVehicleProfiles)-1]['vehicle_profile_id'];
 
-        $result = $vehicleProfile->getVehicleProfileById($vehProfileId);
+		$result = $vehicleProfile->getVehicleProfileById($vehProfileId);
 
-        self::assertNotNull($result);
-        self::assertInstanceOf(
-            VehicleProfile::class,
-            VehicleProfile::fromArray($result)
-        );
-        self::assertEquals($vehProfileId,$result['vehicle_profile_id']);
-    }
-
-    public function testGetVehicleByLicensePlate()
-    {
-        $vehicle = new Vehicle();
-
-        $vehParams = new VehicleParameters();
-        $vehParams->vehicle_license_plate = self::$createdVehicles[0]['vehicle_license_plate'];
-
-        $result = $vehicle->getVehicleByLicensePlate($vehParams);
+		self::assertNotNull($result);
+		self::assertInstanceOf(
+			VehicleProfile::class,
+			VehicleProfile::fromArray($result)
+		);
+		self::assertEquals($vehProfileId,$result['vehicle_profile_id']);
+	}
+
+	public function testGetVehicleByLicensePlate()
+	{
+		$vehicle = new Vehicle();
+
+		$vehParams = new VehicleParameters();
+		$vehParams->vehicle_license_plate = self::$createdVehicles[0]['vehicle_license_plate'];
+
+		$result = $vehicle->getVehicleByLicensePlate($vehParams);
 
-        self::assertNotNull($result);
-        self::assertInstanceOf(
-            VehicleResponse::class,
-            VehicleResponse::fromArray($result)
-        );
-    }
-
-    public function testSearchVehicles()
-    {
-        $this->markTestSkipped('This method is deprecated until resolving the response issue.');
-
-        $vehicle = new Vehicle();
-
-        $searchParams = new VehicleSearchParameters();
-
-        $searchParams->vehicle_ids = array_column(self::$createdVehicles, 'vehicle_id');
-        $searchParams->lat = 29.748868;
-        $searchParams->lng = -95.358473;
-
-        $result = $vehicle->searchVehicles($searchParams);
-
-        self::assertNotNull($result);
-        self::assertInstanceOf(
-            Vehicle::class,
-            VehicleResponse::fromArray($result[0])
-        );
-    }
-
-    public function testUpdateVehicle()
-    {
-        $vehicle = new Vehicle();
-
-        $vehicle->vehicle_alias = self::$createdVehicles[0]['vehicle_alias'] .' Updated';
-        $vehicle->vehicle_vin = '11111111111111111';
-        $vehicle->vehicle_id = self::$createdVehicles[0]['vehicle_id'];
+		self::assertNotNull($result);
+		self::assertInstanceOf(
+			VehicleResponse::class,
+			VehicleResponse::fromArray($result)
+		);
+	}
+
+	public function testSearchVehicles()
+	{
+		$this->markTestSkipped('This method is deprecated until resolving the response issue.');
+
+		$vehicle = new Vehicle();
+
+		$searchParams = new VehicleSearchParameters();
+
+		$searchParams->vehicle_ids = array_column(self::$createdVehicles, 'vehicle_id');
+		$searchParams->lat = 29.748868;
+		$searchParams->lng = -95.358473;
+
+		$result = $vehicle->searchVehicles($searchParams);
+
+		self::assertNotNull($result);
+		self::assertInstanceOf(
+			Vehicle::class,
+			VehicleResponse::fromArray($result[0])
+		);
+	}
+
+	public function testUpdateVehicle()
+	{
+		$vehicle = new Vehicle();
+
+		$vehicle->vehicle_alias = self::$createdVehicles[0]['vehicle_alias'] .' Updated';
+		$vehicle->vehicle_vin = '11111111111111111';
+		$vehicle->vehicle_id = self::$createdVehicles[0]['vehicle_id'];
 
-        $result = $vehicle->updateVehicle($vehicle->toArray());
+		$result = $vehicle->updateVehicle($vehicle->toArray());
 
-        self::assertNotNull($result);
-        self::assertInstanceOf(
-            Vehicle::class,
-            Vehicle::fromArray($result)
-        );
-    }
+		self::assertNotNull($result);
+		self::assertInstanceOf(
+			Vehicle::class,
+			Vehicle::fromArray($result)
+		);
+	}
 
-    public function testUpdateVehicleProfile()
-    {
-        $vehicleProfile = new VehicleProfile();
+	public function testUpdateVehicleProfile()
+	{
+		$vehicleProfile = new VehicleProfile();
 
-        $vehProfileId = self::$createdVehicleProfiles[0]['vehicle_profile_id'];
+		$vehProfileId = self::$createdVehicleProfiles[0]['vehicle_profile_id'];
 
-        $vehicleProfile->name = self::$createdVehicleProfiles[0]['name'].'Updated';
-        $vehicleProfile->fuel_consumption_city_unit = FuelConsumptionUnits::MILES_PER_GALLON_US;
-        $vehicleProfile->fuel_consumption_highway_unit = FuelConsumptionUnits::MILES_PER_GALLON_US;
-        $vehicleProfile->vehicle_profile_id = self::$createdVehicleProfiles[0]['vehicle_profile_id'];
+		$vehicleProfile->name = self::$createdVehicleProfiles[0]['name'].'Updated';
+		$vehicleProfile->fuel_consumption_city_unit = FuelConsumptionUnits::MILES_PER_GALLON_US;
+		$vehicleProfile->fuel_consumption_highway_unit = FuelConsumptionUnits::MILES_PER_GALLON_US;
+		$vehicleProfile->vehicle_profile_id = self::$createdVehicleProfiles[0]['vehicle_profile_id'];
 
-        $result = $vehicleProfile->updateVehicleProfile($vehicleProfile->toArray());
+		$result = $vehicleProfile->updateVehicleProfile($vehicleProfile->toArray());
 
-        self::assertNotNull($result);
-        self::assertInstanceOf(
-            VehicleProfile::class,
-            VehicleProfile::fromArray($result)
-        );
-    }
+		self::assertNotNull($result);
+		self::assertInstanceOf(
+			VehicleProfile::class,
+			VehicleProfile::fromArray($result)
+		);
+	}
 
-    public static function tearDownAfterClass()
-    {
-        $vehicle = new Vehicle();
+	public static function tearDownAfterClass()
+	{
+		$vehicle = new Vehicle();
 
-        $vehParams = new VehicleParameters();
+		$vehParams = new VehicleParameters();
 
-        foreach (self::$createdVehicles as $veh1) {
-            if (isset($veh1['vehicle_id'])) {
-                $vehParams->vehicle_id = $veh1['vehicle_id'];
-                $result1 = $vehicle->removeVehicle($vehParams->toArray());
-            }
-        }
+		foreach (self::$createdVehicles as $veh1) {
+			if (isset($veh1['vehicle_id'])) {
+				$vehParams->vehicle_id = $veh1['vehicle_id'];
+				$result1 = $vehicle->removeVehicle($vehParams->toArray());
+			}
+		}
 
-        $vehProfile = new VehicleProfile();
+		$vehProfile = new VehicleProfile();
 
-        foreach (self::$createdVehicleProfiles as $prof1) {
-            if (isset($prof1['vehicle_profile_id'])) {
-                $result2 = $vehProfile->removeVehicleProfile($prof1['vehicle_profile_id']);
-            }
-        }
-    }
+		foreach (self::$createdVehicleProfiles as $prof1) {
+			if (isset($prof1['vehicle_profile_id'])) {
+				$result2 = $vehProfile->removeVehicleProfile($prof1['vehicle_profile_id']);
+			}
+		}
+	}
 }

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>";
+			}
+
+		}
+	}
 }