TestLibrary::testSearchCountry() - Code Metrics - Inspection of "tep changes" - bsomeshwer/world-countries - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — test ( 7f1499...ccf3d3 )

by Someshwer
created 2020-07-01 03:59 UTC
TestLibrary::testSearchCountry() A

↳ Parent: TestLibrary
Complexity

Conditions	1
Paths	1
Size

Total Lines	7
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	2
nc	1
nop	0
dl	0
loc	7
rs	10
c	1
b	0
f	0
<?php
/**
 * Created by PhpStorm.
 * User: babi
 * Date: 13/6/20
 * Time: 11:35 PM
 */

namespace Tests;

use Someshwer\WorldCountries\Facades\World;

class TestLibrary extends TestCase
{

    /** @test */
    public function testCountries()
    {
        // Arrange
        $countries = World::countries();
        $countries = World::countries();

        // Assert
        $this->assertGreaterThan(count($countries), 200);
    }

    /** @test */
    public function testSearchCountry()
    {
        // Arrange
        $country = World::searchCountry('india');
        $country = World::searchCountry('india');

        // Assert
        $this->assertEquals(count($country) , 1);
    }

    /** @test */
    public function testCurrencies()
    {
        // Arrange
        $currencies = World::currencies();
        $currencies = World::currencies();

        // Assert
        $this->assertGreaterThan(30, count($currencies));
    }

    /** @test */
    public function testSearchCurrency()
    {
        // Arrange
        $currencies = World::searchCurrency('I');
        $currencies = World::searchCurrency('I');

        // Assert
        $this->assertGreaterThan(2, count($currencies));
    }

    /** @test */
    public function testCurrencyByCountryName()
    {
        // Arrange
        $currency = World::currencyByCountryName('India');
        $currency = World::currencyByCountryName('India');

        // Assert
        $this->assertEquals(1, count($currency));
    }

    /** @test */
    public function testCurrencyByCountryCode()
    {
        // Arrange
        $currency = World::currencyByCountryCode('AF');
        $currency = World::currencyByCountryCode('AF');

        // Assert
        $this->assertGreaterThan(0, count($currency));
    }

    /** @test */
    public function testCurrencyByCurrencyName()
    {
        // Arrange
        $currency = World::currencyByCurrencyName('Dollar');
        $currency = World::currencyByCurrencyName('Dollar');

        // Assert
        $this->assertGreaterThan(20, count($currency));
    }

    /** @test */
    public function testCurrencyByCurrencyCode()
    {
        // Arrange
        $currency = World::currencyByCountryCode('US');

        // Assert
        $this->assertEquals(1, count($currency));
    }

    /** @test */
    public function testTimezones()
    {
        // Arrange
        $timezones = World::timezones();
        $timezones = World::timezones();

        // Assert
        $this->assertGreaterThan(100, count($timezones));
    }

    /** @test */
    public function testTimezoneRegions()
    {
        // Arrange
        $timezoneRegions = World::timezoneRegions();
        $timezoneRegions = World::timezoneRegions();

        // Assert
        $this->assertGreaterThan(8, count($timezoneRegions));
    }

    /** @test */
    public function testTimezonesByRegion()
    {
        // Arrange
        $timezones = World::timezonesByRegion('Antarctica');
        $timezones = World::timezonesByRegion('Antarctica');

        // Assert
        $this->assertGreaterThan(5, count($timezones));
    }

    /** @test */
    public function testSearchTimezone()
    {
        // Arrange
        $timezones = World::searchTimezone('UTC');
        $timezones = World::searchTimezone('UTC');

        // Assert
        $this->assertGreaterThan(0, count($timezones));
    }

    /** @test */
    public function testIsoCodes()
    {
        // Arrange
        $isoCodes = World::isoCodes();
        $isoCodes = World::isoCodes();

        // Assert
        $this->assertGreaterThan(100, count($isoCodes));
    }

    /** @test */
    public function testRegions()
    {
        // Arrange
        $regions = World::regions();
        $regions = World::regions();

        // Assert
        $this->assertLessThan(11, count($regions));
    }

    /** @test */
    public function testSearchIsoCodes()
    {
        // Arrange
        $isoCodes = World::searchIsoCodes('91');
        $isoCodes = World::searchIsoCodes('91');

        // Assert
        $this->assertGreaterThan(1, count($isoCodes));
    }

