construi 0.30.0 → 0.31.0

data/spec/lib/construi/image_spec.rb

@@ -0,0 +1,251 @@
+
+require 'spec_helper'
+
+require 'securerandom'
+
+RSpec.describe Construi::Image do
+  let(:id) {  SecureRandom.hex(16) }
+  let(:docker_image) { instance_double(Docker::Image, :id => id).as_null_object }
+  let!(:docker_image_class) { class_spy(Docker::Image).as_stubbed_const }
+  let!(:container_class) { class_spy(Construi::Container).as_stubbed_const }
+
+  subject(:image) { Construi::Image.wrap(docker_image) }
+
+  describe '#id' do
+    subject { image.id }
+    it { is_expected.to eq(id) }
+  end
+
+  describe '#delete' do
+    subject! { image.delete }
+    it { expect(docker_image).to have_received(:delete) }
+  end
+
+  describe '#tagged?' do
+    before { allow(docker_image).to receive(:info).and_return({ 'RepoTags' => tag }) }
+
+    subject { image.tagged? }
+
+    context 'tagged' do
+      let(:tag) { 'tagged:latest' }
+      it { is_expected.to be(true) }
+    end
+
+    context 'not tagged' do
+      let(:tag) { '<none>:<none>' }
+      it { is_expected.to be(false) }
+    end
+  end
+
+  describe '#run' do
+    let(:cmd) { 'cmd1' }
+    let(:env) { ['VAR1=VALUE1'] }
+    let!(:container) { class_spy(Construi::Container).as_stubbed_const }
+
+    subject! { image.run(cmd, env) }
+
+    it { expect(container).to have_received(:run).with(image, cmd, env) }
+  end
+
+  describe '#insert_local' do
+    let(:host) { '/path/host' }
+    let(:container) { '/path/on/container' }
+    let(:permissions) { nil }
+    let(:file) { Construi::Config::Files::File.new host, container, permissions }
+
+    before { allow(docker_image).to receive(:info).and_return({ 'RepoTags' => '<none>:<none>' }) }
+    before { allow(docker_image).to receive(:insert_local).and_return(docker_image) }
+    before { allow(container_class).to receive(:run).and_return image }
+
+    subject! { image.insert_local file }
+
+    context 'no permissions' do
+      it { expect(subject.id).to eq(id) }
+      it do
+        expect(docker_image)
+          .to have_received(:insert_local)
+          .with 'localPath' => host, 'outputPath' => container
+      end
+      it { expect(container_class).to have_received(:run).with(image, "ls -l #{container}", []) }
+    end
+
+    context 'with permissions' do
+      let(:permissions) { '0600' }
+
+      it { expect(subject.id).to eq(id) }
+      it do
+        expect(docker_image)
+          .to have_received(:insert_local)
+          .with 'localPath' => host, 'outputPath' => container
+      end
+      it do
+        expect(container_class)
+          .to have_received(:run)
+          .with(image, "chmod -R #{permissions} #{container}", [])
+      end
+      it { expect($stdout.string).to include(" > chmod -R #{permissions} #{container}") }
+      it { expect(container_class).to have_received(:run).with(image, "ls -l #{container}", []) }
+    end
+
+  end
+
+  describe '.from' do
+    Config = Struct.new :image, :build, :files
+
+    let(:image) { nil }
+    let(:build) { nil }
+    let(:files) { [] }
+    let(:config) { Config.new image, build, files }
+
+    [:create, :build_from_dir].each do |m|
+      before { allow(docker_image_class).to receive(m).and_return docker_image }
+    end
+
+    subject(:from) { -> { Construi::Image.from(config) } }
+
+    context 'when build' do
+      let(:build) { 'build/dir' }
+
+      subject! { from.call }
+
+      it { expect(docker_image_class).to have_received(:build_from_dir) }
+    end
+
+    context 'when image' do
+      let(:image) { 'image:latest' }
+
+      subject! { from.call }
+
+      it { expect(docker_image_class).to have_received(:create) }
+    end
+
+    context 'when invalid' do
+      it { expect { from.call }.to raise_error(Construi::Image::Error, /Invalid image configuration/) }
+    end
+
+    context 'when files' do
+      let(:image) { 'image:latest' }
+      before { allow(docker_image).to receive(:info).and_return({ 'RepoTags' => image }) }
+
+      let(:host) { '/path/host' }
+      let(:container) { '/path/on/container' }
+      let(:permissions) { nil }
+
+      let(:files) { [ Construi::Config::Files::File.new(host, container, permissions) ] }
+
+      subject! { from.call }
+
+      it { expect(docker_image_class).to have_received(:create) }
+      it do
+        expect(docker_image)
+          .to have_received(:insert_local)
+          .with 'localPath' => host, 'outputPath' => container
+      end
+      it { expect($stdout.string).to include("\nCopying #{host} to #{container}...".green) }
+    end
+  end
+
+  describe '.build' do
+    let(:build_dir) { 'etc/docker' }
+
+    before do
+      allow(docker_image_class)
+        .to receive(:build_from_dir)
+        .with(build_dir, :rm => 0)
+        .and_yield('{"stream":"msg1"}')
+        .and_yield('{"stream":"msg2"}')
+        .and_return docker_image
+    end
+
+    subject! { Construi::Image.build(build_dir) }
+
+    it {
+      expect(docker_image_class)
+         .to have_received(:build_from_dir).with(build_dir, :rm => 0)
+    }
+
+    it { expect(docker_image).to have_received(:refresh!) }
+
+    it 'outputs building message' do
+      building_msg = "Building image: 'etc/docker'...".green
+      expect($stdout.string).to include("\n#{building_msg}\n")
+    end
+
+    it 'outputs build status messages' do
+      expect($stdout.string).to include("msg1\nmsg2\n")
+    end
+  end
+
+  describe '.create' do
+    let(:image_tag) { 'tagged:latest' }
+
+    before do
+      allow(docker_image_class)
+        .to receive(:create)
+        .with('fromImage' => image_tag)
+        .and_yield('{"id":"id","status":"msg1"}')
+        .and_yield('{"id":"id","status":"msg2","progressDetail":{}}')
+        .and_yield('{"id":"id","status":"msg3","progressDetail":{"progress":"====>"}}')
+        .and_yield('{"status":"msg4"}')
+        .and_return docker_image
+    end
+
+    subject! { Construi::Image.create(image_tag) }
+
+    it { expect(docker_image_class).to have_received(:create).with('fromImage' => image_tag) }
+    it { expect(docker_image).to have_received(:refresh!) }
+
+    it 'outputs creating message' do
+      creating_msg = "Creating image: 'tagged:latest'...".green
+      expect($stdout.string).to include("\n#{creating_msg}\n")
+    end
+
+    it 'outputs create status messages' do
+      expect($stdout.string).to include("id: msg1\nid: msg2\nmsg4\n")
+    end
+  end
+end
+
+RSpec.describe Construi::IntermediateImage do
+  let(:image) { instance_double(Construi::Image).as_null_object }
+  let(:second_image) { instance_double(Construi::Image).as_null_object }
+
+  before do
+    allow(image)
+      .to receive(:run)
+      .and_return image
+  end
+
+  before { allow(image).to receive(:run).and_return second_image }
+  before do
+    [image, second_image].each do |i|
+      allow(i).to receive(:tagged?).and_return false
+    end
+  end
+
+  subject(:intermediate_image) { Construi::IntermediateImage.seed(image) }
+
+  describe '#run' do
+    let(:cmd) { 'cmd1' }
+    let(:env) { ['VAR1=VALUE1'] }
+
+    context "single run" do
+      subject! { intermediate_image.run(cmd, env) }
+
+      it { expect(image).to have_received(:run).with(cmd, env) }
+      it { expect(image).to_not have_received(:delete) }
+      it { expect(second_image).to_not have_received(:delete) }
+    end
+
+    context "double run" do
+      subject! { intermediate_image.run(cmd, env).run(cmd, env) }
+
+      it { expect(second_image).to have_received(:run).with(cmd, env) }
+      it { expect(second_image).to have_received(:delete) }
+    end
+  end
+
+
+
+end
+

