baha 0.0.1

data/spec/image_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+require 'baha/image'
+
+describe Baha::Image do
+  let(:config) do
+    Baha::Config.new({
+      'defaults' => {
+        'parent' => 'ubuntu:14.04.1',
+        'repository' => 'docker.example.com/baha',
+        'maintainer' => 'Ishmael <ishmael@example.com>',
+        'bind' => '/.baha',
+        'command' => ['/bin/bash','/.baha/init.sh']
+      }
+    })
+  end
+  let(:image) do 
+    {
+      'parent'     => 'ubuntu:14.04.1',
+      'name'       => 'base',
+      'tag'        => '1.0.0',
+      'maintainer' => '"Captain Ahab" <ahab@example.com>',
+      'bind'       => '/.data',
+      'command'    => ['/bin/bash','/.data/setup.sh']
+    }
+  end
+  subject { described_class.new(config,image) }
+
+  describe "#inspect" do
+    its(:inspect) { should match(/^Baha::Image<(@[a-z0-9_]+=.*)+>$/) }
+  end
+
+  describe "#parent_id" do
+    let(:parent) { double('parent') }
+    it 'returns parent full id if available' do
+      allow(Baha::Image).to receive(:get_image!).and_return(parent)
+      allow(parent).to receive(:id).and_return('AAAA')
+      expect(subject.parent_id).to eq('AAAA')
+    end
+  end
+
+  describe "#parse_name" do
+    subject { Baha::Image.parse_name(@name)}
+    it 'parses full name' do
+      @name = "docker.example.com/repo/name:tag"
+      is_expected.to eq({:ns=>"docker.example.com/repo", :name=>"name", :tag=>"tag"})
+    end
+    it 'parses local name' do
+      @name = "name:tag"
+      is_expected.to eq({:ns=>nil, :name=>"name", :tag=>"tag"})
+    end
+    it 'sets default tag to latest' do
+      @name = "name"
+      is_expected.to eq({:ns=>nil, :name=>"name", :tag=>"latest"})
+    end
+    it 'raises error on invalid name' do
+      expect { Baha::Image.parse_name("@@@@@@") }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#parse_with_default" do
+    subject { Baha::Image.parse_with_default(@name,'default.example.com/baha')}
+    it 'does not override repos' do
+      @name = "docker.example.com/repo/name:tag"
+      is_expected.to eq({:ns=>"docker.example.com/repo", :name=>"name", :tag=>"tag"})
+    end
+    it 'sets default namespace' do
+      @name = "name:tag"
+      is_expected.to eq({:ns=>"default.example.com/baha", :name=>"name", :tag=>"tag"})
+    end
+  end
+
+  context "when constructed" do
+    its(:parent) { is_expected.to eq({:ns=>"docker.example.com/baha", :name=>"ubuntu", :tag=>"14.04.1"}) }
+    its(:image) { is_expected.to eq({:ns=>"docker.example.com/baha", :name=>"base", :tag=>"1.0.0"}) }
+    its(:maintainer) { is_expected.to eq('"Captain Ahab" <ahab@example.com>') }
+    its(:options) { is_expected.to be_a(Hash) }
+    its(:bind) { is_expected.to eq('/.data')}
+    its(:command) { is_expected.to eq(['/bin/bash','/.data/setup.sh']) }
+    its(:env) { is_expected.to include(
+      {:parent => {:ns=>"docker.example.com/baha", :name=>"ubuntu", :tag=>"14.04.1"}},
+      {:maintainer => "\"Captain Ahab\" <ahab@example.com>"},
+      {:bind => '/.data'},
+      {:name => 'base'},
+      {:tag => '1.0.0'},
+      :workspace) }
+  end
+
+  describe "#get_image!" do
+    let(:image) do
+      {
+        :ns    => 'docker.example.com/baha',
+        :name  => 'base',
+        :tag   => '1.0.0'
+      }
+    end
+    subject { Baha::Image.get_image!(image) }
+    context 'when image exists locally' do
+      before :example do
+        mock_registry([
+          {:id => 'BBBB', :name => 'base',   :tag => '1.0.0', :pulled => true, :parent => 'AAAA', :tags => ['base:1.0.0']}
+        ])
+      end
+      it { should_not be_nil }
+    end
+    context 'when base image exists' do
+      before :example do
+        mock_registry([
+          {:id => 'BBBB', :name => 'base',   :tag => '1.0.0', :parent => 'AAAA', :tags => ['base:1.0.0']}
+        ])
+      end
+      it { should_not be_nil }
+    end
+    context 'when base image exists remotely' do
+      before :example do
+        mock_registry([
+          {:id => 'BBBB', :name => 'base',   :tag => '1.0.0', :parent => 'AAAA', :tags => ['docker.example.com/baha/base:1.0.0']}
+        ])
+      end
+      it { should_not be_nil }
+    end
+  end
+
+  describe "#needs_update?" do
+    context 'when parent does not exist' do
+      before :example do
+        mock_registry([])
+      end
+      it { expect{ subject.needs_update? }.to raise_error(Baha::ImageNotFoundError) }
+    end
+    context 'when base does not exist' do
+      before :example do
+        mock_registry([
+          {:id => 'AAAA', :name => 'ubuntu', :tag => '14.04.1', :tags => ['ubuntu:14.04.1']},
+          {:id => 'BBBB', :name => 'base', :tag => '1.0.0', :tags => ['base:1.0.0'], :not_found => true}
+        ])
+      end
+      it { expect(subject.needs_update?).to be(true) }
+    end
+    context 'when parent has changed' do
+      before :example do
+        mock_registry([
+          {:id => 'AAAA', :name => 'ubuntu', :tag => '14.04.1', :tags => ['ubuntu:14.04.1']},
+          {:id => 'CCCC', :name => 'base',   :tag => '1.0.0', :parent => 'BBBB', :tags => ['docker.example.com/baha/base:1.0.0']}
+        ])
+      end
+      it { expect(subject.needs_update?).to be(true) }
+    end
+    context 'when tags have changed' do
+      before :example do
+        mock_registry([
+          {:id => 'AAAA', :name => 'ubuntu', :tag => '14.04.1', :tags => ['ubuntu:14.04.1']},
+          {:id => 'CCCC', :name => 'base',   :tag => '1.0.0', :parent => 'BBBB', :tags => ['docker.example.com/baha/base:0.9.0']}
+        ])
+      end
+      it { expect(subject.needs_update?).to be(true) }
+    end
+    context 'when up to date' do
+      before :example do
+        mock_registry([
+          {:id => 'AAAA', :name => 'ubuntu', :tag => '14.04.1', :tags => ['ubuntu:14.04.1']},
+          {:id => 'BBBB', :name => 'base',   :tag => '1.0.0', :parent => 'AAAA', :tags => ['docker.example.com/baha/base:1.0.0']}
+        ])
+      end
+      it { expect(subject.needs_update?).to be(false) }
+    end
+  end
+end

