indocker 0.0.2 → 0.0.5

data/spec/indocker/configs/config_spec.rb

@@ -3,6 +3,26 @@ require 'spec_helper'
 describe Indocker::Configs::Config do
   subject { described_class.new }
 
+  context 'restricts to use reserved keywords' do
+    it 'raise Indocker::Errors::ReservedKeywordUsed "option" name' do
+      expect{
+        subject.option(:config)
+      }.to raise_error(Indocker::Errors::ReservedKeywordUsed)
+    end
+
+    it 'restrict to use "config" name' do
+      expect{
+        subject.config('hash_config')
+      }.to raise_error(Indocker::Errors::ReservedKeywordUsed)
+    end
+
+    it 'restrict to use "hash_config" name' do
+      expect{
+        subject.hash_config(:option)
+      }.to raise_error(Indocker::Errors::ReservedKeywordUsed)
+    end
+  end
+
   describe '#option' do
     it 'creates setter and getter methods with the same name' do
       subject.option(:some_key, group: :default, type: :string)
@@ -21,7 +41,7 @@ describe Indocker::Configs::Config do
   end
 
   describe '#config' do
-    it 'creates getter and subconfiguration object' do
+    it 'creates getter and subconfiguration object for single option' do
       subject.config(:example_config) do
         option(:key1)
         option(:key2, type: :array)
@@ -33,5 +53,36 @@ describe Indocker::Configs::Config do
       expect(subject.example_config.key1).to eq('value1')
       expect(subject.example_config.key2).to match(['value2'])
     end
+
+    it 'creates getter and subconfig for subconfiguration' do
+      subject.config(:parent_config) do
+        config(:child_config) do
+          option(:child_option)
+        end
+      end
+      
+      subject.parent_config.child_config.child_option('Hello World')
+      
+      expect(subject.parent_config.child_config.child_option).to eq('Hello World')
+    end
+  end
+
+  describe '#hash_config' do
+    it 'create subconfiguration for each hash_config key' do
+      subject.hash_config(:multi) do
+        option(:key1)
+      end
+
+      subject.multi(:config1) do
+        key1('value 1')
+      end
+
+      subject.multi(:config2) do
+        key1('value 2')
+      end
+      
+      expect(subject.config1.key1).to eq('value 1')
+      expect(subject.config2.key1).to eq('value 2')
+    end
   end
 end

data/spec/indocker/container/container_builder_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+# TODO: rename to ContainerConfigBuilder
+describe Indocker::ContainerBuilder do
+  describe '#build' do
+    subject { ioc.container_builder }
+    
+    before(:all) do
+      Indocker.define_image :indocker_image do
+        from 'ruby:2.3.1'
+        workdir '/app'
+        cmd 'ls'
+      end
+
+      Indocker.define_network :indocker_network
+      Indocker.define_volume  :indocker_volume
+
+      Indocker.define_container :indocker_container do
+        use images.find_by_repo(:indocker_image, tag: :latest)
+        use networks.find_by_name(:indocker_network)
+        
+        mount volumes.find_by_name(:indocker_volume), to: '/tmp'
+
+        env_file File.join(__dir__, '../../fixtures/spec.env')
+        ports '2000:3000'
+        cmd  '/bin/bash'
+      end
+    end
+
+    after(:all) { truncate_docker_items }
+
+    it 'returns instance of Indocker::DockerAPI::ContainerConfig' do
+      expect(
+        subject.build(:indocker_container)
+      ).to be_a(Indocker::DockerAPI::ContainerConfig)
+    end
+
+    it 'returns config with valid params' do
+      result = subject.build(:indocker_container)
+      
+      expect(result.image).to eq('indocker_image:latest')
+      expect(result.name).to  eq(:indocker_container)
+      expect(result.cmd).to   eq('/bin/bash')
+      expect(result.env).to   match(['RUBY_ENV=development', 'RAILS_ENV=development'])
+
+      expect(result.exposed_ports).to be_a(Indocker::DockerAPI::ContainerConfig::ExposedPortsConfig)
+      expect(result.exposed_ports.ports).to eq(['2000'])
+
+      expect(result.host_config).to be_a(Indocker::DockerAPI::ContainerConfig::HostConfig)
+      expect(result.host_config.port_bindings).to match([
+        {
+          container_port: '2000',
+          host_port:      '3000'
+        }
+      ])
+      expect(result.host_config.binds).to match([
+        {
+          name: 'indocker_volume',
+          to:   '/tmp'
+        }
+      ])
+
+      expect(result.volumes_config).to be_a(Indocker::DockerAPI::ContainerConfig::VolumesConfig)
+      expect(result.volumes_config.volumes).to eq(['/indocker_volume'])
+    end
+  end
+end

