docker-api 1.6.0 → 1.7.0

data/spec/docker/event_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Docker::Event do
+  describe "#to_s" do
+    subject { described_class.new(status, id, from, time) }
+
+    let(:status) { "start" }
+    let(:id) { "398c9f77b5d2" }
+    let(:from) { "base:latest" }
+    let(:time) { 1381956164 }
+
+    let(:expected_string) {
+      "Docker::Event { :status => #{status}, :id => #{id}, "\
+      ":from => #{from}, :time => #{time.to_s} }"
+    }
+
+    it "equals the expected string" do
+      expect(subject.to_s).to eq(expected_string)
+    end
+  end
+
+  describe ".stream" do
+    it 'receives three events', :vcr do
+      pending "get VCR to record events that break"
+      Docker::Event.should_receive(:new_event).exactly(3).times
+        .and_call_original
+      fork do
+        sleep 1
+        Docker::Image.create('fromImage' => 'base').run('bash')
+      end
+      Docker::Event.stream do |event|
+        puts "#{event}"
+        if event.status == "die"
+          break
+        end
+      end
+    end
+  end
+
+  describe ".since" do
+    let!(:time) { Time.now.to_i }
+
+    it 'receives three events', :vcr do
+      pending "get VCR to record events that break"
+      Docker::Event.should_receive(:new_event).exactly(3).times
+        .and_call_original
+      fork do
+        sleep 1
+        Docker::Image.create('fromImage' => 'base').run('bash')
+      end
+      Docker::Event.since(time) do |event|
+        puts "#{event}"
+        if event.status == "die"
+          break
+        end
+      end
+    end
+  end
+
+  describe ".new_event" do
+    subject { Docker::Event.new_event(response_body, nil, nil) }
+    let(:status) { "start" }
+    let(:id) { "398c9f77b5d2" }
+    let(:from) { "base:latest" }
+    let(:time) { 1381956164 }
+    let(:response_body) {
+      "{\"status\":\"#{status}\",\"id\":\"#{id}\""\
+      ",\"from\":\"#{from}\",\"time\":#{time}}"
+    }
+
+    it "returns a Docker::Event" do
+      expect(subject).to be_kind_of(Docker::Event)
+      expect(subject.status).to eq(status)
+      expect(subject.id).to eq(id)
+      expect(subject.from).to eq(from)
+      expect(subject.time).to eq(time)
+    end
+  end
+end

data/spec/docker/image_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Docker::Image do
   describe '#to_s' do
-    subject { described_class.send(:new, Docker.connection, id) }
+    subject { described_class.new(Docker.connection, id, info) }
 
     let(:id) { 'bf119e2' }
     let(:connection) { Docker.connection }
@@ -17,14 +17,6 @@ describe Docker::Image do
         ":connection => #{connection} }"
     end
 
-    before do
-      {
-        :@id => id,
-        :@connection => connection,
-        :@info => info
-      }.each { |k, v| subject.instance_variable_set(k, v) }
-    end
-
     its(:to_s) { should == expected_string }
   end
 
@@ -42,10 +34,10 @@ describe Docker::Image do
     subject { described_class.build('from base') }
     let(:new_image) { subject.insert(:path => '/stallman',
                                      :url => 'http://stallman.org') }
-    let(:ls_output) { new_image.run('ls /').attach.split("\n") }
+    let(:ls_output) { new_image.run('ls /').attach }
 
     it 'inserts the url\'s file into a new Image', :vcr do
-      ls_output.should include('stallman')
+      expect(ls_output.first.first).to include('stallman')
     end
   end
 
@@ -69,9 +61,11 @@ describe Docker::Image do
       let(:gemfile) { File.read('Gemfile') }
 
       it 'creates a new Image that has that file', :vcr do
