route4me / route4me-php-sdk

UnitTestFiles/Test/GeocodingUnitTests.php

Indentation +149 added lines, -149 removed lines

@@ -10,198 +10,198 @@
 
 class GeocodingUnitTests extends \PHPUnit\Framework\TestCase
 {
-    public static function setUpBeforeClass()
-    {
-        Route4Me::setApiKey(Constants::API_KEY);
-    }
+	public static function setUpBeforeClass()
+	{
+		Route4Me::setApiKey(Constants::API_KEY);
+	}
 
-    public function testFromArray()
-    {
-        $geocoding = Geocoding::fromArray([
-            'strExportFormat'   => 'json',
-            'addresses'         => 'Los20%Angeles20%International20%Airport,20%CA',
-        ]);
+	public function testFromArray()
+	{
+		$geocoding = Geocoding::fromArray([
+			'strExportFormat'   => 'json',
+			'addresses'         => 'Los20%Angeles20%International20%Airport,20%CA',
+		]);
 
-        $this->assertEquals('json', $geocoding->strExportFormat);
-        $this->assertEquals('Los20%Angeles20%International20%Airport,20%CA', $geocoding->addresses);
-    }
+		$this->assertEquals('json', $geocoding->strExportFormat);
+		$this->assertEquals('Los20%Angeles20%International20%Airport,20%CA', $geocoding->addresses);
+	}
 
-    public function testForwardGeocoding()
-    {
-        $geoCodingParameters = [
-            'strExportFormat'   => 'json',
-            'addresses'         => 'Los20%Angeles20%International20%Airport,20%CA',
-        ];
+	public function testForwardGeocoding()
+	{
+		$geoCodingParameters = [
+			'strExportFormat'   => 'json',
+			'addresses'         => 'Los20%Angeles20%International20%Airport,20%CA',
+		];
 
-        $fGeocoding = new Geocoding();
+		$fGeocoding = new Geocoding();
 
-        $result = $fGeocoding->forwardGeocoding($geoCodingParameters);
+		$result = $fGeocoding->forwardGeocoding($geoCodingParameters);
 
-        $this->assertNotNull($result);
-        $this->assertTrue(sizeof($result)>0);
+		$this->assertNotNull($result);
+		$this->assertTrue(sizeof($result)>0);
 
-        $firstGeocoding = GeocodingResponse::fromArray(
-            $result[0]
-        );
+		$firstGeocoding = GeocodingResponse::fromArray(
+			$result[0]
+		);
 
-        $this->assertContainsOnlyInstancesOf(GeocodingResponse::class, [$firstGeocoding]);
-    }
+		$this->assertContainsOnlyInstancesOf(GeocodingResponse::class, [$firstGeocoding]);
+	}
 
-    public function testReverseGeocoding()
-    {
-        $geoCodingParameters = [
-            'strExportFormat'   => 'json',
-            'addresses'         => '42.35863,-71.05670',
-        ];
+	public function testReverseGeocoding()
+	{
+		$geoCodingParameters = [
+			'strExportFormat'   => 'json',
+			'addresses'         => '42.35863,-71.05670',
+		];
 
-        $rGeocoding = new Geocoding();
+		$rGeocoding = new Geocoding();
 
-        $result = $rGeocoding->reverseGeocoding($geoCodingParameters);
+		$result = $rGeocoding->reverseGeocoding($geoCodingParameters);
 
-        $this->assertNotNull($result);
-        $this->assertTrue(sizeof($result)>0);
+		$this->assertNotNull($result);
+		$this->assertTrue(sizeof($result)>0);
 
-        $firstGeocoding = GeocodingResponse::fromArray(
-            $result["destination"]
-        );
+		$firstGeocoding = GeocodingResponse::fromArray(
+			$result["destination"]
+		);
 
-        $this->assertContainsOnlyInstancesOf(GeocodingResponse::class, [$firstGeocoding]);
-    }
+		$this->assertContainsOnlyInstancesOf(GeocodingResponse::class, [$firstGeocoding]);
+	}
 
-    public function testGetStreetData()
-    {
-        $this->markTestSkipped('must be revisited.');
+	public function testGetStreetData()
+	{
+		$this->markTestSkipped('must be revisited.');
 
-        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" );
-        }
+		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" );
+		}
 
-        //region Get Single Street Address
-        $result = RapidAddressSearchResponse::fromArray(
-            Geocoding::getStreetData(['pk' => 4])
-        );
+		//region Get Single Street Address
+		$result = RapidAddressSearchResponse::fromArray(
+			Geocoding::getStreetData(['pk' => 4])
+		);
 
-        $this->assertNotNull($result);
-        $this->assertContainsOnlyInstancesOf(RapidAddressSearchResponse::class, [$result]);
-        //endregion
-
-        //region Get All Street Data
-        $resultAll = Geocoding::getStreetData([]);
+		$this->assertNotNull($result);
+		$this->assertContainsOnlyInstancesOf(RapidAddressSearchResponse::class, [$result]);
+		//endregion
+
+		//region Get All Street Data
+		$resultAll = Geocoding::getStreetData([]);
 
-        $this->assertNotNull($resultAll);
-        $this->assertTrue(sizeof($resultAll)>0);
+		$this->assertNotNull($resultAll);
+		$this->assertTrue(sizeof($resultAll)>0);
 
-        $firstGeocoding = RapidAddressSearchResponse::fromArray(
-            $resultAll[0]
-        );
+		$firstGeocoding = RapidAddressSearchResponse::fromArray(
+			$resultAll[0]
+		);
 
-        $this->assertContainsOnlyInstancesOf(RapidAddressSearchResponse::class, [$firstGeocoding]);
-        //endregion
-
-        //region Get Street Data Limited
-        $resultLimited = Geocoding::getStreetData([
-            'offset' => 0,
-            'limit'  => 5,
-        ]);
+		$this->assertContainsOnlyInstancesOf(RapidAddressSearchResponse::class, [$firstGeocoding]);
+		//endregion
+
+		//region Get Street Data Limited
+		$resultLimited = Geocoding::getStreetData([
+			'offset' => 0,
+			'limit'  => 5,
+		]);
 
-        $this->assertNotNull($resultLimited);
-        $this->assertTrue(sizeof($resultLimited)>0);
+		$this->assertNotNull($resultLimited);
+		$this->assertTrue(sizeof($resultLimited)>0);
 
-        $firstGeocoding = RapidAddressSearchResponse::fromArray(
-            $resultLimited[0]
-        );
+		$firstGeocoding = RapidAddressSearchResponse::fromArray(
+			$resultLimited[0]
+		);
 
-        $this->assertContainsOnlyInstancesOf(RapidAddressSearchResponse::class, [$firstGeocoding]);
-        //endregion
-    }
+		$this->assertContainsOnlyInstancesOf(RapidAddressSearchResponse::class, [$firstGeocoding]);
+		//endregion
+	}
 
-    public function testGetZipCode()
-    {
-        $this->markTestSkipped('must be revisited.');
+	public function testGetZipCode()
+	{
+		$this->markTestSkipped('must be revisited.');
 
-        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" );
-        }
+		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" );
+		}
 
-        //region Get All Geocodings With Specified Zipcode
-        $resultZipAll = Geocoding::getZipCode(['zipcode' => '00601']);
+		//region Get All Geocodings With Specified Zipcode
+		$resultZipAll = Geocoding::getZipCode(['zipcode' => '00601']);
 
-        $this->assertNotNull($resultZipAll);
-        $this->assertTrue(sizeof($resultZipAll)>0);
+		$this->assertNotNull($resultZipAll);
+		$this->assertTrue(sizeof($resultZipAll)>0);
 
-        $firstGeocoding = RapidAddressSearchResponse::fromArray(
-            $resultZipAll[0]
-        );
+		$firstGeocoding = RapidAddressSearchResponse::fromArray(
+			$resultZipAll[0]
+		);
 
-        $this->assertContainsOnlyInstancesOf(RapidAddressSearchResponse::class, [$firstGeocoding]);
-        //endregion
+		$this->assertContainsOnlyInstancesOf(RapidAddressSearchResponse::class, [$firstGeocoding]);
+		//endregion
 
-        //region Get Limited Geocodings With Specified Zipcode
-        $resultZipLimited = Geocoding::getZipCode([
-            'zipcode' => '00601',
-            'offset'  => 0,
-            'limit'   => 20,
-        ]);
+		//region Get Limited Geocodings With Specified Zipcode
+		$resultZipLimited = Geocoding::getZipCode([
+			'zipcode' => '00601',
+			'offset'  => 0,
+			'limit'   => 20,
+		]);
 
-        $this->assertNotNull($resultZipLimited);
-        $this->assertTrue(sizeof($resultZipLimited)>0);
+		$this->assertNotNull($resultZipLimited);
+		$this->assertTrue(sizeof($resultZipLimited)>0);
 
-        $firstGeocoding = RapidAddressSearchResponse::fromArray(
-            $resultZipLimited[0]
-        );
+		$firstGeocoding = RapidAddressSearchResponse::fromArray(
+			$resultZipLimited[0]
+		);
 
-        $this->assertContainsOnlyInstancesOf(RapidAddressSearchResponse::class, [$firstGeocoding]);
-        //endregion
-    }
+		$this->assertContainsOnlyInstancesOf(RapidAddressSearchResponse::class, [$firstGeocoding]);
+		//endregion
+	}
 
-    public function testGetService()
-    {
-        $this->markTestSkipped('must be revisited.');
+	public function testGetService()
+	{
+		$this->markTestSkipped('must be revisited.');
 
-        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" );
-        }
+		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" );
+		}
 
-        //region Get All Geocodings With Specified Zipcode And House Number
-        $resultZipHouseAll = Geocoding::getService([
-            'zipcode'     => '00601',
-            'housenumber' => 17,
-        ]);
+		//region Get All Geocodings With Specified Zipcode And House Number
+		$resultZipHouseAll = Geocoding::getService([
+			'zipcode'     => '00601',
+			'housenumber' => 17,
+		]);
 
-        $this->assertNotNull($resultZipHouseAll);
-        $this->assertTrue(sizeof($resultZipHouseAll)>0);
+		$this->assertNotNull($resultZipHouseAll);
+		$this->assertTrue(sizeof($resultZipHouseAll)>0);
 
-        $firstGeocoding = RapidAddressSearchResponse::fromArray(
-            $resultZipHouseAll[0]
-        );
+		$firstGeocoding = RapidAddressSearchResponse::fromArray(
+			$resultZipHouseAll[0]
+		);
 
-        $this->assertContainsOnlyInstancesOf(RapidAddressSearchResponse::class, [$firstGeocoding]);
-        //endregion
+		$this->assertContainsOnlyInstancesOf(RapidAddressSearchResponse::class, [$firstGeocoding]);
+		//endregion
 
-        //region Get Limited Geocodings With Specified Zipcode And House Number
-        $resultZipHouseLimited = Geocoding::getService([
-            'zipcode'       => '00601',
-            'housenumber'   => 17,
-            'offset'        => 0,
-            'limit'         => 10,
-        ]);
+		//region Get Limited Geocodings With Specified Zipcode And House Number
+		$resultZipHouseLimited = Geocoding::getService([
+			'zipcode'       => '00601',
+			'housenumber'   => 17,
+			'offset'        => 0,
+			'limit'         => 10,
+		]);
 
-        $this->assertNotNull($resultZipHouseLimited);
-        $this->assertTrue(sizeof($resultZipHouseLimited)>0);
+		$this->assertNotNull($resultZipHouseLimited);
+		$this->assertTrue(sizeof($resultZipHouseLimited)>0);
 
-        $firstGeocoding = RapidAddressSearchResponse::fromArray(
-            $resultZipHouseLimited[0]
-        );
+		$firstGeocoding = RapidAddressSearchResponse::fromArray(
+			$resultZipHouseLimited[0]
+		);
 
-        $this->assertContainsOnlyInstancesOf(RapidAddressSearchResponse::class, [$firstGeocoding]);
-        //endregion
-    }
-
-    public static function tearDownAfterClass()
-    {
+		$this->assertContainsOnlyInstancesOf(RapidAddressSearchResponse::class, [$firstGeocoding]);
+		//endregion
+	}
+
+	public static function tearDownAfterClass()
+	{
 
-    }
+	}
 }
\ No newline at end of file

UnitTestFiles/Test/AdvancedConstraintsUnitTests.php

Indentation +64 added lines, -64 removed lines

