Having trouble with testing code using PHPunit

I am testing codes using PHPUnit.How do we test if the function is calling another function from the same class inside a loop? This is my dashboardmanager.php

public function getZoneOrderValue($businessUnitId, $fromDate, $toDate)
    {
        $repository = $this->getRepository();
        $query = $repository->getZoneCount($businessUnitId, $fromDate, $toDate);
        $results = $this->type->search($query)->getAggregations('by_zone');

        $results = $results['by_zone']['buckets'];
        $i = 0;
        foreach ($results as $result) {
            $zoneOrderValue[$i] = array();
            $zoneValue = $result['order_value']['value'];
            $zoneId = $result['key'];
            $zoneName = $this->getZoneName($zoneId);
            array_push($zoneOrderValue[$i], $zoneName, $zoneValue);
            $i++;
        }

        return $zoneOrderValue;
    }

public function getZoneName($zoneId)
    {
        $repository = $this->getRepository();
        $query = $repository->getZoneName($zoneId);
        $zone = $this->type->search($query)->getResults();
        $zone = $zone[0]->getFields();
        $zoneName = $zone['zone'][0];

        return $zoneName;
    }

This is my test file. I am having problem in test_getZoneOrderValue().This is my dashboardmanagertest.php

protected $dash;
    protected $ob;
    protected $container;
    protected $prophet;
    protected $elasticManager;
    protected $elasticIndexManager;
    protected $repoManager;
    protected $resultSet;
    protected $type;

    public function setup()
    {
        $this->prophet = new \Prophecy\Prophet();
        $this->ob = $this->prophet->prophesize('Doctrine\Common\Persistence\ObjectManager');
        $this->container = $this->prophet->prophesize('Symfony\Component\DependencyInjection\Container');
        $this->elasticManager = $this->prophet->prophesize('FOS\ElasticaBundle\Doctrine\RepositoryManager');
        $this->elasticIndexManager = $this->prophet->prophesize('Elastica\Type');
        $this->repoManager = $this->prophet->prophesize('UDN\Bundle\DataTransferBundle\Entity\SearchRepository\OrderReportRepository');
        $this->resultSet = $this->prophet->prophesize('Elastica\ResultSet');
        $this->type = $this->createIndex();
        $this->type = $this->prophet->prophesize('Elastica\Type');

        $type = $this->createIndex();


        $index = $this->createIndex();

        $this->dash = new DashBoardManager($this->ob->reveal(), $this->container->reveal(), $this->type->reveal());



    }



    public function test_getZoneOrderValue()
    {
        $queryResult = array('by_zone' => array('buckets' => array(array('key_as_string' => '','key' => '','doc_count' => '','order_value' => array('value' => '')))));

        $this->container->get('fos_elastica.manager')->willReturn($this->elasticManager->reveal());
        $this->elasticManager->getRepository('UDNDataTransferBundle:OrderReport')->willReturn($this->repoManager->reveal());

        $this->repoManager->getZoneCount(2, '2015-02-22', '2015-02-22')->willReturn([]);

        $this->container->get('fos_elastica.index.rosia_test.orders_test')->willReturn($this->type->reveal());

        $this->type->search([])->willReturn($this->resultSet->reveal());
        $this->resultSet->getAggregations('by_zone')->willReturn($queryResult);

        $this
        $this->repoManager->getZoneName(2)->willReturn([]);

        $result = $this->dash->getZoneOrderValue(2, '2015-02-22', '2015-02-22');

        //$this->assertCount(2, $result[0]);
    }

What you're asking is done with a mock object. A mock object is a fake version of your intended class, that only looks if the function is called like you need to test.

There are a lot of mocking libraries, or you can do it directly with PHPUnit. This is an example taken from PHPUnit docs:

<?php
class SubjectTest extends PHPUnit_Framework_TestCase
{
    public function testObserversAreUpdated()
    {
        // Create a mock for the Observer class,
        // only mock the update() method.
        $observer = $this->getMockBuilder('Observer')
                         ->setMethods(array('update'))
                         ->getMock();

        // Set up the expectation for the update() method
        // to be called only once and with the string 'something'
        // as its parameter.
        $observer->expects($this->once())
                 ->method('update')
                 ->with($this->equalTo('something'));

        // Create a Subject object and attach the mocked
        // Observer object to it.
        $subject = new Subject('My subject');
        $subject->attach($observer);

        // Call the doSomething() method on the $subject object
        // which we expect to call the mocked Observer object's
        // update() method with the string 'something'.
        $subject->doSomething();
    }
}
?>