-        new_image.run('cat /Gemfile').start.attach { |chunk|
-          chunk.should == gemfile
+        chunk = nil
+        new_image.run('cat /Gemfile').attach { |stream, c|
+          chunk ||= c
         }
+        expect(chunk).to eq(gemfile)
       end
     end
 
@@ -79,21 +73,38 @@ describe Docker::Image do
       let(:file) { ['./Gemfile', './Rakefile'] }
       let(:gemfile) { File.read('Gemfile') }
       let(:rakefile) { File.read('Rakefile') }
+      let(:response) {
+        new_image.run('cat /Gemfile /Rakefile').attach
+      }
 
       it 'creates a new Image that has each file', :vcr do
-        new_image.run('cat /Gemfile /Rakefile').start.attach do |chunk|
-          chunk.should == gemfile + rakefile
-        end
+        expect(response).to eq([[gemfile, rakefile],[]])
       end
     end
   end
 
   describe '#push' do
     subject { described_class.create('fromImage' => 'base') }
+    let(:credentials) {
+      {
+        :username => 'test',
+        :password => 'test',
+        :auth     => '',
+        :email    => 'test@test.com'
+      }
+    }
+    let(:base_image) {
+      described_class.create('fromImage' => 'base')
+    }
+    let(:container) {
+      base_image.run('true')
+    }
+    let(:new_image) {
+      container.commit('repo' => 'test/base')
+    }
 
     it 'pushes the Image', :vcr do
-      pending 'I don\'t want to push the Image to the Docker Registry'
-      subject.push
+      new_image.push(credentials)
     end
   end
 
@@ -134,7 +145,7 @@ describe Docker::Image do
     context 'when the argument is a String', :vcr do
       let(:cmd) { 'ls /lib64/' }
       it 'splits the String by spaces and creates a new Container' do
-        output.should == "ld-linux-x86-64.so.2\n"
+        expect(output).to eq([["ld-linux-x86-64.so.2\n"],[]])
       end
     end
 
@@ -142,7 +153,26 @@ describe Docker::Image do
       let(:cmd) { %[which pwd] }
 
       it 'creates a new Container', :vcr do
-        output.should == "/bin/pwd\n"
+        expect(output).to eq([["/bin/pwd\n"],[]])
+      end
+    end
+
+    context 'when the argument is nil', :vcr  do
+      let(:cmd) { nil }
+      context 'no command configured in image'do
+        it 'should raise an error if no command is specified' do
+          expect {output}.to raise_error(Docker::Error::ServerError,
+                                         "No command specified.")
+        end
+      end
+
+      context "command configured in image" do
+        let(:container) {Docker::Container.create('Cmd' => %w[true],
+                                                  'Image' => 'base')}
+        subject { container.commit('run' => {"Cmd" => %w[pwd]}) }
+        it 'should normally show result if image has Cmd configured' do
+          expect(output).to eql [["/\n"],[]]
+        end
       end
     end
   end
@@ -229,12 +259,28 @@ describe Docker::Image do
     end
 
     context 'with a valid Dockerfile' do
-      let(:image) { subject.build("from base\n") }
+      context 'without query parameters' do
+        let(:image) { subject.build("from base\n") }
 
-      it 'builds an image', :vcr do
-        image.should be_a Docker::Image
-        image.id.should_not be_nil
-        image.connection.should be_a Docker::Connection
+        it 'builds an image', :vcr do
+          expect(image).to be_a Docker::Image
+          expect(image.id).to_not be_nil
+          expect(image.connection).to be_a Docker::Connection
+        end
+      end
+
+      context 'with specifying a repo in the query parameters' do
+        let(:image) {
+          subject.build("from base\nrun true\n", "t" => "swipely/base")
+        }
+        let(:images) { subject.all }
+
+        it 'builds an image and tags it', :vcr do
+          expect(image).to be_a Docker::Image
+          expect(image.id).to_not be_nil
+          expect(image.connection).to be_a Docker::Connection
+          expect(images.first.info["Repository"]).to eq("swipely/base")
+        end
       end
     end
   end
@@ -243,19 +289,32 @@ describe Docker::Image do
     subject { described_class }
 
     context 'with a valid Dockerfile' do
-      let(:dir) { File.join(File.dirname(__FILE__), '..', 'fixtures') }
+      let(:dir) {
+        File.join(File.dirname(__FILE__), '..', 'fixtures', 'build_from_dir')
+      }
       let(:docker_file) { File.new("#{dir}/Dockerfile") }
-      let(:image) { subject.build_from_dir(dir) }
+      let(:image) { subject.build_from_dir(dir, opts) }
+      let(:opts) { {} }
       let(:container) do
         Docker::Container.create('Image' => image.id,
                                  'Cmd' => %w[cat /Dockerfile])
       end
       let(:output) { container.tap(&:start)
                               .attach(:stderr => true) }
+      let(:images) { subject.all }
 
-      it 'builds the image', :vcr do
-        pending 'webmock / vcr issue'
-        output.should == docker_file.tap(&:rewind).read
+      context 'with no query parameters' do
+        it 'builds the image', :vcr do
+          expect(output).to eq([[docker_file.read],[]])
+        end
+      end
+
+      context 'with specifying a repo in the query parameters' do
+        let(:opts) { { "t" => "swipely/base2" } }
+        it 'builds the image and tags it', :vcr do
+          expect(output).to eq([[docker_file.read],[]])
+          expect(images.first.info["Repository"]).to eq("swipely/base2")
+        end
       end
     end
   end

data/spec/docker/util_spec.rb

@@ -40,4 +40,87 @@ describe Docker::Util do
       end
     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(:x_registry_auth) { Base64.encode64(credential_string).gsub(/\n/, '') }
+    let(:expected_headers) { { 'X-Registry-Auth' => x_registry_auth } }
+
+
+    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_headers)
+      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_headers)
+      end
+    end
+  end
+
+  describe '#decipher_messages' do
+    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_messages) { [["a"], ["b"]] }
+
+      it "returns a single message" do
+        expect(
+          Docker::Util.decipher_messages(raw_text)
+        ).to eq(expected_messages)
+      end
+    end
+
+    context 'given a single header' do
+      let(:raw_text) { "\x01\x00\x00\x00\x00\x00\x00\x01a" }
+      let(:expected_messages) { [["a"], []] }
+
+      it "returns a single message" do
+        expect(
+          Docker::Util.decipher_messages(raw_text)
+        ).to eq(expected_messages)
+      end
+    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_messages) { [["a", "b"], []] }
+
+      it "returns both messages" do
+        expect(
+          Docker::Util.decipher_messages(raw_text)
+        ).to eq(expected_messages)
+      end
+    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_messages) { [[("a" * 257)], []] }
+
+      it "returns both messages" do
+        expect(
+          Docker::Util.decipher_messages(raw_text)
+        ).to eq(expected_messages)
+      end
+    end
+  end
 end