data/spec/indocker/container/container_manager_spec.rb

@@ -1,230 +1,278 @@
 require 'spec_helper'
 
 describe Indocker::ContainerManager do
-  let(:container_manager) { ioc.container_manager }
-  let(:docker_api)        { ioc.docker_api }
+  before(:all) do
+    Indocker.define_image 'indocker_image' do
+      from 'alpine:latest'
+      cmd %w(ls)
+    end
 
-  describe '#create' do
-    before do
-      Indocker.define_image 'indocker_image' do
-        from 'alpine:latest'
-        workdir '.'
-        cmd %w(tail -F -n0 /etc/hosts)
-      end
+    ioc.image_builder.build('indocker_image')
 
-      ioc.image_builder.build('indocker_image')
+    Indocker.define_container 'indocker_container' do
+      use images.find_by_repo(:indocker_image)
     end
+  end
 
-    context 'for existing image' do
-      before do
-        Indocker.define_container 'indocker_simple_container' do
-          use images.indocker_image
-        end
-      end
+  after(:all) { truncate_docker_items }
 
-      it 'runs container' do
-        container_manager.create('indocker_simple_container')
+  describe '#run' do
+    before(:all) { ioc.container_manager.run('indocker_container') }
+    after(:all)  { ioc.docker_api.delete_container('indocker_container') }
 
-        expect(
-          ioc.docker_api.container_exists?('indocker_simple_container')
-        ).to be true
-      end
+    it 'creates container' do
+      expect(
+        ioc.docker_api.container_exists?('indocker_container')
+      ).to be true
+    end
+
+    it 'starts container' do
+      sleep 1 # wait when container stops
+
+      expect(
+        ioc.docker_api.get_container_state('indocker_container')
+      ).to eq(Indocker::ContainerMetadata::States::EXITED)
     end
   end
 
-  describe '#start' do
-    before do
-      Indocker.define_image 'indocker_image' do
-        from 'alpine:latest'
-        workdir '.'
-        cmd %w(tail -F -n0 /etc/hosts)
-      end
+  describe '#create' do
+    before(:all) { ioc.container_manager.create('indocker_container') }
+    after(:all)  { ioc.docker_api.delete_container('indocker_container') }
 
-      ioc.image_builder.build('indocker_image')
+    it 'creates container' do
+      expect(
+        ioc.docker_api.container_exists?('indocker_container')
+      ).to be true
     end
-    
-    context 'with ready timeout' do
-      before do
-        Indocker.define_container 'indocker_timeout_container' do
-          use images.indocker_image
+  end
 
-          ready sleep: 0.1, timeout: 1 do
-            sleep 0.5
-            true
+  describe '#start' do
+    context 'with ready timeout' do
+      context 'if ready returns true' do
+        before(:all) do
+          Indocker.define_container 'indocker_timeout_container' do
+            use images.find_by_repo(:indocker_image)
+
+            ready sleep: 0.1, timeout: 1 do
+              sleep 0.5
+              true
+            end
           end
+
+          ioc.container_manager.create('indocker_timeout_container')
         end
 
-        Indocker.define_container 'indocker_timeout_error_container' do
-          use images.indocker_image
+        it 'starts container if ready_block returns true' do
+          ioc.container_manager.start('indocker_timeout_container')
 
-          ready sleep: 0.1, timeout: 1 do
-            false
-          end
+          sleep 1 # wait when container stops
+
+          expect(
+            ioc.docker_api.get_container_state('indocker_timeout_container')
+          ).to eq(Indocker::ContainerMetadata::States::EXITED)
         end
+      end
 
+      context 'if ready returns false' do
+        before(:all) do
+          Indocker.define_container 'indocker_timeout_error_container' do
+            use images.find_by_repo(:indocker_image)
 
-        ioc.container_manager.create('indocker_timeout_container')
-        ioc.container_manager.create('indocker_timeout_error_container')
-      end
+            ready sleep: 0.1, timeout: 1 do
+              false
+            end
+          end
+
+          ioc.container_manager.create('indocker_timeout_error_container')
+        end
 
-      after do
-        container_manager.stop('indocker_timeout_container')
-        container_manager.delete('indocker_timeout_container')
-        container_manager.stop('indocker_timeout_error_container')
-        container_manager.delete('indocker_timeout_error_container')
+        it 'raises Indocker::Errors::ContainerTimeoutError error if ready_block returns false' do
+          expect{
+            ioc.container_manager.start('indocker_timeout_error_container')
+          }.to raise_error(Indocker::Errors::ContainerTimeoutError)
+        end
       end
 
