CalculatorTest::getDataLocalDate() - Code Metrics - Inspection of "Merge pull request #6 from minube/dev" - minube/geo-timezone - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 0d1135...49cedc )

by Ana Belén

created 2017-09-21 14:53 UTC

CalculatorTest::getDataLocalDate() B

↳ Parent: CalculatorTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	26
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	26
rs	8.8571
cc	1
eloc	20
nc	1
nop	0

<?php

namespace Tests\GeoTimeZone;

use GeoTimeZone\Calculator;
use PHPUnit\Runner\Exception;
use Tests\AbstractUnitTestCase;

class CalculatorTest extends AbstractUnitTestCase
{
    const DATA_DIRECTORY = "/../../data/";
    
    protected $calculator;
    
    protected function setUp()
    {
        $this->calculator = new Calculator(__DIR__ . self::DATA_DIRECTORY);
    }
    
    public function getDataLocalDate()
    {
        return array(
            'Testing Lisbon' => array(
                'latitude' => 41.142700,
                'longitude' => -8.612150,
                'timestamp' => 1458844434,
                'expectedTimeZone' => 'Europe/Lisbon',
                '$expectedOffset' => 0
            ),
            'Testing Madrid' => array(
                'latitude' => 39.452800,
                'longitude' => -0.347038,
                'timestamp' => 1469387760,
                'expectedTimeZone' => 'Europe/Madrid',
                '$expectedOffset' => 7200
            ),
            'Testing Caracas' => array(
                'latitude' => 7.811258,
                'longitude' => -72.199897,
                'timestamp' => 1412482901,
                'expectedTimeZone' => 'America/Caracas',
                '$expectedOffset' => -16200
            )
        );
    }
    
    public function getDataCorrectTimestamp()
    {
        return array(
            'Testing Lisbon' => array(
                'latitude' => 41.142700,
                'longitude' => -8.612150,
                'timestamp' => 1458844434,
                'expectedTimestamp' => 1458844434,
            ),
            'Testing Madrid' => array(
                'latitude' => 39.452800,
                'longitude' => -0.347038,
                'timestamp' => 1469387760,
                'expectedTimestamp' => 1469380560,
            )
        );
    }
    
    public function getDataTimeZoneName()
    {
        return array(
            'Testing Lisbon' => array(
                'latitude' => 41.142700,
                'longitude' => -8.612150,
                'expectedTimeZone' => 'Europe/Lisbon',
            ),
            'Testing Madrid' => array(
                'latitude' => 39.452800,
                'longitude' => -0.347038,
                'expectedTimeZone' => 'Europe/Madrid',
            )
        );
    }
    
    public function getNoTimezone()
    {
        return array(
            'Testing None Timezone' => array(
                'latitude' => -1,
                'longitude' => -1,
                'timestamp' => 0,
                'expectedException' => "ERROR: TimeZone not found",
            )
        );
    }
    
    public function getDataWrongLatitude()
    {
        return array(
            'Testing Wrong Latitude' => array(
                'latitude' => 10000000,
                'longitude' => -8.612150,
                'expectedException' => "Invalid latitude: 10000000",
            ),
            'Testing Null Latitude' => array(
                'latitude' => null,
                'longitude' => -8.612150,
                'expectedException' => "Invalid latitude: ",
            )
        );
    }
    
    public function getDataWrongLongitude()
    {
        return array(
            'Testing Wrong Longitude' => array(
                'latitude' => 41.142700,
                'longitude' => 10000000,
                'expectedException' => "Invalid longitude: 10000000",
            
            ),
            'Testing Null Longitude' => array(
                'latitude' => 41.142700,
                'longitude' => null,
                'expectedException' => "Invalid longitude: ",
            )
        );
    }
    
    public function getDataMaxLatitude()
    {
        return array(
            'Testing Positive Max Latitude' => array(
                'latitude' => 90.0,
                'longitude' => -8.612150,
                'adjustedLatitude' => 89.9999,
                'expectedException' => "ERROR: TimeZone not found",
            ),
            'Testing Negative Max Latitude' => array(
                'latitude' => -90.0,
                'longitude' => -8.612150,
                'adjustedLatitude' => -89.9999,
                'expectedException' => "ERROR: TimeZone not found",
            )
        );
    }
    