data/spec/docker_spec.rb

@@ -87,8 +87,53 @@ describe Docker do
   end
 
   describe '#authenticate!' do
-    it 'logs in' do
-      pending
+    subject { described_class }
+
+    let(:authentication) {
+      subject.authenticate!(credentials)
+    }
+
+    after do
+      Docker.creds = nil
+    end
+
+    context 'with valid credentials' do
+      # Used valid credentials to record VCR and then changed
+      # cassette to match these credentials
+      let(:credentials) {
+        {
+          :username      => 'test',
+          :password      => 'account',
+          :email         => 'test@test.com',
+          :serveraddress => 'https://index.docker.io/v1/'
+        }
+      }
+
+      it 'logs in and sets the creds', :vcr do
+        expect(authentication).to be_true
+        expect(Docker.creds).to eq(credentials.to_json)
+      end
+    end
+
+    context 'with invalid credentials' do
+      # Recorded the VCR with these credentials
+      # to purposely fail
+      let(:credentials) {
+        {
+          :username      => 'test',
+          :password      => 'password',
+          :email         => 'test@example.com',
+          :serveraddress => 'https://index.docker.io/v1/'
+        }
+      }
+
+      it "raises an error and doesn't set the creds", :vcr do
+        pending "VCR won't record when Excon::Expects fail"
+        expect {
+          authentication
+        }.to raise_error(Docker::Error::AuthenticationError)
+        expect(Docker.creds).to be_nil
+      end
     end
   end
 

data/spec/fixtures/top/Dockerfile

@@ -0,0 +1,2 @@
+from base
+run printf '#! /bin/sh\nwhile true\ndo\ntrue\ndone\n' > /while && chmod +x /while

data/spec/support/vcr.rb

@@ -1,11 +1,8 @@
-require 'webmock'
 require 'vcr'
 
-WebMock.disable_net_connect!
-
 VCR.configure do |c|
   c.allow_http_connections_when_no_cassette = false
-  c.hook_into :webmock
+  c.hook_into :excon
   c.cassette_library_dir = File.join(File.dirname(__FILE__), '..', 'vcr')
   c.configure_rspec_metadata!
 end

data/spec/vcr/Docker/_authenticate_/with_valid_credentials/logs_in_and_sets_the_creds.yml

@@ -0,0 +1,33 @@
+---
+http_interactions:
+- request:
+    method: post
+    uri: unix:///var/run/docker.sock/v1.6/auth
+    body:
+      encoding: UTF-8
+      string: ! '{"username":"test","password":"account","email":"test@test.com","serveraddress":"https://index.docker.io/v1/"}'
+    headers:
+      User-Agent:
+      - Swipely/Docker-API 1.6.0
+      Content-Type:
+      - application/json
+  response:
+    status:
+      code: 200
+      message: 
+    headers:
+      !binary "Q29udGVudC1UeXBl":
+      - !binary |-
+        YXBwbGljYXRpb24vanNvbg==
+      !binary "Q29udGVudC1MZW5ndGg=":
+      - !binary |-
+        Mjg=
+      !binary "RGF0ZQ==":
+      - !binary |-
+        RnJpLCAyNSBPY3QgMjAxMyAxNjoyMzo1NSBHTVQ=
+    body:
+      encoding: US-ASCII
+      string: ! '{"Status":"Login Succeeded"}'
+    http_version: 
+  recorded_at: Fri, 25 Oct 2013 16:23:55 GMT
+recorded_with: VCR 2.6.0