docker-api 1.31.0 → 1.32.0

data/spec/docker/messages_spec.rb

@@ -1,97 +0,0 @@
-require 'spec_helper'
-
-describe Docker::Messages do
-  shared_examples_for "two equal messages" do
-    it "has the same messages as we expect" do
-      expect(messages.all_messages).to eq(expected.all_messages)
-      expect(messages.stdout_messages).to eq(expected.stdout_messages)
-      expect(messages.stderr_messages).to eq(expected.stderr_messages)
-      expect(messages.buffer).to eq(expected.buffer)
-    end
-  end
-
-  describe '.decipher_messages' do
-    shared_examples_for "decipher_messages of raw_test" do
-      let(:messages) {
-        subject.decipher_messages(raw_text)
-      }
-
-      it_behaves_like "two equal messages"
-    end
-
-    context 'given both standard out and standard error' do
-      let(:raw_text) {
-        "\x01\x00\x00\x00\x00\x00\x00\x01a\x02\x00\x00\x00\x00\x00\x00\x01b"
-      }
-      let(:expected) {
-        Docker::Messages.new(["a"], ["b"], ["a","b"], "")
-      }
-
-      it_behaves_like "decipher_messages of raw_test"
-    end
-
-    context 'given a single header' do
-      let(:raw_text) { "\x01\x00\x00\x00\x00\x00\x00\x01a" }
-      let(:expected) {
-        Docker::Messages.new(["a"], [], ["a"], "")
-      }
-
-      it_behaves_like "decipher_messages of raw_test"
-    end
-
-    context 'given two headers' do
-      let(:raw_text) {
-        "\x01\x00\x00\x00\x00\x00\x00\x01a\x01\x00\x00\x00\x00\x00\x00\x01b"
-      }
-
-      let(:expected) {
-        Docker::Messages.new(["a", "b"], [], ["a","b"], "")
-      }
-
-      it_behaves_like "decipher_messages of raw_test"
-    end
-
-    context 'given a header for text longer then 255 characters' do
-      let(:raw_text) {
-        "\x01\x00\x00\x00\x00\x00\x01\x01" + ("a" * 257)
-      }
-      let(:expected) {
-        Docker::Messages.new([("a" * 257)], [], [("a" * 257)], "")
-      }
-
-      it_behaves_like "decipher_messages of raw_test"
-    end
-  end
-
-  describe "#append" do
-    context "appending one set of messages on another" do
-      let(:messages) {
-        Docker::Messages.new([], [], [], "")
-      }
-
-      before do
-        messages.append(new_messages)
-      end
-
-      context "with a buffer" do
-        let(:new_messages) {
-          Docker::Messages.new(["a"], [], ["a"], "b")
-        }
-        let(:expected) {
-          Docker::Messages.new(["a"], [], ["a"], "")
-        }
-        it_behaves_like "two equal messages"
-      end
-
-      context "without a buffer" do
-        let(:new_messages) {
-          Docker::Messages.new(["a"], [], ["a"], "")
-        }
-        let(:expected) {
-          Docker::Messages.new(["a"], [], ["a"], "")
-        }
-        it_behaves_like "two equal messages"
-      end
-    end
-  end
-end

data/spec/docker/messages_stack.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe Docker::MessagesStack do
-
-  describe '#append' do
-    context 'without limits' do |variable|
-      it 'does not limit stack size by default' do
-        data = ['foo', 'bar']
-        msg = Docker::Messages.new(data, [], data)
-        expect(subject.messages).not_to receive(:shift)
-        1000.times { subject.append(msg) }
-      end
-    end
-
-    context 'with size limit' do
-      let(:subject) { described_class.new(100) }
-
-      it 'limits stack to given size' do
-        data = ['foo', 'bar']
-        msg = Docker::Messages.new(data, [], data)
-        expect(subject.messages).to receive(:shift).exactly(1900).times
-        1000.times { subject.append(msg) }
-      end
-    end
-  end
-end

data/spec/docker/network_spec.rb

