indocker 0.0.6 → 0.1.0

data/spec/indocker/docker_api/container_config_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-
-describe Indocker::DockerAPI::ContainerConfig do
-  let(:params_hash) {
-    {
-      repo:          'indocker_image', 
-      tag:           'latest',
-      image:         'indocker_another_image:latest',
-      name:          'indocker_container', 
-      cmd:           ['/bin/bash'], 
-      volumes:       ['tmp', 'gems_volume'], 
-      exposed_ports: ['2000', '4000'], 
-      env:           'RUBY_ENV=development RAILS_ENV=development',
-      binds: [
-        { name: 'tmp',         to: '/tmp' },
-        { name: 'gems_volume', to: '/bundle' }
-      ], 
-      port_bindings: [{
-        container_port: '2000',
-        host_port:      '3000'
-      }]
-    }
-  }
-
-  
-
-  describe '#to_hash' do
-    it 'returns hash with valid params' do
-      expect(
-        described_class.new(params_hash).to_hash
-      ).to match(
-        {
-          'Image'        => 'indocker_another_image:latest',
-          'name'         => 'indocker_container',
-          'Cmd'          => ['/bin/bash'],
-          'Env'          => 'RUBY_ENV=development RAILS_ENV=development',
-          'Tty'          => true,
-          'OpenStdin'    => true,
-          'StdinOnce'    => true,
-          'AttachStdin'  => true,
-          'AttachStdout' => true,
-          'ExposedPorts' => { 
-            '2000' => {}, 
-            '4000' => {} 
-          },
-          'Volumes' => {
-            'tmp'         => {},
-            'gems_volume' => {}
-          },
-          'HostConfig' => {
-            'Binds'        => ['tmp:/tmp', 'gems_volume:/bundle'],
-            'PortBindings' => {
-              '2000' => [
-                {
-                  'HostPort' => '3000'
-                }
-              ]
-            }
-          }
-        }
-      )
-    end
-  end
-end

data/spec/indocker/docker_api/docker_api_spec.rb

@@ -1,112 +0,0 @@
-require 'spec_helper'
-
-describe Indocker::DockerAPI do
-  let(:docker_api) { ioc.docker_api }
-
-  describe '#create_network' do
-    context 'simple network' do
-      let!(:id) { docker_api.create_network('indocker') }
-
-      after { docker_api.delete_network(id) }
-
-      it 'creates network' do
-        expect(
-          docker_api.get_network_id('indocker')
-        ).to eq(id)
-      end
-    end
-  end
-
-  describe '#add_container_to_network' do
-    let(:container_id) { 
-      docker_api.create_container(
-        Indocker::DockerAPI::ContainerConfig.new(
-          image: 'alpine:latest',
-          name:  'sample_container'
-        )
-      ) 
-    }
-
-    let(:network_id) { docker_api.create_network('indocker') }
-
-    after do
-      docker_api.stop_container(container_id)
-      docker_api.delete_container(container_id)
-      docker_api.delete_network(network_id)
-    end
-
-    it 'do something' do
-      docker_api.add_container_to_network(
-        network_name:   network_id,
-        container_name: container_id
-      )
-        
-      docker_api.start_container(container_id)
-
-      expect(
-        docker_api.inspect_network(network_id)['Containers'].keys
-      ).to include(container_id)
-    end
-  end
-
-  describe '#get_image_id' do
-    context 'if image presents' do
-      it 'returns instance of Docker::Image class' do
-        expect(docker_api.get_image_id('alpine')).to be_a(String)
-      end
-    end
-
-    context 'if image does not present' do
-      it 'returns nil ' do
-        expect(docker_api.get_image_id('some-invalid-image')).to eq(nil)
-      end
-    end
-  end
-
-  describe '#create_volume' do
-    context 'simple volume' do
-      let!(:id) { docker_api.create_volume('volume') }
-      
-      after { docker_api.delete_volume(id) }
-      
-      it 'creates volume' do
-        expect(
-          docker_api.get_volume_id('volume')
-        ).to eq(id)
-      end
-    end
-  end
-
-  describe '#create_volume' do
-    context 'simple volume' do
-      let!(:id) { docker_api.create_volume('volume') }
-      
-      after { docker_api.delete_volume(id) }
-      
-      it 'creates volume' do
-          expect(
-              docker_api.get_volume_id('volume')
-            ).to eq(id)
-        end
-
-    end
-  end
-
-  describe '#get_container_id' do
-    context 'if container presents' do
-      let!(:container) { Docker::Container.create('Image' => 'alpine:latest', 'name': 'alpine') }
-      after { container.delete(force: true) }
-
-      it 'returns container_id string' do
-        expect(docker_api.get_container_id('alpine')).to be_a(String)
-        expect(docker_api.get_container_id('alpine').size).to eq(64)
-      end
-    end
-
-    context 'if container does not present' do
-      it 'returns nil' do
-        expect(docker_api.get_container_id('invalid-container-name')).to eq(nil)
-      end
-    end
-  end
-end

