docker-api 1.28.0 → 2.0.0

data/script/docker.conf

@@ -1,61 +0,0 @@
-description "Docker daemon"
-
-start on (local-filesystems and net-device-up IFACE!=lo)
-stop on runlevel [!2345]
-limit nofile 524288 1048576
-limit nproc 524288 1048576
-
-respawn
-
-kill timeout 20
-
-pre-start script
-        # see also https://github.com/tianon/cgroupfs-mount/blob/master/cgroupfs-mount
-        if grep -v '^#' /etc/fstab | grep -q cgroup \
-                || [ ! -e /proc/cgroups ] \
-                || [ ! -d /sys/fs/cgroup ]; then
-                exit 0
-        fi
-        if ! mountpoint -q /sys/fs/cgroup; then
-                mount -t tmpfs -o uid=0,gid=0,mode=0755 cgroup /sys/fs/cgroup
-        fi
-        (
-                cd /sys/fs/cgroup
-                for sys in $(awk '!/^#/ { if ($4 == 1) print $1 }' /proc/cgroups); do
-                        mkdir -p $sys
-                        if ! mountpoint -q $sys; then
-                                if ! mount -n -t cgroup -o $sys cgroup $sys; then
-                                        rmdir $sys || true
-                                fi
-                        fi
-                done
-        )
-end script
-
-script
-        # modify these in /etc/default/$UPSTART_JOB (/etc/default/docker)
-        DOCKER=/usr/bin/$UPSTART_JOB
-        DOCKER_OPTS=
-        if [ -f /etc/default/$UPSTART_JOB ]; then
-                . /etc/default/$UPSTART_JOB
-        fi
-        exec "$DOCKER" -d $DOCKER_OPTS
-end script
-
-# Don't emit "started" event until docker.sock is ready.
-# See https://github.com/docker/docker/issues/6647
-post-start script
-        DOCKER_OPTS=
-        if [ -f /etc/default/$UPSTART_JOB ]; then
-                . /etc/default/$UPSTART_JOB
-        fi
-        if ! printf "%s" "$DOCKER_OPTS" | grep -qE -e '-H|--host'; then
-                while ! [ -e /var/run/docker.sock ]; do
-                        initctl status $UPSTART_JOB | grep -qE "(stop|respawn)/" && exit 1
-                        echo "Waiting for /var/run/docker.sock"
-                        sleep 0.1
-                done
-                echo "/var/run/docker.sock is up"
-        fi
-end script
-

data/script/install_docker.sh

@@ -1,35 +0,0 @@
-#!/bin/bash
-set -x
-set -e
-
-# argv[0]
-DOCKER_VERSION=$1
-
-# disable travis default installation
-service docker stop
-apt-get -y --purge remove docker-engine
-
-# install gpg key for docker rpo
-apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv 58118E89F3A912897C070ADBF76221572C52609D
-
-# enable docker repo
-echo 'deb "https://apt.dockerproject.org/repo" ubuntu-trusty main' >> /etc/apt/sources.list.d/docker-main.list
-apt-get update -o Dir::Etc::sourcelist='sources.list.d/docker-main.list' -o Dir::Etc::sourceparts='-' -o APT::Get::List-Cleanup='0'
-apt-cache gencaches
-
-# install package
-apt-get -y --force-yes install docker-engine=${DOCKER_VERSION}-0~trusty
-echo 'DOCKER_OPTS="-H unix:///var/run/docker.sock --pidfile=/var/run/docker.pid"' > /etc/default/docker
-cat /etc/default/docker
-
-# docker 1.6 packages did not come with init files
-if [[ $DOCKER_VERSION == 1.6.* ]]
-then
-    cp script/docker.conf /etc/init/docker.conf
-    cp script/docker /etc/init.d/docker
-    chmod +x /etc/init.d/docker
-else
-    service docker stop
-fi
-
-service docker start

data/spec/docker/connection_spec.rb