data/spec/lib/construi/runner_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+RSpec.describe Construi::Runner do
+  let(:config_yaml) { '{}' }
+  let(:config) { Construi::Config.load(config_yaml) }
+
+  let(:image) { instance_double(Construi::Image).as_null_object }
+  let!(:image_class) { class_spy(Construi::Image).as_stubbed_const }
+
+  before { allow(image_class).to receive(:from).and_return image }
+
+  subject(:runner) { Construi::Runner.new(config) }
+
+  describe '#run' do
+    let(:config_yaml) do
+      <<-YAML
+      image: image:latest
+      targets:
+        target1: cmd1
+      YAML
+    end
+
+    let(:targets) { ['target1'] }
+
+    let!(:docker) { class_spy(Docker).as_stubbed_const }
+
+    before { allow(docker).to receive(:options).and_return({}) }
+
+    before { allow(image).to receive(:run).and_return image }
+    before { allow(image).to receive(:tagged?).and_return false }
+
+    subject! { runner.run(targets) }
+
+    it { expect(docker).to have_received(:validate_version!) }
+    it { expect(image).to have_received(:run).with('cmd1', []) }
+    it { expect(image).to have_received(:delete) }
+
+    it { expect($stdout.string).to include('Running target1...'.green) }
+    it { expect($stdout.string).to include(' > cmd1'.green) }
+  end
+
+
+end
+

data/spec/lib/construi/target_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+RSpec.describe Construi::Target do
+  let(:parent_config) { Construi::Config.load('{}') }
+  let(:target_config) do
+    cfg = {}
+    cfg['image'] = image unless image.nil?
+    cfg['build'] = build unless build.nil?
+
+    Construi::Config::Target.new(cfg, parent_config)
+  end
+
+  subject(:target) { Construi::Target.new nil, target_config }
+end