    public function getDataMaxLongitude()
    {
        return array(
            'Testing Positive Max Longitude' => array(
                'latitude' => -8.612150,
                'longitude' => 180.0,
                'adjustedLongitude' => 179.9999,
                'expectedException' => "ERROR: TimeZone not found",
            ),
            'Testing Negative Max Longitude' => array(
                'latitude' => -8.612150,
                'longitude' => -180.0,
                'adjustedLongitude' => -179.9999,
                'expectedException' => "ERROR: TimeZone not found",
            )
        );
    }
    
    /**
     * @dataProvider getDataWrongLatitude
     * @param $latitude
     * @param $longitude
     * @param $expectedException
     */
    public function testGetTimeZoneNameWithWrongLatitude($latitude, $longitude, $expectedException)
    {
        try {
            $this->expectException(\ErrorException::class);
            $this->expectExceptionMessage($expectedException);
            $timeZone = $this->calculator->getTimeZoneName($latitude, $longitude);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        } catch (Exception $error) {

            echo $error->getMessage();
        }
    }
    
    /**
     * @dataProvider getDataWrongLongitude
     * @param $latitude
     * @param $longitude
     * @param $expectedException
     */
    public function testGetTimeZoneNameWithWrongLongitude($latitude, $longitude, $expectedException)
    {
        try {
            $this->expectException(\ErrorException::class);
            $this->expectExceptionMessage($expectedException);
            $timeZone = $this->calculator->getTimeZoneName($latitude, $longitude);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        } catch (Exception $error) {

            echo $error->getMessage();
        }
    }
    
    /**
     * @dataProvider getDataMaxLatitude
     * @param $latitude
     * @param $longitude
     * @param $adjustedLatitude
     * @param $expectedException
     */
    public function testGetTimeZoneNameWithMaxLatitude($latitude, $longitude, $adjustedLatitude, $expectedException)

    {
        try {
            $this->expectException(\ErrorException::class);
            $this->expectExceptionMessage($expectedException);
            $timeZone = $this->calculator->getTimeZoneName($latitude, $longitude);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        } catch (Exception $error) {

            echo $error->getMessage();
        }
    }
    
    /**
     * @dataProvider getDataMaxLongitude
     * @param $latitude
     * @param $longitude
     * @param $adjustedLongitude
     * @param $expectedException
     */
    public function testGetTimeZoneNameWithMaxLongitude($latitude, $longitude, $adjustedLongitude, $expectedException)

    {
        try {
            $this->expectException(\ErrorException::class);
            $this->expectExceptionMessage($expectedException);
            $timeZone = $this->calculator->getTimeZoneName($latitude, $longitude);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        } catch (Exception $error) {

            echo $error->getMessage();
        }
    }
    
    /**
     * @dataProvider getDataMaxLatitude
     * @param $latitude
     * @param $longitude
     * @param $adjustedLatitude
     * @param $expectedException
     */
    public function testAdjustLatitudeWithMaxLatitude($latitude, $longitude, $adjustedLatitude, $expectedException)

    {
        $method = $this->getPrivateMethod(get_class($this->calculator), 'adjustLatitude');
        $latitudeToTest = $method->invokeArgs($this->calculator, array($latitude));
        $this->assertEquals($adjustedLatitude, $latitudeToTest);
    }
    
    /**
     * @dataProvider getDataMaxLongitude
     * @param $latitude
     * @param $longitude
     * @param $adjustedLongitude
     * @param $expectedException
     */
    public function testAdjustMaxLongitudeWithMaxLongitude($latitude, $longitude, $adjustedLongitude,

                                                           $expectedException)

    {
        $method = $this->getPrivateMethod(get_class($this->calculator), 'adjustLongitude');
        $longitudeToTest = $method->invokeArgs($this->calculator, array($longitude));
        $this->assertEquals($adjustedLongitude, $longitudeToTest);
    }
    
    /**
     * @dataProvider getDataLocalDate
     * @param $latitude
     * @param $longitude
     * @param $timestamp
     * @param $expectedTimeZone
     * @param $expectedOffset
     */
    public function testGetLocalDate($latitude, $longitude, $timestamp, $expectedTimeZone, $expectedOffset)
    {
        $localDate = $this->calculator->getLocalDate($latitude, $longitude, $timestamp);
        $this->assertInstanceOf('DateTime', $localDate);
        $this->assertEquals(
            $localDate->getTimezone()->getName(),
            $expectedTimeZone
        );
        $this->assertEquals(
            $localDate->getOffset(),
            $expectedOffset
        );
    }
    