@@ -14,79 +14,79 @@
 use Route4Me\V5\Addresses\RouteAdvancedConstraints;
 
 class AdvancedConstraintsUnitTests extends \PHPUnit\Framework\TestCase {
-    public static $problem;
+	public static $problem;
 
-    public static function setUpBeforeClass()
-    {
-        Route4Me::setApiKey(Constants::API_KEY);
-        self::$problem = null;
-    }
+	public static function setUpBeforeClass()
+	{
+		Route4Me::setApiKey(Constants::API_KEY);
+		self::$problem = null;
+	}
 
-    public function testAdvancedConstraintsExample12()
-    {
-        $addresses = array_map('str_getcsv', file(dirname(__FILE__).'/data/locations.csv'));
-        array_walk($addresses, function(&$a) use ($addresses) { $a = Address::fromArray(array_combine($addresses[0], $a)); });
-        array_shift($addresses);
+	public function testAdvancedConstraintsExample12()
+	{
+		$addresses = array_map('str_getcsv', file(dirname(__FILE__).'/data/locations.csv'));
+		array_walk($addresses, function(&$a) use ($addresses) { $a = Address::fromArray(array_combine($addresses[0], $a)); });
+		array_shift($addresses);
 
-        $parameters = RouteParameters::fromArray([
-            'algorithm_type' => AlgorithmType::ADVANCED_CVRP_TW,
-            'store_route' => false,
-            'rt' => true,
-            'parts' => 30,
-            'metric' => Metric::MATRIX,
-            'member_id' => 444333,
-            'route_name' => "Drivers Schedules - 3 Territories",
-            'optimize' => "Distance",
-            'distance_unit' => "mi",
-            'device_type' => DeviceType::WEB,
-            'travel_mode' => "Driving",
-            'advanced_constraints' => []
-        ]);
+		$parameters = RouteParameters::fromArray([
+			'algorithm_type' => AlgorithmType::ADVANCED_CVRP_TW,
+			'store_route' => false,
+			'rt' => true,
+			'parts' => 30,
+			'metric' => Metric::MATRIX,
+			'member_id' => 444333,
+			'route_name' => "Drivers Schedules - 3 Territories",
+			'optimize' => "Distance",
+			'distance_unit' => "mi",
+			'device_type' => DeviceType::WEB,
+			'travel_mode' => "Driving",
+			'advanced_constraints' => []
+		]);
 
-        $zones = [["ZONE 01"], ["ZONE 02"], ["ZONE 03"]];
+		$zones = [["ZONE 01"], ["ZONE 02"], ["ZONE 03"]];
 
-        for($i = 0; $i < 30; ++$i)
-        {
-            $parameters->advanced_constraints[] = RouteAdvancedConstraints::fromArray([
-                'tags' => [$zones[$i % 3]],
-                'members_count' => 1,
-                'available_time_windows' => [[(8 + 5) * 3600, (11 + 5) * 3600]],
-                'location_sequence_pattern' => [Address::fromArray([
-                    'address' => "RETAIL LOCATION",
-                    'alias' => "RETAIL LOCATION",
-                    'lat' => 25.8741751,
-                    'lng' => -80.1288583,
-                    'time' => 300
-                ])]
-            ]);
-        }
+		for($i = 0; $i < 30; ++$i)
+		{
+			$parameters->advanced_constraints[] = RouteAdvancedConstraints::fromArray([
+				'tags' => [$zones[$i % 3]],
+				'members_count' => 1,
+				'available_time_windows' => [[(8 + 5) * 3600, (11 + 5) * 3600]],
+				'location_sequence_pattern' => [Address::fromArray([
+					'address' => "RETAIL LOCATION",
+					'alias' => "RETAIL LOCATION",
+					'lat' => 25.8741751,
+					'lng' => -80.1288583,
+					'time' => 300
+				])]
+			]);
+		}
     
-        $optimizationParameters = new OptimizationProblemParams();
-        $optimizationParameters->setAddresses($addresses);
-        $optimizationParameters->setParameters($parameters);
+		$optimizationParameters = new OptimizationProblemParams();
+		$optimizationParameters->setAddresses($addresses);
+		$optimizationParameters->setParameters($parameters);
 
-        self::$problem = OptimizationProblem::optimize($optimizationParameters);
+		self::$problem = OptimizationProblem::optimize($optimizationParameters);
 
-        $this->assertNotNull(self::$problem->optimization_problem_id);
-        $this->assertEquals(self::$problem->parameters->route_name, 'Drivers Schedules - 3 Territories');
-    }
+		$this->assertNotNull(self::$problem->optimization_problem_id);
+		$this->assertEquals(self::$problem->parameters->route_name, 'Drivers Schedules - 3 Territories');
+	}
 
-    public static function tearDownAfterClass()
-    {
-        if(!is_null(self::$problem->optimization_problem_id))
-        {
-            $params = [
-                'optimization_problem_ids' => ['0' => self::$problem->optimization_problem_id],
-                'redirect' => 0,
-            ];
+	public static function tearDownAfterClass()
+	{
+		if(!is_null(self::$problem->optimization_problem_id))
+		{
+			$params = [
+				'optimization_problem_ids' => ['0' => self::$problem->optimization_problem_id],
+				'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>";
+			}
+		}
+	}
 }

UnitTestFiles/Test/AddressBookLocationUnitTests.php

Indentation +434 added lines, -434 removed lines

@@ -9,450 +9,450 @@
 
 class AddressBookLocationUnitTests extends \PHPUnit\Framework\TestCase
 {
-    public static $createdContacts=[];
-
-    public static $csvImportedAddressIDs=[];
-
-    public static function setUpBeforeClass()
-    {
-        Route4Me::setApiKey(Constants::API_KEY);
-
-        $abl = new AddressBookLocation();
-
-        $AddressBookLocationParameters = AddressBookLocation::fromArray([
-            'address_1'             => '1407 MCCOY, Louisville, KY, 40215',
-            'address_alias'         => '1407 MCCOY 40215',
-            'address_group'         => 'Scheduled weekly',
-            'first_name'            => 'Bart',
-            'last_name'             => 'Douglas',
-            'address_email'         => 'bdouglas9514@yahoo.com',
-            'address_phone_number'  => '95487454',
-            'cached_lat'            => 38.202496,
-            'cached_lng'            => -85.786514,
-            'curbside_lat'          => 38.202496,
-            'curbside_lng'          => -85.786514,
-            'address_city'          => 'Louisville',
-            'schedule' => [[
-                'enabled'   => true,
-                'mode'      => 'weekly',
-                'weekly'    => [
-                    'every'    => 1,
-                    'weekdays' => [1, 2, 3, 4, 5],
-                ],
-            ]],
-            'service_time' => 600,
-        ]);
-
-        self::$createdContacts[] = AddressBookLocation::fromArray(
-            $abl->addAdressBookLocation($AddressBookLocationParameters)
-         );
-
-        $AddressBookLocationParameters = AddressBookLocation::fromArray([
-            'address_1'             => '4805 BELLEVUE AVE, Louisville, KY, 40215',
-            'address_2'             => '4806 BELLEVUE AVE, Louisville, KY, 40215',
-            'address_alias'         => '4805 BELLEVUE AVE 40215',
-            'address_group'         => 'Scheduled monthly',
-            'first_name'            => 'Bart',
-            'last_name'             => 'Douglas',
-            'address_email'         => 'bdouglas9514@yahoo.com',
-            'address_phone_number'  => '95487454',
-            'cached_lat'            => 38.178844,
-            'cached_lng'            => -85.774864,
-            'curbside_lat'          => 38.178844,
-            'curbside_lng'          => -85.774864,
-            'address_city'          => 'Louisville',
-            'address_country_id'    => 'US',
-            'address_state_id'      => 'KY',
-            'address_zip'           => '40215',
-            'schedule' => [[
-                'enabled'   => true,
-                'mode'      => 'monthly',
-                'monthly'   => [
-                    'every' => 1,
-                    'mode'  => 'dates',
-                    'dates' => [20, 22, 23, 24, 25],
-                ],
-            ]],
-            'service_time' => 750,
-            'color'        => 'red',
-        ]);
-
-        self::$createdContacts[] = AddressBookLocation::fromArray(
-            $abl->addAdressBookLocation($AddressBookLocationParameters)
-        );
-    }
-
-    public function testAddressBookLocationFromArray()
-    {
-        $location = AddressBookLocation::fromArray([
-            'address_1'             => '1604 PARKRIDGE PKWY, Louisville, KY, 40214',
-            'cached_lat'            => 38.141598,
-            'cached_lng'            => -85.793846,
-            'address_alias'         => '1604 PARKRIDGE PKWY 40214',
-            'address_group'         => 'Scheduled daily',
-            'first_name'            => 'Peter',
-            'last_name'             => 'Newman',
-            'address_email'         => 'pnewman6564@yahoo.com',
-            'address_phone_number'  => '65432178',
-            'address_city'          => 'Louisville',
-            'address_custom_data'   => ['scheduled'     => 'yes',
-                                        'serice type'   => 'publishing', ],
-            'schedule' => [[
-                'enabled'   => true,
-                'mode'      => 'daily',
-                'daily'     => ['every' => 1],
-            ]],
-            'service_time'          => 900,
-        ]);
-
-        $this->assertEquals('1604 PARKRIDGE PKWY, Louisville, KY, 40214', $location->address_1);
-        $this->assertEquals(38.141598, $location->cached_lat);
-        $this->assertEquals(-85.793846, $location->cached_lng);
-        $this->assertEquals('1604 PARKRIDGE PKWY 40214', $location->address_alias);
-
-        $this->assertEquals('Peter', $location->first_name);
-        $this->assertEquals('Newman', $location->last_name);
-        $this->assertEquals('pnewman6564@yahoo.com', $location->address_email);
-        $this->assertEquals('65432178', $location->address_phone_number);
-        $this->assertEquals('Louisville', $location->address_city);
-    }
-
-    public function testToArray()
-    {
-        $location = AddressBookLocation::fromArray([
-            'address_1'             => '1604 PARKRIDGE PKWY, Louisville, KY, 40214',
-            'cached_lat'            => 38.141598,
-            'cached_lng'            => -85.793846,
-            'address_alias'         => '1604 PARKRIDGE PKWY 40214',
-            'address_group'         => 'Scheduled daily',
-            'first_name'            => 'Peter',
-            'last_name'             => 'Newman',
-            'address_email'         => 'pnewman6564@yahoo.com',
-            'address_phone_number'  => '65432178',
-            'address_city'          => 'Louisville',
-            'address_custom_data'   => ['scheduled'     => 'yes',
-                'serice type'   => 'publishing', ],
-            'schedule' => [[
-                'enabled'   => true,
-                'mode'      => 'daily',
-                'daily'     => ['every' => 1],
-            ]],
-            'service_time'          => 900,
-        ]);
-
-        $this->assertEquals($location->toArray(),
-            [
-                'address_1'             => '1604 PARKRIDGE PKWY, Louisville, KY, 40214',
-                'cached_lat'            => 38.141598,
-                'cached_lng'            => -85.793846,
-                'address_alias'         => '1604 PARKRIDGE PKWY 40214',
-                'address_group'         => 'Scheduled daily',
-                'first_name'            => 'Peter',
-                'last_name'             => 'Newman',
-                'address_email'         => 'pnewman6564@yahoo.com',
-                'address_phone_number'  => '65432178',
-                'address_city'          => 'Louisville',
-                'address_custom_data'   => ['scheduled'     => 'yes',
-                    'serice type'   => 'publishing', ],
-                'schedule' => [[
-                    'enabled'   => true,
-                    'mode'      => 'daily',
-                    'daily'     => ['every' => 1],
-                ]],
-                'service_time'          => 900,
-            ]
-        );
-    }
-
-    public function testGetAddressBookLocation()
-    {
-        $abl = new AddressBookLocation();
-
-        $addressID = self::$createdContacts[0]->address_id;
-
-        $result = AddressBookLocation::fromArray(
-            $abl->getAddressBookLocation($addressID)
-        );
-
-        $this->assertNotNull($addressID);
-        $this->assertContainsOnlyInstancesOf(AddressBookLocation::class, [$result]);
-
-    }
-
-    public function testSearchAddressBookLocations()
-    {
-        $abl = new AddressBookLocation();
-
-        $params = [
-            'query'  => 'Douglas',
-            'fields' => 'first_name,address_email,schedule_blacklist,schedule,address_custom_data,address_1',
-            'offset' => 0,
-            'limit'  => 5,
-        ];
+	public static $createdContacts=[];
+
+	public static $csvImportedAddressIDs=[];
+
+	public static function setUpBeforeClass()
+	{
+		Route4Me::setApiKey(Constants::API_KEY);
+
+		$abl = new AddressBookLocation();
+
+		$AddressBookLocationParameters = AddressBookLocation::fromArray([
+			'address_1'             => '1407 MCCOY, Louisville, KY, 40215',
+			'address_alias'         => '1407 MCCOY 40215',
+			'address_group'         => 'Scheduled weekly',
+			'first_name'            => 'Bart',
+			'last_name'             => 'Douglas',
+			'address_email'         => 'bdouglas9514@yahoo.com',
+			'address_phone_number'  => '95487454',
+			'cached_lat'            => 38.202496,
+			'cached_lng'            => -85.786514,
+			'curbside_lat'          => 38.202496,
+			'curbside_lng'          => -85.786514,
+			'address_city'          => 'Louisville',
+			'schedule' => [[
+				'enabled'   => true,
+				'mode'      => 'weekly',
+				'weekly'    => [
+					'every'    => 1,
+					'weekdays' => [1, 2, 3, 4, 5],
+				],
+			]],
+			'service_time' => 600,
+		]);
+
+		self::$createdContacts[] = AddressBookLocation::fromArray(
+			$abl->addAdressBookLocation($AddressBookLocationParameters)
+		 );
+
+		$AddressBookLocationParameters = AddressBookLocation::fromArray([
+			'address_1'             => '4805 BELLEVUE AVE, Louisville, KY, 40215',
+			'address_2'             => '4806 BELLEVUE AVE, Louisville, KY, 40215',
+			'address_alias'         => '4805 BELLEVUE AVE 40215',
+			'address_group'         => 'Scheduled monthly',
+			'first_name'            => 'Bart',
+			'last_name'             => 'Douglas',
+			'address_email'         => 'bdouglas9514@yahoo.com',
+			'address_phone_number'  => '95487454',
+			'cached_lat'            => 38.178844,
+			'cached_lng'            => -85.774864,
+			'curbside_lat'          => 38.178844,
+			'curbside_lng'          => -85.774864,
+			'address_city'          => 'Louisville',
+			'address_country_id'    => 'US',
+			'address_state_id'      => 'KY',
+			'address_zip'           => '40215',
+			'schedule' => [[
+				'enabled'   => true,
+				'mode'      => 'monthly',
+				'monthly'   => [
+					'every' => 1,
+					'mode'  => 'dates',
+					'dates' => [20, 22, 23, 24, 25],
+				],
+			]],
+			'service_time' => 750,
+			'color'        => 'red',
+		]);
+
+		self::$createdContacts[] = AddressBookLocation::fromArray(
+			$abl->addAdressBookLocation($AddressBookLocationParameters)
+		);
+	}
+
+	public function testAddressBookLocationFromArray()
+	{
+		$location = AddressBookLocation::fromArray([
+			'address_1'             => '1604 PARKRIDGE PKWY, Louisville, KY, 40214',
+			'cached_lat'            => 38.141598,
+			'cached_lng'            => -85.793846,
+			'address_alias'         => '1604 PARKRIDGE PKWY 40214',
+			'address_group'         => 'Scheduled daily',
+			'first_name'            => 'Peter',
+			'last_name'             => 'Newman',
+			'address_email'         => 'pnewman6564@yahoo.com',
+			'address_phone_number'  => '65432178',
+			'address_city'          => 'Louisville',
+			'address_custom_data'   => ['scheduled'     => 'yes',
+										'serice type'   => 'publishing', ],
+			'schedule' => [[
+				'enabled'   => true,
+				'mode'      => 'daily',
+				'daily'     => ['every' => 1],
+			]],
+			'service_time'          => 900,
+		]);
+
+		$this->assertEquals('1604 PARKRIDGE PKWY, Louisville, KY, 40214', $location->address_1);
+		$this->assertEquals(38.141598, $location->cached_lat);
+		$this->assertEquals(-85.793846, $location->cached_lng);
+		$this->assertEquals('1604 PARKRIDGE PKWY 40214', $location->address_alias);
+
+		$this->assertEquals('Peter', $location->first_name);
+		$this->assertEquals('Newman', $location->last_name);
+		$this->assertEquals('pnewman6564@yahoo.com', $location->address_email);
+		$this->assertEquals('65432178', $location->address_phone_number);
+		$this->assertEquals('Louisville', $location->address_city);
+	}
+
+	public function testToArray()
+	{
+		$location = AddressBookLocation::fromArray([
+			'address_1'             => '1604 PARKRIDGE PKWY, Louisville, KY, 40214',
+			'cached_lat'            => 38.141598,
+			'cached_lng'            => -85.793846,
+			'address_alias'         => '1604 PARKRIDGE PKWY 40214',
+			'address_group'         => 'Scheduled daily',
+			'first_name'            => 'Peter',
+			'last_name'             => 'Newman',
+			'address_email'         => 'pnewman6564@yahoo.com',
+			'address_phone_number'  => '65432178',
+			'address_city'          => 'Louisville',
+			'address_custom_data'   => ['scheduled'     => 'yes',
+				'serice type'   => 'publishing', ],
+			'schedule' => [[
+				'enabled'   => true,
+				'mode'      => 'daily',
+				'daily'     => ['every' => 1],
+			]],
+			'service_time'          => 900,
+		]);
+
+		$this->assertEquals($location->toArray(),
+			[
+				'address_1'             => '1604 PARKRIDGE PKWY, Louisville, KY, 40214',
+				'cached_lat'            => 38.141598,
+				'cached_lng'            => -85.793846,
+				'address_alias'         => '1604 PARKRIDGE PKWY 40214',
+				'address_group'         => 'Scheduled daily',
+				'first_name'            => 'Peter',
+				'last_name'             => 'Newman',
+				'address_email'         => 'pnewman6564@yahoo.com',
+				'address_phone_number'  => '65432178',
+				'address_city'          => 'Louisville',
+				'address_custom_data'   => ['scheduled'     => 'yes',
+					'serice type'   => 'publishing', ],
+				'schedule' => [[
+					'enabled'   => true,
+					'mode'      => 'daily',
+					'daily'     => ['every' => 1],
+				]],
+				'service_time'          => 900,
+			]
+		);
+	}
+
+	public function testGetAddressBookLocation()
+	{
+		$abl = new AddressBookLocation();
+
+		$addressID = self::$createdContacts[0]->address_id;
+
+		$result = AddressBookLocation::fromArray(
+			$abl->getAddressBookLocation($addressID)
+		);
+
+		$this->assertNotNull($addressID);
+		$this->assertContainsOnlyInstancesOf(AddressBookLocation::class, [$result]);
+
+	}
+
+	public function testSearchAddressBookLocations()
+	{
+		$abl = new AddressBookLocation();
+
+		$params = [
+			'query'  => 'Douglas',
+			'fields' => 'first_name,address_email,schedule_blacklist,schedule,address_custom_data,address_1',
+			'offset' => 0,
+			'limit'  => 5,
+		];
                                                                                                                                 
-        $result =  SearchResponse::fromArray(
-            $abl->searchAddressBookLocations($params)
-        );
+		$result =  SearchResponse::fromArray(
+			$abl->searchAddressBookLocations($params)
+		);
 
-        $this->assertNotNull($result);
-        $this->assertTrue(sizeof($result->fields)==6);
-        $this->assertContains('first_name',$result->fields);
-        $this->assertContains('address_email',$result->fields);
+		$this->assertNotNull($result);
+		$this->assertTrue(sizeof($result->fields)==6);
+		$this->assertContains('first_name',$result->fields);
+		$this->assertContains('address_email',$result->fields);
 
-        $this->assertNotNull($result->results);
+		$this->assertNotNull($result->results);
 
-        $txt = json_encode($result->results[0]);
+		$txt = json_encode($result->results[0]);
 
-        $firstRecord = strtolower($txt);
+		$firstRecord = strtolower($txt);
         
-        $this->assertTrue(strpos($firstRecord, 'douglas')>=0);
-    }
+		$this->assertTrue(strpos($firstRecord, 'douglas')>=0);
+	}
 
-    public function testGetAddressBookLocations()
-    {
-        $abl = new AddressBookLocation();
+	public function testGetAddressBookLocations()
+	{
+		$abl = new AddressBookLocation();
 
-        $AddressBookLocationParameters = [
-            'limit'  => 5,
-            'offset' => 0,
-        ];
+		$AddressBookLocationParameters = [
+			'limit'  => 5,
+			'offset' => 0,
+		];
 
-        $result = SearchResponse::fromArray(
-            $abl->getAddressBookLocations($AddressBookLocationParameters)
-        );
+		$result = SearchResponse::fromArray(
+			$abl->getAddressBookLocations($AddressBookLocationParameters)
+		);
 
-        $firstLocation = AddressBookLocation::fromArray(
-            $result->results[0]
-        );
+		$firstLocation = AddressBookLocation::fromArray(
+			$result->results[0]
+		);
 
-        $this->assertNotNull($result);
-        $this->assertNotNull($result->results);
-        $this->assertContainsOnlyInstancesOf(AddressBookLocation::class, [$firstLocation]);
-    }
+		$this->assertNotNull($result);
+		$this->assertNotNull($result->results);
+		$this->assertContainsOnlyInstancesOf(AddressBookLocation::class, [$firstLocation]);
+	}
 
-    public function testGetRandomAddressBookLocation()
-    {
-        $AddressBookLocationParameters = [
-            'limit'  => 30,
-            'offset' => 0,
-        ];
-
-        $result = AddressBookLocation::fromArray(
-            AddressBookLocation::getRandomAddressBookLocation($AddressBookLocationParameters)
-        );
-
-        $this->assertNotNull($result);
-        $this->assertContainsOnlyInstancesOf(AddressBookLocation::class, [$result]);
-    }
-
-    public function testAddAdressBookLocation()
-    {
-        $abl = new AddressBookLocation();
-
-        $AddressBookLocationParameters = AddressBookLocation::fromArray([
-            'first_name'    => 'Test FirstName '.strval(rand(10000, 99999)),
-            'address_1'     => 'Test Address1 '.strval(rand(10000, 99999)),
-            'cached_lat'    => 38.024654,
-            'cached_lng'    => -77.338814,
-        ]);
-
-        $result = AddressBookLocation::fromArray(
-            $abl->addAdressBookLocation($AddressBookLocationParameters)
-        );
-
-        $this->assertNotNull($result);
-        $this->assertContainsOnlyInstancesOf(AddressBookLocation::class, [$result]);
-
-        self::$createdContacts[] = $result;
-    }
-
-    public function testDeleteAdressBookLocation()
-    {
-        $abl = new AddressBookLocation();
-
-        $lastContact = end(self::$createdContacts);
-
-        $deleteResult = $abl->deleteAdressBookLocation([$lastContact->address_id]);
-
-        $this->assertTrue(isset($deleteResult['status']), 'Address Book Location delete operation failed!.. <br>');
-        $this->assertTrue($deleteResult['status'], 'Address Book Location delete operation failed!.. <br>');
-
-        self::$createdContacts[] = array_pop(self::$createdContacts);
-    }
-
-    public function testUpdateAddressBookLocation()
-    {
-        $abl = new AddressBookLocation();
-
-        reset(self::$createdContacts);
-
-        $firstContact = self::$createdContacts[0];
-
-        $firstContact->first_name = $firstContact->first_name.' updated';
-
-        $result = AddressBookLocation::fromArray(
-            $abl->updateAddressBookLocation($firstContact)
-        );
-
-        $this->assertNotNull($result);
-        $this->assertContainsOnlyInstancesOf(AddressBookLocation::class, [$result]);
-        $this->assertEquals($firstContact->first_name, $result->first_name);
-    }
-
-    public function testValidateScheduleMode()
-    {
-        $this->assertTrue(AddressBookLocation::validateScheduleMode('daily'));
-        $this->assertTrue(AddressBookLocation::validateScheduleMode('weekly'));
-        $this->assertTrue(AddressBookLocation::validateScheduleMode('monthly'));
-        $this->assertTrue(AddressBookLocation::validateScheduleMode('annually'));
-
-        $this->assertFalse(AddressBookLocation::validateScheduleMode('wrongMode'));
-    }
-
-    public function testValidateScheduleEnable()
-    {
-        $this->assertTrue(AddressBookLocation::validateScheduleEnable(true));
-        $this->assertTrue(AddressBookLocation::validateScheduleEnable(false));
-
-        $this->assertFalse(AddressBookLocation::validateScheduleEnable('wrongValue'));
-        $this->assertFalse(AddressBookLocation::validateScheduleEnable(null));
-    }
-
-    public function testValidateScheduleEvery()
-    {
-        $this->assertTrue(AddressBookLocation::validateScheduleEvery(1));
-        $this->assertTrue(AddressBookLocation::validateScheduleEvery(8));
-
-        $this->assertFalse(AddressBookLocation::validateScheduleEvery(0));
-        $this->assertFalse(AddressBookLocation::validateScheduleEvery(-1));
-        $this->assertFalse(AddressBookLocation::validateScheduleEvery('stringValue'));
-        $this->assertFalse(AddressBookLocation::validateScheduleEvery(true));
-        $this->assertFalse(AddressBookLocation::validateScheduleEvery(null));
-    }
-
-    public function testValidateScheduleWeekDays()
-    {
-        $this->assertTrue(AddressBookLocation::validateScheduleWeekDays('1,2,3,4,5,6,7'));
-
-        $this->assertFalse(AddressBookLocation::validateScheduleWeekDays('1,2,3,4,5,6,7,8'));
-        $this->assertFalse(AddressBookLocation::validateScheduleWeekDays('1,-2,3,4,5,6,7'));
-        $this->assertFalse(AddressBookLocation::validateScheduleWeekDays(true));
-        $this->assertTrue(AddressBookLocation::validateScheduleWeekDays(4));
-        $this->assertFalse(AddressBookLocation::validateScheduleWeekDays('dds'));
-    }
-
-    public function testValidateScheduleMonthlyMode()
-    {
-        $this->assertTrue(AddressBookLocation::validateScheduleMonthlyMode('dates'));
-        $this->assertTrue(AddressBookLocation::validateScheduleMonthlyMode('nth' ));
-
-        $this->assertFalse(AddressBookLocation::validateScheduleMonthlyMode('wrongParam' ));
-        $this->assertFalse(AddressBookLocation::validateScheduleMonthlyMode(4 ));
-        $this->assertFalse(AddressBookLocation::validateScheduleMonthlyMode(true ));
-    }
-
-    public function testValidateScheduleMonthlyDates()
-    {
-        $this->assertTrue(AddressBookLocation::validateScheduleMonthlyDates('1,2,3,7,31'));
-        $this->assertTrue(AddressBookLocation::validateScheduleMonthlyDates('12,21,23,24,28'));
-
-        $this->assertFalse(AddressBookLocation::validateScheduleMonthlyDates('0,2,3,7,31'));
-        $this->assertFalse(AddressBookLocation::validateScheduleMonthlyDates('0,2,3,7,33'));
-        $this->assertFalse(AddressBookLocation::validateScheduleMonthlyDates('-1,2,3,7'));
-        $this->assertFalse(AddressBookLocation::validateScheduleMonthlyDates('wrongText'));
-        $this->assertFalse(AddressBookLocation::validateScheduleMonthlyDates(true));
-        $this->assertFalse(AddressBookLocation::validateScheduleMonthlyDates(false));
-    }
-
-    public function testValidateScheduleNthN()
-    {
-        $this->assertTrue(AddressBookLocation::validateScheduleNthN(1));
-        $this->assertTrue(AddressBookLocation::validateScheduleNthN(2));
-        $this->assertTrue(AddressBookLocation::validateScheduleNthN(3));
-        $this->assertTrue(AddressBookLocation::validateScheduleNthN(4));
-        $this->assertTrue(AddressBookLocation::validateScheduleNthN(5));
-        $this->assertTrue(AddressBookLocation::validateScheduleNthN(-1));
-
-        $this->assertFalse(AddressBookLocation::validateScheduleNthN(-5));
-        $this->assertFalse(AddressBookLocation::validateScheduleNthN(0));
-        $this->assertFalse(AddressBookLocation::validateScheduleNthN(7));
-        $this->assertFalse(AddressBookLocation::validateScheduleNthN(true));
-        $this->assertFalse(AddressBookLocation::validateScheduleNthN(false));
-        $this->assertFalse(AddressBookLocation::validateScheduleNthN('wrongText'));
-    }
-
-    public function testValidateScheduleNthWhat()
-    {
-        for ($i=1;$i<11;$i++) $this->assertTrue(AddressBookLocation::validateScheduleNthWhat($i));
-
-        $this->assertFalse(AddressBookLocation::validateScheduleNthWhat(0));
-        $this->assertFalse(AddressBookLocation::validateScheduleNthWhat(14));
-        $this->assertFalse(AddressBookLocation::validateScheduleNthWhat(true));
-        $this->assertFalse(AddressBookLocation::validateScheduleNthWhat(false));
-        $this->assertFalse(AddressBookLocation::validateScheduleNthWhat('wrongText'));
-    }
-
-    public function testAddLocationsFromCsvFile()
-    {
-        $root = realpath(dirname(__FILE__).'/../../');
-        $source_file = $root.'/UnitTestFiles/Test/data/addresses_10.csv';
-
-        $locationsFieldsMapping['cached_lat'] = 0;
-        $locationsFieldsMapping['cached_lng'] = 1;
-        $locationsFieldsMapping['address_alias'] = 2;
-        $locationsFieldsMapping['address_1'] = 3;
-        $locationsFieldsMapping['address_city'] = 4;
-        $locationsFieldsMapping['address_state_id'] = 5;
-        $locationsFieldsMapping['address_zip'] = 6;
-        $locationsFieldsMapping['address_phone_number'] = 7;
-        $locationsFieldsMapping['schedule_mode'] = 8;
-        $locationsFieldsMapping['schedule_enabled'] = 9;
-        $locationsFieldsMapping['schedule_every'] = 10;
-        $locationsFieldsMapping['schedule_weekdays'] = 11;
-        $locationsFieldsMapping['monthly_mode'] = 12;
-        $locationsFieldsMapping['monthly_dates'] = 13;
-        $locationsFieldsMapping['monthly_nth_n'] = 14;
-        $locationsFieldsMapping['monthly_nth_what'] = 15;
-        $locationsFieldsMapping['anually_nth_n'] = 16;
-        $locationsFieldsMapping['anually_nth_what'] = 17;
-
-        $handle = fopen("$source_file", 'r');
-
-        $this->assertNotNull($handle);
-
-        $abl = new AddressBookLocation();
-
-        $results = $abl->addLocationsFromCsvFile($handle, $locationsFieldsMapping);
-
-        $this->assertNotNull($results);
-
-        $this->assertTrue(isset($results['success']));
-
-        $this->assertTrue(isset($results['fail']));
-
-        foreach ($results['success'] as $sc) {
-            self::$csvImportedAddressIDs[] = filter_var($sc, FILTER_SANITIZE_NUMBER_INT);
-        }
-
-        $this->assertTrue(sizeof(self::$csvImportedAddressIDs)==10);
-    }
-
-    public static function tearDownAfterClass()
-    {
-        $addressBookLocations=[];
-
-        foreach (self::$createdContacts as $createdContact) {
-            $addressBookLocations[] = $createdContact->address_id;
-        }
-
-        $addressBookLocations = array_merge($addressBookLocations,self::$csvImportedAddressIDs);
-
-        $abl = new AddressBookLocation();
-
-        $deleteResult = $abl->deleteAdressBookLocation($addressBookLocations);
-
-        if (isset($deleteResult['status']) && $deleteResult['status']) {
-            echo "Created contacts were removed.<br>";
-        }
-    }
+	public function testGetRandomAddressBookLocation()
+	{
+		$AddressBookLocationParameters = [
+			'limit'  => 30,
+			'offset' => 0,
+		];
+
+		$result = AddressBookLocation::fromArray(
+			AddressBookLocation::getRandomAddressBookLocation($AddressBookLocationParameters)
+		);
+
+		$this->assertNotNull($result);
+		$this->assertContainsOnlyInstancesOf(AddressBookLocation::class, [$result]);
+	}
+
+	public function testAddAdressBookLocation()
+	{
+		$abl = new AddressBookLocation();
+
+		$AddressBookLocationParameters = AddressBookLocation::fromArray([
+			'first_name'    => 'Test FirstName '.strval(rand(10000, 99999)),
+			'address_1'     => 'Test Address1 '.strval(rand(10000, 99999)),
+			'cached_lat'    => 38.024654,
+			'cached_lng'    => -77.338814,
+		]);
+
+		$result = AddressBookLocation::fromArray(
+			$abl->addAdressBookLocation($AddressBookLocationParameters)
+		);
+
+		$this->assertNotNull($result);
+		$this->assertContainsOnlyInstancesOf(AddressBookLocation::class, [$result]);
+
+		self::$createdContacts[] = $result;
+	}
+
+	public function testDeleteAdressBookLocation()
+	{
+		$abl = new AddressBookLocation();
+
+		$lastContact = end(self::$createdContacts);
+
+		$deleteResult = $abl->deleteAdressBookLocation([$lastContact->address_id]);
+
+		$this->assertTrue(isset($deleteResult['status']), 'Address Book Location delete operation failed!.. <br>');
+		$this->assertTrue($deleteResult['status'], 'Address Book Location delete operation failed!.. <br>');
+
+		self::$createdContacts[] = array_pop(self::$createdContacts);
+	}
+
+	public function testUpdateAddressBookLocation()
+	{
+		$abl = new AddressBookLocation();
+
+		reset(self::$createdContacts);
+
+		$firstContact = self::$createdContacts[0];
+
+		$firstContact->first_name = $firstContact->first_name.' updated';
+
+		$result = AddressBookLocation::fromArray(
+			$abl->updateAddressBookLocation($firstContact)
+		);
+
+		$this->assertNotNull($result);
+		$this->assertContainsOnlyInstancesOf(AddressBookLocation::class, [$result]);
+		$this->assertEquals($firstContact->first_name, $result->first_name);
+	}
+
+	public function testValidateScheduleMode()
+	{
+		$this->assertTrue(AddressBookLocation::validateScheduleMode('daily'));
+		$this->assertTrue(AddressBookLocation::validateScheduleMode('weekly'));
+		$this->assertTrue(AddressBookLocation::validateScheduleMode('monthly'));
+		$this->assertTrue(AddressBookLocation::validateScheduleMode('annually'));
+
+		$this->assertFalse(AddressBookLocation::validateScheduleMode('wrongMode'));
+	}
+
+	public function testValidateScheduleEnable()
+	{
+		$this->assertTrue(AddressBookLocation::validateScheduleEnable(true));
+		$this->assertTrue(AddressBookLocation::validateScheduleEnable(false));
+
+		$this->assertFalse(AddressBookLocation::validateScheduleEnable('wrongValue'));
+		$this->assertFalse(AddressBookLocation::validateScheduleEnable(null));
+	}
+
+	public function testValidateScheduleEvery()
+	{
+		$this->assertTrue(AddressBookLocation::validateScheduleEvery(1));
+		$this->assertTrue(AddressBookLocation::validateScheduleEvery(8));
+
+		$this->assertFalse(AddressBookLocation::validateScheduleEvery(0));
+		$this->assertFalse(AddressBookLocation::validateScheduleEvery(-1));
+		$this->assertFalse(AddressBookLocation::validateScheduleEvery('stringValue'));
+		$this->assertFalse(AddressBookLocation::validateScheduleEvery(true));
+		$this->assertFalse(AddressBookLocation::validateScheduleEvery(null));
+	}
+
+	public function testValidateScheduleWeekDays()
+	{
+		$this->assertTrue(AddressBookLocation::validateScheduleWeekDays('1,2,3,4,5,6,7'));
+
+		$this->assertFalse(AddressBookLocation::validateScheduleWeekDays('1,2,3,4,5,6,7,8'));
+		$this->assertFalse(AddressBookLocation::validateScheduleWeekDays('1,-2,3,4,5,6,7'));
+		$this->assertFalse(AddressBookLocation::validateScheduleWeekDays(true));
+		$this->assertTrue(AddressBookLocation::validateScheduleWeekDays(4));
+		$this->assertFalse(AddressBookLocation::validateScheduleWeekDays('dds'));
+	}
+
+	public function testValidateScheduleMonthlyMode()
+	{
+		$this->assertTrue(AddressBookLocation::validateScheduleMonthlyMode('dates'));
+		$this->assertTrue(AddressBookLocation::validateScheduleMonthlyMode('nth' ));
+
+		$this->assertFalse(AddressBookLocation::validateScheduleMonthlyMode('wrongParam' ));
+		$this->assertFalse(AddressBookLocation::validateScheduleMonthlyMode(4 ));
+		$this->assertFalse(AddressBookLocation::validateScheduleMonthlyMode(true ));
+	}
+
+	public function testValidateScheduleMonthlyDates()
+	{
+		$this->assertTrue(AddressBookLocation::validateScheduleMonthlyDates('1,2,3,7,31'));
+		$this->assertTrue(AddressBookLocation::validateScheduleMonthlyDates('12,21,23,24,28'));
+
+		$this->assertFalse(AddressBookLocation::validateScheduleMonthlyDates('0,2,3,7,31'));
+		$this->assertFalse(AddressBookLocation::validateScheduleMonthlyDates('0,2,3,7,33'));
+		$this->assertFalse(AddressBookLocation::validateScheduleMonthlyDates('-1,2,3,7'));
+		$this->assertFalse(AddressBookLocation::validateScheduleMonthlyDates('wrongText'));
+		$this->assertFalse(AddressBookLocation::validateScheduleMonthlyDates(true));
+		$this->assertFalse(AddressBookLocation::validateScheduleMonthlyDates(false));
+	}
+
+	public function testValidateScheduleNthN()
+	{
+		$this->assertTrue(AddressBookLocation::validateScheduleNthN(1));
+		$this->assertTrue(AddressBookLocation::validateScheduleNthN(2));
+		$this->assertTrue(AddressBookLocation::validateScheduleNthN(3));
+		$this->assertTrue(AddressBookLocation::validateScheduleNthN(4));
+		$this->assertTrue(AddressBookLocation::validateScheduleNthN(5));
+		$this->assertTrue(AddressBookLocation::validateScheduleNthN(-1));
+
+		$this->assertFalse(AddressBookLocation::validateScheduleNthN(-5));
+		$this->assertFalse(AddressBookLocation::validateScheduleNthN(0));
+		$this->assertFalse(AddressBookLocation::validateScheduleNthN(7));
+		$this->assertFalse(AddressBookLocation::validateScheduleNthN(true));
+		$this->assertFalse(AddressBookLocation::validateScheduleNthN(false));
+		$this->assertFalse(AddressBookLocation::validateScheduleNthN('wrongText'));
+	}
+
+	public function testValidateScheduleNthWhat()
+	{
+		for ($i=1;$i<11;$i++) $this->assertTrue(AddressBookLocation::validateScheduleNthWhat($i));
+
+		$this->assertFalse(AddressBookLocation::validateScheduleNthWhat(0));
+		$this->assertFalse(AddressBookLocation::validateScheduleNthWhat(14));
+		$this->assertFalse(AddressBookLocation::validateScheduleNthWhat(true));
+		$this->assertFalse(AddressBookLocation::validateScheduleNthWhat(false));
+		$this->assertFalse(AddressBookLocation::validateScheduleNthWhat('wrongText'));
+	}
+
+	public function testAddLocationsFromCsvFile()
+	{
+		$root = realpath(dirname(__FILE__).'/../../');
+		$source_file = $root.'/UnitTestFiles/Test/data/addresses_10.csv';
+
+		$locationsFieldsMapping['cached_lat'] = 0;
+		$locationsFieldsMapping['cached_lng'] = 1;
+		$locationsFieldsMapping['address_alias'] = 2;
+		$locationsFieldsMapping['address_1'] = 3;
+		$locationsFieldsMapping['address_city'] = 4;
+		$locationsFieldsMapping['address_state_id'] = 5;
+		$locationsFieldsMapping['address_zip'] = 6;
+		$locationsFieldsMapping['address_phone_number'] = 7;
+		$locationsFieldsMapping['schedule_mode'] = 8;
+		$locationsFieldsMapping['schedule_enabled'] = 9;
+		$locationsFieldsMapping['schedule_every'] = 10;
+		$locationsFieldsMapping['schedule_weekdays'] = 11;
+		$locationsFieldsMapping['monthly_mode'] = 12;
+		$locationsFieldsMapping['monthly_dates'] = 13;
+		$locationsFieldsMapping['monthly_nth_n'] = 14;
+		$locationsFieldsMapping['monthly_nth_what'] = 15;
+		$locationsFieldsMapping['anually_nth_n'] = 16;
+		$locationsFieldsMapping['anually_nth_what'] = 17;
+
+		$handle = fopen("$source_file", 'r');
+
+		$this->assertNotNull($handle);
+
+		$abl = new AddressBookLocation();
+
+		$results = $abl->addLocationsFromCsvFile($handle, $locationsFieldsMapping);
+
+		$this->assertNotNull($results);
+
+		$this->assertTrue(isset($results['success']));
+
+		$this->assertTrue(isset($results['fail']));
+
+		foreach ($results['success'] as $sc) {
+			self::$csvImportedAddressIDs[] = filter_var($sc, FILTER_SANITIZE_NUMBER_INT);
+		}
+
+		$this->assertTrue(sizeof(self::$csvImportedAddressIDs)==10);
+	}
+
+	public static function tearDownAfterClass()
+	{
+		$addressBookLocations=[];
+
+		foreach (self::$createdContacts as $createdContact) {
+			$addressBookLocations[] = $createdContact->address_id;
+		}
+
+		$addressBookLocations = array_merge($addressBookLocations,self::$csvImportedAddressIDs);
+
+		$abl = new AddressBookLocation();
+
+		$deleteResult = $abl->deleteAdressBookLocation($addressBookLocations);
+
+		if (isset($deleteResult['status']) && $deleteResult['status']) {
+			echo "Created contacts were removed.<br>";
+		}
+	}
 }
\ No newline at end of file

UnitTestFiles/Test/AddressUnitTests.php

Indentation +328 added lines, -328 removed lines

@@ -12,339 +12,339 @@
 use Route4Me\RouteParameters;
 
 class AddressUnitTests extends \PHPUnit\Framework\TestCase {
-    protected $address;
-    public static $createdAddresses;
-
-    public static $problem;
-    public static $problemDest;
-
-    public static $route_id = null;
-    public static $address_id = null;
-    public static $address_address = null;
-    public static $address_lat = null;
-    public static $address_lng = null;
-    public static $address_is_depot = null;
-
-    public static $addresIdMarkedAsVisited;
-
-    public static $afterAddressId;
-    public static $route_id_dest;
-
-    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::$createdAddresses = $routes[0]->addresses;
-
-        self::$problemDest = OptimizationProblem::optimize($optimizationParameters);
-        $routesDest = self::$problemDest->getRoutes();
-        $addressesDest = $routesDest[0]->addresses;
-        self::$route_id_dest = $routesDest[0]->route_id;
-        self::$afterAddressId = $addressesDest[2]->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;
-
-        self::$addresIdMarkedAsVisited = $addresses[2]->getAddressId();
-
-        $params = [
-            'route_id'      =>  self::$route_id,
-            'address_id'    =>  self::$addresIdMarkedAsVisited,
-            'is_visited'    => 1
-        ];
-
-        $result =  $addresses[2]->markAsVisited($params);
-
-    }
-
-    public function testAddressFromArray()
-    {
-        $address = Address::fromArray([
-            'address'           => '10609 Mystic Pointe Dr, Fredericksburg, VA 22407',
-            'lat'               => 38.2513427734,
-            'lng'               => -77.5993652344,
-            'time'              => 300,
-            'time_window_end'   => 75600,
-            'time_window_start' => 28800,
-        ]);
-
-        $this->assertEquals($address->address, '10609 Mystic Pointe Dr, Fredericksburg, VA 22407');
-        $this->assertEquals($address->lat, 38.2513427734);
-        $this->assertEquals($address->lng, -77.5993652344);
-        $this->assertEquals($address->time, 300);
-        $this->assertEquals($address->time_window_start, 28800);
-        $this->assertEquals($address->time_window_end, 75600);
-    }
-
-    public function testToArray()
-    {
-        $address = Address::fromArray([
-            'address'           => '10609 Mystic Pointe Dr, Fredericksburg, VA 22407',
-            'lat'               => 38.2513427734,
-            'lng'               => -77.5993652344,
-            'time'              => 300,
-            'time_window_end'   => 75600,
-            'time_window_start' => 28800,
-            'custom_fields'     => [
-                'cf_1' => 1,
-            ],
-        ]);
-
-        $this->assertEquals($address->toArray(), [
-            'address'           => '10609 Mystic Pointe Dr, Fredericksburg, VA 22407',
-            'lat'               => 38.2513427734,
-            'lng'               => -77.5993652344,
-            'is_depot'          => false,
-            'time'              => 300,
-            'time_window_end'   => 75600,
-            'time_window_start' => 28800,
-            'custom_fields'     => [
-                'cf_1' => 1,
-            ],
-        ]);
-    }
-
-    public function testBadParameter()
-    {
-        $this->expectException(BadParam::class);
-
-        $address = Address::fromArray([
-            'lat1' => 38.2513427734,
-            'lng1' => -77.5993652344,
-        ]);
-
-        echo "address: ".$address->lat." <br>";
-    }
-
-    public function testAddressFromArrayWithBadKeys()
-    {
-        $this->expectException(BadParam::class);
-
-        $address = Address::fromArray([
-            'address'       => '10609 Mystic Pointe Dr, Fredericksburg, VA 22407',
-            'lat'           => 38.2513427734,
-            'lng'           => -77.5993652344,
-            'demoaddress'   => '333333',
-        ]);
-
-        $this->assertNotNull($address->address);
-        $this->assertEquals($address->address, '10609 Mystic Pointe Dr, Fredericksburg, VA 22407');
-        $this->assertEquals($address->lat, 38.2513427734);
-        $this->assertEquals($address->lng, -77.5993652344);
-
-        $this->assertFalse(property_exists($address, 'demoaddress'));
-    }
-
-    public function testGetAddress()
-    {
-        $address = Address::getAddress(self::$route_id, self::$address_id);
-
-        $this->assertNotNull($address);
-        $this->assertNotNull($address->address);
-        $this->assertEquals($address->address, self::$address_address);
-        $this->assertEquals($address->lat, self::$address_lat);
-        $this->assertEquals($address->lng, self::$address_lng);
-        $this->assertEquals($address->is_depot, self::$address_is_depot);
-
-        return $address;
-    }
-
-    public function testUpdateAddress()
-    {
-        $address = Address::getAddress(self::$route_id, self::$address_id);
-        $this->assertNotNull($address);
-
-        $address->route_id = self::$route_id;
-
-        $address->address = 'Updated address';
-        $newAddress = $address->update();
-
-        $this->assertEquals($newAddress->address, 'Updated address');
-    }
-
-    public function testMarkAsDeparted()
-    {
-        $address = new Address();
-
-        $params = [
-            'route_id'      =>  self::$route_id,
-            'address_id'    =>  self::$addresIdMarkedAsVisited,
-            'is_departed'   => 1
-        ];
-
-        $result = $address->markAsDeparted($params);
-
-        $this->assertNotNull($result);
-        $this->assertIsBool($result['status']);
-        $this->assertTrue($result['status']);
-    }
-
-    public function testMarkAsVisited()
-    {
-        $address = new Address();
-
-        $params = [
-            'route_id'   =>  self::$route_id,
-            'address_id' =>  self::$address_id,
-            'is_visited' => 1
-        ];
-
-        $result = $address->markAsVisited($params);
-
-        $this->assertNotNull($result);
-        $this->assertIsInt($result);
-        $this->assertEquals(1,$result);
-    }
-
-    public function testDeleteAddress()
-    {
-        $lastAddressId = self::$createdAddresses[sizeof(self::$createdAddresses)-1]->route_destination_id;
-
-        $address = Address::getAddress(self::$route_id, $lastAddressId);
-        $this->assertNotNull($address);
-
-        $state = $address->deleteAddress();
-        $this->assertTrue($state);
-
-        array_pop(self::$createdAddresses);
-    }
-
-    public function testMoveDestinationToRoute()
-    {
-        $lastAddressId = self::$createdAddresses[sizeof(self::$createdAddresses)-1]->route_destination_id;
-
-        // Move the destination to the route
-        $routeParams = [
-            'to_route_id'           => self::$route_id_dest,
-            'route_destination_id'  => $lastAddressId,
-            'after_destination_id'  => self::$afterAddressId,
-        ];
-
-        $address = new Address();
-        $result = $address->moveDestinationToRoute($routeParams);
-
-        $this->assertNotNull($result);
-        $this->assertNotNull($result['success']);
-        $this->assertEquals(true,$result['success']);
-    }
-
-    public function testChangeRouteDepote()
-    {
-        $address1 = Address::getAddress(
-            self::$route_id,
-            self::$createdAddresses[0]->route_destination_id);
+	protected $address;
+	public static $createdAddresses;
+
+	public static $problem;
+	public static $problemDest;
+
+	public static $route_id = null;
+	public static $address_id = null;
+	public static $address_address = null;
+	public static $address_lat = null;
+	public static $address_lng = null;
+	public static $address_is_depot = null;
+
+	public static $addresIdMarkedAsVisited;
+
+	public static $afterAddressId;
+	public static $route_id_dest;
+
+	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::$createdAddresses = $routes[0]->addresses;
+
+		self::$problemDest = OptimizationProblem::optimize($optimizationParameters);
+		$routesDest = self::$problemDest->getRoutes();
+		$addressesDest = $routesDest[0]->addresses;
+		self::$route_id_dest = $routesDest[0]->route_id;
+		self::$afterAddressId = $addressesDest[2]->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;
+
+		self::$addresIdMarkedAsVisited = $addresses[2]->getAddressId();
+
+		$params = [
+			'route_id'      =>  self::$route_id,
+			'address_id'    =>  self::$addresIdMarkedAsVisited,
+			'is_visited'    => 1
+		];
+
+		$result =  $addresses[2]->markAsVisited($params);
+
+	}
+
+	public function testAddressFromArray()
+	{
+		$address = Address::fromArray([
+			'address'           => '10609 Mystic Pointe Dr, Fredericksburg, VA 22407',
+			'lat'               => 38.2513427734,
+			'lng'               => -77.5993652344,
+			'time'              => 300,
+			'time_window_end'   => 75600,
+			'time_window_start' => 28800,
+		]);
+
+		$this->assertEquals($address->address, '10609 Mystic Pointe Dr, Fredericksburg, VA 22407');
+		$this->assertEquals($address->lat, 38.2513427734);
+		$this->assertEquals($address->lng, -77.5993652344);
+		$this->assertEquals($address->time, 300);
+		$this->assertEquals($address->time_window_start, 28800);
+		$this->assertEquals($address->time_window_end, 75600);
+	}
+
+	public function testToArray()
+	{
+		$address = Address::fromArray([
+			'address'           => '10609 Mystic Pointe Dr, Fredericksburg, VA 22407',
+			'lat'               => 38.2513427734,
+			'lng'               => -77.5993652344,
+			'time'              => 300,
+			'time_window_end'   => 75600,
+			'time_window_start' => 28800,
+			'custom_fields'     => [
+				'cf_1' => 1,
+			],
+		]);
+
+		$this->assertEquals($address->toArray(), [
+			'address'           => '10609 Mystic Pointe Dr, Fredericksburg, VA 22407',
+			'lat'               => 38.2513427734,
+			'lng'               => -77.5993652344,
+			'is_depot'          => false,
+			'time'              => 300,
+			'time_window_end'   => 75600,
+			'time_window_start' => 28800,
+			'custom_fields'     => [
+				'cf_1' => 1,
+			],
+		]);
+	}
+
+	public function testBadParameter()
+	{
+		$this->expectException(BadParam::class);
+
+		$address = Address::fromArray([
+			'lat1' => 38.2513427734,
+			'lng1' => -77.5993652344,
+		]);
+
+		echo "address: ".$address->lat." <br>";
+	}
+
+	public function testAddressFromArrayWithBadKeys()
+	{
+		$this->expectException(BadParam::class);
+
+		$address = Address::fromArray([
+			'address'       => '10609 Mystic Pointe Dr, Fredericksburg, VA 22407',
+			'lat'           => 38.2513427734,
+			'lng'           => -77.5993652344,
+			'demoaddress'   => '333333',
+		]);
+
+		$this->assertNotNull($address->address);
+		$this->assertEquals($address->address, '10609 Mystic Pointe Dr, Fredericksburg, VA 22407');
+		$this->assertEquals($address->lat, 38.2513427734);
+		$this->assertEquals($address->lng, -77.5993652344);
+
+		$this->assertFalse(property_exists($address, 'demoaddress'));
+	}
+
+	public function testGetAddress()
+	{
+		$address = Address::getAddress(self::$route_id, self::$address_id);
+
+		$this->assertNotNull($address);
+		$this->assertNotNull($address->address);
+		$this->assertEquals($address->address, self::$address_address);
+		$this->assertEquals($address->lat, self::$address_lat);
+		$this->assertEquals($address->lng, self::$address_lng);
+		$this->assertEquals($address->is_depot, self::$address_is_depot);
+
+		return $address;
+	}
+
+	public function testUpdateAddress()
+	{
+		$address = Address::getAddress(self::$route_id, self::$address_id);
+		$this->assertNotNull($address);
+
+		$address->route_id = self::$route_id;
+
+		$address->address = 'Updated address';
+		$newAddress = $address->update();
+
+		$this->assertEquals($newAddress->address, 'Updated address');
+	}
+
+	public function testMarkAsDeparted()
+	{
+		$address = new Address();
+
+		$params = [
+			'route_id'      =>  self::$route_id,
+			'address_id'    =>  self::$addresIdMarkedAsVisited,
+			'is_departed'   => 1
+		];
+
+		$result = $address->markAsDeparted($params);
+
+		$this->assertNotNull($result);
+		$this->assertIsBool($result['status']);
+		$this->assertTrue($result['status']);
+	}
+
+	public function testMarkAsVisited()
+	{
+		$address = new Address();
+
+		$params = [
+			'route_id'   =>  self::$route_id,
+			'address_id' =>  self::$address_id,
+			'is_visited' => 1
+		];
+
+		$result = $address->markAsVisited($params);
+
+		$this->assertNotNull($result);
+		$this->assertIsInt($result);
+		$this->assertEquals(1,$result);
+	}
+
+	public function testDeleteAddress()
+	{
+		$lastAddressId = self::$createdAddresses[sizeof(self::$createdAddresses)-1]->route_destination_id;
+
+		$address = Address::getAddress(self::$route_id, $lastAddressId);
+		$this->assertNotNull($address);
+
+		$state = $address->deleteAddress();
+		$this->assertTrue($state);
+
+		array_pop(self::$createdAddresses);
+	}
+
+	public function testMoveDestinationToRoute()
+	{
+		$lastAddressId = self::$createdAddresses[sizeof(self::$createdAddresses)-1]->route_destination_id;
+
+		// Move the destination to the route
+		$routeParams = [
+			'to_route_id'           => self::$route_id_dest,
+			'route_destination_id'  => $lastAddressId,
+			'after_destination_id'  => self::$afterAddressId,
+		];
+
+		$address = new Address();
+		$result = $address->moveDestinationToRoute($routeParams);
+
+		$this->assertNotNull($result);
+		$this->assertNotNull($result['success']);
+		$this->assertEquals(true,$result['success']);
+	}
+
+	public function testChangeRouteDepote()
+	{
+		$address1 = Address::getAddress(
+			self::$route_id,
+			self::$createdAddresses[0]->route_destination_id);
 
-        $address1->route_id = self::$route_id;
-
-        $address2 = Address::getAddress(
-            self::$route_id,
-            self::$createdAddresses[1]->route_destination_id);
-
-        $address2->route_id = self::$route_id;
+		$address1->route_id = self::$route_id;
+
+		$address2 = Address::getAddress(
+			self::$route_id,
+			self::$createdAddresses[1]->route_destination_id);
+
+		$address2->route_id = self::$route_id;
 
-        $this->assertEquals(true, $address1->is_depot);
-        $this->assertEquals(false, $address2->is_depot);
+		$this->assertEquals(true, $address1->is_depot);
+		$this->assertEquals(false, $address2->is_depot);
 
-        $address1->is_depot = false;
-        $updatedAddress1 = $address1->update();
+		$address1->is_depot = false;
+		$updatedAddress1 = $address1->update();
 
-        $address2->is_depot = true;
-        $updatedAddress2 = $address2->update();
+		$address2->is_depot = true;
+		$updatedAddress2 = $address2->update();
 
-        $this->assertEquals(false, $updatedAddress1->is_depot);
-        $this->assertEquals(true, $updatedAddress2->is_depot);
-    }
+		$this->assertEquals(false, $updatedAddress1->is_depot);
+		$this->assertEquals(true, $updatedAddress2->is_depot);
+	}
 
-    public static function tearDownAfterClass()
-    {
-        $optimizationProblemId = self:: $problem->optimization_problem_id;
-        $destOptimizationProblemId = self::$problemDest->optimization_problem_id;
-
-        $params = [
-            'optimization_problem_ids' => [
-                '0' => $optimizationProblemId,
-                '1' => $destOptimizationProblemId
-            ],
-            'redirect' => 0,
-        ];
-
-        $result = self:: $problem->removeOptimization($params);
+	public static function tearDownAfterClass()
+	{
+		$optimizationProblemId = self:: $problem->optimization_problem_id;
+		$destOptimizationProblemId = self::$problemDest->optimization_problem_id;
+
+		$params = [
+			'optimization_problem_ids' => [
+				'0' => $optimizationProblemId,
+				'1' => $destOptimizationProblemId
+			],
+			'redirect' => 0,
+		];
+
+		$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>";
+		}
+	}
 }