-      it 'starts container if ready_block returns true' do
-        container_manager.start('indocker_timeout_container')
+      context 'if ready reaches timeout' do
+        before(:all) do
+          Indocker.define_container 'indocker_timeout_reached_container' do
+            use images.find_by_repo(:indocker_image)
 
-        expect(
-          docker_api.get_container_state('indocker_timeout_container')
-        ).to eq(Indocker::ContainerMetadata::States::RUNNING)
-      end
+            ready sleep: 0.1, timeout: 1 do
+              sleep 2
+
+              true
+            end
+          end
+
+          ioc.container_manager.create('indocker_timeout_reached_container')
+        end
 
-      it 'raises Indocker::Errors::ContainerTimeoutError error if ready_block returns false' do
-        expect{
-          container_manager.start('indocker_timeout_error_container')
-        }.to raise_error(Indocker::Errors::ContainerTimeoutError)
+        it 'raises Indocker::Errors::ContainerTimeoutError error if ready_block returns false' do
+          expect{
+            ioc.container_manager.start('indocker_timeout_reached_container')
+          }.to raise_error(Indocker::Errors::ContainerTimeoutError)
+        end
       end
     end
 
     context 'with container dependencies' do
-      let(:main_container_id)      { docker_api.get_container_id('indocker_main_container') }
-      let(:dependecy_container_id) { docker_api.get_container_id('indocker_dependency_container') }
+      before(:all) do
+        Indocker.define_container 'indocker_container_depends_on' do
+          use images.find_by_repo(:indocker_image)
 
-      before do
-        Indocker.define_container 'indocker_dependency_container' do
-          use images.indocker_image
+          depends_on containers.get_by_name('indocker_container')
         end
 
-        Indocker.define_container 'indocker_main_container' do
-          use images.indocker_image
+        ioc.container_manager.create('indocker_container_depends_on')
+      end
 
-          depends_on containers.get_by_name('indocker_dependency_container')
-        end
+      after(:all)  { ioc.docker_api.delete_container('indocker_container') }
+
+      it 'starts dependency container before' do
+        ioc.container_manager.start('indocker_container_depends_on')
+
+        sleep 1 # wait when container stops
+
+        expect(
+          ioc.docker_api.get_container_state('indocker_container')
+        ).to eq(Indocker::ContainerMetadata::States::EXITED)
+      end
+    end
 
-        ioc.container_manager.create('indocker_main_container')
-        ioc.container_manager.create('indocker_dependency_container')
+    context 'with specified volume' do
+      before(:all) do
+        Indocker.define_volume 'indocker_volume'
+
+        Indocker.define_container 'indocker_volume_container' do
+          use images.find_by_repo(:indocker_image)
+          mount volumes.find_by_name('indocker_volume'), to: '/app'
+        end
 
-        container_manager.start('indocker_main_container')
+        ioc.container_manager.create('indocker_volume_container')
+        ioc.container_manager.start('indocker_volume_container')
       end
 
-      after do
-        container_manager.stop('indocker_main_container')
-        container_manager.delete('indocker_main_container')
-        container_manager.stop('indocker_dependency_container')
-        container_manager.delete('indocker_dependency_container')
+      after(:all) do
+        ioc.docker_api.delete_container('indocker_volume_container')
+        ioc.docker_api.delete_volume('indocker_volume')
       end
 
-      it 'runs dependency container before' do
+      it 'creates volume before start' do
         expect(
-          docker_api.get_container_state('indocker_dependency_container')
-        ).to eq(Indocker::ContainerMetadata::States::RUNNING)
+          ioc.docker_api.volume_exists?('indocker_volume')
+        ).to be true
       end
     end
 
     context 'with specified network' do
-      let(:container_id) { docker_api.get_container_id('indocker_simple_container') }
-      let(:network_id)   { docker_api.get_network_id('indocker_network') }
-
-      before do
+      before(:all) do
         Indocker.define_network 'indocker_network'
 
-        Indocker.define_container 'indocker_simple_container' do
-          use images.indocker_image
+        Indocker.define_container 'indocker_network_container' do
+          use images.find_by_repo(:indocker_image)
           use networks.indocker_network
         end
 
-        ioc.container_manager.create('indocker_simple_container')
-
-        container_manager.start('indocker_simple_container')
+        ioc.container_manager.create('indocker_network_container')
+        ioc.container_manager.start('indocker_network_container')
       end
 
-      after do
-        container_manager.stop('indocker_simple_container')
-        container_manager.delete('indocker_simple_container')
-        docker_api.remove_network('indocker_network')
+      after(:all) do
+        ioc.container_manager.delete('indocker_network_container')
+        ioc.docker_api.delete_network('indocker_network')
       end
 
       context 'creates network before start' do
         it 'for new network' do