@@ -1,150 +0,0 @@
-require 'spec_helper'
-
-describe Docker::Network, docker_1_9: true do
-  let(:name) do |example|
-    example.description.downcase.gsub('\s', '-')
-  end
-
-  describe '#to_s' do
-    subject { described_class.new(Docker.connection, info) }
-    let(:connection) { Docker.connection }
-
-    let(:id) do
-      'a6c5ffd25e07a6c906accf804174b5eb6a9d2f9e07bccb8f5aa4f4de5be6d01d'
-    end
-
-    let(:info) do
-      {
-        'Name' => 'bridge',
-        'Scope' => 'local',
-        'Driver' => 'bridge',
-        'IPAM' => {
-          'Driver' => 'default',
-          'Config' => [{ 'Subnet' => '172.17.0.0/16' }]
-        },
-        'Containers' => {},
-        'Options' => {
-          'com.docker.network.bridge.default_bridge' => 'true',
-          'com.docker.network.bridge.enable_icc' => 'true',
-          'com.docker.network.bridge.enable_ip_masquerade' => 'true',
-          'com.docker.network.bridge.host_binding_ipv4' => '0.0.0.0',
-          'com.docker.network.bridge.name' => 'docker0',
-          'com.docker.network.driver.mtu' => '1500'
-        },
-        'id' => id
-      }
-    end
-
-    let(:expected_string) do
-      "Docker::Network { :id => #{id}, :info => #{info.inspect}, "\
-        ":connection => #{connection} }"
-    end
-
-    its(:to_s) { should == expected_string }
-  end
-
-  describe '.create' do
-    let!(:id) { subject.id }
-    subject { described_class.create(name) }
-    after { described_class.remove(id) }
-
-    it 'creates a Network' do
-      expect(Docker::Network.all.map(&:id)).to include(id)
-    end
-  end
-
-  describe '.remove' do
-    let(:id) { subject.id }
-    subject { described_class.create(name) }
-
-    it 'removes the Network' do
-      described_class.remove(id)
-      expect(Docker::Network.all.map(&:id)).to_not include(id)
-    end
-  end
-
-  describe '.get' do
-    after do
-      described_class.remove(name)
-    end
-
-    let!(:network) { described_class.create(name) }
-
-    it 'returns a network' do
-      expect(Docker::Network.get(name).id).to eq(network.id)
-    end
-  end
-
-  describe '.all' do
-    let!(:networks) do
-      5.times.map { |i| described_class.create("#{name}-#{i}") }
-    end
-
-    after do
-      networks.each(&:remove)
-    end
-
-    it 'should return all networks' do
-      expect(Docker::Network.all.map(&:id)).to include(*networks.map(&:id))
-    end
-  end
-
-  describe '#connect' do
-    let!(:container) do
-      Docker::Container.create(
-        'Cmd' => %w(sleep 10),
-        'Image' => 'debian:wheezy'
-      )
-    end
-    subject { described_class.create(name) }
-
-    before(:each) { container.start }
-    after(:each) do
-      container.kill!.remove
-      subject.remove
-    end
-
-    it 'connects a container to a network' do
-      subject.connect(container.id)
-      expect(subject.info['Containers']).to include(container.id)
-    end
-  end
-
-  describe '#disconnect' do
-    let!(:container) do
-      Docker::Container.create(
-        'Cmd' => %w(sleep 10),
-        'Image' => 'debian:wheezy'
-      )
-    end
-
-    subject { described_class.create(name) }
-
-    before(:each) do
-      container.start
-      sleep 1
-      subject.connect(container.id)
-    end
-
-    after(:each) do
-      container.kill!.remove
-      subject.remove
-    end
-
-    it 'connects a container to a network' do
-      subject.disconnect(container.id)
-      expect(subject.info['Containers']).not_to include(container.id)
-    end
-  end
-
-  describe '#remove' do
-    let(:id) { subject.id }
-    let(:name) { 'test-network-remove' }
-    subject { described_class.create(name) }
-
-    it 'removes the Network' do
-      subject.remove
-      expect(Docker::Network.all.map(&:id)).to_not include(id)
-    end
-  end
-end

data/spec/docker/util_spec.rb