UnitTestFiles/Test/TrackingTests.php

Indentation +256 added lines, -256 removed lines

@@ -26,260 +26,260 @@
 
 class TrackingTests extends \PHPUnit\Framework\TestCase
 {
-    public static $createdProblems = [];
-    public static $testRoutes = [];
-
-    public static function setUpBeforeClass()
-    {
-        Route4Me::setApiKey(Constants::API_KEY);
-
-        $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;
-
-        $params = TrackSetParams::fromArray([
-            'format'            => Format::SERIALIZED,
-            'route_id'          => self::$testRoutes[0]->route_id,
-            'member_id'         => self::$testRoutes[0]->parameters->member_id,
-            'course'            => 1,
-            'speed'             => 120,
-            'lat'               => 41.8927521,
-            'lng'               => -109.0803888,
-            'device_type'       => 'android_phone',
-            'device_guid'       => 'qweqweqwe',
-            'device_timestamp'  => date('Y-m-d H:i:s', strtotime('-2 day')),
-        ]);
-
-        $status = Track ::set($params);
-
-        self::assertNotNull($status, "Cannot send GPS position to the selected route");
-        self::assertTrue(isset($status['status']), "Cannot send GPS position to the selected route");
-        self::assertTrue($status['status'], "Cannot send GPS position to the selected route");
-    }
-
-    public function testFromArray()
-    {
-        $trackingParams = TrackSetParams::fromArray([
-            'member_id'     => 44444,
-            'format'        => 'json',
-            'route_id'      => '489D597EE62534C906096F1AAC278D26',
-            'course'        => 72,
-            'speed'         => 65,
-            'lat'           => 38.218662,
-            'lng'           => -85.789032,
-            'device_type'   => 'android_phone',
-            'device_guid'   => 'HK5454H0K454564WWER445'
-        ]);
-
-        $this->assertEquals(44444, $trackingParams->member_id);
-        $this->assertEquals('489D597EE62534C906096F1AAC278D26', $trackingParams->route_id);
-
-        $this->assertEquals(72, $trackingParams->course);
-        $this->assertEquals(65, $trackingParams->speed);
-        $this->assertEquals(38.218662, $trackingParams->lat);
-        $this->assertEquals(-85.789032, $trackingParams->lng);
-        $this->assertEquals('android_phone', $trackingParams->device_type);
-        $this->assertEquals('HK5454H0K454564WWER445', $trackingParams->device_guid);
-    }
-
-    public function testFindAsset()
-    {
-        $trackingNumber = null;
-
-        //region -- Get a tracking number from a random route destination --
-        $routeId = self::$testRoutes[0]->route_id;
-
-        $addresses = self::$testRoutes[0]->addresses;
-        assert(!is_null($addresses), "Cannot retrieve a random route ID");
-
-        foreach ($addresses as $addr1) {
-            if (!is_null($addr1->tracking_number)) {
-                $trackingNumber = $addr1->tracking_number;
-                break;
-            }
-        }
-
-        $this->assertNotNull($trackingNumber, "Cannot select a tracking number");
-
-        //endregion
-
-        $params = [
-            'tracking' => $trackingNumber,
-        ];
-
-        $route = new Route();
-
-        $result = $route->GetAssetTracking($params);
-
-        $this->assertNotNull($result);
-        $this->assertInstanceOf(FindAssetResponse::class, FindAssetResponse::fromArray($result));
-    }
-
-    public function testGetAllUserLocations()
-    {
-        $track = new Track();
-
-        $userLocations = $track->getUserLocations();
-
-        $this->assertNotNull($userLocations);
-        $this->assertTrue(is_array($userLocations));
-        $this->assertTrue(sizeof($userLocations)>0);
-        $this->assertInstanceOf(
-            UserLocation::class,
-            UserLocation::fromArray($userLocations[0]));
-        $this->assertInstanceOf(
-            MemberData::class,
-            MemberData::fromArray($userLocations[0]['member_data']));
-        $this->assertInstanceOf(
-            UserTracking::class,
-            UserTracking::fromArray($userLocations[0]['tracking']));
-    }
-
-    public function testQueryUserLocations()
-    {
-        $track = new Track();
-        $userLocations = $track->getUserLocations();
-        $userLocation = reset($userLocations);
-
-        $email = $userLocation['member_data']['member_email'];
-
-        $queriedUserLocations = $track->getUserLocations($email);
-
-        $this->assertNotNull($queriedUserLocations);
-        $this->assertTrue(is_array($queriedUserLocations));
-        $this->assertTrue(sizeof($queriedUserLocations)>0);
-        $this->assertInstanceOf(
-            UserLocation::class,
-            UserLocation::fromArray($queriedUserLocations[0])
-        );
-        $this->assertInstanceOf(
-            MemberData::class,
-            MemberData::fromArray($queriedUserLocations[0]['member_data'])
-        );
-        $this->assertInstanceOf(
-            UserTracking::class,
-            UserTracking::fromArray($queriedUserLocations[0]['tracking'])
-        );
-    }
-
-    public function testGetDeviceHistoryTimeRange()
-    {
-        $startDate = time() - 30 * 24 * 3600;
-        $endDate = time() + 1 * 24 * 3600;
-
-        $params = [
-            'route_id'      => self::$testRoutes[0]->route_id,
-            'format'        => Format::JSON,
-            'time_period'   => 'custom',
-            'start_date'    => $startDate,
-            'end_date'      => $endDate,
-        ];
-
-        $route = new Route();
-
-        $result = $route->GetTrackingHistoryFromTimeRange($params);
-
-        $this->assertNotNull($result);
-    }
-
-    public function testSetGPSPosition()
-    {
-        $route = new Route();
-
-        $routeId = self::$testRoutes[0]->route_id;
-
-        // Set GPS postion to the selected route
-        // Set right member_id corresponding to the API key
-        $params = TrackSetParams::fromArray([
-            'format'            => Format::CSV,
-            'route_id'          => $routeId,
-            'member_id'         => self::$testRoutes[0]->parameters->member_id,
-            'course'            => 1,
-            'speed'             => 120,
-            'lat'               => 41.8927521,
-            'lng'               => -109.0803888,
-            'device_type'       => 'android_phone',
-            'device_guid'       => 'qweqweqwe',
-            'device_timestamp'  => date('Y-m-d H:i:s', strtotime('-1 day')),
-        ]);
-
-        $status = Track::set($params);
-
-        $this->assertNotNull($status);
-        $this->assertInstanceOf(
-            SetGpsResponse::class,
-            SetGpsResponse::fromArray($status)
-        );
-        $this->assertTrue($status['status']);
-    }
-
-    public function testTrackDeviceLastLocationHistory()
-    {
-        $route = new Route();
-
-        $routeId = self::$testRoutes[0]->route_id;
-
-        $params = [
-            'route_id'                  => $routeId,
-            'device_tracking_history'   => '1',
-        ];
-
-        $result = $route->GetLastLocation($params);
-
-        $this->assertNotNull($result);
-        $this->assertInstanceOf(Route::class, $result);
-        $this->assertTrue(isset($result->tracking_history));
-    }
-
-    public static function tearDownAfterClass()
-    {
-        if (sizeof(self::$createdProblems)>0) {
-            $optimizationProblemIDs = [];
-
-            foreach (self::$createdProblems as $problem) {
-                $optimizationProblemId = $problem->optimization_problem_id;
-
-                $optimizationProblemIDs[] = $optimizationProblemId;
-            }
-
-            $params = [
-                'optimization_problem_ids' => $optimizationProblemIDs,
-                'redirect'                 => 0,
-            ];
-
-            $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>";
-            }
-        }
-    }
+	public static $createdProblems = [];
+	public static $testRoutes = [];
+
+	public static function setUpBeforeClass()
+	{
+		Route4Me::setApiKey(Constants::API_KEY);
+
+		$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;
+
+		$params = TrackSetParams::fromArray([
+			'format'            => Format::SERIALIZED,
+			'route_id'          => self::$testRoutes[0]->route_id,
+			'member_id'         => self::$testRoutes[0]->parameters->member_id,
+			'course'            => 1,
+			'speed'             => 120,
+			'lat'               => 41.8927521,
+			'lng'               => -109.0803888,
+			'device_type'       => 'android_phone',
+			'device_guid'       => 'qweqweqwe',
+			'device_timestamp'  => date('Y-m-d H:i:s', strtotime('-2 day')),
+		]);
+
+		$status = Track ::set($params);
+
+		self::assertNotNull($status, "Cannot send GPS position to the selected route");
+		self::assertTrue(isset($status['status']), "Cannot send GPS position to the selected route");
+		self::assertTrue($status['status'], "Cannot send GPS position to the selected route");
+	}
+
+	public function testFromArray()
+	{
+		$trackingParams = TrackSetParams::fromArray([
+			'member_id'     => 44444,
+			'format'        => 'json',
+			'route_id'      => '489D597EE62534C906096F1AAC278D26',
+			'course'        => 72,
+			'speed'         => 65,
+			'lat'           => 38.218662,
+			'lng'           => -85.789032,
+			'device_type'   => 'android_phone',
+			'device_guid'   => 'HK5454H0K454564WWER445'
+		]);
+
+		$this->assertEquals(44444, $trackingParams->member_id);
+		$this->assertEquals('489D597EE62534C906096F1AAC278D26', $trackingParams->route_id);
+
+		$this->assertEquals(72, $trackingParams->course);
+		$this->assertEquals(65, $trackingParams->speed);
+		$this->assertEquals(38.218662, $trackingParams->lat);
+		$this->assertEquals(-85.789032, $trackingParams->lng);
+		$this->assertEquals('android_phone', $trackingParams->device_type);
+		$this->assertEquals('HK5454H0K454564WWER445', $trackingParams->device_guid);
+	}
+
+	public function testFindAsset()
+	{
+		$trackingNumber = null;
+
+		//region -- Get a tracking number from a random route destination --
+		$routeId = self::$testRoutes[0]->route_id;
+
+		$addresses = self::$testRoutes[0]->addresses;
+		assert(!is_null($addresses), "Cannot retrieve a random route ID");
+
+		foreach ($addresses as $addr1) {
+			if (!is_null($addr1->tracking_number)) {
+				$trackingNumber = $addr1->tracking_number;
+				break;
+			}
+		}
+
+		$this->assertNotNull($trackingNumber, "Cannot select a tracking number");
+
+		//endregion
+
+		$params = [
+			'tracking' => $trackingNumber,
+		];
+
+		$route = new Route();
+
+		$result = $route->GetAssetTracking($params);
+
+		$this->assertNotNull($result);
+		$this->assertInstanceOf(FindAssetResponse::class, FindAssetResponse::fromArray($result));
+	}
+
+	public function testGetAllUserLocations()
+	{
+		$track = new Track();
+
+		$userLocations = $track->getUserLocations();
+
+		$this->assertNotNull($userLocations);
+		$this->assertTrue(is_array($userLocations));
+		$this->assertTrue(sizeof($userLocations)>0);
+		$this->assertInstanceOf(
+			UserLocation::class,
+			UserLocation::fromArray($userLocations[0]));
+		$this->assertInstanceOf(
+			MemberData::class,
+			MemberData::fromArray($userLocations[0]['member_data']));
+		$this->assertInstanceOf(
+			UserTracking::class,
+			UserTracking::fromArray($userLocations[0]['tracking']));
+	}
+
+	public function testQueryUserLocations()
+	{
+		$track = new Track();
+		$userLocations = $track->getUserLocations();
+		$userLocation = reset($userLocations);
+
+		$email = $userLocation['member_data']['member_email'];
+
+		$queriedUserLocations = $track->getUserLocations($email);
+
+		$this->assertNotNull($queriedUserLocations);
+		$this->assertTrue(is_array($queriedUserLocations));
+		$this->assertTrue(sizeof($queriedUserLocations)>0);
+		$this->assertInstanceOf(
+			UserLocation::class,
+			UserLocation::fromArray($queriedUserLocations[0])
+		);
+		$this->assertInstanceOf(
+			MemberData::class,
+			MemberData::fromArray($queriedUserLocations[0]['member_data'])
+		);
+		$this->assertInstanceOf(
+			UserTracking::class,
+			UserTracking::fromArray($queriedUserLocations[0]['tracking'])
+		);
+	}
+
+	public function testGetDeviceHistoryTimeRange()
+	{
+		$startDate = time() - 30 * 24 * 3600;
+		$endDate = time() + 1 * 24 * 3600;
+
+		$params = [
+			'route_id'      => self::$testRoutes[0]->route_id,
+			'format'        => Format::JSON,
+			'time_period'   => 'custom',
+			'start_date'    => $startDate,
+			'end_date'      => $endDate,
+		];
+
+		$route = new Route();
+
+		$result = $route->GetTrackingHistoryFromTimeRange($params);
+
+		$this->assertNotNull($result);
+	}
+
+	public function testSetGPSPosition()
+	{
+		$route = new Route();
+
+		$routeId = self::$testRoutes[0]->route_id;
+
+		// Set GPS postion to the selected route
+		// Set right member_id corresponding to the API key
+		$params = TrackSetParams::fromArray([
+			'format'            => Format::CSV,
+			'route_id'          => $routeId,
+			'member_id'         => self::$testRoutes[0]->parameters->member_id,
+			'course'            => 1,
+			'speed'             => 120,
+			'lat'               => 41.8927521,
+			'lng'               => -109.0803888,
+			'device_type'       => 'android_phone',
+			'device_guid'       => 'qweqweqwe',
+			'device_timestamp'  => date('Y-m-d H:i:s', strtotime('-1 day')),
+		]);
+
+		$status = Track::set($params);
+
+		$this->assertNotNull($status);
+		$this->assertInstanceOf(
+			SetGpsResponse::class,
+			SetGpsResponse::fromArray($status)
+		);
+		$this->assertTrue($status['status']);
+	}
+
+	public function testTrackDeviceLastLocationHistory()
+	{
+		$route = new Route();
+
+		$routeId = self::$testRoutes[0]->route_id;
+
+		$params = [
+			'route_id'                  => $routeId,
+			'device_tracking_history'   => '1',
+		];
+
+		$result = $route->GetLastLocation($params);
+
+		$this->assertNotNull($result);
+		$this->assertInstanceOf(Route::class, $result);
+		$this->assertTrue(isset($result->tracking_history));
+	}
+
+	public static function tearDownAfterClass()
+	{
+		if (sizeof(self::$createdProblems)>0) {
+			$optimizationProblemIDs = [];
+
+			foreach (self::$createdProblems as $problem) {
+				$optimizationProblemId = $problem->optimization_problem_id;
+
+				$optimizationProblemIDs[] = $optimizationProblemId;
+			}
+
+			$params = [
+				'optimization_problem_ids' => $optimizationProblemIDs,
+				'redirect'                 => 0,
+			];
+
+			$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>";
+			}
+		}
+	}
 }