data/spec/log_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+require 'baha/log'
+require 'stringio'
+
+shared_examples "a logger" do |level|
+  subject { Baha::Log.for_name("specs") }
+  before do
+    Baha::Log.level = :debug
+  end
+  let(:loglevel) { level.to_s.upcase }
+  let(:regex) {
+    Regexp.new("^[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}.[0-9]{3} \\[\\s*#{loglevel}\\] specs -- Hello$")
+  }
+  context "when given a block" do
+    it 'prints a valid message' do
+      subject.send(level) { "Hello" }
+      expect(io.string).to match(regex)
+    end
+  end
+  context "when given a string" do
+    it 'prints a valid message' do
+      subject.send(level,"Hello")
+      expect(io.string).to match(regex)
+    end
+  end
+  context "when given an object" do
+    it 'prints object.inspect' do
+      subject.send(level,{ :hello => 'world' })
+      expect(io.string).to match("specs -- {:hello=>\"world\"}")
+    end
+  end
+  context "when given an exception" do
+    it 'prints a exception backtrace' do
+      begin
+        raise ArgumentError.new("Hello")
+      rescue Exception => e
+        subject.send(level,e)
+      end
+      expect(io.string).to match(/specs -- Hello \(ArgumentError\)\n((.+?):(\d+)(|:in `(.+)')\n)+/)
+    end
+  end
+end
+
+describe Baha::Log do
+  subject { Baha::Log }
+  
+  before do
+    Baha::Log.level = :error
+  end
+
+  it { expect(Baha::Log.level).to eq(:error) }
+
+  describe "#level=" do
+    it 'sets level' do
+      Baha::Log.level = "WARN"
+      expect(Baha::Log.level).to eq(:warn)   
+    end
+    it 'raises error on invalid input type' do
+      expect { Baha::Log.level = 123 }.to raise_error(ArgumentError)   
+    end
+    it 'raises error on invalid level' do
+      expect { Baha::Log.level = 'NOTALEVEL' }.to raise_error(ArgumentError)   
+    end
+  end
+  
+  describe "#for_name" do
+    subject { Baha::Log.for_name("specs") }
+    it { expect(subject).not_to be_nil }
+    its(:progname) { should eq("specs") }
+  end
+
+  context 'with log instance' do
+    let(:io) { StringIO.new }
+    before do
+      Baha::Log.logfile = io
+    end
+    it_behaves_like "a logger", :debug
+    it_behaves_like "a logger", :info
+    it_behaves_like "a logger", :warn
+    it_behaves_like "a logger", :error
+    it_behaves_like "a logger", :fatal
+    describe "#close!" do
+      before do
+        subject.close!
+      end
+      it { expect(io.closed?).to eq(true) }      
+    end
+  end
+end

data/spec/options_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'baha/container_options'
+
+describe Baha::ContainerOptions do
+  describe 'parse_option' do
+    it 'parses Cmd' do
+      expect(Baha::ContainerOptions::parse_option(:cmd,'/bin/bash -l')).to be_a(Baha::ContainerOptions::Cmd)
+    end
+    it 'parses Entrypoint' do
+      expect(Baha::ContainerOptions::parse_option(:entrypoint,['/bin/bash','-l'])).to be_a(Baha::ContainerOptions::Entrypoint)
+    end
+    it 'parses Env' do
+      expect(Baha::ContainerOptions::parse_option(:env,{'key' => 'value'})).to be_a(Baha::ContainerOptions::Env)
+    end
+    it 'parses raw option' do
+      expect(Baha::ContainerOptions::parse_option(:hostname,'host.local')).to be_a(Baha::ContainerOptions::Option)
+    end
+    it 'parses Volumes' do
+      expect(Baha::ContainerOptions::parse_option(:volumes,['/mnt/media'])).to be_a(Baha::ContainerOptions::Volumes)
+    end
+    it 'parses ExposedPorts' do
+      expect(Baha::ContainerOptions::parse_option(:exposedports,[8080,'8443/tcp'])).to be_a(Baha::ContainerOptions::ExposedPorts)
+    end
+    it 'validates values' do
+      expect{ Baha::ContainerOptions::parse_option(:exposedports,:notavalidvalue) }.to raise_error(Baha::ContainerOptions::InvalidOptionError)
+    end
+  end
+  describe 'parse_options' do
+    it 'parses all options' do
+      expected = {
+        :entrypoint => Baha::ContainerOptions::Entrypoint.new('/bin/bash'),
+        :cmd => Baha::ContainerOptions::Cmd.new('-l'),
+        :volumes => Baha::ContainerOptions::Volumes.new(['/mnt/data']),
+        :env => Baha::ContainerOptions::Env.new({'ENVKEY' => 'Hello'}),
+        :exposedports => Baha::ContainerOptions::ExposedPorts.new([8080,'8443/tcp']),
+        :hostname => Baha::ContainerOptions::Option.new('hostname','localhost.localdomain')
+      }
+      actual = Baha::ContainerOptions::parse_options({
+        'entrypoint' => '/bin/bash',
+        'cmd' => '-l',
+        'volumes' => ['/mnt/data'],
+        'env' => {'ENVKEY' => 'Hello'},
+        'exposedports' => [ 8080, '8443/tcp' ],
+        'hostname' => 'localhost.localdomain'
+      })
+      expect(actual).to eql(expected)
+    end
+    it 'returns empty map on nil options' do
+      expect(Baha::ContainerOptions::parse_options(nil)).to eql({})
+    end
+  end
+end

data/spec/pre_build/command_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+require 'pathname'
+require 'baha/pre_build'
+require 'baha/pre_build/command'
+
+describe Baha::PreBuild::Module::Command do
+  describe "#execute" do
+    let(:cmd) { ['echo','Hello'] }
+    let(:test) { 'test' }
+    let(:stdin) { double('in') }
+    let(:output) { double('output') }
+    let(:thread) { double('wait') }
+    let(:exit_status) { double('exit') }
+    let(:config) { double('config') }
+    let(:image) { double('image') }
+    before do
+      allow(image).to receive(:workspace).and_return(Pathname.new('/tmp'))
+      allow(output).to receive(:each).and_yield("OUTPUT LINE\n")
+      allow(thread).to receive(:value).and_return(exit_status)
+      allow(Open3).to receive(:popen2e).with(cmd,:chdir=>'/tmp').and_yield(stdin,output,thread)
+    end
+    subject {  {'command' => cmd, :image => image, :config => config } }
+    it 'runs command' do
+      Baha::PreBuild::Module.execute(subject) 
+      expect(Open3).to have_received(:popen2e).with(cmd,:chdir=>'/tmp') 
+    end
+    context "when creates given" do
+      subject {  {'command' => cmd,'creates' => 'file', :image => image, :config => config } }
+      context "and file exists" do 
+        it 'it does not execute' do
+          allow_any_instance_of(Pathname).to receive(:exist?).and_return(true)
+          Baha::PreBuild::Module.execute(subject)
+          expect(Open3).not_to have_received(:popen2e).with(cmd)
+        end
+      end
+      context "and file does not exist" do
+        it 'it executes' do
+          allow_any_instance_of(Pathname).to receive(:exist?).and_return(false)
+          Baha::PreBuild::Module.execute(subject)
+          expect(Open3).to have_received(:popen2e).with(cmd,:chdir=>'/tmp')
+        end
+      end
+    end
+    context "when onlyif given" do
+      subject {  {'command' => cmd,'only_if' => test, :image => image, :config => config } }
+      before do
+        allow(Open3).to receive(:popen2e).with(test,:chdir=>'/tmp').and_yield(stdin,output,thread)
+        allow(Open3).to receive(:popen2e).with(cmd,:chdir=>'/tmp').and_yield(stdin,output,thread)
+      end
+      context "and returns fail" do 
+        it 'it does not execute' do
+          allow(exit_status).to receive(:success?).and_return(false)
+          Baha::PreBuild::Module.execute(subject)
+          expect(Open3).to have_received(:popen2e).with(test,:chdir=>'/tmp')
+          expect(Open3).not_to have_received(:popen2e).with(cmd,:chdir=>'/tmp')
+        end
+      end
+      context "and returns success" do
+        it 'it executes' do
+          allow(exit_status).to receive(:success?).and_return(true)
+          Baha::PreBuild::Module.execute(subject)
+          expect(Open3).to have_received(:popen2e).with(test,:chdir=>'/tmp')
+          expect(Open3).to have_received(:popen2e).with(cmd,:chdir=>'/tmp')
+        end
+      end
+    end
+  end
+end

data/spec/pre_build/download_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+require 'pathname'
+require 'baha/pre_build'
+require 'baha/pre_build/download'
+
+describe Baha::PreBuild::Module::Download do
+  let(:file) { 
+    double("file") 
+  } 
+  let(:url) { 
+    double("url") 
+  }
+  let(:config) { 
+    double('config') 
+  }
+  let(:image) { double('image') }
+  subject {
+    {:config => config, :image => image, 'download' => 'http://www.google.com/', 'file' => 'url' }
+  }
+
+  describe "#execute" do
+    before do
+      allow(file).to receive(:write)
+      allow(url).to receive(:read).and_return('content')
+      allow(Baha::PreBuild::Module::Download).to receive(:open).with('http://www.google.com/','rb').and_yield(url)
+      allow(File).to receive(:open)
+      allow(File).to receive(:open).with(Pathname.new('/tmp/url'),'w').and_yield(file)
+      allow(image).to receive(:workspace).and_return(Pathname.new('/tmp'))
+    end
+    it 'downloads url to file' do
+      Baha::PreBuild::Module.execute(subject)
+      expect(file).to have_received(:write).with("content")
+    end
+    context "when file exists" do
+      it 'does not download file' do
+        allow_any_instance_of(Pathname).to receive(:exist?).and_return(true)
+        Baha::PreBuild::Module.execute(subject)
+        expect(file).not_to have_received(:write)
+      end
+    end
+  end
+end

data/spec/pre_build/template_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+require 'pathname'
+require 'baha/pre_build'
+require 'baha/pre_build/template'
+
+describe Baha::PreBuild::Module::Template do
+  let(:dest) { 
+    double("dest") 
+  }
+  let(:config) { 
+    double('config') 
+  }
+  let(:image) { double('image') }
+  subject {
+    {:config => config, :image => image, 'template' => '/tmp/file', 'dest' => 'dest.txt' }
+  }
+
+  describe "#execute" do
+    before do
+      allow(image).to receive(:workspace).and_return(Pathname.new('/tmp'))
+      allow(image).to receive(:env).and_return({:name => 'test'})
+      allow(config).to receive(:resolve_file).and_return(nil)
+      allow(config).to receive(:resolve_file).with('/tmp/file').and_return('/tmp/file')      
+      allow(config).to receive(:resolve_file).with('include.erb').and_return('/tmp/include.erb')
+      allow(File).to receive(:read).with('/tmp/file').and_return("<%= name %>")
+      allow(File).to receive(:read).with('/tmp/include.erb').and_return("included")
+      allow(File).to receive(:open).with(Pathname.new("/tmp/dest.txt"),"w").and_yield(dest)
+      allow(dest).to receive(:write)
+    end
+    it 'writes template content to dest' do
+      Baha::PreBuild::Module.execute(subject)
+      expect(dest).to have_received(:write).with("test")
+    end
+    context 'with render function' do
+      before do
+        allow(File).to receive(:read).with('/tmp/file').and_return("<%= render 'include.erb' %>")
+      end
+      it 'includes render file' do
+        Baha::PreBuild::Module.execute(subject)
+        expect(dest).to have_received(:write).with("included")
+      end
+      it 'raises error when not found' do
+        allow(config).to receive(:resolve_file).with('include.erb').and_return(nil)
+        expect { Baha::PreBuild::Module.execute(subject) }.to raise_error(ArgumentError)
+      end
+    end
+    context "when template not found" do
+      it 'raises ArgumentError' do
+        allow(config).to receive(:resolve_file).and_return(nil)
+        expect { Baha::PreBuild::Module.execute(subject) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/pre_build_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'baha/config'
+require 'baha/pre_build'
+
+describe Baha::Builder do
+  let(:task) do
+    { 'download' => '', 'url' => 'http://www.google.com', 'file' => 'out.txt' }
+  end
+  let(:badtask) do
+    { 'no_such_module' => 'throws error' }
+  end
+
+  describe "#execute" do
+    context 'with valid task' do
+      before do
+        allow(Baha::PreBuild::Module).to receive(:module_download)
+        Baha::PreBuild::Module.execute(task)
+      end
+      it 'exeecutes module' do
+        expect(Baha::PreBuild::Module).to have_received(:module_download).with(instance_of(Baha::PreBuild::Module))
+      end
+    end
+    context 'with invalid task' do
+      it do
+        expect { Baha::PreBuild::Module.execute(badtask) }.to raise_error(Baha::PreBuild::ModuleNotFoundError)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/spec/'
+end
+
+require 'bundler/setup'
+Bundler.setup
+
+require 'baha'
+require 'helpers/docker_helpers.rb'
+require 'rspec/its'
+require 'rspec/mocks'
+require 'pathname'
+require 'stringio'
+
+def fixture_path
+  Pathname.new(File.expand_path(File.join(__FILE__, '..', 'fixtures')))
+end
+def fixture(filename)
+  file = fixture_path + filename
+  raise ArgumentError.new("File #{filename} could not be found") unless file.exist?
+  file
+end
+
+RSpec.configure do |config|
+ # config.color_enabled = true
+  config.order = "random"
+
+  config.include DockerHelpers
+
+  # Forbid old 'should' syntax
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.before(:each) do
+    Baha::Log.logfile = StringIO.new
+  end
+end