    /** @test */
    public function testIsoInfoByCountryName()
    {
        // Arrange
        $isoInfoByCountryName = World::isoInfoByCountryName('India');
        $isoInfoByCountryName = World::isoInfoByCountryName('India');

        // Assert
        $this->assertEquals(0, count($isoInfoByCountryName));
    }

    /** @test */
    public function testIsoInfoByCode()
    {
        // Arrange
        $isoInfoByCode = World::isoInfoByCode('IN');
        $isoInfoByCode = World::isoInfoByCode('IN');

        // Assert
        $this->assertEquals($isoInfoByCode->status(), 200);
    }

    /** @test */
    public function testIsoCodesByRegion()
    {
        // Arrange
        $isoCodesByRegion = World::isoCodesByRegion('Europe');
        $isoCodesByRegion = World::isoCodesByRegion('Europe');

        // Assert
        $this->assertGreaterThan(0, count($isoCodesByRegion));
    }

    /** @test */
    public function testStates()
    {
        // Arrange
        $states = World::states();
        $states = World::states();

        // Assert
        $this->assertGreaterThan(4000, count($states));
    }

    /** @test */
    public function testSearchStates()
    {
        // Arrange
        $states = World::searchStates('tel');
        $states = World::searchStates('tel');

        // Assert
        $this->assertGreaterThan(5, count($states));
    }

    /** @test */
    public function testCountriesForStates()
    {
        // Arrange
        $countriesForStates = World::countriesForStates('UAE');
        $countriesForStates = World::countriesForStates('UAE');

        // Assert
        $this->assertGreaterThan(200, count($countriesForStates));
    }

    /** @test */
    public function testGetStatesByCountry()
    {
        // Arrange
        $states = World::getStatesByCountry('Taiwan');
        $states = World::getStatesByCountry('Taiwan');

        // Assert
        $this->assertGreaterThan(25, count($states));
    }

    /** @test */
    public function testStdCodes()
    {
        // Arrange
        $stdCodes = World::stdCodes();
        $stdCodes = World::stdCodes();

        // Assert
        $this->assertGreaterThan(200, count($stdCodes));
    }

    /** @test */
    public function testSearchStdCodes()
    {
        // Arrange
        $stdCodes = World::searchStdCodes('44');
        $stdCodes = World::searchStdCodes('44');

        // Assert
        $this->assertLessThan(10, count($stdCodes));
    }

    /** @test */
    public function testStdCodeByCountryName()
    {
        // Arrange
        $stdCodeByCountryName = World::stdCodeByCountryName('Russia');
        $stdCodeByCountryName = World::stdCodeByCountryName('Russia');

        // Assert
        $this->assertEquals(count($stdCodeByCountryName), 1);
    }

    /** @test */
    public function testStdCodeByCountryCode()
    {
        // Arrange
        $stdCodeByCountryCode = World::stdCodeByCountryCode('CH');
        $stdCodeByCountryCode = World::stdCodeByCountryCode('CH');

        // Assert
        $this->assertEquals(count($stdCodeByCountryCode), 1);
    }

    /** @test */
    public function testCities()
    {
        // Arrange
        $cities = World::cities();
        $cities = World::cities();

        // Assert
        $this->assertGreaterThan(5000, count($cities));
    }

    /** @test */
    public function testSearchCities()
    {
        // Arrange
        $cities = World::searchCities('hy');
        $cities = World::searchCities('hy');

        // Assert
        $this->assertGreaterThan(15, count($cities));
    }

    /** @test */
    public function statesForCities()
    {
        // Arrange
        $statesForCities = World::statesForCities();
        $statesForCities = World::statesForCities();

        // Assert
        $this->assertGreaterThan(4000, count($statesForCities));
    }

    /** @test */
    public function countriesForCities()
    {
        // Arrange
        $countriesForCities = World::countriesForCities();
        $countriesForCities = World::countriesForCities();

        // Assert
        $this->assertGreaterThan(245, count($countriesForCities));
    }

    /** @test */
    public function getCitiesByStateName()
    {
        // Arrange
        $city = World::getCitiesByStateName('Karnataka');
        $city = World::getCitiesByStateName('Karnataka');

        // Assert
        $this->assertGreaterThan(323, count($city));
    }

    /** @test */
    public function getCitiesByCountryName()
    {
        // Arrange
        $city = World::getCitiesByCountryName('China');
        $city = World::getCitiesByCountryName('China');

        // Assert
        $this->assertGreaterThan(1300, count($city));
    }

}
bsomeshwer / world-countries

Push — test ( 7f1499...ccf3d3 )

TestLibrary::testSearchCountry() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