-          expect(network_id).to match(/[\w\d]{64}/)
-          expect(docker_api.network_exists?('indocker_network')).to be true
+          expect(
+            ioc.docker_api.get_network_id('indocker_network')
+          ).to match(/[\w\d]{64}/)
+
+          expect(ioc.docker_api.network_exists?('indocker_network')).to be true
         end
 
         it 'if network already exists' do
-          container_manager.stop('indocker_simple_container')
-          container_manager.start('indocker_simple_container')
+          ioc.container_manager.stop('indocker_network_container')
+          ioc.container_manager.start('indocker_network_container')
 
-          expect(network_id).to match(/[\w\d]{64}/)
-          expect(docker_api.network_exists?('indocker_network')).to be true
+          expect(
+            ioc.docker_api.get_network_id('indocker_network')
+          ).to match(/[\w\d]{64}/)
+
+          expect(ioc.docker_api.network_exists?('indocker_network')).to be true
         end
       end
 
       it 'connect container to specified network' do
         expect(
-          docker_api.inspect_network(network_id)['Containers'].keys
-        ).to include(container_id)
+          ioc.docker_api.inspect_network('indocker_network')['Containers'].keys
+        ).to include(
+          ioc.docker_api.get_container_id('indocker_network_container')
+        )
       end
 
       it 'starts container' do
+        sleep 1 # wait when container stops
+
         expect(
-          docker_api.get_container_state(container_id)
-        ).to eq(Indocker::ContainerMetadata::States::RUNNING)
+          ioc.docker_api.get_container_state(
+            ioc.docker_api.get_container_id('indocker_network_container')
+          )
+        ).to eq(Indocker::ContainerMetadata::States::EXITED)
       end
     end
   end
 
   describe '#copy' do
-    let(:copy_to_path) { File.expand_path File.join(__dir__, '../../tmp/indocker_list_container_files') }
-
-    before do
+    let(:copy_to_path) { ioc.config.build_dir.join('indocker_list_container_files') }
+    
+    before(:all) do
       Indocker.define_image 'indocker_copy_image' do
         from 'alpine'
 
-        run 'mkdir -p /sample'
-        run 'mkdir -p /sample/deeper'
-        run 'echo "example1.txt" > /sample/example1.txt'
-        run 'echo "example2.txt" > /sample/example2.txt'
-        run 'echo "example3.txt" > /sample/deeper/example3.txt'
-        run 'echo "example4.txt" > /sample/deeper/example4.txt'
-
-        cmd ['ls']
+        run "mkdir -p /sample/deeper &&                 
+        echo 'example1.txt' > /sample/example1.txt &&
+        echo 'example3.txt' > /sample/deeper/example2.txt"
       end
-      ioc.image_builder.build('indocker_copy_image')
-
+      
       Indocker.define_container :indocker_copy_container do
-        use images.indocker_copy_image
+        use images.find_by_repo('indocker_copy_image')
       end
+      
+      ioc.image_builder.build('indocker_copy_image')
+      ioc.container_manager.create('indocker_copy_container')
     end
 
     it 'returns files list' do
       expect(
-        container_manager.copy(
+        ioc.container_manager.copy(
           name:      :indocker_copy_container,
           copy_from: '/sample/deeper',
           copy_to:   copy_to_path
         )
-      ).to match(
-        [
-          'deeper/example3.txt',
-          'deeper/example4.txt'
-        ]
-      )
+      ).to match(['deeper/example2.txt'])
     end
 
     it 'copies files to output path' do
-      container_manager.copy(
+      ioc.container_manager.copy(
         name:      :indocker_copy_container,
         copy_from: '/sample/.',
         copy_to:   copy_to_path
       )
 
       ensure_content(File.join(copy_to_path, 'example1.txt'), 'example1.txt')
-      ensure_content(File.join(copy_to_path, 'example2.txt'), 'example2.txt')
-      ensure_content(File.join(copy_to_path, 'deeper/example3.txt'), 'example3.txt')
-      ensure_content(File.join(copy_to_path, 'deeper/example4.txt'), 'example4.txt')
+      ensure_content(File.join(copy_to_path, 'deeper/example2.txt'), 'example3.txt')
+    end
+
+    it 'copies single file' do
+      ioc.container_manager.copy(
+        name:      :indocker_copy_container,
+        copy_from: '/sample/example1.txt',
+        copy_to:   copy_to_path
+      )
+
+      ensure_content(File.join(copy_to_path, 'example1.txt'), 'example1.txt')
     end
   end
 end

data/spec/indocker/docker_api/container_config_spec.rb

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