@@ -1,123 +0,0 @@
-require 'spec_helper'
-
-describe Docker::Connection do
-  subject { described_class.new('http://localhost:4243', {}) }
-
-  describe '#initialize' do
-    let(:url) { 'http://localhost:4243' }
-    let(:options) { {} }
-    subject { described_class.new(url, options) }
-
-    context 'when the first argument is not a String' do
-      let(:url) { :lol_not_a_string }
-
-      it 'raises an error' do
-        expect { subject }.to raise_error(Docker::Error::ArgumentError)
-      end
-    end
-
-    context 'when the first argument is a String' do
-      context 'and the url is a unix socket' do
-        let(:url) { 'unix:///var/run/docker.sock' }
-
-        it 'sets the socket path in the options' do
-          expect(subject.url).to eq('unix:///')
-          expect(subject.options).to include(:socket => '/var/run/docker.sock')
-        end
-      end
-
-      context 'but the second argument is not a Hash' do
-        let(:options) { :lol_not_a_hash }
-
-        it 'raises an error' do
-          expect { subject }.to raise_error(Docker::Error::ArgumentError)
-        end
-      end
-
-      context 'and the second argument is a Hash' do
-        it 'sets the url and options' do
-          expect(subject.url).to eq url
-          expect(subject.options).to eq options
-        end
-      end
-    end
-
-    context 'url conversion to uri' do
-      context 'when the url does not contain a scheme' do
-        let(:url) { 'localhost:4243' }
-
-        it 'adds the scheme to the url' do
-          expect(subject.url).to eq "http://#{url}"
-        end
-      end
-
-      context 'when the url is a complete uri' do
-        let(:url) { 'http://localhost:4243' }
-
-        it 'leaves the url intact' do
-          expect(subject.url).to eq url
-        end
-      end
-    end
-  end
-
-  describe '#resource' do
-    its(:resource) { should be_a Excon::Connection }
-  end
-
-  describe '#request' do
-    let(:method) { :get }
-    let(:path) { '/test' }
-    let(:query) { { :all => true } }
-    let(:options) { { :expects => 201, :lol => true } }
-    let(:body) { rand(10000000) }
-    let(:resource) { double(:resource) }
-    let(:response) { double(:response, :body => body) }
-    let(:expected_hash) {
-      {
-        :method  => method,
-        :path    => "/v#{Docker::API_VERSION}#{path}",
-        :query   => query,
-        :headers => { 'Content-Type' => 'text/plain',
-                      'User-Agent'   => "Swipely/Docker-API #{Docker::VERSION}",
-                    },
-        :expects => 201,
-        :idempotent => true,
-        :lol => true
-      }
-    }
-
-    before do
-      allow(subject).to receive(:resource).and_return(resource)
-      expect(resource).to receive(:request).
-        with(expected_hash).
-        and_return(response)
-    end
-
-    it 'sends #request to #resource with the compiled params' do
-      expect(subject.request(method, path, query, options)).to eq body
-    end
-  end
-
-  [:get, :put, :post, :delete].each do |method|
-    describe "##{method}" do
-      it 'is delegated to #request' do
-        expect(subject).to receive(:request).with(method)
-        subject.public_send(method)
-      end
-    end
-  end
-
-  describe '#to_s' do
-    let(:url) { 'http://google.com:4000' }
-    let(:options) { {} }
-    let(:expected_string) {
-      "Docker::Connection { :url => #{url}, :options => #{options} }"
-    }
-    subject { described_class.new(url, options) }
-
-    it 'returns a pretty version with the url and port' do
-      expect(subject.to_s).to eq expected_string
-    end
-  end
-end

data/spec/docker/container_spec.rb

