indocker 0.0.2 → 0.0.5

data/spec/indocker/{utils → docker_api}/docker_api_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
-describe Indocker::DockerApi do
+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.remove_network(id) }
+      after { docker_api.delete_network(id) }
 
       it 'creates network' do
         expect(
@@ -20,10 +20,10 @@ describe Indocker::DockerApi do
   describe '#add_container_to_network' do
     let(:container_id) { 
       docker_api.create_container(
-        repo:    'alpine',
-        tag:     'latest',
-        name:    'indocker_alpine_container',
-        command: %w(tail -F -n0 /etc/hosts)
+        Indocker::DockerAPI::ContainerConfig.new(
+          image: 'alpine:latest',
+          name:  'sample_container'
+        )
       ) 
     }
 
@@ -32,7 +32,7 @@ describe Indocker::DockerApi do
     after do
       docker_api.stop_container(container_id)
       docker_api.delete_container(container_id)
-      docker_api.remove_network(network_id)
+      docker_api.delete_network(network_id)
     end
 
     it 'do something' do
@@ -58,13 +58,40 @@ describe Indocker::DockerApi do
 
     context 'if image does not present' do
       it 'returns nil ' do
-        expect{
-          docker_api.get_image_id('some-invalid-image')
-        }.to raise_error(Docker::Error::NotFoundError)
+        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') }
@@ -78,9 +105,7 @@ describe Indocker::DockerApi do
 
     context 'if container does not present' do
       it 'returns nil' do
-        expect{
-          docker_api.get_container_id('invalid-container-name')
-        }.to raise_error(Docker::Error::NotFoundError)
+        expect(docker_api.get_container_id('invalid-container-name')).to eq(nil)
       end
     end
   end

data/spec/indocker/handlers/container_run_spec.rb

@@ -0,0 +1,60 @@
+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,20 +1,18 @@
 require 'spec_helper'
 
 describe 'Indocker::ImageBuilder' do
-  subject { ioc.image_builder }
-
   context 'for image without dependencies' do
-    before do
+    before(:all) do
       Indocker.define_image('indocker_image') do
-        before_build { 'test' }
-        
         from 'hello-world'
         workdir '/'
       end
 
-      subject.build('indocker_image')
+      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')
@@ -31,59 +29,63 @@ describe 'Indocker::ImageBuilder' do
   end
 
   context 'for image with dependencies' do
-    context 'circular dependencies' do
+    context 'circular docker_cp dependency' do
       before do
-        Indocker.define_image('indocker_circular_image') do
+        Indocker.define_image('indocker_image') do
           before_build do
-            docker_cp 'circular_container'
+            docker_cp 'indocker_container'
           end
           
           from 'hello-world'
           workdir '/'
         end
 
-        Indocker.define_container 'circular_container' do
-          use images.indocker_circular_image
+        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{
-          subject.build('indocker_circular_image')
+          ioc.image_builder.build('indocker_image')
         }.to raise_error(Indocker::Errors::CircularImageDependency)
       end
     end
 
-    context 'for non circular dependencies' do
+    context 'for non circular docker_cp dependency' do
       before do
-        Indocker.define_image('indocker_image') do          
+        Indocker.define_image('indocker_dependency_image') do          
           from 'alpine:latest'
           workdir '/'
           run 'echo "Hello World" > test.txt'
         end
 
-        Indocker.define_image('indocker_image_with_dependency') do
+        Indocker.define_image('indocker_image') do
           before_build do
             docker_cp 'indocker_container' do
-              copy 'test.txt' => build_dir
+              copy 'test.txt' => '/copy' 
             end
           end
           
-          from 'alpine:latest'
+          from :indocker_dependency_image, tag: :latest
           workdir '/'
-          copy 'test.txt' => '/'
+          copy '/copy/test.txt' => '/'
         end
 
         Indocker.define_container 'indocker_container' do
-          use images.indocker_image
+          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
-        subject.build('indocker_image_with_dependency')
-        
         expect(
-          ioc.docker_api.image_exists?('indocker_image_with_dependency')
+          ioc.docker_api.image_exists?('indocker_image')
         ).to be true
       end
     end
@@ -92,23 +94,59 @@ describe 'Indocker::ImageBuilder' do
   context 'for not existing image' do
     it 'raises Indocker::Errors::ImageIsNotDefined' do
       expect{
-        subject.build('indocker_image_without_dependencies')
+        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_copy_image') do          
+      Indocker.define_image('indocker_image') do          
         from 'alpine:latest'
 
-        copy 'assets/.' => 'assets'
+        copy File.join(__dir__, '../../example/assets/.') => 'assets'
       end
     end
 
+    after(:all) { truncate_docker_items }
+
     it 'does not raise error' do
       expect{
-        subject.build('indocker_copy_image')
+        ioc.image_builder.build('indocker_image')
       }.to_not raise_error
     end
   end

data/spec/indocker/image/image_directives_runner_spec.rb

@@ -0,0 +1,141 @@
+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

data/spec/indocker/image/image_dockerfile_builder_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Indocker::ImageDockerfileBuilder do
+  subject { ioc.image_dockerfile_builder }
+  
+  describe '#build' do
+    let(:from_directive)     { Indocker::ImageDirectives::From.new('ruby-alpine:latest') }
+    let(:workdir_directive)  { Indocker::ImageDirectives::Workdir.new('/app') }
+    let(:env_file_directive) { 
+      Indocker::ImageDirectives::EnvFile.new(
+        File.expand_path(File.join(__dir__, '../../fixtures/spec.env'))
+      ) 
+    }
+
+    it 'generates valid dockerfile' do
+      expect(
+        subject.build(from_directive, workdir_directive, env_file_directive)
+      ).to eq(
+        "FROM ruby-alpine:latest\n" <<
+        "WORKDIR /app\n" <<
+        "ENV RUBY_ENV=development RAILS_ENV=development"
+      )
+    end
+  end
+end

data/spec/indocker/image/image_evaluator_spec.rb

@@ -1,7 +1,8 @@
 require 'spec_helper'
 
 describe 'Indocker::ImageEvaluator' do
-  subject { ioc.image_evaluator }
+  subject       { ioc.image_evaluator }
+  let(:context) { Indocker::DSLContext.new(build_dir: 'some/path') }
 
   before do    
     Indocker.define_partial 'example_partial' do
@@ -41,7 +42,6 @@ describe 'Indocker::ImageEvaluator' do
       end
     end
     
-    let(:context)    { Indocker::DSLContext.new(build_dir: 'some/path') }
     let(:directives) { subject.evaluate(context, &example_image_definition) }
 
     it 'returns array of directives' do
@@ -53,13 +53,33 @@ describe 'Indocker::ImageEvaluator' do
     end
 
     it 'rerurns proper directives classes' do
-      expect(directives[0]).to be_a(Indocker::PrepareDirectives::DockerCp)
-      expect(directives[1]).to be_a(Indocker::DockerDirectives::From)
-      expect(directives[2]).to be_a(Indocker::PrepareDirectives::DockerCp)
-      expect(directives[3]).to be_a(Indocker::DockerDirectives::Run)
-      expect(directives[4]).to be_a(Indocker::DockerDirectives::Run)
-      expect(directives[5]).to be_a(Indocker::DockerDirectives::Workdir)
-      expect(directives[6]).to be_a(Indocker::DockerDirectives::Run)
+      expect(directives[0]).to be_a(Indocker::ImageDirectives::DockerCp)
+      expect(directives[1]).to be_a(Indocker::ImageDirectives::From)
+      expect(directives[2]).to be_a(Indocker::ImageDirectives::DockerCp)
+      expect(directives[3]).to be_a(Indocker::ImageDirectives::Run)
+      expect(directives[4]).to be_a(Indocker::ImageDirectives::Run)
+      expect(directives[5]).to be_a(Indocker::ImageDirectives::Workdir)
+      expect(directives[6]).to be_a(Indocker::ImageDirectives::Run)
+    end
+  end
+
+  context 'with partial with options' do
+    let(:image_with_partial_definition) {
+      Proc.new do
+        partial :partial_directive, some_arg: 'some_arg_value'
+      end
+    }
+
+    before(:all) do
+      Indocker.define_partial :partial_directive do
+        run "echo #{some_arg}"
+      end
+    end
+
+    it 'generates valid dockerfile' do
+      partial_directive = subject.evaluate(context, &image_with_partial_definition).first
+
+      expect(partial_directive.to_s).to eq(%q(RUN echo some_arg_value))
     end
   end
 end

data/spec/spec_helper.rb

@@ -10,7 +10,10 @@ SmartIoC.set_load_proc do |location|
   require(location)
 end
 
-Indocker.root(Pathname.new File.expand_path(File.join(__dir__, 'example')))
+ioc.config.build_dir      Pathname.new File.expand_path(File.join(__dir__, '../tmp/build'))
+ioc.config.git.cache_dir  Pathname.new File.expand_path(File.join(__dir__, '../tmp/cache'))
+
+ioc.config.docker.registry(:localhost) { serveraddress 'http://localhost:1000' }
 
 RSpec.configure do |config|
   config.expect_with :rspec do |expectations|
@@ -20,21 +23,7 @@ RSpec.configure do |config|
   config.mock_with :rspec
   config.shared_context_metadata_behavior = :apply_to_host_groups
 
-  config.after(:each) do
-    ioc.docker_api.delete_containers_where { |container| container.refresh!.info['Config']['Image'] =~ /^indocker/ }
-    ioc.docker_api.delete_containers_where { |container| container.refresh!.info['Names'].grep(/^\/indocker/).any? }
-    ioc.docker_api.delete_images_where     { |image|     image.info['RepoTags'].grep(/^indocker/).any? }
-    ioc.docker_api.delete_networks_where   { |network|   network.info['Name'] =~ /^indocker/ }
-
-    ioc.image_metadata_repository.clear
-    ioc.container_metadata_repository.clear
-    ioc.partial_metadata_repository.clear
-    ioc.network_metadata_repository.clear
-
-    ioc.logger.clear
-
-    FileUtils.rm_rf(Dir.glob(File.join(__dir__, '../tmp/*')))
-  end
+  config.after(:all) { truncate_docker_items }
 end
 
 def ensure_exists(file)
@@ -43,4 +32,37 @@ end
 
 def ensure_content(file, content)
   expect(File.read(file)).to match(content)
+end
+
+def truncate_docker_items
+  ioc.docker_api.delete_containers_where { |container| container.refresh!.info['Config']['Image'] =~ /^indocker/ }
+  ioc.docker_api.delete_containers_where { |container| container.refresh!.info['Names'].grep(/^\/indocker/).any? }
+  ioc.docker_api.delete_images_where     { |image|     image.info['RepoTags'].grep(/^indocker/).any? }
+  ioc.docker_api.delete_networks_where   { |network|   network.info['Name'] =~ /^indocker/ }
+  ioc.docker_api.delete_volumes_where    { |volume|    volume.info['Name'] =~ /^indocker/ }
+
+  ioc.image_metadata_repository.clear
+  ioc.container_metadata_repository.clear
+  ioc.partial_metadata_repository.clear
+  ioc.network_metadata_repository.clear
+  ioc.volume_metadata_repository.clear
+
+  ioc.logger.clear
+    
+  FileUtils.rm_rf(Dir.glob(File.join(__dir__, '../tmp/*')))
+end
+
+def set_local_registry
+  Indocker.define_image :registry do
+    from 'registry:latest'
+  end
+  
+  Indocker.define_container :indocker_registry do
+    use images.find_by_repo(:registry)
+    env 'REGISTRY_STORAGE_DELETE_ENABLED=true'
+    ports '5000:1000'
+  end
+  
+  ioc.image_builder.build('registry')
+  ioc.container_manager.run('indocker_registry')
 end