bigrig 0.0.0 → 0.0.7

data/spec/bigrig/docker_adapter_spec.rb

@@ -0,0 +1,409 @@
+require 'pry'
+module Bigrig
+  describe DockerAdapter do
+
+    describe '::build' do
+      subject { described_class.build path }
+      let(:path) { test_file 'build' }
+      let(:image_id) { subject }
+
+      it 'builds the given directory', :vcr do
+        expect { Docker::Image.get(image_id) }.to_not raise_error
+      end
+
+      it 'passes build input to a block', :vcr do
+        described_class.build path do |chunk|
+          puts "chunk: #{chunk}"
+        end
+      end
+    end
+
+    describe '::container_exists?' do
+      subject { described_class.container_exists?(name) }
+
+      context 'when the container exists' do
+        let!(:container) { Docker::Container.create 'name' => name, 'Image' => 'hawknewton/true' }
+        let(:name) { 'container_exists' }
+
+        after { container.remove }
+
+        it 'is true', :vcr do
+          is_expected.to be true
+        end
+      end
+
+      context 'when the container does not exist' do
+        let(:name) { 'container_does_not_exist' }
+
+        it 'is false', :vcr do
+          is_expected.to be false
+        end
+      end
+    end
+
+    describe '::image_id_by_tag' do
+      subject { DockerAdapter.image_id_by_tag(tag) }
+
+      context 'when the image exists' do
+        let(:tag) { 'image_exists' }
+        let!(:image) { Docker::Image.create 'fromImage' => 'hawknewton/true' }
+
+        # Get the long id
+        let(:image_id) { Docker::Image.get(image.id).id }
+
+        before { image.tag 'repo' => tag }
+        after { image.remove name: tag }
+
+        it 'returns the image id', :vcr do
+          is_expected.to eq image_id
+        end
+      end
+
+      context 'when the image does not exist' do
+        let(:tag) { 'hawknewton/true:not_exist' }
+
+        before do
+          begin
+            image = Docker::Image.get tag
+            image.remove name: tag
+          rescue Docker::Error::NotFoundError # rubocop:disable Lint/HandleExceptions
+          end
+        end
+
+        it 'raise a ImageNotFoundError', :vcr do
+          expect { subject }.to raise_error ImageNotFoundError
+        end
+      end
+    end
+
+    describe '::kill' do
+      subject { described_class.kill container_id }
+
+      context 'given the container is running' do
+        let(:container) { Docker::Container.create('Image' => image.id).tap(&:start) }
+        let(:container_id) { container.id }
+        let(:image) { Docker::Image.create 'fromImage' => 'hawknewton/show-env' }
+        let(:running?) { container.json['State']['Running'] }
+        let!(:kill) { subject }
+
+        after { container.delete force: true }
+
+        it 'should kill the container', :vcr do
+          expect(running?).to be false
+        end
+      end
+
+      context 'given the container does not exist' do
+        let(:container_id) { 'doesnotexist' }
+
+        it 'should raise an error', :vcr do
+          expect { subject }.to raise_error ContainerNotFoundError
+        end
+      end
+    end
+
+    describe '::logs' do
+      subject { described_class.logs(container.id) { |s, c| logs << [s, c] } }
+      let(:logs) { [] }
+      let(:image) { Docker::Image.create 'fromImage' => 'hawknewton/log-test:0.0.1' }
+      let(:container) { Docker::Container.get 'log-test' }
+
+      before  do
+        Docker::Container.create('Image' => image.id, 'name' => 'log-test').start
+      end
+
+      after { container.kill.delete }
+
+      it 'streams logs to a block', :vcr do
+        allow(Docker::Container).to receive(:get).with(container.id, {}, anything).
+          and_return container
+        expect(container).to receive(:streaming_logs).
+          with(follow: true, stdout: true, stderr: true).
+          and_yield('stream #1', 'I am log message #1').
+          and_yield('stream #2', 'I am log message #2')
+
+        subject
+        expect(logs).to include ['stream #1', 'I am log message #1']
+        expect(logs).to include ['stream #2', 'I am log message #2']
+      end
+    end
+
+    describe '::push' do
+      subject { described_class.push tag, credentials }
+      let(:credentials) { nil }
+      let(:host) { URI.parse(Docker.connection.url).host }
+      let(:image) { Docker::Image.import test_file 'tiny-image.tar' }
+      let(:repo) { "#{host}:5000/test/push-me" }
+      let(:version) { '1.2.3' }
+      let(:tag) { "#{repo}:#{version}" }
+      let(:registry) do
+        Docker::Image.create 'fromImage' => 'registry:latest'
+        Docker::Container.create(
+          'name' => 'registry',
+          'Image' => 'registry',
+          'Env' => ['GUNICORN_OPTS=[--preload]'],
+          'ExposedPorts' => {
+            '5000/tcp' => {}
+          },
+          'HostConfig' => {
+            'PortBindings' => { '5000/tcp' => [{ 'HostPort' => '5000' }] }
+          }
+        )
+      end
+
+      before do
+        registry.start
+        image.tag 'repo' => repo, 'tag' => version
+        sleep 1
+      end
+
+      after do
+        registry.kill.delete
+        image.remove 'force' => true
+      end
+
+      it 'should push the image', :vcr do
+        subject
+        Docker::Image.get(tag).remove 'force' => true
+        expect { Docker::Image.create 'fromImage' => tag }.to_not raise_error
+      end
+
+      context 'given credentials' do
+        let(:credentials) do
+          {
+            'username' => 'username',
+            'password' => 'pass',
+            'email' => 'email@email.com',
+            'serveraddress' => 'https://index.docker.io/v1'
+          }
+        end
+        # I don't have the energy to set one of these up for real
+
+        it 'will pass login and password', :vcr do
+          creds = {
+            'username' => 'username',
+            'password' => 'pass',
+            'serveraddress' => 'https://index.docker.io/v1',
+            'email' => 'email@email.com'
+          }
+          expect_any_instance_of(Docker::Image).to receive(:push).
+            with(creds, {})
+          subject
+        end
+      end
+    end
+
+    describe '::pull' do
+      subject { described_class.pull repo }
+
+      context 'given the repo exists' do
+        let(:repo) { 'hawknewton/true:latest' }
+        let(:image_id) { Docker::Image.get(repo).id }
+
+        it 'returns the image id', :vcr do
+          is_expected.to eq image_id
+        end
+      end
+
+      context 'given the repo does not exist' do
+        let(:repo) { 'hawknewton/doesnotexist' }
+
+        it 'raises a RepoNotFoundError', :vcr do
+          expect { subject }.to raise_error RepoNotFoundError
+        end
+      end
+
+      context 'given a block to capture output' do
+        let(:repo) { 'hawknewton/true' }
+        let(:output) { '' }
+        let(:block) { proc { |chunk| output << chunk } }
+        let!(:image_id) { described_class.pull repo, &block }
+
+        it 'should capture output', :vcr do
+          expect(output).to match(/Pulling repository hawknewton\/true/)
+        end
+      end
+    end
+
+    describe '::remove_container' do
+      subject { described_class.remove_container container_id }
+
+      context 'when the container exists' do
+        let(:container_id) { Docker::Container.create('Image' => 'hawknewton/true').id }
+        let!(:remove) { subject }
+
+        it 'should remove the container', :vcr do
+          expect { Docker::Container.get container_id }.
+            to raise_error { Docker::Error::NotFoundError }
+        end
+      end
+
+      context 'when the container does not exist' do
+        let(:container_id) { 'doesnotexist' }
+
+        it 'raises a ContainerNotFoundError', :vcr do
+          expect { subject }.to raise_error ContainerNotFoundError
+        end
+      end
+
+      context 'when the container is running' do
+        let(:container_id) do
+          Docker::Container.create('Image' => 'hawknewton/true').tap(&:start).id
+        end
+
+        it 'raises a ContainerRunningError', :vcr do
+          expect { subject }.to raise_error ContainerRunningError
+        end
+      end
+    end
+
+    describe '::remove_image' do
+      subject { described_class.remove_image image_id }
+
+      context 'when the image exists' do
+        let(:image_id) { Docker::Image.import(test_file 'tiny-image.tar').id }
+
+        it 'removes the image', :vcr do
+          subject
+          expect { Docker::Image.get(image_id) }.to raise_error(/404 Not Found/)
+        end
+      end
+
+      context 'when the image doesn''t exist' do
+        let(:image_id) { 'does_not_exist' }
+
+        it 'raises an error', :vcr do
+          expect { subject }.to raise_error ImageNotFoundError
+        end
+      end
+    end
+
+    describe '::run' do
+      subject { DockerAdapter.run({ image_id: image_id }.merge opts) }
+
+      context 'given an image_id that exists' do
+        let(:image_id) { 'hawknewton/show-env' }
+        let(:container_id) { subject }
+        let(:container) { Docker::Container.get container_id }
+        let(:running?) { container.json['State']['Running'] }
+
+        context 'and a name' do
+          let(:opts) { { name: name } }
+          let(:name) { 'and_a_name' }
+
+          # strip the leading '/' from the json name
+          let(:container_name) { container.json['Name'][1..-1] }
+
+          after { Docker::Container.get(name).kill!.delete }
+
+          it 'starts the container with the right name', :vcr do
+            expect(running?).to be true
+            expect(container_name).to eq name
+          end
+        end
+
+        context 'and a name and ports' do
+          let(:free_port) { TCPServer.new('0.0.0.0', 0).addr[1] }
+          let(:opts) { { name: name, ports: ["#{free_port}:80", '70'] } }
+          let(:name) { 'with_ports' }
+          let(:exposed_ports) { container.json['Config']['ExposedPorts'].map { |k, _| k } }
+          let(:mapped_ports) do
+            container.json['NetworkSettings']['Ports'].each_with_object({}) do |arr, hash|
+              hash[arr[0]] = arr[1][0]['HostPort']
+            end
+          end
+
+          after { Docker::Container.get(name).kill!.delete }
+
+          it 'starts the container with ports exposed', :vcr do
+            expect(running?).to be true
+            expect(exposed_ports).to eq ['70/tcp', '80/tcp']
+            expect(mapped_ports).to include '80/tcp'
+            expect(mapped_ports).to include '70/tcp'
+
+            # Because the free port will move around under VCR we can't actually
+            # assert anything
+            expect(mapped_ports['80/tcp'].to_i).to be_a Fixnum
+            expect(mapped_ports['70/tcp'].to_i).to be_a Fixnum
+          end
+        end
+
+        context 'and a name and env variables' do
+          let(:name) { 'with_env' }
+          let(:opts) { { name: name, env: { 'NAME1' => 'VALUE1', 'NAME2' => 'VALUE2' } } }
+          let(:envs) { container.json['Config']['Env'] }
+
+          after { Docker::Container.get(name).kill!.delete }
+
+          it 'starts the container with env set', :vcr do
+            expect(running?).to be true
+            expect(envs).to include 'NAME1=VALUE1'
+            expect(envs).to include 'NAME2=VALUE2'
+          end
+        end
+      end
+    end
+
+    describe '::running?' do
+      subject { described_class.running? container_id }
+      let(:result) { subject }
+
+      context 'when the container is running' do
+        let(:container) do
+          Docker::Container.create('Image' => 'hawknewton/show-env')
+        end
+        let(:container_id) { container.id }
+
+        before { container.start }
+        after { container.delete force: true }
+
+        it 'returns true', :vcr do
+          expect(result).to be true
+        end
+      end
+
+      context 'when the container is not running' do
+        let(:container) do
+          Docker::Container.create('Image' => 'hawknewton/show-env')
+        end
+        let(:container_id) { container.id }
+
+        after { container.delete force: true }
+
+        it 'returns false', :vcr do
+          expect(result).to be false
+        end
+      end
+
+      context 'when the container does not exist', :vcr do
+        let(:container_id) { 'doesnotexist' }
+
+        it 'returns false' do
+          expect(result).to be false
+        end
+      end
+    end
+
+    describe '::tag' do
+      subject { described_class.tag id, tag }
+      let(:id) { Docker::Image.create('fromImage' => 'hawknewton/true').id }
+      let(:tag) { 'test/tag:1.2.3' }
+
+      before do
+        begin
+          Docker::Image.get(tag).remove 'force' => true
+        rescue Docker::Error::NotFoundError # rubocop:disable Lint/HandleExceptions
+        end
+      end
+
+      after do
+        Docker::Image.get(tag).remove 'force' => true
+      end
+
+      it 'should tag the image', :vcr do
+        subject
+        expect { Docker::Image.get 'test/tag:1.2.3' }.to_not raise_error
+      end
+    end
+  end
+end