\ No newline at end of file

UnitTestFiles/Test/TelematicsGateWayApiTests.php

Indentation +476 added lines, -476 removed lines

@@ -15,490 +15,490 @@
 
 class TelematicsGateWayApiTests extends \PHPUnit\Framework\TestCase
 {
-    static $createdConnections = [];
-    static $firstMemberId;
+	static $createdConnections = [];
+	static $firstMemberId;
 
-    static $api_token;
-    static $tomtom_vendor;
+	static $api_token;
+	static $tomtom_vendor;
     
-    public static function setUpBeforeClass()
-    {
-        Route4Me::setApiKey(Constants::API_KEY);
+	public static function setUpBeforeClass()
+	{
+		Route4Me::setApiKey(Constants::API_KEY);
         
-        $member = new Member();
+		$member = new Member();
         
-        $results = $member->getUsers();
+		$results = $member->getUsers();
 
-        self::$firstMemberId = Member::fromArray($results['results'][0])->member_id;
+		self::$firstMemberId = Member::fromArray($results['results'][0])->member_id;
         
-        print_r("\n member_id = ".self::$firstMemberId."\n");
-
-        //region Get API token
-
-        $vendorParameters = new TelematicsVendorParameters();
-        $vendorParameters->member_id = self::$firstMemberId;
-        $vendorParameters->api_key = Constants::API_KEY;
-
-        $vendors = new TelematicsVendor();
-        $result = $vendors->RegisterTelematicsMember($vendorParameters);
-
-        self::assertNotNull($result);
-        self::assertInstanceOf(
-            TelematicsRegisterMemberResponse::class,
-            TelematicsRegisterMemberResponse::fromArray($result)
-        );
-
-        self::$api_token = TelematicsRegisterMemberResponse::fromArray(
-            $result
-        )->api_token;
-
-        //endregion
-
-        //region Get TomTom vendor
-
-        $vendorsParameters = TelematicsVendorParameters::fromArray([
-            //"country"     => "GB",  // uncomment this line for searching by Country
-            'is_integrated' => 1,
-            //"feature"     => "satellite",  // uncomment this line for searching by Feature
-            'search'        => 'tomtom',
-            'page'          => 1,
-            'per_page'      => 5,
-        ]);
-
-        $vendors = new TelematicsVendor();
-        $vendorsResults = $vendors->GetTelematicsVendors($vendorsParameters);
-
-        self::assertNotNull($vendorsResults);
-        self::assertTrue(is_array($vendorsResults));
-        self::assertTrue(sizeof($vendorsResults)>0);
-        self::assertTrue(
-            TelematicsVendor::fromArray($vendorsResults['vendors'][0])
-                instanceof
-                TelematicsVendor);
-
-        self::$tomtom_vendor = TelematicsVendor::fromArray($vendorsResults['vendors'][0]);
-        //endregion
-
-        //region Create Test Connection
-
-        $vendParams = new TelematicsConnectionParameters();
-
-        $vendParams->vendor       = TelematicsVendorsTypes::GEOTAB;
-        $vendParams->account_id   = '54321';
-        $vendParams->username     = 'John Doe 0';
-        $vendParams->password     = 'password0';
-        $vendParams->vehicle_position_refresh_rate    = 60;
-        $vendParams->name         = 'Test Geotab Connection from php SDK';
-        $vendParams->validate_remote_credentials      = 0;
-
-        $teleConnection = new TelematicsConnection();
-
-        $result2 = $teleConnection->createTelematicsConnection(
-            self::$api_token,
-            $vendParams->toArray()
-        );
-
-        self::assertNotNull($result2);
-        self::assertTrue( CreateConnectionResponse::fromArray($result2) instanceof CreateConnectionResponse);
-
-        self::$createdConnections[] = TelematicsConnection::fromArray($result2);
-        //endregion
-    }
-
-    public function testFromArray()
-    {
-        $vendorParameters = TelematicsVendor::fromArray([
-            'id'            => 14,
-            'name'          => 'Borea',
-            'slug'          => 'borea',
-            'description'   => 'Borea is a leading connected vehicle platform, helping our customers turn data about vehicles and their use into intelligence',
-            'logo_url'      => 'https:\/\/storage.googleapis.com\/telematics-directory-production\/silent-passanger555555.png',
-            'website_url'   => 'https:\/\/www.borea.com\/',
-            'api_docs_url'  => 'https:\/\/www.borea.com\/docs\/',
-            'is_integrated' => true,
-            'size'          => 'regional',
-            'features'      => [
-                0 => [
-                    'id'    => '1',
-                    'name'  => 'Customizable Reports',
-                    'slug'  => 'customizable-reports',
-                    'feature_group' => 'Analytics & Reporting'
-                ],
-                1 => [
-                    'id'            => '2',
-                    'name'          => 'Publicly Accessible API Documention',
-                    'slug'          => 'publicly-accessible-api-doc',
-                    'feature_group' => 'API & SDK'
-                ]
-            ],
-            'countries' => [
-                0 => [
-                    'id'            => '38',
-                    'country_code'  => 'CA',
-                    'country_name'  => 'Canada'
-                ],
-                1 => [
-                    'id'            => '230',
-                    'country_code'  => 'USA',
-                    'country_name'  => 'United States'
-                ]
-            ]
-        ]);
-
-        $this->assertEquals(14, $vendorParameters->id);
-        $this->assertEquals('Borea', $vendorParameters->name);
-        $this->assertEquals('borea', $vendorParameters->slug);
-        $this->assertEquals(
-            'Borea is a leading connected vehicle platform, helping our customers turn data about vehicles and their use into intelligence',
-            $vendorParameters->description
-        );
-        $this->assertEquals(
-            'https:\/\/storage.googleapis.com\/telematics-directory-production\/silent-passanger555555.png',
-            $vendorParameters->logo_url
-        );
-        $this->assertEquals('https:\/\/www.borea.com\/', $vendorParameters->website_url);
-        $this->assertEquals('https:\/\/www.borea.com\/docs\/', $vendorParameters->api_docs_url);
-        $this->assertEquals(true, $vendorParameters->is_integrated);
-        $this->assertEquals('regional', $vendorParameters->size);
-        $this->assertEquals(
-            [
-                0 => [
-                    'id'            => '1',
-                    'name'          => 'Customizable Reports',
-                    'slug'          => 'customizable-reports',
-                    'feature_group' => 'Analytics & Reporting'
-                ],
-                1 => [
-                    'id'            => '2',
-                    'name'          => 'Publicly Accessible API Documention',
-                    'slug'          => 'publicly-accessible-api-doc',
-                    'feature_group' => 'API & SDK'
-                ]
-            ],
-            $vendorParameters->features
-        );
-        $this->assertEquals(
-            [
-                0 => [
-                    'id'            => '38',
-                    'country_code'  => 'CA',
-                    'country_name'  => 'Canada'
-                ],
-                1 => [
-                    'id'            => '230',
-                    'country_code'  => 'USA',
-                    'country_name'  => 'United States'
-                ]
-            ],
-            $vendorParameters->countries
-        );
-    }
-
-    public function testToArray()
-    {
-        $vendorParameters = TelematicsVendor::fromArray([
-            'id'            => 14,
-            'name'          => 'Borea',
-            'slug'          => 'borea',
-            'description'   => 'Borea is a leading connected vehicle platform, helping our customers turn data about vehicles and their use into intelligence',
-            'logo_url'      => 'https:\/\/storage.googleapis.com\/telematics-directory-production\/silent-passanger555555.png',
-            'website_url'   => 'https:\/\/www.borea.com\/',
-            'api_docs_url'  => 'https:\/\/www.borea.com\/docs\/',
-            'is_integrated' => true,
-            'size'          => 'regional',
-            'features'      => [
-                0 => [
-                    'id'            => '1',
-                    'name'          => 'Customizable Reports',
-                    'slug'          => 'customizable-reports',
-                    'feature_group' => 'Analytics & Reporting'
-                ],
-                1 => [
-                    'id'            => '2',
-                    'name'          => 'Publicly Accessible API Documention',
-                    'slug'          => 'publicly-accessible-api-doc',
-                    'feature_group' => 'API & SDK'
-                ]
-            ],
-            'countries' => [
-                0 => [
-                    'id'            => '38',
-                    'country_code'  => 'CA',
-                    'country_name'  => 'Canada'
-                ],
-                1 => [
-                    'id'            => '230',
-                    'country_code'  => 'USA',
-                    'country_name'  => 'United States'
-                ]
-            ]
-        ]);
-
-        $this->assertEquals(14, $vendorParameters->id);
-        $this->assertEquals('Borea', $vendorParameters->name);
-        $this->assertEquals('borea', $vendorParameters->slug);
-        $this->assertEquals(
-            'Borea is a leading connected vehicle platform, helping our customers turn data about vehicles and their use into intelligence',
-            $vendorParameters->description
-        );
-        $this->assertEquals(
-            'https:\/\/storage.googleapis.com\/telematics-directory-production\/silent-passanger555555.png',
-            $vendorParameters->logo_url
-        );
-        $this->assertEquals('https:\/\/www.borea.com\/', $vendorParameters->website_url);
-        $this->assertEquals('https:\/\/www.borea.com\/docs\/', $vendorParameters->api_docs_url);
-        $this->assertEquals(true, $vendorParameters->is_integrated);
-        $this->assertEquals('regional', $vendorParameters->size);
-        $this->assertEquals(
-            [
-                0 => [
-                    'id'            => '1',
-                    'name'          => 'Customizable Reports',
-                    'slug'          => 'customizable-reports',
-                    'feature_group' => 'Analytics & Reporting'
-                ],
-                1 => [
-                    'id'            => '2',
-                    'name'          => 'Publicly Accessible API Documention',
-                    'slug'          => 'publicly-accessible-api-doc',
-                    'feature_group' => 'API & SDK'
-                ]
-            ],
-            $vendorParameters->features
-        );
-        $this->assertEquals(
-            [
-                0 => [
-                    'id'            => '38',
-                    'country_code'  => 'CA',
-                    'country_name'  => 'Canada'
-                ],
-                1 => [
-                    'id'            => '230',
-                    'country_code'  => 'USA',
-                    'country_name'  => 'United States'
-                ]
-            ],
-            $vendorParameters->countries
-        );
-
-        $this->assertEquals($vendorParameters->toArray(),
-            [
-                'id'            => 14,
-                'name'          => 'Borea',
-                'slug'          => 'borea',
-                'description'   => 'Borea is a leading connected vehicle platform, helping our customers turn data about vehicles and their use into intelligence',
-                'logo_url'      => 'https:\/\/storage.googleapis.com\/telematics-directory-production\/silent-passanger555555.png',
-                'website_url'   => 'https:\/\/www.borea.com\/',
-                'api_docs_url'  => 'https:\/\/www.borea.com\/docs\/',
-                'is_integrated' => true,
-                'size'          => 'regional',
-                'features'      => [
-                    0 => [
-                        'id'            => '1',
-                        'name'          => 'Customizable Reports',
-                        'slug'          => 'customizable-reports',
-                        'feature_group' => 'Analytics & Reporting'
-                    ],
-                    1 => [
-                        'id'            => '2',
-                        'name'          => 'Publicly Accessible API Documention',
-                        'slug'          => 'publicly-accessible-api-doc',
-                        'feature_group' => 'API & SDK'
-                    ]
-                ],
-                'countries' => [
-                    0 => [
-                        'id'            => '38',
-                        'country_code'  => 'CA',
-                        'country_name'  => 'Canada'
-                    ],
-                    1 => [
-                        'id'            => '230',
-                        'country_code'  => 'USA',
-                        'country_name'  => 'United States'
-                    ]
-                ]
-            ]
-        );
-    }
-
-    public function testGetAllVendors()
-    {
-        $vendorsParameters = TelematicsVendor::fromArray( [ ] );
-
-        $vendors = new TelematicsVendor();
-        $vendorsResults = $vendors->GetTelematicsVendors($vendorsParameters);
-
-        $this->assertNotNull($vendorsResults);
-        $this->assertTrue(is_array($vendorsResults));
-        $this->assertTrue(sizeof($vendorsResults)>0);
-        $this->assertInstanceOf(
-            TelematicsVendor::class,
-            TelematicsVendor::fromArray($vendorsResults['vendors'][0])
-        );
-    }
-
-    public function testGetVendor()
-    {
-        $vendorResult = TelematicsVendor::getVendorById(self::$tomtom_vendor->id);
-
-        $this->assertNotNull($vendorResult);
-        $this->assertTrue(is_array($vendorResult));
-        $this->assertInstanceOf(
-            TelematicsVendor::class,
-            TelematicsVendor::fromArray($vendorResult)
-        );
-    }
-
-    public function testSearchVendors()
-    {
-        $vendorsParameters = TelematicsVendorParameters::fromArray([
-            //"country"     => "GB",  // uncomment this line for searching by Country
-            'is_integrated' => 1,
-            //"feature"     => "satellite",  // uncomment this line for searching by Feature
-            'search'        => 'Fleet',
-            'page'          => 1,
-            'per_page'      => 5,
-        ]);
-
-        $vendors = new TelematicsVendor();
-        $vendorsResults = $vendors->GetTelematicsVendors($vendorsParameters);
-
-        $this->assertNotNull($vendorsResults);
-        $this->assertTrue(is_array($vendorsResults));
-        $this->assertTrue(sizeof($vendorsResults)>0);
-        $this->assertInstanceOf(
-            TelematicsVendor::class,
-            TelematicsVendor::fromArray($vendorsResults['vendors'][0])
-        );
-    }
-
-    public function testVendorsComparison()
-    {
-        $vendorsParameters = TelematicsVendorParameters::fromArray([
-            'vendors' => '55,56,57',
-        ]);
-
-        $vendors = new TelematicsVendor();
-        $comparisonResults = $vendors->GetTelematicsVendors($vendorsParameters);
-
-        $this->assertNotNull($comparisonResults);
-        $this->assertTrue(is_array($comparisonResults));
-        $this->assertTrue(sizeof($comparisonResults)>0);
-        $this->assertInstanceOf(
-            TelematicsVendor::class,
-            TelematicsVendor::fromArray($comparisonResults['vendors'][0])
-        );
-    }
+		print_r("\n member_id = ".self::$firstMemberId."\n");
+
+		//region Get API token
+
+		$vendorParameters = new TelematicsVendorParameters();
+		$vendorParameters->member_id = self::$firstMemberId;
+		$vendorParameters->api_key = Constants::API_KEY;
+
+		$vendors = new TelematicsVendor();
+		$result = $vendors->RegisterTelematicsMember($vendorParameters);
+
+		self::assertNotNull($result);
+		self::assertInstanceOf(
+			TelematicsRegisterMemberResponse::class,
+			TelematicsRegisterMemberResponse::fromArray($result)
+		);
+
+		self::$api_token = TelematicsRegisterMemberResponse::fromArray(
+			$result
+		)->api_token;
+
+		//endregion
+
+		//region Get TomTom vendor
+
+		$vendorsParameters = TelematicsVendorParameters::fromArray([
+			//"country"     => "GB",  // uncomment this line for searching by Country
+			'is_integrated' => 1,
+			//"feature"     => "satellite",  // uncomment this line for searching by Feature
+			'search'        => 'tomtom',
+			'page'          => 1,
+			'per_page'      => 5,
+		]);
+
+		$vendors = new TelematicsVendor();
+		$vendorsResults = $vendors->GetTelematicsVendors($vendorsParameters);
+
+		self::assertNotNull($vendorsResults);
+		self::assertTrue(is_array($vendorsResults));
+		self::assertTrue(sizeof($vendorsResults)>0);
+		self::assertTrue(
+			TelematicsVendor::fromArray($vendorsResults['vendors'][0])
+				instanceof
+				TelematicsVendor);
+
+		self::$tomtom_vendor = TelematicsVendor::fromArray($vendorsResults['vendors'][0]);
+		//endregion
+
+		//region Create Test Connection
+
+		$vendParams = new TelematicsConnectionParameters();
+
+		$vendParams->vendor       = TelematicsVendorsTypes::GEOTAB;
+		$vendParams->account_id   = '54321';
+		$vendParams->username     = 'John Doe 0';
+		$vendParams->password     = 'password0';
+		$vendParams->vehicle_position_refresh_rate    = 60;
+		$vendParams->name         = 'Test Geotab Connection from php SDK';
+		$vendParams->validate_remote_credentials      = 0;
+
+		$teleConnection = new TelematicsConnection();
+
+		$result2 = $teleConnection->createTelematicsConnection(
+			self::$api_token,
+			$vendParams->toArray()
+		);
+
+		self::assertNotNull($result2);
+		self::assertTrue( CreateConnectionResponse::fromArray($result2) instanceof CreateConnectionResponse);
+
+		self::$createdConnections[] = TelematicsConnection::fromArray($result2);
+		//endregion
+	}
+
+	public function testFromArray()
+	{
+		$vendorParameters = TelematicsVendor::fromArray([
+			'id'            => 14,
+			'name'          => 'Borea',
+			'slug'          => 'borea',
+			'description'   => 'Borea is a leading connected vehicle platform, helping our customers turn data about vehicles and their use into intelligence',
+			'logo_url'      => 'https:\/\/storage.googleapis.com\/telematics-directory-production\/silent-passanger555555.png',
+			'website_url'   => 'https:\/\/www.borea.com\/',
+			'api_docs_url'  => 'https:\/\/www.borea.com\/docs\/',
+			'is_integrated' => true,
+			'size'          => 'regional',
+			'features'      => [
+				0 => [
+					'id'    => '1',
+					'name'  => 'Customizable Reports',
+					'slug'  => 'customizable-reports',
+					'feature_group' => 'Analytics & Reporting'
+				],
+				1 => [
+					'id'            => '2',
+					'name'          => 'Publicly Accessible API Documention',
+					'slug'          => 'publicly-accessible-api-doc',
+					'feature_group' => 'API & SDK'
+				]
+			],
+			'countries' => [
+				0 => [
+					'id'            => '38',
+					'country_code'  => 'CA',
+					'country_name'  => 'Canada'
+				],
+				1 => [
+					'id'            => '230',
+					'country_code'  => 'USA',
+					'country_name'  => 'United States'
+				]
+			]
+		]);
+
+		$this->assertEquals(14, $vendorParameters->id);
+		$this->assertEquals('Borea', $vendorParameters->name);
+		$this->assertEquals('borea', $vendorParameters->slug);
+		$this->assertEquals(
+			'Borea is a leading connected vehicle platform, helping our customers turn data about vehicles and their use into intelligence',
+			$vendorParameters->description
+		);
+		$this->assertEquals(
+			'https:\/\/storage.googleapis.com\/telematics-directory-production\/silent-passanger555555.png',
+			$vendorParameters->logo_url
+		);
+		$this->assertEquals('https:\/\/www.borea.com\/', $vendorParameters->website_url);
+		$this->assertEquals('https:\/\/www.borea.com\/docs\/', $vendorParameters->api_docs_url);
+		$this->assertEquals(true, $vendorParameters->is_integrated);
+		$this->assertEquals('regional', $vendorParameters->size);
+		$this->assertEquals(
+			[
+				0 => [
+					'id'            => '1',
+					'name'          => 'Customizable Reports',
+					'slug'          => 'customizable-reports',
+					'feature_group' => 'Analytics & Reporting'
+				],
+				1 => [
+					'id'            => '2',
+					'name'          => 'Publicly Accessible API Documention',
+					'slug'          => 'publicly-accessible-api-doc',
+					'feature_group' => 'API & SDK'
+				]
+			],
+			$vendorParameters->features
+		);
+		$this->assertEquals(
+			[
+				0 => [
+					'id'            => '38',
+					'country_code'  => 'CA',
+					'country_name'  => 'Canada'
+				],
+				1 => [
+					'id'            => '230',
+					'country_code'  => 'USA',
+					'country_name'  => 'United States'
+				]
+			],
+			$vendorParameters->countries
+		);
+	}
+
+	public function testToArray()
+	{
+		$vendorParameters = TelematicsVendor::fromArray([
+			'id'            => 14,
+			'name'          => 'Borea',
+			'slug'          => 'borea',
+			'description'   => 'Borea is a leading connected vehicle platform, helping our customers turn data about vehicles and their use into intelligence',
+			'logo_url'      => 'https:\/\/storage.googleapis.com\/telematics-directory-production\/silent-passanger555555.png',
+			'website_url'   => 'https:\/\/www.borea.com\/',
+			'api_docs_url'  => 'https:\/\/www.borea.com\/docs\/',
+			'is_integrated' => true,
+			'size'          => 'regional',
+			'features'      => [
+				0 => [
+					'id'            => '1',
+					'name'          => 'Customizable Reports',
+					'slug'          => 'customizable-reports',
+					'feature_group' => 'Analytics & Reporting'
+				],
+				1 => [
+					'id'            => '2',
+					'name'          => 'Publicly Accessible API Documention',
+					'slug'          => 'publicly-accessible-api-doc',
+					'feature_group' => 'API & SDK'
+				]
+			],
+			'countries' => [
+				0 => [
+					'id'            => '38',
+					'country_code'  => 'CA',
+					'country_name'  => 'Canada'
+				],
+				1 => [
+					'id'            => '230',
+					'country_code'  => 'USA',
+					'country_name'  => 'United States'
+				]
+			]
+		]);
+
+		$this->assertEquals(14, $vendorParameters->id);
+		$this->assertEquals('Borea', $vendorParameters->name);
+		$this->assertEquals('borea', $vendorParameters->slug);
+		$this->assertEquals(
+			'Borea is a leading connected vehicle platform, helping our customers turn data about vehicles and their use into intelligence',
+			$vendorParameters->description
+		);
+		$this->assertEquals(
+			'https:\/\/storage.googleapis.com\/telematics-directory-production\/silent-passanger555555.png',
+			$vendorParameters->logo_url
+		);
+		$this->assertEquals('https:\/\/www.borea.com\/', $vendorParameters->website_url);
+		$this->assertEquals('https:\/\/www.borea.com\/docs\/', $vendorParameters->api_docs_url);
+		$this->assertEquals(true, $vendorParameters->is_integrated);
+		$this->assertEquals('regional', $vendorParameters->size);
+		$this->assertEquals(
+			[
+				0 => [
+					'id'            => '1',
+					'name'          => 'Customizable Reports',
+					'slug'          => 'customizable-reports',
+					'feature_group' => 'Analytics & Reporting'
+				],
+				1 => [
+					'id'            => '2',
+					'name'          => 'Publicly Accessible API Documention',
+					'slug'          => 'publicly-accessible-api-doc',
+					'feature_group' => 'API & SDK'
+				]
+			],
+			$vendorParameters->features
+		);
+		$this->assertEquals(
+			[
+				0 => [
+					'id'            => '38',
+					'country_code'  => 'CA',
+					'country_name'  => 'Canada'
+				],
+				1 => [
+					'id'            => '230',
+					'country_code'  => 'USA',
+					'country_name'  => 'United States'
+				]
+			],
+			$vendorParameters->countries
+		);
+
+		$this->assertEquals($vendorParameters->toArray(),
+			[
+				'id'            => 14,
+				'name'          => 'Borea',
+				'slug'          => 'borea',
+				'description'   => 'Borea is a leading connected vehicle platform, helping our customers turn data about vehicles and their use into intelligence',
+				'logo_url'      => 'https:\/\/storage.googleapis.com\/telematics-directory-production\/silent-passanger555555.png',
+				'website_url'   => 'https:\/\/www.borea.com\/',
+				'api_docs_url'  => 'https:\/\/www.borea.com\/docs\/',
+				'is_integrated' => true,
+				'size'          => 'regional',
+				'features'      => [
+					0 => [
+						'id'            => '1',
+						'name'          => 'Customizable Reports',
+						'slug'          => 'customizable-reports',
+						'feature_group' => 'Analytics & Reporting'
+					],
+					1 => [
+						'id'            => '2',
+						'name'          => 'Publicly Accessible API Documention',
+						'slug'          => 'publicly-accessible-api-doc',
+						'feature_group' => 'API & SDK'
+					]
+				],
+				'countries' => [
+					0 => [
+						'id'            => '38',
+						'country_code'  => 'CA',
+						'country_name'  => 'Canada'
+					],
+					1 => [
+						'id'            => '230',
+						'country_code'  => 'USA',
+						'country_name'  => 'United States'
+					]
+				]
+			]
+		);
+	}
+
+	public function testGetAllVendors()
+	{
+		$vendorsParameters = TelematicsVendor::fromArray( [ ] );
+
+		$vendors = new TelematicsVendor();
+		$vendorsResults = $vendors->GetTelematicsVendors($vendorsParameters);
+
+		$this->assertNotNull($vendorsResults);
+		$this->assertTrue(is_array($vendorsResults));
+		$this->assertTrue(sizeof($vendorsResults)>0);
+		$this->assertInstanceOf(
+			TelematicsVendor::class,
+			TelematicsVendor::fromArray($vendorsResults['vendors'][0])
+		);
+	}
+
+	public function testGetVendor()
+	{
+		$vendorResult = TelematicsVendor::getVendorById(self::$tomtom_vendor->id);
+
+		$this->assertNotNull($vendorResult);
+		$this->assertTrue(is_array($vendorResult));
+		$this->assertInstanceOf(
+			TelematicsVendor::class,
+			TelematicsVendor::fromArray($vendorResult)
+		);
+	}
+
+	public function testSearchVendors()
+	{
+		$vendorsParameters = TelematicsVendorParameters::fromArray([
+			//"country"     => "GB",  // uncomment this line for searching by Country
+			'is_integrated' => 1,
+			//"feature"     => "satellite",  // uncomment this line for searching by Feature
+			'search'        => 'Fleet',
+			'page'          => 1,
+			'per_page'      => 5,
+		]);
+
+		$vendors = new TelematicsVendor();
+		$vendorsResults = $vendors->GetTelematicsVendors($vendorsParameters);
+
+		$this->assertNotNull($vendorsResults);
+		$this->assertTrue(is_array($vendorsResults));
+		$this->assertTrue(sizeof($vendorsResults)>0);
+		$this->assertInstanceOf(
+			TelematicsVendor::class,
+			TelematicsVendor::fromArray($vendorsResults['vendors'][0])
+		);
+	}
+
+	public function testVendorsComparison()
+	{
+		$vendorsParameters = TelematicsVendorParameters::fromArray([
+			'vendors' => '55,56,57',
+		]);
+
+		$vendors = new TelematicsVendor();
+		$comparisonResults = $vendors->GetTelematicsVendors($vendorsParameters);
+
+		$this->assertNotNull($comparisonResults);
+		$this->assertTrue(is_array($comparisonResults));
+		$this->assertTrue(sizeof($comparisonResults)>0);
+		$this->assertInstanceOf(
+			TelematicsVendor::class,
+			TelematicsVendor::fromArray($comparisonResults['vendors'][0])
+		);
+	}
     
-    public function testRegisterTelematicsVendor() 
-    {
-        $vendorParameters = new TelematicsVendorParameters();
-        $vendorParameters->member_id = self::$firstMemberId;
-        $vendorParameters->api_key = Constants::API_KEY;
+	public function testRegisterTelematicsVendor() 
+	{
+		$vendorParameters = new TelematicsVendorParameters();
+		$vendorParameters->member_id = self::$firstMemberId;
+		$vendorParameters->api_key = Constants::API_KEY;
         
-        $vendors = new TelematicsVendor();
-        $result = $vendors->RegisterTelematicsMember($vendorParameters);
+		$vendors = new TelematicsVendor();
+		$result = $vendors->RegisterTelematicsMember($vendorParameters);
         
-        $this->assertNotNull($result);
-        $this->assertInstanceOf(
-            TelematicsRegisterMemberResponse::class,
-            TelematicsRegisterMemberResponse::fromArray($result)
-        );
-    }
-
-    public function testGetTelematicsConnections()
-    {
-        $teleConnection = new TelematicsConnection();
-
-        $connections = $teleConnection->getTelematicsConnections(self::$api_token);
-
-        $this->assertNotNull($connections);
-        $this->assertTrue(
-            TelematicsConnection::fromArray($connections[0])
-            instanceof
-            TelematicsConnection);
-    }
-
-    public function testGetTelematicsConnection()
-    {
-        $teleConnection = new TelematicsConnection();
-
-        $connection = $teleConnection->getTelematicsConnection(
-            self::$api_token,
-            self::$createdConnections[sizeof(self::$createdConnections)-1]->connection_token
-        );
-
-        $this->assertNotNull($connection);
-        $this->assertTrue(
-            TelematicsConnection::fromArray($connection)
-            instanceof
-            TelematicsConnection);
-    }
-
-    public function testCreateTelematicsConnection()
-    {
-        $vendorParameters = new TelematicsConnectionParameters();
-
-        $vendorParameters->vendor_id    = self::$tomtom_vendor->id;
-        $vendorParameters->vendor       = self::$tomtom_vendor->slug;
-        $vendorParameters->account_id   = '12345';
-        $vendorParameters->username     = 'John Doe';
-        $vendorParameters->password     = 'password';
-        $vendorParameters->vehicle_position_refresh_rate    = 60;
-        $vendorParameters->name         = 'Test Telematics Connection from php SDK';
-        $vendorParameters->validate_remote_credentials      = 0;
-
-        $teleConnection = new TelematicsConnection();
-
-       $result = $teleConnection->createTelematicsConnection(
-           self::$api_token,
-           $vendorParameters->toArray()
-       );
-
-        $this->assertNotNull($result);
-        $this->assertTrue( CreateConnectionResponse::fromArray($result) instanceof CreateConnectionResponse);
-
-        self::$createdConnections[] = TelematicsConnection::fromArray($result);
-    }
-
-    public function testUpdateTelematicsConnection()
-    {
-        $teleConParams = new TelematicsConnectionParameters();
-
-        $teleConParams->vehicle_position_refresh_rate    = 50;
-        $teleConParams->name         = 'Test Telematics Connection from php SDK Updated';
-        $teleConParams->validate_remote_credentials      = 0;
-
-        $teleConnection = new TelematicsConnection();
-
-        $result = $teleConnection->updateTelematicsConnection(
-            self::$api_token,
-            self::$createdConnections[0]->connection_token,
-            $teleConParams->toArray()
-        );
-
-        $this->assertNotNull($result);
-        $this->assertTrue(
-            TelematicsConnection::fromArray($result)
-            instanceof
-            TelematicsConnection);
-    }
-
-    public static function tearDownAfterClass()
-    {
-        if (sizeof(self::$createdConnections)>0) {
-
-            $teleConn = new TelematicsConnection();
-
-            foreach (self::$createdConnections as $createdConn) {
-                $deleted = $teleConn->deleteTelematicsConnection(
-                    self::$api_token,
-                    $createdConn->connection_token
-                );
-            }
-        }
-    }
+		$this->assertNotNull($result);
+		$this->assertInstanceOf(
+			TelematicsRegisterMemberResponse::class,
+			TelematicsRegisterMemberResponse::fromArray($result)
+		);
+	}
+
+	public function testGetTelematicsConnections()
+	{
+		$teleConnection = new TelematicsConnection();
+
+		$connections = $teleConnection->getTelematicsConnections(self::$api_token);
+
+		$this->assertNotNull($connections);
+		$this->assertTrue(
+			TelematicsConnection::fromArray($connections[0])
+			instanceof
+			TelematicsConnection);
+	}
+
+	public function testGetTelematicsConnection()
+	{
+		$teleConnection = new TelematicsConnection();
+
+		$connection = $teleConnection->getTelematicsConnection(
+			self::$api_token,
+			self::$createdConnections[sizeof(self::$createdConnections)-1]->connection_token
+		);
+
+		$this->assertNotNull($connection);
+		$this->assertTrue(
+			TelematicsConnection::fromArray($connection)
+			instanceof
+			TelematicsConnection);
+	}
+
+	public function testCreateTelematicsConnection()
+	{
+		$vendorParameters = new TelematicsConnectionParameters();
+
+		$vendorParameters->vendor_id    = self::$tomtom_vendor->id;
+		$vendorParameters->vendor       = self::$tomtom_vendor->slug;
+		$vendorParameters->account_id   = '12345';
+		$vendorParameters->username     = 'John Doe';
+		$vendorParameters->password     = 'password';
+		$vendorParameters->vehicle_position_refresh_rate    = 60;
+		$vendorParameters->name         = 'Test Telematics Connection from php SDK';
+		$vendorParameters->validate_remote_credentials      = 0;
+
+		$teleConnection = new TelematicsConnection();
+
+	   $result = $teleConnection->createTelematicsConnection(
+		   self::$api_token,
+		   $vendorParameters->toArray()
+	   );
+
+		$this->assertNotNull($result);
+		$this->assertTrue( CreateConnectionResponse::fromArray($result) instanceof CreateConnectionResponse);
+
+		self::$createdConnections[] = TelematicsConnection::fromArray($result);
+	}
+
+	public function testUpdateTelematicsConnection()
+	{
+		$teleConParams = new TelematicsConnectionParameters();
+
+		$teleConParams->vehicle_position_refresh_rate    = 50;
+		$teleConParams->name         = 'Test Telematics Connection from php SDK Updated';
+		$teleConParams->validate_remote_credentials      = 0;
+
+		$teleConnection = new TelematicsConnection();
+
+		$result = $teleConnection->updateTelematicsConnection(
+			self::$api_token,
+			self::$createdConnections[0]->connection_token,
+			$teleConParams->toArray()
+		);
+
+		$this->assertNotNull($result);
+		$this->assertTrue(
+			TelematicsConnection::fromArray($result)
+			instanceof
+			TelematicsConnection);
+	}
+
+	public static function tearDownAfterClass()
+	{
+		if (sizeof(self::$createdConnections)>0) {
+
+			$teleConn = new TelematicsConnection();
+
+			foreach (self::$createdConnections as $createdConn) {
+				$deleted = $teleConn->deleteTelematicsConnection(
+					self::$api_token,
+					$createdConn->connection_token
+				);
+			}
+		}
+	}
 
 }