data/spec/indocker/handlers/container_run_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-describe 'Indocker::Handlers::ContainerRun' do
-  describe '#handle' do
-    after(:all) { truncate_docker_items }
-    
-    before(:all) do
-      Indocker.define_image :indocker_image do
-        from 'alpine:latest'
-        
-        cmd  ['/bin/sh']
-      end
-    end
-    context 'for valid cmd process in container' do
-      context 'for new container' do
-        before(:all) do
-          Indocker.define_container :indocker_correct_container do
-            use images.find_by_repo(:indocker_image)
-          end
-
-          ioc.run_container_handler.handle(name: :indocker_correct_container, current_path: nil)
-        end
-        
-        it 'creates container' do
-          expect(
-            ioc.docker_api.container_exists?(:indocker_correct_container)
-          ).to be true
-        end
-
-        it 'runs container' do
-          expect(
-            ioc.docker_api.get_container_state(:indocker_correct_container)
-          ).to eq(Indocker::ContainerMetadata::States::RUNNING)
-        end
-
-        it 'logs successfull result' do
-          expect(
-            ioc.logger.messages.last
-          ).to eq("INFO".colorize(:green) + ": Successfully started container :indocker_correct_container")
-        end
-      end
-    end
-    
-    context 'for falling cmd process in container' do
-      before(:all) do
-        Indocker.define_container :container_with_falling_cmd do
-          use images.find_by_repo(:indocker_image)
-
-          cmd ['invalid_command']
-        end
-      end
-      
-      it 'raises Docker::Error::ClientError error' do
-        expect{
-          ioc.run_container_handler.handle(name: :container_with_falling_cmd, current_path: nil)
-        }.to raise_error(Docker::Error::ClientError)
-      end
-    end
-  end
-end

data/spec/indocker/image/image_builder_spec.rb