data/spec/bigrig/models/application_spec.rb

@@ -0,0 +1,32 @@
+module Bigrig
+  describe Application do
+    it { is_expected.to respond_to :name }
+    it { is_expected.to respond_to :name= }
+
+    it { is_expected.to respond_to :containers }
+    it { is_expected.to respond_to :containers= }
+
+    describe '::from_json' do
+      subject { described_class.from_json json }
+
+      context 'given a simple file' do
+        let(:file) { 'single.json' }
+        let(:json) { Descriptor.read(test_file(file)).as_json }
+
+        its('containers.size') { is_expected.to eq 1 }
+
+        it 'should set the container name' do
+          expect(subject.containers[0].name).to eq 'single-test'
+        end
+
+        it 'should set the container tag' do
+          expect(subject.containers[0].tag).to eq '0.0.1'
+        end
+
+        it 'should set the container repo' do
+          expect(subject.containers[0].repo).to eq 'hawknewton/show-env'
+        end
+      end
+    end
+  end
+end

data/spec/bigrig/models/container_spec.rb

@@ -0,0 +1,115 @@
+module Bigrig
+  describe Container do
+    it { is_expected.to respond_to :hosts= }
+    it { is_expected.to respond_to :hosts }
+    it { is_expected.to respond_to :links= }
+    it { is_expected.to respond_to :links }
+    it { is_expected.to respond_to :name }
+    it { is_expected.to respond_to :name= }
+    it { is_expected.to respond_to :path }
+    it { is_expected.to respond_to :path= }
+    it { is_expected.to respond_to :ports }
+    it { is_expected.to respond_to :ports= }
+    it { is_expected.to respond_to :repo }
+    it { is_expected.to respond_to :repo= }
+    it { is_expected.to respond_to :tag }
+    it { is_expected.to respond_to :tag= }
+    it { is_expected.to respond_to :volumes_from }
+    it { is_expected.to respond_to :volumes_from= }
+
+    it 'accepts volumes_from as an array' do
+      expect(Container.from_json(nil, 'volumes_from' => ['test']).volumes_from).to be_kind_of Array
+    end
+
+    it 'wraps a single volumes_from in an array' do
+      expect(Container.from_json(nil, 'volumes_from' => 'test').volumes_from).to be_kind_of Array
+    end
+
+    it 'accepts links as an array' do
+      expect(Container.from_json(nil, 'links' => ['machine:alias']).links).to be_kind_of Array
+    end
+
+    it 'wraps a single links in an array' do
+      expect(Container.from_json(nil, 'links' => 'machine:alias').links).to be_kind_of Array
+    end
+
+    it 'accepts hosts as an array' do
+      expect(Container.from_json(nil, 'links' => ['host:alias']).links).to be_kind_of Array
+    end
+
+    it 'wraps a single links in an array' do
+      expect(Container.from_json(nil, 'hosts' => 'host:alias').links).to be_kind_of Array
+    end
+
+    it 'depends on containers it mounts volumes from' do
+      expect(Container.from_json(nil, 'volumes_from' => 'test').dependencies).to eq ['test']
+    end
+
+    it 'depends on containers it links to' do
+      expect(Container.from_json(nil, 'links' => 'machine:alias').dependencies).to eq ['machine']
+    end
+
+    describe '#dependencies' do
+      it 'returns an empty array when no dependencies are present' do
+        expect(Container.from_json(nil, {}).dependencies).to eq []
+      end
+    end
+
+    describe '::from_json' do
+      subject { Container.from_json name, json }
+      let(:name) { 'name' }
+
+      context 'with an empty json document' do
+        let(:json) { {} }
+
+        its(:env) { is_expected.to be_empty }
+        its(:env) { is_expected.to be_a Hash }
+
+        its(:volumes_from) { is_expected.to be_empty }
+        its(:volumes_from) { is_expected.to be_a Array }
+
+        its(:ports) { is_expected.to be_a Array }
+        its(:ports) { is_expected.to be_empty }
+
+      end
+
+      context 'given json with a path' do
+        let(:json) { { 'path' => '/path/to/Dockerfile' } }
+
+        it 'sets the path' do
+          expect(subject.path).to eq '/path/to/Dockerfile'
+        end
+      end
+
+      context 'given json with env params' do
+        let(:json) { { 'env' => { 'NAME1' => 'VALUE1', 'NAME2' => 'VALUE2' } } }
+
+        it 'parses the environment variables' do
+          expect(subject.env).to include(
+            'NAME1' => 'VALUE1',
+            'NAME2' => 'VALUE2'
+          )
+        end
+
+        context 'that reference environment variables' do
+          let(:json) { { 'env' => { 'NAME1' => "\#{ENV['NAME1']}" } } }
+
+          before { ENV['NAME1'] = 'ENV1' }
+          after { ENV['NAME1'] = nil }
+
+          it 'retrieves the variable from the environemnt' do
+            expect(subject.env).to include('NAME1' => 'ENV1')
+          end
+        end
+      end
+
+      context 'given json with ports' do
+        let(:json) { { 'ports' => ['80:8080', '12345'] } }
+
+        it 'has ports' do
+          expect(subject.ports).to eq ['80:8080', '12345']
+        end
+      end
+    end
+  end
+end