\ No newline at end of file

UnitTestFiles/Test/MemberConfigurationTest.php

Indentation +162 added lines, -162 removed lines

@@ -10,187 +10,187 @@
 
 class MemberConfigurationTest extends \PHPUnit\Framework\TestCase
 {
-    public static $createdConfigurationKeys;
-
-    public static function setUpBeforeClass()
-    {
-        Route4Me::setApiKey(Constants::API_KEY);
+	public static $createdConfigurationKeys;
+
+	public static function setUpBeforeClass()
+	{
+		Route4Me::setApiKey(Constants::API_KEY);
 
-        $memberConfiguration = new MemberConfiguration();
+		$memberConfiguration = new MemberConfiguration();
 
-        $query = [
-            'config_key' => 'Test My weight'
-        ];
-
-        $removed = $memberConfiguration->RemoveConfigurationData($query, $errorText);
+		$query = [
+			'config_key' => 'Test My weight'
+		];
+
+		$removed = $memberConfiguration->RemoveConfigurationData($query, $errorText);
 
-        $memberConfiguration->config_key = 'Test My height';
-        $memberConfiguration->config_value = '180';
-
-        $result = $memberConfiguration->CreateNewConfigurationData($memberConfiguration->toArray(), $errorText);
+		$memberConfiguration->config_key = 'Test My height';
+		$memberConfiguration->config_value = '180';
+
+		$result = $memberConfiguration->CreateNewConfigurationData($memberConfiguration->toArray(), $errorText);
 
-        if(isset($result['affected']) && $result['affected']==1) {
-            self::$createdConfigurationKeys[] = 'Test My height';
-        } else {
-            echo "$errorText <br>";
-        }
-    }
+		if(isset($result['affected']) && $result['affected']==1) {
+			self::$createdConfigurationKeys[] = 'Test My height';
+		} else {
+			echo "$errorText <br>";
+		}
+	}
 
-    public function testConfigurationMemberFromArray()
-    {
-        $memberConfiguration = MemberConfiguration::fromArray([
-            'member_id'     =>  444444,
-            'config_key'    =>  'test_key',
-            'config_value'  =>  'test_value'
-        ]);
+	public function testConfigurationMemberFromArray()
+	{
+		$memberConfiguration = MemberConfiguration::fromArray([
+			'member_id'     =>  444444,
+			'config_key'    =>  'test_key',
+			'config_value'  =>  'test_value'
+		]);
 
-        $this->assertEquals($memberConfiguration->member_id, 444444 ,"member_id != 444444");
-        $this->assertEquals($memberConfiguration->config_key, 'test_key' ,"config_key != 'test_key'");
-        $this->assertEquals($memberConfiguration->config_value, 'test_value' ,"config_value != 'test_value'");
-    }
+		$this->assertEquals($memberConfiguration->member_id, 444444 ,"member_id != 444444");
+		$this->assertEquals($memberConfiguration->config_key, 'test_key' ,"config_key != 'test_key'");
+		$this->assertEquals($memberConfiguration->config_value, 'test_value' ,"config_value != 'test_value'");
+	}
 
-    public function testToArray()
-    {
-        $memberConfiguration = MemberConfiguration::fromArray([
-            'member_id'     =>  444444,
-            'config_key'    =>  'test_key',
-            'config_value'  =>  'test_value'
-        ]);
+	public function testToArray()
+	{
+		$memberConfiguration = MemberConfiguration::fromArray([
+			'member_id'     =>  444444,
+			'config_key'    =>  'test_key',
+			'config_value'  =>  'test_value'
+		]);
 
-        $this->assertEquals($memberConfiguration->toArray(), [
-            'member_id'     =>  444444,
-            'config_key'    =>  'test_key',
-            'config_value'  =>  'test_value'
-         ]);
-    }
+		$this->assertEquals($memberConfiguration->toArray(), [
+			'member_id'     =>  444444,
+			'config_key'    =>  'test_key',
+			'config_value'  =>  'test_value'
+		 ]);
+	}
 
-    public function testBadParameter()
-    {
-        $this->expectException(BadParam::class);
+	public function testBadParameter()
+	{
+		$this->expectException(BadParam::class);
 
-        $memberConfiguration = MemberConfiguration::fromArray([
-            'memberID'   => 44444444,
-            'config_kkk' => 'test_key'
-        ]);
+		$memberConfiguration = MemberConfiguration::fromArray([
+			'memberID'   => 44444444,
+			'config_kkk' => 'test_key'
+		]);
 
-        echo "memberConfiguration: ".$memberConfiguration->memberID." <br>";
-    }
+		echo "memberConfiguration: ".$memberConfiguration->memberID." <br>";
+	}
 
-    public function testGetAllConfigurationData()
-    {
-        $memberConfiguration = new MemberConfiguration();
+	public function testGetAllConfigurationData()
+	{
+		$memberConfiguration = new MemberConfiguration();
 
-        $result = $memberConfiguration->GetConfigurationData();
-
-        $this->assertNotNull($result);
-        $this->assertTrue(isset($result['result']), "Wrong response for member configuration data.");
-        $this->assertEquals($result['result'], "OK", "Cannot retrieve the member configuration data.");
-    }
+		$result = $memberConfiguration->GetConfigurationData();
+
+		$this->assertNotNull($result);
+		$this->assertTrue(isset($result['result']), "Wrong response for member configuration data.");
+		$this->assertEquals($result['result'], "OK", "Cannot retrieve the member configuration data.");
+	}
 
-    public function testGetSpecificConfigurationKeyData()
-    {
-        $memberConfiguration = new MemberConfiguration();
-
-        $allData = $memberConfiguration->GetConfigurationData();
-
-        $this->assertNotNull($allData);
-        $this->assertTrue(isset($allData['data']), "Wrong response for member configuration data.");
-        $this->assertTrue(sizeof($allData['data'])>0, "Retrieved member data size <1");
-
-        $query = [
-            'config_key' => $allData['data'][0]['config_key']
-        ];
-
-        $result = $memberConfiguration->GetConfigurationData($query);
-
-        $this->assertNotNull($result);
-        $this->assertTrue(isset($result['data']), "Wrong response for member configuration data.");
-        $this->assertTrue(sizeof($result['data'])==1, "Retrieved member data size != 1");
-        $this->assertEquals($result['data'][0]['config_key'], $allData['data'][0]['config_key']);
-    }
-
-    public function testCreateConfigurationData()
-    {
-        $memberConfiguration = new MemberConfiguration();
-
-        $memberConfiguration->config_key = 'Test My weight';
-        $memberConfiguration->config_value = '100';
-
-        $result = $memberConfiguration->CreateNewConfigurationData($memberConfiguration->toArray(), $errorText);
-
-        $this->assertNotNull($result);
-        $this->assertTrue(isset($result['result']), "Wrong response for member configuration data.");
-        $this->assertTrue(isset($result['affected']), "Wrong response for member configuration data.");
-        $this->assertEquals(1, $result['affected'], "Cannot create new member configuration data <br> $errorText");
-
-        if($result['affected']==1) {
-            self::$createdConfigurationKeys[] = 'Test My weight';
-        }
-    }
-
-    public function testUpdateConfigurationData()
-    {
-        $memberConfiguration = new MemberConfiguration();
-
-        $memberConfiguration->config_key = 'Test My height';
-        $memberConfiguration->config_value = '120';
-
-        $result = $memberConfiguration->UpdateConfigurationData($memberConfiguration->toArray(), $errorText);
-
-        $this->assertNotNull($result);
-        $this->assertTrue(isset($result['result']), "Wrong response for member configuration data.");
-        $this->assertTrue(isset($result['affected']), "Wrong response for member configuration data.");
-        $this->assertEquals(1, $result['affected'], "Cannot update member configuration data <br> $errorText");
-
-        $query = [
-            'config_key' => 'Test My height'
-        ];
-
-        $updatedResult = $memberConfiguration->GetConfigurationData($query);
-
-        $this->assertNotNull($updatedResult);
-        $this->assertTrue(isset($updatedResult['data']), "Wrong response for member configuration data.");
-        $this->assertTrue(sizeof($updatedResult['data'])==1, "Retrieved member data size != 1");
-        $this->assertEquals('120', $updatedResult['data'][0]['config_value'], "The config value is not updated");
-    }
-
-    public function testRemoveConfigurationData()
-    {
-        $memberConfiguration = new MemberConfiguration();
-
-        $query = [
-            'config_key' => 'Test My height'
-        ];
+	public function testGetSpecificConfigurationKeyData()
+	{
+		$memberConfiguration = new MemberConfiguration();
+
+		$allData = $memberConfiguration->GetConfigurationData();
+
+		$this->assertNotNull($allData);
+		$this->assertTrue(isset($allData['data']), "Wrong response for member configuration data.");
+		$this->assertTrue(sizeof($allData['data'])>0, "Retrieved member data size <1");
+
+		$query = [
+			'config_key' => $allData['data'][0]['config_key']
+		];
+
+		$result = $memberConfiguration->GetConfigurationData($query);
+
+		$this->assertNotNull($result);
+		$this->assertTrue(isset($result['data']), "Wrong response for member configuration data.");
+		$this->assertTrue(sizeof($result['data'])==1, "Retrieved member data size != 1");
+		$this->assertEquals($result['data'][0]['config_key'], $allData['data'][0]['config_key']);
+	}
+
+	public function testCreateConfigurationData()
+	{
+		$memberConfiguration = new MemberConfiguration();
+
+		$memberConfiguration->config_key = 'Test My weight';
+		$memberConfiguration->config_value = '100';
+
+		$result = $memberConfiguration->CreateNewConfigurationData($memberConfiguration->toArray(), $errorText);
+
+		$this->assertNotNull($result);
+		$this->assertTrue(isset($result['result']), "Wrong response for member configuration data.");
+		$this->assertTrue(isset($result['affected']), "Wrong response for member configuration data.");
+		$this->assertEquals(1, $result['affected'], "Cannot create new member configuration data <br> $errorText");
+
+		if($result['affected']==1) {
+			self::$createdConfigurationKeys[] = 'Test My weight';
+		}
+	}
+
+	public function testUpdateConfigurationData()
+	{
+		$memberConfiguration = new MemberConfiguration();
+
+		$memberConfiguration->config_key = 'Test My height';
+		$memberConfiguration->config_value = '120';
+
+		$result = $memberConfiguration->UpdateConfigurationData($memberConfiguration->toArray(), $errorText);
+
+		$this->assertNotNull($result);
+		$this->assertTrue(isset($result['result']), "Wrong response for member configuration data.");
+		$this->assertTrue(isset($result['affected']), "Wrong response for member configuration data.");
+		$this->assertEquals(1, $result['affected'], "Cannot update member configuration data <br> $errorText");
+
+		$query = [
+			'config_key' => 'Test My height'
+		];
+
+		$updatedResult = $memberConfiguration->GetConfigurationData($query);
+
+		$this->assertNotNull($updatedResult);
+		$this->assertTrue(isset($updatedResult['data']), "Wrong response for member configuration data.");
+		$this->assertTrue(sizeof($updatedResult['data'])==1, "Retrieved member data size != 1");
+		$this->assertEquals('120', $updatedResult['data'][0]['config_value'], "The config value is not updated");
+	}
+
+	public function testRemoveConfigurationData()
+	{
+		$memberConfiguration = new MemberConfiguration();
+
+		$query = [
+			'config_key' => 'Test My height'
+		];
 
-        $removed = $memberConfiguration->RemoveConfigurationData($query, $errorText);
+		$removed = $memberConfiguration->RemoveConfigurationData($query, $errorText);
 
-        echo (isset($removed['affected']) && $removed['affected']==1)
-            ? "The config data with key 'Test My height' removed"
-            : "The config data with key 'Test My height' cannot remove - ".$errorText;
+		echo (isset($removed['affected']) && $removed['affected']==1)
+			? "The config data with key 'Test My height' removed"
+			: "The config data with key 'Test My height' cannot remove - ".$errorText;
 
-        $this->assertNotNull($removed);
-        $this->assertTrue(isset($removed['result']), "Wrong response for member configuration data.");
-        $this->assertTrue(isset($removed['affected']), "Wrong response for member configuration data.");
-        $this->assertEquals(1, $removed['affected'], "Cannot create new member configuration data");
+		$this->assertNotNull($removed);
+		$this->assertTrue(isset($removed['result']), "Wrong response for member configuration data.");
+		$this->assertTrue(isset($removed['affected']), "Wrong response for member configuration data.");
+		$this->assertEquals(1, $removed['affected'], "Cannot create new member configuration data");
 
-        if($removed['affected']==1) {
-            $key = array_search('Test My height', self::$createdConfigurationKeys);
-            array_splice(self::$createdConfigurationKeys, $key, 1);
-        }
-    }
+		if($removed['affected']==1) {
+			$key = array_search('Test My height', self::$createdConfigurationKeys);
+			array_splice(self::$createdConfigurationKeys, $key, 1);
+		}
+	}
 
-    public static function tearDownAfterClass()
-    {
-        $memberConfiguration = new MemberConfiguration();
+	public static function tearDownAfterClass()
+	{
+		$memberConfiguration = new MemberConfiguration();
 
-        if (sizeof(self::$createdConfigurationKeys)>0) {
-            foreach (self::$createdConfigurationKeys as $configKey) {
-                $removed = $memberConfiguration->RemoveConfigurationData(['config_key' => $configKey], $errorText);
+		if (sizeof(self::$createdConfigurationKeys)>0) {
+			foreach (self::$createdConfigurationKeys as $configKey) {
+				$removed = $memberConfiguration->RemoveConfigurationData(['config_key' => $configKey], $errorText);
 
-                echo (isset($removed['affected']) && $removed['affected']==1)
-                            ? "The config data with key '$configKey' removed"
-                            : "The config data with key '$configKey' cannot remove - ".$errorText;
-            }
-        }
-    }
+				echo (isset($removed['affected']) && $removed['affected']==1)
+							? "The config data with key '$configKey' removed"
+							: "The config data with key '$configKey' cannot remove - ".$errorText;
+			}
+		}
+	}
 }

