dockly 3.3.0 → 4.2.0

data/spec/dockly/build_cache/docker_spec.rb

@@ -156,7 +156,7 @@ describe Dockly::BuildCache::Docker, :docker do
     context "when parameter command returns successfully" do
       let(:command) { "uname -r" }
       it 'returns the output of the parameter_command' do
-        expect(build_cache.parameter_output(command)).to match(/\A3\.\d{2}\.\d-\d{1,2}-\w+\Z/)
+        expect(build_cache.parameter_output(command)).to match(/\A\d.\d.\d+-\w+-\w+\z/)
       end
     end
 

data/spec/dockly/deb_spec.rb

@@ -175,6 +175,25 @@ describe Dockly::Deb do
         expect(`dpkg --contents #{filename}`).to_not include("dockly-startup.sh")
       end
     end
+
+    context 'when package_startup_script is a string' do
+      context 'when the string is empty' do
+        before { subject.package_startup_script('') }
+
+        it 'does not place a startup script with the provided name in the package' do
+          expect{subject.create_package!}.to raise_error(ArgumentError)
+        end
+      end
+
+      context 'when the string is not empty' do
+        before { subject.package_startup_script('special-startup.sh') }
+
+        it 'places a startup script with the provided name in the package' do
+          subject.create_package!
+          expect(`dpkg --contents #{filename}`).to include("special-startup.sh")
+        end
+      end
+    end
   end
 
   describe '#exists?' do
@@ -186,14 +205,19 @@ describe Dockly::Deb do
         pre_install "ls"
         post_install "rd /s /q C:\*"
         build_dir 'build/deb/s3'
+        s3_bucket 'bucket'
       end
     end
 
     context 'when the object does exist' do
       before do
-        allow(Dockly.s3)
-          .to receive(:head_object)
-          .and_return({})
+        allow(Dockly)
+          .to receive(:s3)
+          .and_return(
+            Aws::S3::Client.new(
+              stub_responses: { :head_object => {} }
+            )
+          )
       end
 
       it 'is true' do
@@ -203,12 +227,16 @@ describe Dockly::Deb do
 
     context 'when the object does not exist' do
       before do
-        allow(Dockly.s3)
-          .to receive(:head_object)
-          .and_raise(StandardError.new('object does not exist'))
+        allow(Dockly)
+          .to receive(:s3)
+          .and_return(
+            Aws::S3::Client.new(
+              stub_responses: { :head_object => 'ObjectDoesNotExist' }
+            )
+          )
       end
 
-      it 'is true' do
+      it 'is false' do
         expect(subject.exists?).to be_false
       end
     end
@@ -248,12 +276,24 @@ describe Dockly::Deb do
       context 'when the package has been created' do
         before { subject.create_package! }
 
+        let(:client) do
+          client = Aws::S3::Client.new(stub_responses: true)
+          client.stub_responses(
+            :put_object, ->(context) do
+              expect(context.params[:bucket]).to eq(bucket_name)
+              expect(context.params[:key]).to eq(subject.s3_object_name)
+              expect(context.params).to have_key(:body)
+
+              {}
+            end
+          )
+          client
+        end
+
         it 'inserts the deb package into that bucket' do
-          expect(Dockly.s3).to receive(:put_object) do |hash|
-            expect(hash[:bucket]).to eq(bucket_name)
-            expect(hash[:key]).to eq(subject.s3_object_name)
-            expect(hash).to have_key(:body)
-          end
+          expect(Dockly)
+            .to receive(:s3)
+            .and_return(client)
 
           subject.upload_to_s3
         end

data/spec/dockly/docker/ecr_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Dockly::Docker::ECR do
+  subject do
+    described_class.new(name: 'ecr', server_address: registry)
+  end
+
+  let(:username) { 'AWS' }
+  let(:password) { 'password' }
+  let(:registry) { 'accountid.dkr.ecr.region.amazonaws.com' }
+  let(:endpoint) { "https://#{registry}" }
+  let(:ecr_client) { Aws::ECR::Client.new(stub_responses: true) }
+
+  after do
+    Aws.config[:ecr] = { stub_responses: {} }
+  end
+
+  describe '#authenticate!' do
+    context 'when AWS provides a username and password for ECR' do
+      before do
+        Aws.config[:ecr] = {
+          stub_responses: {
+            get_authorization_token: {
+              authorization_data: [
+                {
+                  authorization_token: Base64.encode64("#{username}:#{password}"),
+                  proxy_endpoint: endpoint
+                }
+              ]
+            }
+          }
+        }
+      end
+
+      context 'and docker auth succeeds' do
+        before do
+          allow(::Docker)
+            .to receive(:authenticate!)
+            .with({
+              'serveraddress' => endpoint,
+              'username' => username,
+              'password' => password
+            })
+        end
+
+        it 'does not error' do
+          expect { subject.authenticate! }.to_not raise_error
+        end
+      end
+
+      context 'and docker auth raises and error' do
+        before do
+          allow(::Docker)
+            .to receive(:authenticate!)
+            .and_raise(::Docker::Error::AuthenticationError)
+        end
+
+        it 'raises' do
+          expect { subject.authenticate! }
+            .to raise_error(/Could not authenticate/)
+        end
+      end
+    end
+  end
+
+  context 'when it is unable to get auth from AWS' do
+    before do
+      Aws.config[:ecr] = {
+        stub_responses: {
+          get_authorization_token: ->(_context) { raise 'Unable to get token' }
+        }
+      }
+    end
+
+    it 'raises' do
+      expect(::Docker).not_to receive(:authenticate!)
+      expect { subject.authenticate! }.to raise_error
+    end
+  end
+end