@@ -1,801 +0,0 @@
-require 'spec_helper'
-
-describe Docker::Container do
-  describe '#to_s' do
-    subject {
-      described_class.send(:new, Docker.connection, 'id' => rand(10000).to_s)
-    }
-
-    let(:id) { 'bf119e2' }
-    let(:connection) { Docker.connection }
-    let(:expected_string) {
-      "Docker::Container { :id => #{id}, :connection => #{connection} }"
-    }
-    before do
-      {
-        :@id => id,
-        :@connection => connection
-      }.each { |k, v| subject.instance_variable_set(k, v) }
-    end
-
-    its(:to_s) { should == expected_string }
-  end
-
-  describe '#json' do
-    subject {
-      described_class.create('Cmd' => %w[true], 'Image' => 'debian:wheezy')
-    }
-    let(:description) { subject.json }
-    after(:each) { subject.remove }
-
-    it 'returns the description as a Hash' do
-      expect(description).to be_a Hash
-      expect(description['Id']).to start_with(subject.id)
-    end
-  end
-
-  describe '#streaming_logs' do
-    let(:options) { {} }
-    subject do
-      described_class.create(
-        {'Cmd' => ['/bin/bash', '-lc', 'echo hello'], 'Image' => 'debian:wheezy'}.merge(options)
-      )
-    end
-
-    before(:each) { subject.tap(&:start).wait }
-    after(:each) { subject.remove }
-
-    context 'when not selecting any stream' do
-      let(:non_destination) { subject.streaming_logs }
-      it 'raises a client error' do
-        expect { non_destination }.to raise_error(Docker::Error::ClientError)
-      end
-    end
-
-    context 'when selecting stdout' do
-      let(:stdout) { subject.streaming_logs(stdout: 1) }
-      it 'returns blank logs' do
-        expect(stdout).to be_a String
-        expect(stdout).to match("hello")
-      end
-    end
-
-    context 'when using a tty' do
-      let(:options) { { 'Tty' => true } }
-
-      let(:output) { subject.streaming_logs(stdout: 1, tty: 1) }
-      it 'returns `hello`' do
-        expect(output).to be_a(String)
-        expect(output).to match("hello")
-      end
-    end
-
-    context 'when passing a block' do
-      let(:lines) { [] }
-      let(:output) { subject.streaming_logs(stdout: 1, follow: 1) { |s,c| lines << c } }
-      it 'returns `hello`' do
-        expect(output).to be_a(String)
-        expect(output).to match("hello")
-        expect(lines.join).to match("hello")
-      end
-    end
-  end
-
-  describe '#logs' do
-    subject {
-      described_class.create('Cmd' => "echo hello", 'Image' => 'debian:wheezy')
-    }
-    after(:each) { subject.remove }
-
-    context "when not selecting any stream" do
-      let(:non_destination) { subject.logs }
-      it 'raises a client error' do
-        expect { non_destination }.to raise_error(Docker::Error::ClientError)
-      end
-    end
-
-    context "when selecting stdout" do
-      let(:stdout) { subject.logs(stdout: 1) }
-      it 'returns blank logs' do
-        expect(stdout).to be_a String
-        expect(stdout).to eq ""
-      end
-    end
-  end
-
-  describe '#create' do
-    subject {
-      described_class.create({
-        'Cmd' => %w[true],
-        'Image' => 'debian:wheezy'
-      }.merge(opts))
-    }
-
-    context 'when creating a container named bob' do
-      let(:opts) { {"name" => "bob"} }
-      after(:each) { subject.remove }
-
-      it 'should have name set to bob' do
-        expect(subject.json["Name"]).to eq("/bob")
-      end
-    end
-  end
-
-  describe '#rename' do
-    subject {
-      described_class.create({
-        'name' => 'foo',
-        'Cmd' => %w[true],
-        'Image' => 'debian:wheezy'
-      })
-    }
-
-    before { subject.start }
-    after(:each) { subject.tap(&:wait).remove }
-
-    it 'renames the container' do
-      subject.rename('bar')
-      expect(subject.json["Name"]).to match(%r{bar})
-    end
-  end
-
-  describe '#changes' do
-    subject {
-      described_class.create(
-        'Cmd' => %w[rm -rf /root],
-        'Image' => 'debian:wheezy'
-      )
-    }
-    let(:changes) { subject.changes }
-
-    before { subject.tap(&:start).tap(&:wait) }
-    after(:each) { subject.tap(&:wait).remove }
-
-    it 'returns the changes as an array' do
-      expect(changes).to eq [
-        {
-          "Path" => "/root",
-          "Kind" => 2
-        },
-      ]
-    end
-  end
-
-  describe '#top' do
-    let(:dir) {
-      File.join(File.dirname(__FILE__), '..', 'fixtures', 'top')
-    }
-    let(:image) { Docker::Image.build_from_dir(dir) }
-    let(:top) { sleep 1; container.top }
-    let!(:container) { image.run('/while') }
-    after do
-      container.kill!.remove
-      image.remove
-    end
-
-    it 'returns the top commands as an Array' do
-      expect(top).to be_a Array
-      expect(top).to_not be_empty
-      expect(top.first.keys).to include('PID')
-    end
-  end
-
-  describe '#copy' do
-    let(:image) { Docker::Image.create('fromImage' => 'debian:wheezy') }
-    subject { image.run('touch /test').tap { |c| c.wait } }
-
-    after(:each) { subject.remove }
-
-    context 'when the file does not exist' do
-      it 'raises an error' do
-        expect { subject.copy('/lol/not/a/real/file') { |chunk| puts chunk } }
-          .to raise_error
-      end
-    end
-
-    context 'when the input is a file' do
-      it 'yields each chunk of the tarred file' do
-        chunks = []
-        subject.copy('/test') { |chunk| chunks << chunk }
-        chunks = chunks.join("\n")
-        expect(chunks).to be_include('test')
-      end
-    end
-
-    context 'when the input is a directory' do
-      it 'yields each chunk of the tarred directory' do
-        chunks = []
-        subject.copy('/etc/logrotate.d') { |chunk| chunks << chunk }
-        chunks = chunks.join("\n")
-        expect(%w[apt dpkg]).to be_all { |file| chunks.include?(file) }
-      end
-    end
-  end
-
-  describe '#archive_in', :docker_1_8 do
-    let(:license_path) { File.absolute_path(File.join(__FILE__, '..', '..', '..', 'LICENSE')) }
-    subject { Docker::Container.create('Image' => 'debian:wheezy', 'Cmd' => ['/bin/sh']) }
-    let(:committed_image) { subject.commit }
-    let(:ls_container) { committed_image.run('ls /').tap(&:wait) }
-    let(:output) { ls_container.streaming_logs(stdout: true, stderr: true) }
-
-    after do
-      subject.remove
-    end
-
-    context 'when the input is a tar' do
-      after do
-        ls_container.remove
-        committed_image.remove
-      end
-
-      it 'file exists in the container' do
-        subject.archive_in(license_path, '/', overwrite: false)
-        expect(output).to include('LICENSE')
-      end
-    end
-  end
-
-  describe '#archive_in_stream', :docker_1_8 do
-    let(:tar) { StringIO.new(Docker::Util.create_tar('/lol' => 'TEST')) }
-    subject { Docker::Container.create('Image' => 'debian:wheezy', 'Cmd' => ['/bin/sh']) }
-    let(:committed_image) { subject.commit }
-    let(:ls_container) { committed_image.run('ls /').tap(&:wait) }
-    let(:output) { ls_container.streaming_logs(stdout: true, stderr: true) }
-
-    after do
-      subject.remove
-    end
-
-    context 'when the input is a tar' do
-      after do
-        ls_container.remove
-        committed_image.remove
-      end
-
-      it 'file exists in the container' do
-        subject.archive_in_stream('/', overwrite: false) { tar.read }
-        expect(output).to include('lol')
-      end
-    end
-
-    context 'when the input would overwrite a directory with a file' do
-      let(:tar) { StringIO.new(Docker::Util.create_tar('/etc' => 'TEST')) }
-
-      it 'raises an error' do
-        # Docs say this should return a client error: clearly wrong
-        # https://docs.docker.com/engine/reference/api/docker_remote_api_v1.21/
-        # #extract-an-archive-of-files-or-folders-to-a-directory-in-a-container
-        expect {
-          subject.archive_in_stream('/', overwrite: false) { tar.read }
-        }.to raise_error(Docker::Error::ServerError)
-      end
-    end
-  end
-
-  describe '#archive_out', :docker_1_8 do
-    subject { Docker::Container.create('Image' => 'debian:wheezy', 'Cmd' => ['touch','/test']) }
-
-    after { subject.remove }
-
-    context 'when the file does not exist' do
-      it 'raises an error' do
-        subject.start
-        subject.wait
-
-        expect { subject.archive_out('/lol') { |chunk| puts chunk } }
-          .to raise_error(Docker::Error::NotFoundError)
-      end
-    end
-
-    context 'when the input is a file' do
-      it 'yields each chunk of the tarred file' do
-        subject.start; subject.wait
-
-        chunks = []
-        subject.archive_out('/test') { |chunk| chunks << chunk }
-        chunks = chunks.join("\n")
-        expect(chunks).to be_include('test')
-      end
-    end
-
-    context 'when the input is a directory' do
-      it 'yields each chunk of the tarred directory' do
-        subject.start; subject.wait
-
-        chunks = []
-        subject.archive_out('/etc/logrotate.d') { |chunk| chunks << chunk }
-        chunks = chunks.join("\n")
-        expect(%w[apt dpkg]).to be_all { |file| chunks.include?(file) }
-      end
-    end
-  end
-
-  describe '#export' do
-    subject { described_class.create('Cmd' => %w[/true],
-                                     'Image' => 'tianon/true') }
-    before { subject.start }
-    after { subject.tap(&:wait).remove }
-
-    it 'yields each chunk' do
-      first = nil
-      subject.export do |chunk|
-        first ||= chunk
-      end
-      expect(first[257..261]).to eq "ustar" # Make sure the export is a tar.
-    end
-  end
-
-  describe '#attach' do
-    subject {
-      described_class.create(
-        'Cmd' => ['bash','-c','sleep 2; echo hello'],
-        'Image' => 'debian:wheezy'
-      )
-    }
-
-    before { subject.start }
-    after(:each) { subject.stop.remove }
-
-    context 'with normal sized chunks' do
-      it 'yields each chunk' do
-        chunk = nil
-        subject.attach do |stream, c|
-          chunk ||= c
-        end
-        expect(chunk).to eq("hello\n")
-      end
-    end
-
-    context 'with very small chunks' do
-      before do
-        Docker.options = { :chunk_size => 1 }
-      end
-
-      after do
-        Docker.options = {}
-      end
-
-      it 'yields each chunk' do
-        chunk = nil
-        subject.attach do |stream, c|
-          chunk ||= c
-        end
-        expect(chunk).to eq("hello\n")
-      end
-    end
-  end
-
-  describe '#attach with stdin' do
-    it 'yields the output' do
-      container = described_class.create(
-        'Cmd'       => %w[cat],
-        'Image'     => 'debian:wheezy',
-        'OpenStdin' => true,
-        'StdinOnce' => true
-      )
-      chunk = nil
-      container
-        .tap(&:start)
-        .attach(stdin: StringIO.new("foo\nbar\n")) do |stream, c|
-          chunk ||= c
-        end
-      container.tap(&:wait).remove
-
-      expect(chunk).to eq("foo\nbar\n")
-    end
-  end
-
-  describe '#start' do
-    subject {
-      described_class.create(
-        'Cmd' => %w[test -d /foo],
-        'Image' => 'debian:wheezy',
-        'Volumes' => {'/foo' => {}}
-      )
-    }
-    let(:all) { Docker::Container.all(all: true) }
-
-    before { subject.start('Binds' => ["/tmp:/foo"]) }
-    after(:each) { subject.remove }
-
-    it 'starts the container' do
-      expect(all.map(&:id)).to be_any { |id| id.start_with?(subject.id) }
-      expect(subject.wait(10)['StatusCode']).to be_zero
-    end
-  end
-
-  describe '#stop' do
-    subject {
-      described_class.create('Cmd' => %w[true], 'Image' => 'debian:wheezy')
-    }
-
-    before { subject.tap(&:start).stop('timeout' => '10') }
-    after { subject.remove }
-
-    it 'stops the container' do
-      expect(described_class.all(:all => true).map(&:id)).to be_any { |id|
-        id.start_with?(subject.id)
-      }
-      expect(described_class.all.map(&:id)).to be_none { |id|
-        id.start_with?(subject.id)
-      }
-    end
-  end
-
-  describe '#exec' do
-    subject {
-      described_class.create(
-        'Cmd' => %w[sleep 20],
-        'Image' => 'debian:wheezy'
-      ).start
-    }
-    after { subject.kill!.remove }
-
-    context 'when passed only a command' do
-      let(:output) { subject.exec(['bash','-c','sleep 2; echo hello']) }
-
-      it 'returns the stdout/stderr messages and exit code' do
-        expect(output).to eq([["hello\n"], [], 0])
-      end
-    end
-
-    context 'when detach is true' do
-      let(:output) { subject.exec(['date'], detach: true) }
-
-      it 'returns the Docker::Exec object' do
-        expect(output).to be_a Docker::Exec
-        expect(output.id).to_not be_nil
-      end
-    end
-
-    context 'when passed a block' do
-      it 'streams the stdout/stderr messages' do
-        chunk = nil
-        subject.exec(['bash','-c','sleep 2; echo hello']) do |stream, c|
-          chunk ||= c
-        end
-        expect(chunk).to eq("hello\n")
-      end
-    end
-
-    context 'when stdin object is passed' do
-      let(:output) { subject.exec(['cat'], stdin: StringIO.new("hello")) }
-
-      it 'returns the stdout/stderr messages' do
-        expect(output).to eq([["hello"],[],0])
-      end
-    end
-
-    context 'when tty is true' do
-      let(:command) { [
-        "bash", "-c",
-        "if [ -t 1 ]; then echo -n \"I'm a TTY!\"; fi"
-      ] }
-      let(:output) { subject.exec(command, tty: true) }
-
-      it 'returns the raw stdout/stderr output' do
-        expect(output).to eq([["I'm a TTY!"], [], 0])
-      end
-    end
-  end
-
-  describe '#kill' do
-    let(:command) { ['/bin/bash', '-c', 'while [ 1 ]; do echo hello; done'] }
-    subject {
-      described_class.create('Cmd' => command, 'Image' => 'debian:wheezy')
-    }
-
-    before { subject.start }
-    after(:each) {subject.remove }
-
-    it 'kills the container' do
-      subject.kill
-      expect(described_class.all.map(&:id)).to be_none { |id|
-        id.start_with?(subject.id)
-      }
-      expect(described_class.all(:all => true).map(&:id)).to be_any { |id|
-        id.start_with?(subject.id)
-      }
-    end
-
-    context 'with a kill signal' do
-      let(:command) {
-        [
-          '/bin/bash',
-          '-c',
-          'trap echo SIGTERM; while [ 1 ]; do echo hello; done'
-        ]
-      }
-      it 'kills the container' do
-        subject.kill(:signal => "SIGTERM")
-        expect(described_class.all.map(&:id)).to be_any { |id|
-          id.start_with?(subject.id)
-        }
-        expect(described_class.all(:all => true).map(&:id)).to be_any { |id|
-          id.start_with?(subject.id)
-        }
-
-        subject.kill(:signal => "SIGKILL")
-        expect(described_class.all.map(&:id)).to be_none { |id|
-          id.start_with?(subject.id)
-        }
-        expect(described_class.all(:all => true).map(&:id)).to be_any { |id|
-          id.start_with?(subject.id)
-        }
-      end
-    end
-  end
-
-  describe '#delete' do
-    subject {
-      described_class.create('Cmd' => ['ls'], 'Image' => 'debian:wheezy')
-    }
-
-    it 'deletes the container' do
-      subject.delete(:force => true)
-      expect(described_class.all.map(&:id)).to be_none { |id|
-        id.start_with?(subject.id)
-      }
-    end
-  end
-
-  describe '#restart' do
-    subject {
-      described_class.create('Cmd' => %w[sleep 10], 'Image' => 'debian:wheezy')
-    }
-
-    before { subject.start }
-    after { subject.kill!.remove }
-
-    it 'restarts the container' do
-      expect(described_class.all.map(&:id)).to be_any { |id|
-        id.start_with?(subject.id)
-      }
-      subject.stop
-      expect(described_class.all.map(&:id)).to be_none { |id|
-        id.start_with?(subject.id)
-      }
-      subject.restart('timeout' => '10')
-      expect(described_class.all.map(&:id)).to be_any { |id|
-        id.start_with?(subject.id)
-      }
-    end
-  end
-
-  describe '#pause' do
-    subject {
-      described_class.create(
-        'Cmd' => %w[sleep 50],
-        'Image' => 'debian:wheezy'
-      ).start
-    }
-    after { subject.unpause.kill!.remove }
-
-    it 'pauses the container' do
-      subject.pause
-      expect(described_class.get(subject.id).info['State']['Paused']).to be true
-    end
-  end
-
-  describe '#unpause' do
-    subject {
-      described_class.create(
-        'Cmd' => %w[sleep 50],
-        'Image' => 'debian:wheezy'
-      ).start
-    }
-    before { subject.pause }
-    after { subject.kill!.remove }
-
-    it 'unpauses the container' do
-      subject.unpause
-      expect(
-        described_class.get(subject.id).info['State']['Paused']
-      ).to be false
-    end
-  end
-
-  describe '#wait' do
-    subject {
-      described_class.create(
-        'Cmd' => %w[tar nonsense],
-        'Image' => 'debian:wheezy'
-      )
-    }
-
-    before { subject.start }
-    after(:each) { subject.remove }
-
-    it 'waits for the command to finish' do
-      expect(subject.wait['StatusCode']).to_not be_zero
-    end
-
-    context 'when an argument is given' do
-      subject { described_class.create('Cmd' => %w[sleep 5],
-                                       'Image' => 'debian:wheezy') }
-
-      it 'sets the :read_timeout to that amount of time' do
-        expect(subject.wait(6)['StatusCode']).to be_zero
-      end
-
-      context 'and a command runs for too long' do
-        it 'raises a ServerError' do
-          expect{subject.wait(4)}.to raise_error(Docker::Error::TimeoutError)
-          subject.tap(&:wait)
-        end
-      end
-    end
-  end
-
-  describe '#run' do
-    let(:run_command) { subject.run('ls') }
-
-    context 'when the Container\'s command does not return status code of 0' do
-      subject { described_class.create('Cmd' => %w[false],
-                                       'Image' => 'debian:wheezy') }
-
-      after do
-        subject.remove
-      end
-
-      it 'raises an error' do
-        expect { run_command }
-            .to raise_error(Docker::Error::UnexpectedResponseError)
-      end
-    end
-
-    context 'when the Container\'s command returns a status code of 0' do
-      subject { described_class.create('Cmd' => %w[pwd],
-                                       'Image' => 'debian:wheezy') }
-      after do
-        subject.remove
-        image = run_command.json['Image']
-        run_command.remove
-        Docker::Image.get(image).history.each do |layer|
-          next unless layer['CreatedBy'] == 'pwd'
-          Docker::Image.get(layer['Id']).remove(:noprune => true)
-        end
-      end
-
-      it 'creates a new container to run the specified command' do
-        expect(run_command.wait['StatusCode']).to be_zero
-      end
-    end
-  end
-
-  describe '#commit' do
-    subject {
-      described_class.create('Cmd' => %w[true], 'Image' => 'debian:wheezy')
-    }
-    let(:image) { subject.commit }
-
-    after(:each) do
-      subject.remove
-      image.remove
-    end
-
-    it 'creates a new Image from the  Container\'s changes' do
-      subject.tap(&:start).wait
-
-      expect(image).to be_a Docker::Image
-      expect(image.id).to_not be_nil
-    end
-
-    context 'if run is passed, it saves the command in the image' do
-      let(:image) { subject.commit }
-      let(:container) { image.run('pwd') }
-
-      it 'saves the command' do
-        container.wait
-        expect(container.attach(logs: true, stream: false)).to eql [["/\n"],[]]
-        container.remove
-      end
-    end
-  end
-
-  describe '.create' do
-    subject { described_class }
-
-    context 'when the Container does not yet exist' do
-      context 'when the HTTP request does not return a 200' do
-        before do
-          Docker.options = { :mock => true }
-          Excon.stub({ :method => :post }, { :status => 400 })
-        end
-        after do
-          Excon.stubs.shift
-          Docker.options = {}
-        end
-
-        it 'raises an error' do
-          expect { subject.create }.to raise_error(Docker::Error::ClientError)
-        end
-      end
-
-      context 'when the HTTP request returns a 200' do
-        let(:options) do
-          {
-            "Cmd"          => ["date"],
-            "Image"        => "debian:wheezy",
-          }
-        end
-        let(:container) { subject.create(options) }
-        after { container.remove }
-
-        it 'sets the id' do
-          expect(container).to be_a Docker::Container
-          expect(container.id).to_not be_nil
-          expect(container.connection).to_not be_nil
-        end
-      end
-    end
-  end
-
-  describe '.get' do
-    subject { described_class }
-
-    context 'when the HTTP response is not a 200' do
-      before do
-        Docker.options = { :mock => true }
-        Excon.stub({ :method => :get }, { :status => 500 })
-      end
-      after do
-        Excon.stubs.shift
-        Docker.options = {}
-      end
-
-      it 'raises an error' do
-        expect { subject.get('randomID') }
-            .to raise_error(Docker::Error::ServerError)
-      end
-    end
-
-    context 'when the HTTP response is a 200' do
-      let(:container) {
-        subject.create('Cmd' => ['ls'], 'Image' => 'debian:wheezy')
-      }
-      after { container.remove }
-
-      it 'materializes the Container into a Docker::Container' do
-        expect(subject.get(container.id)).to be_a Docker::Container
-      end
-    end
-
-  end
-
-  describe '.all' do
-    subject { described_class }
-
-    context 'when the HTTP response is not a 200' do
-      before do
-        Docker.options = { :mock => true }
-        Excon.stub({ :method => :get }, { :status => 500 })
-      end
-      after do
-        Excon.stubs.shift
-        Docker.options = {}
-      end
-
-      it 'raises an error' do
-        expect { subject.all }
-            .to raise_error(Docker::Error::ServerError)
-      end
-    end
-
-    context 'when the HTTP response is a 200' do
-      let(:container) {
-        subject.create('Cmd' => ['ls'], 'Image' => 'debian:wheezy')
-      }
-      before { container }
-      after { container.remove }
-
-      it 'materializes each Container into a Docker::Container' do
-        expect(subject.all(:all => true)).to be_all { |container|
-          container.is_a?(Docker::Container)
-        }
-        expect(subject.all(:all => true).length).to_not be_zero
-      end
-    end
-  end
-end