UnitTestFiles/Test/CustomNoteTypeResponseUnitTests.php

Indentation +22 added lines, -22 removed lines

@@ -6,27 +6,27 @@
 
 class CustomNoteTypeResponseUnitTests extends \PHPUnit\Framework\TestCase
 {
-    public function testFromArray()
-    {
-        $customNoteTypeResponse = CustomNoteTypeResponse::fromArray([
-            'note_custom_type_id'       => 10,
-            'note_custom_type'          => 'Dropoff Location',
-            'root_owner_member_id'      => 1,
-            'note_custom_type_values'   => [
-                'Front door',
-                'Backdoor',
-                'Roof'
-            ]
-        ]);
+	public function testFromArray()
+	{
+		$customNoteTypeResponse = CustomNoteTypeResponse::fromArray([
+			'note_custom_type_id'       => 10,
+			'note_custom_type'          => 'Dropoff Location',
+			'root_owner_member_id'      => 1,
+			'note_custom_type_values'   => [
+				'Front door',
+				'Backdoor',
+				'Roof'
+			]
+		]);
 
-        $this->assertEquals(10, $customNoteTypeResponse->note_custom_type_id);
-        $this->assertEquals('Dropoff Location', $customNoteTypeResponse->note_custom_type);
-        $this->assertEquals(1, $customNoteTypeResponse->root_owner_member_id);
-        $this->assertEquals([
-                'Front door',
-                'Backdoor',
-                'Roof'
-            ],
-            $customNoteTypeResponse->note_custom_type_values);
-    }
+		$this->assertEquals(10, $customNoteTypeResponse->note_custom_type_id);
+		$this->assertEquals('Dropoff Location', $customNoteTypeResponse->note_custom_type);
+		$this->assertEquals(1, $customNoteTypeResponse->root_owner_member_id);
+		$this->assertEquals([
+				'Front door',
+				'Backdoor',
+				'Roof'
+			],
+			$customNoteTypeResponse->note_custom_type_values);
+	}
 }