    /**
     * @dataProvider getNoTimezone
     * @param $latitude
     * @param $longitude
     * @param $timestamp
     * @param $expectedException
     */
    public function testGetLocalDateException($latitude, $longitude, $timestamp, $expectedException)
    {
        try {
            $this->expectException(\ErrorException::class);
            $this->expectExceptionMessage($expectedException);
            $localDate = $this->calculator->getLocalDate($latitude, $longitude, $timestamp);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        } catch (Exception $error) {

            echo $error->getMessage();
        }
    }
    
    /**
     * @dataProvider getDataCorrectTimestamp
     * @param $latitude
     * @param $longitude
     * @param $timestamp
     * @param $expectedTimestamp
     */
    public function testGetCorrectTimestamp($latitude, $longitude, $timestamp, $expectedTimestamp)
    {
        $correctTimestamp = $this->calculator->getCorrectTimestamp($latitude, $longitude, $timestamp);
        $this->assertEquals($correctTimestamp, $expectedTimestamp);
    }
    
    /**
     * @dataProvider getNoTimezone
     * @param $latitude
     * @param $longitude
     * @param $timestamp
     * @param $expectedException
     */
    public function testGetCorrectTimestampException($latitude, $longitude, $timestamp, $expectedException)
    {
        try {
            $this->expectException(\ErrorException::class);
            $this->expectExceptionMessage($expectedException);
            $correctTimestamp = $this->calculator->getCorrectTimestamp($latitude, $longitude, $timestamp);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        } catch (Exception $error) {

            echo $error->getMessage();
        }
    }
    
    /**
     * @dataProvider getDataTimeZoneName
     * @param $latitude
     * @param $longitude
     * @param $expectedTimeZone
     */
    public function testGetTimeZoneName($latitude, $longitude, $expectedTimeZone)
    {
        try {
            $timeZoneName = $this->calculator->getTimeZoneName($latitude, $longitude);
            $this->assertEquals($timeZoneName, $expectedTimeZone);
        } catch (Exception $error) {

            echo $error->getMessage();
        }
    }
    
    /**
     * @dataProvider getNoTimezone
     * @param $latitude
     * @param $longitude
     * @param $timestamp
     * @param $expectedException
     */
    public function testGetTimeZoneNameException($latitude, $longitude, $timestamp, $expectedException)

    {
        try {
            $this->expectException(\ErrorException::class);
            $this->expectExceptionMessage($expectedException);
            $timeZoneName = $this->calculator->getTimeZoneName($latitude, $longitude);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        } catch (Exception $error) {

            echo $error->getMessage();
        }
    }
}


1			<?php
2
3			namespace Tests\GeoTimeZone;
4
5			use GeoTimeZone\Calculator;
6			use PHPUnit\Runner\Exception;
7			use Tests\AbstractUnitTestCase;
8
9			class CalculatorTest extends AbstractUnitTestCase
10			{
11			const DATA_DIRECTORY = "/../../data/";
12
13			protected $calculator;
14
15			protected function setUp()
16			{
17			$this->calculator = new Calculator(__DIR__ . self::DATA_DIRECTORY);
18			}
19
20			public function getDataLocalDate()
21			{
22			return array(
23			'Testing Lisbon' => array(
24			'latitude' => 41.142700,
25			'longitude' => -8.612150,
26			'timestamp' => 1458844434,
27			'expectedTimeZone' => 'Europe/Lisbon',
28			'$expectedOffset' => 0
29			),
30			'Testing Madrid' => array(
31			'latitude' => 39.452800,
32			'longitude' => -0.347038,
33			'timestamp' => 1469387760,
34			'expectedTimeZone' => 'Europe/Madrid',
35			'$expectedOffset' => 7200
36			),
37			'Testing Caracas' => array(
38			'latitude' => 7.811258,
39			'longitude' => -72.199897,
40			'timestamp' => 1412482901,

minube / geo-timezone

GitHub Access Token became invalid

Push — master ( 0d1135...49cedc )

CalculatorTest::getDataLocalDate() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like