Docker\Tests\Manager\ImageManagerTest

Complexity

Total Complexity

9

Size/Duplication

Total Lines	120
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes	3
Bugs	0	Features	2

7 Methods

Rating	Name	Duplication	Size	Complexity
A	getManager()	0	4	1
A	testBuildStream()	0	19	1
A	testBuildObject()	0	11	1
A	testCreateStream()	0	19	2
A	testCreateObject()	0	9	1
B	testPushStream()	0	27	2
A	testPushObject()	0	17	1

<?php

namespace Docker\Tests\Manager;

use Docker\API\Model\AuthConfig;
use Docker\API\Model\BuildInfo;
use Docker\API\Model\CreateImageInfo;
use Docker\API\Model\PushImageInfo;
use Docker\Context\ContextBuilder;
use Docker\Manager\ImageManager;
use Docker\Tests\TestCase;

class ImageManagerTest extends TestCase
{
    /**
     * Return a container manager
     *
     * @return ImageManager
     */
    private function getManager()
    {
        return $this->getDocker()->getImageManager();
    }

    public function testBuildStream()
    {
        $contextBuilder = new ContextBuilder();
        $contextBuilder->from('ubuntu:precise');
        $contextBuilder->add('/test', 'test file content');

        $buildStream = $this->getManager()->build($contextBuilder->getContext()->read(), ['t' => 'test-image'], ImageManager::FETCH_STREAM);

        $this->assertInstanceOf('Docker\Stream\BuildStream', $buildStream);

        $lastMessage = "";

        $buildStream->onFrame(function (BuildInfo $frame) use (&$lastMessage) {

The method onFrame does only exist in Docker\Stream\BuildStream, but not in Psr\Http\Message\ResponseInterface.

            $lastMessage = $frame->getStream();
        });
        $buildStream->wait();

The method wait does only exist in Docker\Stream\BuildStream, but not in Psr\Http\Message\ResponseInterface.

        $this->assertContains("Successfully built", $lastMessage);
    }

    public function testBuildObject()
    {
        $contextBuilder = new ContextBuilder();
        $contextBuilder->from('ubuntu:precise');
        $contextBuilder->add('/test', 'test file content');

        $buildInfos = $this->getManager()->build($contextBuilder->getContext()->read(), ['t' => 'test-image'], ImageManager::FETCH_OBJECT);

        $this->assertInternalType('array', $buildInfos);
        $this->assertContains("Successfully built", $buildInfos[count($buildInfos) - 1]->getStream());
    }

    public function testCreateStream()
    {
        $createImageStream = $this->getManager()->create([
            'fromImage' => 'registry:latest'
        ], ImageManager::FETCH_STREAM);

        $this->assertInstanceOf('Docker\Stream\CreateImageStream', $createImageStream);

        $firstMessage = null;

        $createImageStream->onFrame(function (CreateImageInfo $createImageInfo) use (&$firstMessage) {

The method onFrame does only exist in Docker\Stream\CreateImageStream, but not in Psr\Http\Message\ResponseInterface.

            if (null === $firstMessage) {
                $firstMessage = $createImageInfo->getStatus();
            }
        });
        $createImageStream->wait();

The method wait does only exist in Docker\Stream\CreateImageStream, but not in Psr\Http\Message\ResponseInterface.

        $this->assertContains("Pulling from library/registry", $firstMessage);
    }

    public function testCreateObject()
    {
        $createImagesInfos = $this->getManager()->create([
            'fromImage' => 'registry:latest'
        ], ImageManager::FETCH_OBJECT);

        $this->assertInternalType('array', $createImagesInfos);
        $this->assertContains("Pulling from library/registry", $createImagesInfos[0]->getStatus());
    }

    public function testPushStream()
    {
        $contextBuilder = new ContextBuilder();
        $contextBuilder->from('ubuntu:precise');
        $contextBuilder->add('/test', 'test file content');

        $this->getManager()->build($contextBuilder->getContext()->read(), ['t' => 'localhost:5000/test-image'], ImageManager::FETCH_OBJECT);

        $registryConfig = new AuthConfig();
        $registryConfig->setServeraddress('localhost:5000');
        $pushImageStream = $this->getManager()->push('localhost:5000/test-image', [
            'X-Registry-Auth' => $registryConfig
        ], ImageManager::FETCH_STREAM);

        $this->assertInstanceOf('Docker\Stream\PushStream', $pushImageStream);

        $firstMessage = null;

        $pushImageStream->onFrame(function (PushImageInfo $pushImageInfo) use (&$firstMessage) {

The method onFrame does only exist in Docker\Stream\PushStream, but not in Psr\Http\Message\ResponseInterface.

            if (null === $firstMessage) {
                $firstMessage = $pushImageInfo->getStatus();
            }
        });
        $pushImageStream->wait();

The method wait does only exist in Docker\Stream\PushStream, but not in Psr\Http\Message\ResponseInterface.

        $this->assertContains("The push refers to a repository [localhost:5000/test-image]", $firstMessage);
    }

    public function testPushObject()
    {
        $contextBuilder = new ContextBuilder();
        $contextBuilder->from('ubuntu:precise');
        $contextBuilder->add('/test', 'test file content');

        $this->getManager()->build($contextBuilder->getContext()->read(), ['t' => 'localhost:5000/test-image'], ImageManager::FETCH_OBJECT);

        $registryConfig = new AuthConfig();
        $registryConfig->setServeraddress('localhost:5000');
        $pushImageInfos = $this->getManager()->push('localhost:5000/test-image', [
            'X-Registry-Auth' => $registryConfig
        ], ImageManager::FETCH_OBJECT);

        $this->assertInternalType('array', $pushImageInfos);
        $this->assertContains("The push refers to a repository [localhost:5000/test-image]", $pushImageInfos[0]->getStatus());
    }
}