data/spec/lib/construi_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+RSpec.describe Construi do
+  describe 'run' do
+    let(:targets) { ['target1', 'target2'] }
+    let(:config) { { 'image' => 'image:latest' } }
+
+    let(:runner) { instance_double(Construi::Runner).as_null_object }
+    let(:runner_class) { class_double(Construi::Runner).as_stubbed_const }
+
+    before { allow(Construi::Config).to receive(:load_file).with('construi.yml').and_return(config) }
+    before { allow(runner_class).to receive(:new).with(config).and_return runner }
+
+    subject! { Construi.run(targets) }
+
+    it { expect(runner_class).to have_received(:new).with(config) }
+    it { expect(runner).to have_received(:run).with(targets) }
+  end
+end
+

data/spec/lib/container_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+require 'securerandom'
+
+RSpec.describe Construi::Container do
+  let!(:docker_container_class) { class_spy(Docker::Container).as_stubbed_const }
+  let(:docker_container) do
+    instance_double(Docker::Container, :id => SecureRandom.hex(16)).as_null_object
+  end
+
+  let(:image_id) { SecureRandom.hex(16) }
+  let(:image) { instance_double(Docker::Image, :id => image_id).as_null_object }
+
+  let(:container) { Construi::Container.wrap docker_container }
+
+  describe '#delete' do
+    subject! { container.delete }
+
+    it { expect(docker_container).to have_received(:delete) }
+  end
+
+  describe '#attach_stdout' do
+    subject(:attach_stdout) { -> { container.attach_stdout } }
+
+    context 'when attached succesfully' do
+      before do
+        allow(docker_container)
+          .to receive(:attach)
+          .and_yield('stream', 'msg1')
+          .and_yield('stream', 'msg2')
+      end
+
+      subject! { attach_stdout.call }
+
+      it { expect(docker_container).to have_received(:attach).with(:stream => true, :logs => true) }
+      it { expect($stdout.string).to include("msg1\nmsg2") }
+    end
+
+    context 'when attach times out' do
+      before do
+        allow(docker_container)
+          .to receive(:attach)
+          .and_raise(Docker::Error::TimeoutError.new)
+      end
+
+      subject! { attach_stdout.call }
+
+      it { expect($stdout.string).to include('Failed to attach to stdout'.yellow) }
+    end
+  end
+
+  describe '#commit' do
+    before { allow(docker_container).to receive(:commit).and_return image }
+
+    subject! { container.commit }
+
+    it { expect(docker_container).to have_received(:commit) }
+    it { is_expected.to eq(Construi::Image.wrap(image)) }
+  end
+
+  describe '#run' do
+    before { allow(docker_container).to receive(:wait).and_return({'StatusCode' => status_code}) }
+    before { allow(docker_container).to receive(:commit).and_return image }
+
+    subject(:run) { -> { container.run } }
+
+    context 'when command succeeds' do
+      let(:status_code) { 0 }
+
+      subject! { run.call }
+
+      it { expect(docker_container).to have_received(:start) }
+      it { expect(docker_container).to have_received(:attach).with(:stream => true, :logs => true) }
+      it { expect(docker_container).to have_received(:wait) }
+      it { expect(docker_container).to have_received(:commit) }
+      it { is_expected.to eq(Construi::Image.wrap(image)) }
+    end
+
+    context 'when command fails' do
+      let(:status_code) { 1 }
+
+      it { expect { run.call }.to raise_error Construi::Container::Error,  /status code: 1/}
+    end
+  end
+
+  describe '.create' do
+    let(:cmd) { 'cmd1 p1 p2' }
+    let(:env) { ['ENV1=VAL1', 'ENV2=VAL2'] }
+    let(:pwd) { '/project/dir' }
+
+    before { allow(docker_container_class).to receive(:create).and_return docker_container }
+    before { allow(Dir).to receive(:pwd).and_return(pwd) }
+
+    subject! { Construi::Container::create(image, cmd, env) }
+
+    it do
+      expect(docker_container_class).to have_received(:create).with( {
+        'Cmd' => ['cmd1', 'p1', 'p2' ],
+        'Image' => image_id,
+        'Env' => env.to_json,
+        'Tty' => false,
+        'WorkingDir' => '/var/workspace',
+        'HostConfig' => { 'Binds' => ["#{pwd}:/var/workspace"] }
+        } )
+    end
+    it { is_expected.to eq(Construi::Container.wrap docker_container) }
+  end
+
+  describe '.run' do
+    let(:cmd) { 'cmd1 p1 p2' }
+
+    before { allow(docker_container_class).to receive(:create).and_return docker_container }
+    before { allow(docker_container).to receive(:wait).and_return({'StatusCode' => 0}) }
+    before { allow(docker_container).to receive(:commit).and_return image }
+
+    subject! { Construi::Container.run(image, cmd, []) }
+
+    it do
+      expect(docker_container_class).to have_received(:create).with(
+        hash_including( {
+          'Cmd' => ['cmd1', 'p1', 'p2'],
+          'Image' => image_id
+        }))
+    end
+    it { is_expected.to eq(Construi::Image.wrap image) }
+    it { expect(docker_container).to have_received(:start) }
+    it { expect(docker_container).to have_received(:commit) }
+    it { expect(docker_container).to have_received(:delete) }
+  end
+
+end
+