data/spec/bigrig/output_parser_spec.rb

@@ -0,0 +1,71 @@
+module Bigrig
+  describe OutputParser do
+    describe '#parse' do
+      subject do
+        parser = described_class.new
+        [input].flatten.map { |i| parser.parse i }.last
+      end
+
+      let(:mock_io) { double IO }
+      let(:output) { subject }
+
+      context 'with input that has a stream' do
+        let(:input) { '{"stream": "value"}' }
+
+        it 'returns the value of stream' do
+          expect(output).to eq 'value'
+        end
+      end
+
+      context 'with input that has no id and a status' do
+        let(:input) { '{"status": "status_value"}' }
+
+        it 'returns the value of status with a linefeed' do
+          expect(output).to eq "status_value\n"
+        end
+      end
+
+      context 'with input that has an id, status, and progress' do
+        let(:input) { '{"id": "id", "status": "status", "progress" : "progress" }' }
+
+        it 'formats the output with a trailing carrage return' do
+          expect(output).to eq "id: status progress\r"
+        end
+      end
+
+      context 'when the id changes' do
+        let(:input) do
+          ['{"id": "id", "status": "status", "progress" : "progress" }',
+           '{"id": "new_id", "status": "status", "progress" : "progress" }']
+        end
+
+        it 'prints a linefeed' do
+          expect(output).to eq "\nnew_id: status progress\r"
+        end
+      end
+
+      context 'when the id noralizes after changing' do
+        let(:input) do
+          ['{"id": "id", "status": "status", "progress" : "progress" }',
+           '{"id": "new_id", "status": "status", "progress" : "progress" }',
+           '{"id": "new_id", "status": "status", "progress" : "progress" }']
+        end
+
+        it 'does not print a linefeed' do
+          expect(output).to eq "new_id: status progress\r"
+        end
+      end
+
+      context 'when a shorter message is returned with the same id' do
+        let(:input) do
+          ['{"id": "id", "status": "status", "progress" : "i am a much longer message" }',
+           '{"id": "id", "status": "status", "progress" : "progress" }']
+        end
+
+        it 'pads the output' do
+          expect(output).to eq "id: status progress                  \r"
+        end
+      end
+    end
+  end
+end