@@ -1,170 +0,0 @@
-require 'spec_helper'
-require 'tempfile'
-
-describe Docker::Util do
-  subject { described_class }
-
-  describe '.parse_json' do
-    subject { described_class.parse_json(arg) }
-
-    context 'when the argument is nil' do
-      let(:arg) { nil }
-
-      it { should be_nil }
-    end
-
-    context 'when the argument is empty' do
-      let(:arg) { '' }
-
-      it { should be_nil }
-    end
-
-    context 'when the argument is \'null\'' do
-      let(:arg) { 'null' }
-
-      it { should be_nil }
-    end
-
-    context 'when the argument is not valid JSON' do
-      let(:arg) { '~~lol not valid json~~' }
-
-      it 'raises an error' do
-        expect { subject }.to raise_error Docker::Error::UnexpectedResponseError
-      end
-    end
-
-    context 'when the argument is valid JSON' do
-      let(:arg) { '{"yolo":"swag"}' }
-
-      it 'parses the JSON into a Hash' do
-        expect(subject).to eq 'yolo' => 'swag'
-      end
-    end
-  end
-
-  describe '.fix_json' do
-    let(:response) { '{"this":"is"}{"not":"json"}' }
-    subject { Docker::Util.fix_json(response) }
-
-    it 'fixes the "JSON" response that Docker returns' do
-      expect(subject).to eq [
-        {
-          'this' => 'is'
-        },
-        {
-          'not' => 'json'
-        }
-      ]
-    end
-  end
-
-  describe '.create_dir_tar' do
-    attr_accessor :tmpdir
-
-    around do |example|
-      Dir.mktmpdir do |tmpdir|
-        self.tmpdir = tmpdir
-        example.call
-      end
-    end
-
-    specify do
-      tar = subject.create_dir_tar tmpdir
-      expect { FileUtils.rm tar }.to_not raise_error
-    end
-  end
-
-  describe '.build_auth_header' do
-    subject { described_class }
-
-    let(:credentials) {
-      {
-        :username      => 'test',
-        :password      => 'password',
-        :email         => 'test@example.com',
-        :serveraddress => 'https://registry.com/'
-      }
-    }
-    let(:credential_string) { credentials.to_json }
-    let(:encoded_creds) { Base64.encode64(credential_string).gsub(/\n/, '') }
-    let(:expected_header) {
-      {
-        'X-Registry-Auth' => encoded_creds
-      }
-    }
-
-
-    context 'given credentials as a Hash' do
-      it 'returns an X-Registry-Auth header encoded' do
-        expect(subject.build_auth_header(credentials)).to eq(expected_header)
-      end
-    end
-
-    context 'given credentials as a String' do
-      it 'returns an X-Registry-Auth header encoded' do
-        expect(
-          subject.build_auth_header(credential_string)
-        ).to eq(expected_header)
-      end
-    end
-  end
-
-  describe '.build_config_header' do
-    subject { described_class }
-
-    let(:credentials) {
-      {
-        :username      => 'test',
-        :password      => 'password',
-        :email         => 'test@example.com',
-        :serveraddress => 'https://registry.com/'
-      }
-    }
-
-    let(:credentials_object) {
-      {
-        :'https://registry.com/' => {
-          :username => 'test',
-          :password => 'password',
-          :email    => 'test@example.com',
-        }
-      }.to_json
-    }
-
-    let(:encoded_creds) { Base64.encode64(credentials_object).gsub(/\n/, '') }
-    let(:expected_header) {
-      {
-        'X-Registry-Config' => encoded_creds
-      }
-    }
-
-    context 'given credentials as a Hash' do
-      it 'returns an X-Registry-Config header encoded' do
-        expect(subject.build_config_header(credentials)).to eq(expected_header)
-      end
-    end
-
-    context 'given credentials as a String' do
-      it 'returns an X-Registry-Config header encoded' do
-        expect(
-          subject.build_config_header(credentials.to_json)
-        ).to eq(expected_header)
-      end
-    end
-  end
-
-  describe '.filesystem_permissions' do
-    it 'returns the permissions on a file' do
-      file = Tempfile.new('test_file')
-      file.close
-      expected_permissions = 0600
-      File.chmod(expected_permissions, file.path)
-
-      actual_permissions = subject.filesystem_permissions(file.path)
-
-      file.unlink
-      expect(actual_permissions).to eql(expected_permissions)
-    end
-  end
-
-end

data/spec/docker/volume_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-# Volume requests are actually slow enough to occasionally not work
-# Use sleep statements to manage that
-describe Docker::Volume, :docker_1_9 do
-  let(:name) { "ArbitraryNameForTheRakeTestVolume" }
-
-  describe '.create' do
-    let(:volume) { Docker::Volume.create(name) }
-
-    after { volume.remove }
-
-    it 'creates a volume' do
-      expect(volume.id).to eq(name)
-    end
-  end
-
-  describe '.get' do
-    let(:volume) { Docker::Volume.get(name) }
-
-    before { Docker::Volume.create(name); sleep 1 }
-    after { volume.remove }
-
-    it 'gets volume details' do
-      expect(volume.id).to eq(name)
-      expect(volume.info).to_not be_empty
-    end
-  end
-
-  describe '.all' do
-    after { Docker::Volume.get(name).remove }
-
-    it 'gets a list of volumes' do
-      expect { Docker::Volume.create(name); sleep 1 }.to change { Docker::Volume.all.length }.by(1)
-    end
-  end
-
-  describe '#remove' do
-    it 'removes a volume' do
-      volume = Docker::Volume.create(name)
-      sleep 1
-      expect { volume.remove }.to change { Docker::Volume.all.length }.by(-1)
-    end
-  end
-
-end