data/spec/dockly/docker_spec.rb

@@ -3,6 +3,76 @@ require 'spec_helper'
 describe Dockly::Docker do
   subject { described_class.new(:name => :test_docker) }
 
+  describe '#registry' do
+    context 'when there is no registry' do
+      it 'returns nil' do
+        expect(subject.registry).to eq(nil)
+      end
+    end
+
+    context 'when there is only an ecr registry' do
+      subject do
+        Dockly::Docker.new do
+          ecr { server_address 'accountid.dkr.ecr.region.amazonaws.com' }
+        end
+      end
+
+      it 'returns an ecr registry' do
+        registry = subject.registry
+
+        expect(registry).not_to eq(nil)
+        expect(registry).to be_a(Dockly::Docker::ECR)
+        expect(registry.server_address)
+          .to eq('accountid.dkr.ecr.region.amazonaws.com')
+      end
+    end
+
+    context 'when there is a docker registry' do
+      context 'and an ecr registry' do
+        subject do
+          Dockly::Docker.new do
+            registry do
+              username ENV['DOCKER_USER']
+              email ENV['DOCKER_EMAIL']
+              password ENV['DOCKER_PASS']
+            end
+
+            ecr { server_address 'accountid.dkr.ecr.region.amazonaws.com' }
+          end
+        end
+
+        it 'prefers the ecr registry' do
+          registry = subject.registry
+
+          expect(registry).not_to eq(nil)
+          expect(registry).to be_a(Dockly::Docker::ECR)
+          expect(registry.server_address)
+            .to eq('accountid.dkr.ecr.region.amazonaws.com')
+        end
+      end
+
+      context 'and only a docker registry' do
+        subject do
+          Dockly::Docker.new do
+            registry do
+              username ENV['DOCKER_USER']
+              email ENV['DOCKER_EMAIL']
+              password ENV['DOCKER_PASS']
+            end
+          end
+
+          it 'returns the docker registry' do
+            registry = subject.registry
+
+            expect(registry).not_to eq(nil)
+            expect(registry).to be_a(Dockly::Docker::Registry)
+            expect(registry.username).to eq(ENV['DOCKER_USER'])
+          end
+        end
+      end
+    end
+  end
+
   describe '#ensure_tar' do
     let(:action) { subject.ensure_tar(file) }
 
@@ -134,11 +204,15 @@ describe Dockly::Docker do
         let(:url) { 's3://bucket/object' }
         let(:data) { 'sweet, sweet data' }
 
+        let(:client) { double() }
+
         before do
-          allow(Dockly.s3)
+          allow(client)
             .to receive(:get_object)
-            .with(bucket: 'bucket', key: 'object')
+            .with(hash_including({ bucket: 'bucket', key: 'object' }))
             .and_yield(data)
+
+          allow(Dockly).to receive(:s3).and_return(client)
         end
 
         it 'pulls the file from S3' do
@@ -147,7 +221,7 @@ describe Dockly::Docker do
       end
 
       context 'and it points to a non-S3 url' do
-        let(:url) { 'http://www.html5zombo.com' }
+        let(:url) { 'http://html5zombo.com' }
 
        before { subject.tag 'yolo' }
 
@@ -172,7 +246,7 @@ describe Dockly::Docker do
     context "with a registry export" do
       let(:registry) { double(:registry) }
       before do
-        subject.instance_variable_set(:"@registry", registry)
+        subject.instance_variable_set(:"@docker_registry", registry)
         expect(subject).to receive(:push_to_registry)
       end
 
@@ -243,6 +317,107 @@ describe Dockly::Docker do
     end
   end
 