@@ -1,153 +0,0 @@
-require 'spec_helper'
-
-describe 'Indocker::ImageBuilder' do
-  context 'for image without dependencies' do
-    before(:all) do
-      Indocker.define_image('indocker_image') do
-        from 'hello-world'
-        workdir '/'
-      end
-
-      ioc.image_builder.build('indocker_image')
-    end
-
-    after(:all) { truncate_docker_items }
-
-    it 'builds image without dependencies' do
-      expect(
-        ioc.docker_api.image_exists?('indocker_image')
-      ).to be true
-    end
-
-    it 'deletes build_path after image building' do
-      image_metadata = ioc.image_metadata_repository.find_by_repo('indocker_image')
-
-      expect(
-        File.exists?(image_metadata.build_dir)
-      ).to be false
-    end
-  end
-
-  context 'for image with dependencies' do
-    context 'circular docker_cp dependency' do
-      before do
-        Indocker.define_image('indocker_image') do
-          before_build do
-            docker_cp 'indocker_container'
-          end
-          
-          from 'hello-world'
-          workdir '/'
-        end
-
-        Indocker.define_container 'indocker_container' do
-          use images.find_by_repo(:indocker_image)
-        end
-      end
-
-      after(:all) { truncate_docker_items }
-
-      it 'raises Indocker::Errors::CircularImageDependency' do
-        expect{
-          ioc.image_builder.build('indocker_image')
-        }.to raise_error(Indocker::Errors::CircularImageDependency)
-      end
-    end
-
-    context 'for non circular docker_cp dependency' do
-      before do
-        Indocker.define_image('indocker_dependency_image') do          
-          from 'alpine:latest'
-          workdir '/'
-          run 'echo "Hello World" > test.txt'
-        end
-
-        Indocker.define_image('indocker_image') do
-          before_build do
-            docker_cp 'indocker_container' do
-              copy 'test.txt' => '/copy' 
-            end
-          end
-          
-          from :indocker_dependency_image, tag: :latest
-          workdir '/'
-          copy '/copy/test.txt' => '/'
-        end
-
-        Indocker.define_container 'indocker_container' do
-          use images.find_by_repo(:indocker_dependency_image)
-        end
-
-        ioc.image_builder.build('indocker_image')
-      end
-
-      after(:all) { truncate_docker_items }
-
-      it 'builds image with dependency' do
-        expect(
-          ioc.docker_api.image_exists?('indocker_image')
-        ).to be true
-      end
-    end
-  end
-
-  context 'for not existing image' do
-    it 'raises Indocker::Errors::ImageIsNotDefined' do
-      expect{
-        ioc.image_builder.build('indocker_image')
-      }.to raise_error(Indocker::Errors::ImageIsNotDefined)
-    end
-  end
-
-  context 'when push image to registry' do
-    before(:all) do
-      Indocker.define_image('indocker_image') do
-        from 'alpine:latest'
-        
-        use registry.localhost(push: true)
-      end
-
-      set_local_registry
-      ioc.image_builder.build('indocker_image')
-    end
-
-    it 'tags image with specified registry_repo_tag' do
-      expect(
-        ioc.docker_api.image_exists?('localhost:1000/indocker_image')
-      ).to be true
-    end
-
-    it 'pushes image to registry' do
-      ioc.docker_api.delete_image('indocker_image')
-
-      ioc.docker_api.pull('fromImage' => 'localhost:1000/indocker_image:latest')
-
-      expect(
-        ioc.docker_api.image_exists?('localhost:1000/indocker_image')
-      ).to be true
-    end
-
-    after(:all) do 
-      ioc.registry_api.get(:localhost).rmtag('indocker_image')
-      truncate_docker_items
-    end
-  end
-
-  context 'with coping files from project_root' do
-    before do
-      Indocker.define_image('indocker_image') do          
-        from 'alpine:latest'
-
-        copy File.join(__dir__, '../../example/assets/.') => 'assets'
-      end
-    end
-
-    after(:all) { truncate_docker_items }
-
-    it 'does not raise error' do
-      expect{
-        ioc.image_builder.build('indocker_image')
-      }.to_not raise_error
-    end
-  end
-end

data/spec/indocker/image/image_directives_runner_spec.rb