\ No newline at end of file

UnitTestFiles/Test/OrderTests.php

Indentation +542 added lines, -542 removed lines

@@ -20,546 +20,546 @@
 
 class OrderTests extends \PHPUnit\Framework\TestCase
 {
-    public static $createdOrders = [];
-    public static $createdProblems = [];
-
-    public static function setUpBeforeClass()
-    {
-        Route4Me::setApiKey(Constants::API_KEY);
-
-        //region -- Create Test Optimization --
-
-        // Huge list of addresses
-        $json = json_decode(file_get_contents(dirname(__FILE__).'/data/addresses.json'), true);
-        $json = array_slice($json, 0, 10);
-
-        $addresses = [];
-        foreach ($json as $address) {
-            $addresses[] = Address::fromArray($address);
-        }
-
-        $parameters = RouteParameters::fromArray([
-            'algorithm_type'    => Algorithmtype::TSP,
-            'route_name'        => 'Single Driver Multiple TW 10 Stops '.date('Y-m-d H:i'),
-            'route_date'        => time() + 24 * 60 * 60,
-            'route_time'        => 5 * 3600 + 30 * 60,
-            'distance_unit'     => DistanceUnit::MILES,
-            'device_type'       => DeviceType::WEB,
-            'optimize'          => OptimizationType::DISTANCE,
-            'metric'            => Metric::GEODESIC,
-        ]);
-
-        $optimizationParams = new OptimizationProblemParams();
-        $optimizationParams->setAddresses($addresses);
-        $optimizationParams->setParameters($parameters);
-
-        $problem = OptimizationProblem::optimize($optimizationParams);
-
-        self::$createdProblems[] = $problem;
-
-        //endregion
-
-        //region -- Create Test Order --
-
-        $orderParameters = Order::fromArray([
-            'address_1'                 => '1358 E Luzerne St, Philadelphia, PA 19124, US',
-            'cached_lat'                => 48.335991,
-            'cached_lng'                => 31.18287,
-            'address_alias'             => 'Auto test address',
-            'address_city'              => 'Philadelphia',
-            'day_scheduled_for_YYMMDD'  => date('Y-m-d'),
-            'EXT_FIELD_first_name'      => 'Igor',
-            'EXT_FIELD_last_name'       => 'Progman',
-            'EXT_FIELD_email'           => 'progman@gmail.com',
-            'EXT_FIELD_phone'           => '380380380380',
-            'EXT_FIELD_custom_data'     => [
-                0 => [
-                    'order_id'  => '10',
-                    'name'      => 'Bill Soul',
-                ],
-            ],
-        ]);
-
-        $order = new Order();
-
-        $response = $order->addOrder($orderParameters);
-
-        self::assertNotNull($response);
-        self::assertInstanceOf(Order::class, Order::fromArray($response));
-
-        self::$createdOrders[] = $response;
-
-        //endregion
-    }
-
-    public function testFromArray()
-    {
-        $orderParameters = Order::fromArray([
-            'address_1'                 => '1358 E Luzerne St, Philadelphia, PA 19124, US',
-            'cached_lat'                => 48.335991,
-            'cached_lng'                => 31.18287,
-            'address_alias'             => 'Auto test address',
-            'address_city'              => 'Philadelphia',
-            'day_scheduled_for_YYMMDD'  => date('Y-m-d'),
-            'EXT_FIELD_first_name'      => 'Igor',
-            'EXT_FIELD_last_name'       => 'Progman',
-            'EXT_FIELD_email'           => 'progman@gmail.com',
-            'EXT_FIELD_phone'           => '380380380380',
-            'EXT_FIELD_custom_data'     => [
-                0 => [
-                    'order_id'  => '10',
-                    'name'      => 'Bill Soul',
-                ],
-            ],
-        ]);
-
-        $this->assertEquals('1358 E Luzerne St, Philadelphia, PA 19124, US', $orderParameters->address_1);
-        $this->assertEquals(48.335991, $orderParameters->cached_lat);
-        $this->assertEquals(31.18287, $orderParameters->cached_lng);
-        $this->assertEquals('Auto test address', $orderParameters->address_alias);
-        $this->assertEquals('Philadelphia', $orderParameters->address_city);
-        $this->assertEquals(date('Y-m-d'), $orderParameters->day_scheduled_for_YYMMDD);
-        $this->assertEquals('Igor', $orderParameters->EXT_FIELD_first_name);
-        $this->assertEquals('Progman', $orderParameters->EXT_FIELD_last_name);
-        $this->assertEquals('progman@gmail.com', $orderParameters->EXT_FIELD_email);
-        $this->assertEquals('380380380380', $orderParameters->EXT_FIELD_phone);
-        $this->assertEquals([
-            0 => [
-                'order_id'  => '10',
-                'name'      => 'Bill Soul',
-            ],
-        ], $orderParameters->EXT_FIELD_custom_data);
-    }
-
-    public function testToArray()
-    {
-        $orderParameters = Order::fromArray([
-            'address_1'                 => '1358 E Luzerne St, Philadelphia, PA 19124, US',
-            'cached_lat'                => 48.335991,
-            'cached_lng'                => 31.18287,
-            'address_alias'             => 'Auto test address',
-            'address_city'              => 'Philadelphia',
-            'day_scheduled_for_YYMMDD'  => date('Y-m-d'),
-            'EXT_FIELD_first_name'      => 'Igor',
-            'EXT_FIELD_last_name'       => 'Progman',
-            'EXT_FIELD_email'           => 'progman@gmail.com',
-            'EXT_FIELD_phone'           => '380380380380',
-            'EXT_FIELD_custom_data'     => [
-                0 => [
-                    'order_id'  => '10',
-                    'name'      => 'Bill Soul',
-                ],
-            ],
-        ]);
-
-        $this->assertEquals($orderParameters->toArray(),
-            [
-                'address_1'                 => '1358 E Luzerne St, Philadelphia, PA 19124, US',
-                'cached_lat'                => 48.335991,
-                'cached_lng'                => 31.18287,
-                'address_alias'             => 'Auto test address',
-                'address_city'              => 'Philadelphia',
-                'day_scheduled_for_YYMMDD'  => date('Y-m-d'),
-                'EXT_FIELD_first_name'      => 'Igor',
-                'EXT_FIELD_last_name'       => 'Progman',
-                'EXT_FIELD_email'           => 'progman@gmail.com',
-                'EXT_FIELD_phone'           => '380380380380',
-                'EXT_FIELD_custom_data'     => [
-                    0 => [
-                        'order_id'  => '10',
-                        'name'      => 'Bill Soul',
-                    ],
-                ],
-            ]
-        );
-    }
-
-    public function testGetOrders()
-    {
-        $order = new Order();
-
-        $orderParameters = Order::fromArray([
-            'offset'    => 0,
-            'limit'     => 5,
-        ]);
-
-        $response = $order->getOrders($orderParameters);
-
-        $this->assertNotNull($response);
-        $this->assertTrue(is_array($response));
-        $this->assertTrue(isset($response['total']));
-        $this->assertTrue(isset($response['results']));
-        $this->assertInstanceOf(
-            Order::class,
-            Order::fromArray($response['results'][0])
-        );
-    }
-
-    public function testCreateNewOrder()
-    {
-        $orderParameters = Order::fromArray([
-            'address_1'                 => '106 Liberty St, New York, NY 10006, USA',
-            'address_alias'             => 'BK Restaurant #: 2446',
-            'cached_lat'                => 40.709637,
-            'cached_lng'                => -74.011912,
-            'curbside_lat'              => 40.709637,
-            'curbside_lng'              => -74.011912,
-            'address_city'              => 'New York',
-            'EXT_FIELD_first_name'      => 'Lui',
-            'EXT_FIELD_last_name'       => 'Carol',
-            'EXT_FIELD_email'           => 'lcarol654@yahoo.com',
-            'EXT_FIELD_phone'           => '897946541',
-            'local_time_window_end'     => 39000,
-            'local_time_window_end_2'   => 46200,
-            'local_time_window_start'   => 37800,
-            'local_time_window_start_2' => 45000,
-            'local_timezone_string'     => 'America/New_York',
-            'order_icon'                => 'emoji/emoji-bank',
-        ]);
-
-        $order = new Order();
-
-        $response = $order->addOrder($orderParameters);
-
-        self::assertNotNull($response);
-        self::assertInstanceOf(Order::class, Order::fromArray($response));
-
-        self::$createdOrders[] = $response;
-    }
-
-    public function testAddOrdersToOptimization()
-    {
-        $body = json_decode(file_get_contents(dirname(__FILE__).'/data/add_order_to_optimization_data.json'), true);
-
-        $optimizationProblemId = self::$createdProblems[0]->optimization_problem_id;
-
-        $orderParameters = [
-            'optimization_problem_id'   => $optimizationProblemId,
-            'redirect'                  => 0,
-            'device_type'               => 'web',
-            'addresses'                 => $body['addresses'],
-        ];
-
-        $order = new Order();
-
-        $response = $order->addOrder2Optimization($orderParameters);
-
-        self::assertNotNull($response);
-        self::assertInstanceOf(OptimizationProblem::class, OptimizationProblem::fromArray($response));
-    }
-
-    public function testAddOrdersToRoute()
-    {
-        $body = json_decode(file_get_contents(dirname(__FILE__).'/data/add_order_to_route_data.json'), true);
-
-        $routeId = self::$createdProblems[0]->routes[0]->route_id;
-
-        $orderParameters = Order::fromArray([
-            'route_id'  => $routeId,
-            'redirect'  => 0,
-            'addresses' => $body['addresses'],
-        ]);
-
-        $order = new Order();
-
-        $response = $order->addOrder2Route($orderParameters);
-
-        self::assertNotNull($response);
-        self::assertInstanceOf(Route::class, Route::fromArray($response));
-    }
-
-    public function testAddScheduledOrder()
-    {
-        $orderParameters = Order::fromArray([
-            'address_1'                 => '318 S 39th St, Louisville, KY 40212, USA',
-            'cached_lat'                => 38.259326,
-            'cached_lng'                => -85.814979,
-            'curbside_lat'              => 38.259326,
-            'curbside_lng'              => -85.814979,
-            'address_alias'             => '318 S 39th St 40212',
-            'address_city'              => 'Louisville',
-            'EXT_FIELD_first_name'      => 'Lui',
-            'EXT_FIELD_last_name'       => 'Carol',
-            'EXT_FIELD_email'           => 'lcarol654@yahoo.com',
-            'EXT_FIELD_phone'           => '897946541',
-            'EXT_FIELD_custom_data'     => ['order_type' => 'scheduled order'],
-            'day_scheduled_for_YYMMDD'  => date('Y-m-d'),
-            'local_time_window_end'     => 39000,
-            'local_time_window_end_2'   => 46200,
-            'local_time_window_start'   => 37800,
-            'local_time_window_start_2' => 45000,
-            'local_timezone_string'     => 'America/New_York',
-            'order_icon'                => 'emoji/emoji-bank',
-        ]);
-
-        $order = new Order();
-
-        $response = $order->addOrder($orderParameters);
-
-        self::assertNotNull($response);
-        self::assertInstanceOf(Order::class, Order::fromArray($response));
-
-        self::$createdOrders[] = $response;
-    }
-
-    public function testCreateOrderWithCustomField()
-    {
-        $orderParameters = Order::fromArray([
-            'address_1'                => '1358 E Luzerne St, Philadelphia, PA 19124, US',
-            'cached_lat'               => 48.335991,
-            'cached_lng'               => 31.18287,
-            'day_scheduled_for_YYMMDD' => '2019-10-11',
-            'address_alias'            => 'Auto test address',
-            'custom_user_fields' => [
-                OrderCustomField::fromArray([
-                    'order_custom_field_id'    => 93,
-                    'order_custom_field_value' => 'false'
-                ])
-            ]
-        ]);
-
-        $order = new Order();
-
-        $response = $order->addOrder($orderParameters);
-
-        self::assertNotNull($response);
-        self::assertInstanceOf(Order::class, Order::fromArray($response));
-        $this->assertEquals(93,$response['custom_user_fields'][0]['order_custom_field_id']);
-        $this->assertEquals('false',$response['custom_user_fields'][0]['order_custom_field_value']);
-
-        self::$createdOrders[] = $response;
-    }
-
-    public function testGetOrderByID()
-    {
-        $order = new Order();
-
-        $orderID = self::$createdOrders[0]['order_id'];
-
-        // Get an order
-        $orderParameters = Order::fromArray([
-            'order_id' => $orderID,
-        ]);
-
-        $response = $order->getOrder($orderParameters);
-
-        self::assertNotNull($response);
-        self::assertInstanceOf(Order::class, Order::fromArray($response));
-    }
-
-    public function testGetOrderByInsertedDate()
-    {
-        $orderParameters = Order::fromArray([
-            'day_added_YYMMDD'  => date('Y-m-d', strtotime('0 days')),
-            'offset'            => 0,
-            'limit'             => 5,
-        ]);
-
-        $order = new Order();
-
-        $response = $order->getOrder($orderParameters);
-
-        $this->assertNotNull($response);
-        $this->assertTrue(is_array($response));
-        $this->assertTrue(isset($response['total']));
-        $this->assertTrue(isset($response['results']));
-        $this->assertInstanceOf(
-            Order::class,
-            Order::fromArray($response['results'][0])
-        );
-    }
-
-    public function testGetOrderByScheduledDate()
-    {
-        $orderParameters = Order::fromArray([
-            'day_scheduled_for_YYMMDD'  => date('Y-m-d', strtotime('0 days')),
-            'offset'                    => 0,
-            'limit'                     => 5,
-        ]);
-
-        $order = new Order();
-
-        $response = $order->getOrder($orderParameters);
-
-        $this->assertNotNull($response);
-        $this->assertTrue(is_array($response));
-        $this->assertTrue(isset($response['total']));
-        $this->assertTrue(isset($response['results']));
-        $this->assertInstanceOf(
-            Order::class,
-            Order::fromArray($response['results'][0])
-        );
-    }
-
-    public function testGetOrdersByCustomFields()
-    {
-        $orderParameters = Order::fromArray([
-            'fields'    => 'order_id,member_id',
-            'offset'    => 0,
-            'limit'     => 5,
-        ]);
-
-        $order = new Order();
-
-        $response = $order->getOrder($orderParameters);
-
-        $response = $order->getOrder($orderParameters);
-
-        $this->assertNotNull($response);
-        $this->assertTrue(is_array($response));
-        $this->assertTrue(isset($response['total']));
-        $this->assertTrue(isset($response['results']));
-        $this->assertTrue(isset($response['fields']));
-        $this->assertInstanceOf(
-            Order::class,
-            Order::fromArray($response['results'][0])
-        );
-    }
-
-    public function testGetOrdersByScheduleFilter()
-    {
-        $orderParameters = Order::fromArray([
-            'limit'  => 5,
-            'filter' => [
-                'display'               => 'all',
-                'scheduled_for_YYMMDD'  => [
-                    date('Y-m-d', strtotime('-1 days')),
-                    date('Y-m-d', strtotime('1 days'))
-                ]
-            ]
-        ]);
-
-        $order = new Order();
-
-        $response = $order->getOrder($orderParameters);
-
-        $this->assertNotNull($response);
-        $this->assertTrue(is_array($response));
-        $this->assertTrue(isset($response['total']));
-        $this->assertTrue(isset($response['results']));
-        $this->assertInstanceOf(
-            Order::class,
-            Order::fromArray($response['results'][0])
-        );
-    }
-
-    public function testGetOrdersBySpecifiedText()
-    {
-        $orderParameters = Order::fromArray([
-            'query'     => 'Auto test',
-            'offset'    => 0,
-            'limit'     => 5,
-        ]);
-
-        $order = new Order();
-
-        $response = $order->getOrder($orderParameters);
-
-        $this->assertNotNull($response);
-        $this->assertTrue(is_array($response));
-        $this->assertTrue(isset($response['total']));
-        $this->assertTrue(isset($response['results']));
-        $this->assertInstanceOf(
-            Order::class,
-            Order::fromArray($response['results'][0])
-        );
-    }
-
-    public function testUpdateOrder()
-    {
-        $order = new Order();
-
-        // Update the order
-        self::$createdOrders[0]['address_2'] = 'Lviv';
-        self::$createdOrders[0]['EXT_FIELD_phone'] = '032268593';
-        self::$createdOrders[0]['EXT_FIELD_custom_data'] = [
-            0 => [
-                'customer_no' => '11',
-            ],
-        ];
-
-        $response = $order->updateOrder(self::$createdOrders[0]);
-
-        $this->assertNotNull($response);
-        $this->assertInstanceOf(Order::class, Order::fromArray($response));
-        $this->assertEquals('Lviv', $response['address_2']);
-        $this->assertEquals('032268593', $response['EXT_FIELD_phone']);
-        $this->assertEquals(
-            [
-                0 => [ 'customer_no' => '11' ],
-            ],
-            $response['EXT_FIELD_custom_data']
-        );
-    }
-
-    public function testUpdateOrderWithCustomFiel()
-    {
-        $orderParameters = Order::fromArray([
-            'order_id'              => self::$createdOrders[0]['order_id'],
-            'custom_user_fields'    => [
-                OrderCustomField::fromArray([
-                    'order_custom_field_id'    => 93,
-                    'order_custom_field_value' => 'true'
-                ])
-            ]
-        ]);
-
-        $order = new Order();
-
-        $response = $order->updateOrder($orderParameters);
-
-        $this->assertNotNull($response);
-        $this->assertInstanceOf(Order::class, Order::fromArray($response));
-        $this->assertEquals(93, $response['custom_user_fields'][0]['order_custom_field_id']);
-        $this->assertEquals('true', $response['custom_user_fields'][0]['order_custom_field_value']);
-    }
-
-    public static function tearDownAfterClass()
-    {
-        if (sizeof(self::$createdOrders)) {
-            $orderIDs = [];
-
-            foreach (self::$createdOrders as $ord) {
-                $orderIDs[] = $ord['order_id'];
-            }
-
-            $orderParameters = Order::fromArray([
-                'order_ids' => $orderIDs
-            ]);
-
-            $order = new Order();
-
-            $response = $order->removeOrder($orderParameters);
-
-            if (!is_null($response) &&
-                isset($response['status']) &&
-                $response['status']) {
-                echo "The test orders removed <br>";
-            }
-        }
-
-        if (sizeof(self::$createdProblems)>0) {
-            $optimizationProblemIDs = [];
-
-            foreach (self::$createdProblems as $problem) {
-                $optimizationProblemId = $problem->optimization_problem_id;
-
-                $optimizationProblemIDs[] = $optimizationProblemId;
-            }
-
-            $params = [
-                'optimization_problem_ids' => $optimizationProblemIDs,
-                'redirect'                 => 0,
-            ];
-
-            $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>";
-            }
-        }
-    }
+	public static $createdOrders = [];
+	public static $createdProblems = [];
+
+	public static function setUpBeforeClass()
+	{
+		Route4Me::setApiKey(Constants::API_KEY);
+
+		//region -- Create Test Optimization --
+
+		// Huge list of addresses
+		$json = json_decode(file_get_contents(dirname(__FILE__).'/data/addresses.json'), true);
+		$json = array_slice($json, 0, 10);
+
+		$addresses = [];
+		foreach ($json as $address) {
+			$addresses[] = Address::fromArray($address);
+		}
+
+		$parameters = RouteParameters::fromArray([
+			'algorithm_type'    => Algorithmtype::TSP,
+			'route_name'        => 'Single Driver Multiple TW 10 Stops '.date('Y-m-d H:i'),
+			'route_date'        => time() + 24 * 60 * 60,
+			'route_time'        => 5 * 3600 + 30 * 60,
+			'distance_unit'     => DistanceUnit::MILES,
+			'device_type'       => DeviceType::WEB,
+			'optimize'          => OptimizationType::DISTANCE,
+			'metric'            => Metric::GEODESIC,
+		]);
+
+		$optimizationParams = new OptimizationProblemParams();
+		$optimizationParams->setAddresses($addresses);
+		$optimizationParams->setParameters($parameters);
+
+		$problem = OptimizationProblem::optimize($optimizationParams);
+
+		self::$createdProblems[] = $problem;
+
+		//endregion
+
+		//region -- Create Test Order --
+
+		$orderParameters = Order::fromArray([
+			'address_1'                 => '1358 E Luzerne St, Philadelphia, PA 19124, US',
+			'cached_lat'                => 48.335991,
+			'cached_lng'                => 31.18287,
+			'address_alias'             => 'Auto test address',
+			'address_city'              => 'Philadelphia',
+			'day_scheduled_for_YYMMDD'  => date('Y-m-d'),
+			'EXT_FIELD_first_name'      => 'Igor',
+			'EXT_FIELD_last_name'       => 'Progman',
+			'EXT_FIELD_email'           => 'progman@gmail.com',
+			'EXT_FIELD_phone'           => '380380380380',
+			'EXT_FIELD_custom_data'     => [
+				0 => [
+					'order_id'  => '10',
+					'name'      => 'Bill Soul',
+				],
+			],
+		]);
+
+		$order = new Order();
+
+		$response = $order->addOrder($orderParameters);
+
+		self::assertNotNull($response);
+		self::assertInstanceOf(Order::class, Order::fromArray($response));
+
+		self::$createdOrders[] = $response;
+
+		//endregion
+	}
+
+	public function testFromArray()
+	{
+		$orderParameters = Order::fromArray([
+			'address_1'                 => '1358 E Luzerne St, Philadelphia, PA 19124, US',
+			'cached_lat'                => 48.335991,
+			'cached_lng'                => 31.18287,
+			'address_alias'             => 'Auto test address',
+			'address_city'              => 'Philadelphia',
+			'day_scheduled_for_YYMMDD'  => date('Y-m-d'),
+			'EXT_FIELD_first_name'      => 'Igor',
+			'EXT_FIELD_last_name'       => 'Progman',
+			'EXT_FIELD_email'           => 'progman@gmail.com',
+			'EXT_FIELD_phone'           => '380380380380',
+			'EXT_FIELD_custom_data'     => [
+				0 => [
+					'order_id'  => '10',
+					'name'      => 'Bill Soul',
+				],
+			],
+		]);
+
+		$this->assertEquals('1358 E Luzerne St, Philadelphia, PA 19124, US', $orderParameters->address_1);
+		$this->assertEquals(48.335991, $orderParameters->cached_lat);
+		$this->assertEquals(31.18287, $orderParameters->cached_lng);
+		$this->assertEquals('Auto test address', $orderParameters->address_alias);
+		$this->assertEquals('Philadelphia', $orderParameters->address_city);
+		$this->assertEquals(date('Y-m-d'), $orderParameters->day_scheduled_for_YYMMDD);
+		$this->assertEquals('Igor', $orderParameters->EXT_FIELD_first_name);
+		$this->assertEquals('Progman', $orderParameters->EXT_FIELD_last_name);
+		$this->assertEquals('progman@gmail.com', $orderParameters->EXT_FIELD_email);
+		$this->assertEquals('380380380380', $orderParameters->EXT_FIELD_phone);
+		$this->assertEquals([
+			0 => [
+				'order_id'  => '10',
+				'name'      => 'Bill Soul',
+			],
+		], $orderParameters->EXT_FIELD_custom_data);
+	}
+
+	public function testToArray()
+	{
+		$orderParameters = Order::fromArray([
+			'address_1'                 => '1358 E Luzerne St, Philadelphia, PA 19124, US',
+			'cached_lat'                => 48.335991,
+			'cached_lng'                => 31.18287,
+			'address_alias'             => 'Auto test address',
+			'address_city'              => 'Philadelphia',
+			'day_scheduled_for_YYMMDD'  => date('Y-m-d'),
+			'EXT_FIELD_first_name'      => 'Igor',
+			'EXT_FIELD_last_name'       => 'Progman',
+			'EXT_FIELD_email'           => 'progman@gmail.com',
+			'EXT_FIELD_phone'           => '380380380380',
+			'EXT_FIELD_custom_data'     => [
+				0 => [
+					'order_id'  => '10',
+					'name'      => 'Bill Soul',
+				],
+			],
+		]);
+
+		$this->assertEquals($orderParameters->toArray(),
+			[
+				'address_1'                 => '1358 E Luzerne St, Philadelphia, PA 19124, US',
+				'cached_lat'                => 48.335991,
+				'cached_lng'                => 31.18287,
+				'address_alias'             => 'Auto test address',
+				'address_city'              => 'Philadelphia',
+				'day_scheduled_for_YYMMDD'  => date('Y-m-d'),
+				'EXT_FIELD_first_name'      => 'Igor',
+				'EXT_FIELD_last_name'       => 'Progman',
+				'EXT_FIELD_email'           => 'progman@gmail.com',
+				'EXT_FIELD_phone'           => '380380380380',
+				'EXT_FIELD_custom_data'     => [
+					0 => [
+						'order_id'  => '10',
+						'name'      => 'Bill Soul',
+					],
+				],
+			]
+		);
+	}
+
+	public function testGetOrders()
+	{
+		$order = new Order();
+
+		$orderParameters = Order::fromArray([
+			'offset'    => 0,
+			'limit'     => 5,
+		]);
+
+		$response = $order->getOrders($orderParameters);
+
+		$this->assertNotNull($response);
+		$this->assertTrue(is_array($response));
+		$this->assertTrue(isset($response['total']));
+		$this->assertTrue(isset($response['results']));
+		$this->assertInstanceOf(
+			Order::class,
+			Order::fromArray($response['results'][0])
+		);
+	}
+
+	public function testCreateNewOrder()
+	{
+		$orderParameters = Order::fromArray([
+			'address_1'                 => '106 Liberty St, New York, NY 10006, USA',
+			'address_alias'             => 'BK Restaurant #: 2446',
+			'cached_lat'                => 40.709637,
+			'cached_lng'                => -74.011912,
+			'curbside_lat'              => 40.709637,
+			'curbside_lng'              => -74.011912,
+			'address_city'              => 'New York',
+			'EXT_FIELD_first_name'      => 'Lui',
+			'EXT_FIELD_last_name'       => 'Carol',
+			'EXT_FIELD_email'           => 'lcarol654@yahoo.com',
+			'EXT_FIELD_phone'           => '897946541',
+			'local_time_window_end'     => 39000,
+			'local_time_window_end_2'   => 46200,
+			'local_time_window_start'   => 37800,
+			'local_time_window_start_2' => 45000,
+			'local_timezone_string'     => 'America/New_York',
+			'order_icon'                => 'emoji/emoji-bank',
+		]);
+
+		$order = new Order();
+
+		$response = $order->addOrder($orderParameters);
+
+		self::assertNotNull($response);
+		self::assertInstanceOf(Order::class, Order::fromArray($response));
+
+		self::$createdOrders[] = $response;
+	}
+
+	public function testAddOrdersToOptimization()
+	{
+		$body = json_decode(file_get_contents(dirname(__FILE__).'/data/add_order_to_optimization_data.json'), true);
+
+		$optimizationProblemId = self::$createdProblems[0]->optimization_problem_id;
+
+		$orderParameters = [
+			'optimization_problem_id'   => $optimizationProblemId,
+			'redirect'                  => 0,
+			'device_type'               => 'web',
+			'addresses'                 => $body['addresses'],
+		];
+
+		$order = new Order();
+
+		$response = $order->addOrder2Optimization($orderParameters);
+
+		self::assertNotNull($response);
+		self::assertInstanceOf(OptimizationProblem::class, OptimizationProblem::fromArray($response));
+	}
+
+	public function testAddOrdersToRoute()
+	{
+		$body = json_decode(file_get_contents(dirname(__FILE__).'/data/add_order_to_route_data.json'), true);
+
+		$routeId = self::$createdProblems[0]->routes[0]->route_id;
+
+		$orderParameters = Order::fromArray([
+			'route_id'  => $routeId,
+			'redirect'  => 0,
+			'addresses' => $body['addresses'],
+		]);
+
+		$order = new Order();
+
+		$response = $order->addOrder2Route($orderParameters);
+
+		self::assertNotNull($response);
+		self::assertInstanceOf(Route::class, Route::fromArray($response));
+	}
+
+	public function testAddScheduledOrder()
+	{
+		$orderParameters = Order::fromArray([
+			'address_1'                 => '318 S 39th St, Louisville, KY 40212, USA',
+			'cached_lat'                => 38.259326,
+			'cached_lng'                => -85.814979,
+			'curbside_lat'              => 38.259326,
+			'curbside_lng'              => -85.814979,
+			'address_alias'             => '318 S 39th St 40212',
+			'address_city'              => 'Louisville',
+			'EXT_FIELD_first_name'      => 'Lui',
+			'EXT_FIELD_last_name'       => 'Carol',
+			'EXT_FIELD_email'           => 'lcarol654@yahoo.com',
+			'EXT_FIELD_phone'           => '897946541',
+			'EXT_FIELD_custom_data'     => ['order_type' => 'scheduled order'],
+			'day_scheduled_for_YYMMDD'  => date('Y-m-d'),
+			'local_time_window_end'     => 39000,
+			'local_time_window_end_2'   => 46200,
+			'local_time_window_start'   => 37800,
+			'local_time_window_start_2' => 45000,
+			'local_timezone_string'     => 'America/New_York',
+			'order_icon'                => 'emoji/emoji-bank',
+		]);
+
+		$order = new Order();
+
+		$response = $order->addOrder($orderParameters);
+
+		self::assertNotNull($response);
+		self::assertInstanceOf(Order::class, Order::fromArray($response));
+
+		self::$createdOrders[] = $response;
+	}
+
+	public function testCreateOrderWithCustomField()
+	{
+		$orderParameters = Order::fromArray([
+			'address_1'                => '1358 E Luzerne St, Philadelphia, PA 19124, US',
+			'cached_lat'               => 48.335991,
+			'cached_lng'               => 31.18287,
+			'day_scheduled_for_YYMMDD' => '2019-10-11',
+			'address_alias'            => 'Auto test address',
+			'custom_user_fields' => [
+				OrderCustomField::fromArray([
+					'order_custom_field_id'    => 93,
+					'order_custom_field_value' => 'false'
+				])
+			]
+		]);
+
+		$order = new Order();
+
+		$response = $order->addOrder($orderParameters);
+
+		self::assertNotNull($response);
+		self::assertInstanceOf(Order::class, Order::fromArray($response));
+		$this->assertEquals(93,$response['custom_user_fields'][0]['order_custom_field_id']);
+		$this->assertEquals('false',$response['custom_user_fields'][0]['order_custom_field_value']);
+
+		self::$createdOrders[] = $response;
+	}
+
+	public function testGetOrderByID()
+	{
+		$order = new Order();
+
+		$orderID = self::$createdOrders[0]['order_id'];
+
+		// Get an order
+		$orderParameters = Order::fromArray([
+			'order_id' => $orderID,
+		]);
+
+		$response = $order->getOrder($orderParameters);
+
+		self::assertNotNull($response);
+		self::assertInstanceOf(Order::class, Order::fromArray($response));
+	}
+
+	public function testGetOrderByInsertedDate()
+	{
+		$orderParameters = Order::fromArray([
+			'day_added_YYMMDD'  => date('Y-m-d', strtotime('0 days')),
+			'offset'            => 0,
+			'limit'             => 5,
+		]);
+
+		$order = new Order();
+
+		$response = $order->getOrder($orderParameters);
+
+		$this->assertNotNull($response);
+		$this->assertTrue(is_array($response));
+		$this->assertTrue(isset($response['total']));
+		$this->assertTrue(isset($response['results']));
+		$this->assertInstanceOf(
+			Order::class,
+			Order::fromArray($response['results'][0])
+		);
+	}
+
+	public function testGetOrderByScheduledDate()
+	{
+		$orderParameters = Order::fromArray([
+			'day_scheduled_for_YYMMDD'  => date('Y-m-d', strtotime('0 days')),
+			'offset'                    => 0,
+			'limit'                     => 5,
+		]);
+
+		$order = new Order();
+
+		$response = $order->getOrder($orderParameters);
+
+		$this->assertNotNull($response);
+		$this->assertTrue(is_array($response));
+		$this->assertTrue(isset($response['total']));
+		$this->assertTrue(isset($response['results']));
+		$this->assertInstanceOf(
+			Order::class,
+			Order::fromArray($response['results'][0])
+		);
+	}
+
+	public function testGetOrdersByCustomFields()
+	{
+		$orderParameters = Order::fromArray([
+			'fields'    => 'order_id,member_id',
+			'offset'    => 0,
+			'limit'     => 5,
+		]);
+
+		$order = new Order();
+
+		$response = $order->getOrder($orderParameters);
+
+		$response = $order->getOrder($orderParameters);
+
+		$this->assertNotNull($response);
+		$this->assertTrue(is_array($response));
+		$this->assertTrue(isset($response['total']));
+		$this->assertTrue(isset($response['results']));
+		$this->assertTrue(isset($response['fields']));
+		$this->assertInstanceOf(
+			Order::class,
+			Order::fromArray($response['results'][0])
+		);
+	}
+
+	public function testGetOrdersByScheduleFilter()
+	{
+		$orderParameters = Order::fromArray([
+			'limit'  => 5,
+			'filter' => [
+				'display'               => 'all',
+				'scheduled_for_YYMMDD'  => [
+					date('Y-m-d', strtotime('-1 days')),
+					date('Y-m-d', strtotime('1 days'))
+				]
+			]
+		]);
+
+		$order = new Order();
+
+		$response = $order->getOrder($orderParameters);
+
+		$this->assertNotNull($response);
+		$this->assertTrue(is_array($response));
+		$this->assertTrue(isset($response['total']));
+		$this->assertTrue(isset($response['results']));
+		$this->assertInstanceOf(
+			Order::class,
+			Order::fromArray($response['results'][0])
+		);
+	}
+
+	public function testGetOrdersBySpecifiedText()
+	{
+		$orderParameters = Order::fromArray([
+			'query'     => 'Auto test',
+			'offset'    => 0,
+			'limit'     => 5,
+		]);
+
+		$order = new Order();
+
+		$response = $order->getOrder($orderParameters);
+
+		$this->assertNotNull($response);
+		$this->assertTrue(is_array($response));
+		$this->assertTrue(isset($response['total']));
+		$this->assertTrue(isset($response['results']));
+		$this->assertInstanceOf(
+			Order::class,
+			Order::fromArray($response['results'][0])
+		);
+	}
+
+	public function testUpdateOrder()
+	{
+		$order = new Order();
+
+		// Update the order
+		self::$createdOrders[0]['address_2'] = 'Lviv';
+		self::$createdOrders[0]['EXT_FIELD_phone'] = '032268593';
+		self::$createdOrders[0]['EXT_FIELD_custom_data'] = [
+			0 => [
+				'customer_no' => '11',
+			],
+		];
+
+		$response = $order->updateOrder(self::$createdOrders[0]);
+
+		$this->assertNotNull($response);
+		$this->assertInstanceOf(Order::class, Order::fromArray($response));
+		$this->assertEquals('Lviv', $response['address_2']);
+		$this->assertEquals('032268593', $response['EXT_FIELD_phone']);
+		$this->assertEquals(
+			[
+				0 => [ 'customer_no' => '11' ],
+			],
+			$response['EXT_FIELD_custom_data']
+		);
+	}
+
+	public function testUpdateOrderWithCustomFiel()
+	{
+		$orderParameters = Order::fromArray([
+			'order_id'              => self::$createdOrders[0]['order_id'],
+			'custom_user_fields'    => [
+				OrderCustomField::fromArray([
+					'order_custom_field_id'    => 93,
+					'order_custom_field_value' => 'true'
+				])
+			]
+		]);
+
+		$order = new Order();
+
+		$response = $order->updateOrder($orderParameters);
+
+		$this->assertNotNull($response);
+		$this->assertInstanceOf(Order::class, Order::fromArray($response));
+		$this->assertEquals(93, $response['custom_user_fields'][0]['order_custom_field_id']);
+		$this->assertEquals('true', $response['custom_user_fields'][0]['order_custom_field_value']);
+	}
+
+	public static function tearDownAfterClass()
+	{
+		if (sizeof(self::$createdOrders)) {
+			$orderIDs = [];
+
+			foreach (self::$createdOrders as $ord) {
+				$orderIDs[] = $ord['order_id'];
+			}
+
+			$orderParameters = Order::fromArray([
+				'order_ids' => $orderIDs
+			]);
+
+			$order = new Order();
+
+			$response = $order->removeOrder($orderParameters);
+
+			if (!is_null($response) &&
+				isset($response['status']) &&
+				$response['status']) {
+				echo "The test orders removed <br>";
+			}
+		}
+
+		if (sizeof(self::$createdProblems)>0) {
+			$optimizationProblemIDs = [];
+
+			foreach (self::$createdProblems as $problem) {
+				$optimizationProblemId = $problem->optimization_problem_id;
+
+				$optimizationProblemIDs[] = $optimizationProblemId;
+			}
+
+			$params = [
+				'optimization_problem_ids' => $optimizationProblemIDs,
+				'redirect'                 => 0,
+			];
+
+			$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>";
+			}
+		}
+	}
 }