+  describe '#push_to_registry', :docker do
+    let(:image) { Docker::Image.create('fromImage' => 'ubuntu:14.04') }
+    let(:ecr) { double(:ecr) }
+
+    context 'when there is no registry' do
+      it 'raises' do
+        expect(subject.registry).to eq(nil)
+
+        expect { subject.push_to_registry(image) }.to raise_error(/No registry/)
+      end
+    end
+
+    context 'when there is a registry' do
+      before do
+        subject.instance_variable_set(:"@ecr", ecr)
+
+        allow(ecr)
+          .to receive(:server_address)
+          .and_return('server_address')
+
+        expect(subject.registry).to eq(ecr)
+      end
+
+      context "that can't be authenticated to" do
+        before do
+          allow(ecr)
+            .to receive(:authenticate!)
+            .and_raise
+        end
+
+        it 'raises' do
+          expect { subject.push_to_registry(image) }
+            .to raise_error(StandardError)
+        end
+      end
+
+      context 'that can be authenticated to' do
+        before do
+          allow(ecr).to receive(:authenticate!)
+
+          allow(Docker::Image)
+            .to receive(:all)
+            .with(all: true)
+            .and_return(available_images)
+        end
+
+        context "but the image isn't found" do
+          let(:available_images) { [] }
+
+          it 'raises' do
+            expect { subject.push_to_registry(image) }
+              .to raise_error(/Could not find image after authentication/)
+          end
+        end
+
+        context 'and the image is found' do
+          let(:available_images) { [image] }
+
+          before do
+            allow(ecr)
+              .to receive(:to_h)
+              .and_return({})
+            allow(image)
+              .to receive(:push)
+              .and_yield(push_message)
+          end
+
+          context 'but the push to the registry fails' do
+            let(:push_message) do
+              <<-EOF
+                {"errorDetail":{"message":"name unknown: The repository with name 'repository'
+                does not exist in the registry with id 'accoundid'"},"error":"name unknown:
+                The repository with name 'repository' does not exist in the registry with id 'accountid'"}
+              EOF
+            end
+
+            it 'raises' do
+              expect { subject.push_to_registry(image) }
+                .to raise_error(/Error pushing to registry/)
+            end
+          end
+
+          context 'and the push to the registry succeeds' do
+            let(:push_message) do
+              <<-EOF
+                {"status":"Pushed","progressDetail":{},"id":"id"}
+                {"status":"sha: digest: digest size: 2048"}
+                {"progressDetail":{},"aux":{"Tag":"sha","Digest":"digest","Size":2048}}
+              EOF
+            end
+
+            it 'passes' do
+              expect(subject.push_to_registry(image))
+                .not_to raise_error
+            end
+          end
+        end
+      end
+    end
+  end
+
   describe '#export_image_diff', :docker do
     let(:images) { [] }
     let(:output) { StringIO.new }

data/spec/dockly/foreman_spec.rb

@@ -29,9 +29,9 @@ describe Dockly::Foreman do
         subject.create!
         File.exist?('build/foreman/foreman.target').should be_true
         File.exist?('build/foreman/foreman-web.target').should be_true
-        File.exist?('build/foreman/foreman-web-1.service').should be_true
-        File.read('build/foreman/foreman-web-1.service')
-            .lines.grep(/^ExecStart=\/bin\/bash -lc '\/bin\/sh start_my_server'$/)
+        File.exist?('build/foreman/foreman-web@.service').should be_true
+        File.open('build/foreman/foreman-web@.service')
+            .grep(/^ExecStart=\/bin\/bash -lc 'exec \/bin\/sh start_my_server'$/)
             .length.should == 1
       end
     end

data/spec/dockly/rpm_spec.rb

@@ -11,6 +11,7 @@ describe Dockly::Rpm do
         pre_install "ls"
         post_install "rd /s /q C:\*"
         build_dir 'build'
+        s3_bucket 'bucket'
       end
     end
     let(:filename) { "build/rpm/my-sweet-rpm_77.0.8_x86_64.rpm" }
@@ -173,14 +174,17 @@ describe Dockly::Rpm do
         pre_install "ls"
         post_install "rd /s /q C:\*"
         build_dir 'build/rpm/s3'
+        s3_bucket 'bucket'
       end
     end
 
     context 'when the object does exist' do
       before do
-        allow(Dockly.s3)
-          .to receive(:head_object)
-          .and_return({})
+        allow(Dockly)
+          .to receive(:s3)
+          .and_return(
+            Aws::S3::Client.new(stub_responses: true)
+          )
       end
 
       it 'is true' do
@@ -190,9 +194,13 @@ describe Dockly::Rpm do
 
     context 'when the object does not exist' do
       before do
-        allow(Dockly.s3)
-          .to receive(:head_object)
-          .and_raise(StandardError.new('object does not exist'))
+        allow(Dockly)
+          .to receive(:s3)
+          .and_return(
+            Aws::S3::Client.new(
+              stub_responses: { :head_object => 'NoSuchKey' }
+            )
+          )
       end
 
       it 'is true' do
@@ -235,12 +243,24 @@ describe Dockly::Rpm do
       context 'when the package has been created' do
         before { subject.create_package! }
 
+        let(:client) do
+          client = Aws::S3::Client.new(stub_responses: true)
+          client.stub_responses(
+            :put_object, ->(context) do
+              expect(context.params[:bucket]).to eq(bucket_name)
+              expect(context.params[:key]).to eq(subject.s3_object_name)
+              expect(context.params).to have_key(:body)
+
+              {}
+            end
+          )
+          client
+        end
+
         it 'inserts the rpm package into that bucket' do
-          expect(Dockly.s3).to receive(:put_object) do |hash|
-            expect(hash[:bucket]).to eq(bucket_name)
-            expect(hash[:key]).to eq(subject.s3_object_name)
-            expect(hash).to have_key(:body)
-          end
+          expect(Dockly)
+            .to receive(:s3)
+            .and_return(client)
 
           subject.upload_to_s3
         end