@@ -1,141 +0,0 @@
-require 'spec_helper'
-
-describe Indocker::ImageDirectivesRunner do
-  let(:image_directives_runner) { ioc.image_directives_runner }
-  let(:project_dir)             { Pathname.new File.expand_path(File.join(__dir__, '../../example')) }
-
-  let(:context) {
-    Indocker::DSLContext.new(
-      display:    'none',
-      use_strict: true,
-      build_dir:  build_dir,
-      repo:       'indocker_image',
-      tag:        'latest'
-    )
-  }
-
-  let(:build_dir) { ioc.config.build_dir }
-
-
-  describe '#run_registry' do
-    let(:registry_directive) do
-      Indocker::ImageDirectives::Registry.new(
-        repo:     'indocker_image',
-        tag:      'latest',
-        registry: 'http://localhost:5000',
-        push:     true
-      )
-    end
-
-    class DockerImageStub
-      def tag(*args)
-      end
-
-      def push(*args)
-      end
-    end
-
-    it 'tags image with registry_repotag' do
-      allow(Docker::Image).to receive(:get).and_return(DockerImageStub.new)
-      expect_any_instance_of(DockerImageStub).to receive(:tag)
-
-      image_directives_runner.run(registry_directive)
-    end
-
-    it 'pushes registry_repotag' do
-      allow(Docker::Image).to receive(:get).and_return(DockerImageStub.new)
-      expect_any_instance_of(DockerImageStub).to receive(:push)
-
-      image_directives_runner.run(registry_directive)
-    end
-  end
-
-  describe "#run_copy" do
-    let(:from_path) { project_dir.join 'assets/.' }
-    let(:to_path)   { '/assets' }
-    let(:copy_directive) { 
-      Indocker::ImageDirectives::Copy.new(
-        locals:    context.storage,
-        build_dir: context.build_dir, 
-        compile:   false,
-        copy_actions: { 
-          from_path => to_path 
-        }
-      ) 
-    }
-    
-    context 'for :from as directory path' do
-      context "when directory exists" do
-        it 'copy files from passed to build directory' do
-          image_directives_runner.run(copy_directive)
-
-          ensure_content(File.join(build_dir, project_dir, 'assets', 'index.css'), "* { display: <%= display %>; }")
-          ensure_content(File.join(build_dir, project_dir, 'assets', 'index.js'), "<% if use_strict %>'use strict';<% end %>")
-        end
-      end
-
-      context "when directory does not exists" do
-        let(:from_path) { 'invalid/dir/.' }
-        let(:to_path)   { '/invalid/dir' }
-
-        it "raises error ArgumentError" do
-          expect{
-            image_directives_runner.run(copy_directive)
-          }.to raise_error(ArgumentError)
-        end
-      end
-
-      context 'with compile: true option' do
-        let(:copy_directive) { 
-          Indocker::ImageDirectives::Copy.new(
-            locals:    context.storage,
-            build_dir: context.build_dir, 
-            compile:   true,
-            copy_actions: { 
-              from_path => to_path 
-            }
-          ) 
-        }
-
-        it 'copy compiles files from root to build directory' do
-          image_directives_runner.run(copy_directive)
-
-          ensure_content(File.join(build_dir, project_dir, 'assets', 'index.css'), "* { display: none; }")
-          ensure_content(File.join(build_dir, project_dir, 'assets', 'index.js'), "'use strict';")
-        end
-      end
-    end
-
-    context "for :from as single file path" do
-      let(:from_path) { project_dir.join 'assets/index.css' }
-      let(:to_path)   { '/assets' }
-
-      context 'without compilation' do
-        it 'copy files from root to build directory if no file in build directory' do
-          image_directives_runner.run(copy_directive)
-          
-          ensure_content(File.join(build_dir, project_dir, 'assets', 'index.css'), "* { display: <%= display %>; }")
-        end
-      end
-
-      context 'with compilaton' do
-        let(:copy_directive) { 
-          Indocker::ImageDirectives::Copy.new(
-            locals:    context.storage,
-            build_dir: context.build_dir, 
-            compile:   true,
-            copy_actions: { 
-              from_path => to_path 
-            }
-          ) 
-        }
-
-        it 'compiles and overwrites file is present in build directory' do
-          image_directives_runner.run(copy_directive)
-
-          ensure_content(File.join(build_dir, project_dir, 'assets', 'index.css'), "* { display: none; }")
-        end
-      end
-    end
-  end
-end