hyperb 0.2.1 → 0.2.2

data/spec/auth_object_spec.rb

@@ -0,0 +1,45 @@
+require 'helper'
+
+RSpec.describe Hyperb::AuthObject do
+
+  it '#valid? with invalid object' do
+    auth_object = Hyperb::AuthObject.new(username: '')
+    expect(auth_object.valid?).to be false
+  end
+
+  it '#valid? with valid object' do
+    auth_object = Hyperb::AuthObject.new(username: 'l', email: 't@t.com', password: fixture('auth_obj.json'), serveraddress: 'https://gcr.io')
+    expect(auth_object.valid?).to be true
+  end
+
+  it '#attrs' do
+    auth_object = Hyperb::AuthObject.new(username: 'l', email: 't@t.com', password: fixture('auth_obj.json'), serveraddress: 'https://gcr.io')
+    expect(auth_object.attrs).to be_a Hash
+    expect(auth_object.attrs[:username]).to eql('l')
+    expect(auth_object.attrs[:email]).to eql('t@t.com')
+    expect(auth_object.attrs[:password]).to eql(fixture('auth_obj.json').read)
+    expect(auth_object.attrs[:serveraddress]).to eql('https://gcr.io')
+  end
+
+  it '#password should read contents of file when File' do
+    auth_object = Hyperb::AuthObject.new(username: 'l', email: 't@t.com', password: fixture('auth_obj.json'))
+    expect(auth_object.attrs[:password]).to eql(fixture('auth_obj.json').read)
+  end
+
+  it '#password should also accept a String' do
+    auth_object = Hyperb::AuthObject.new(username: 'l', email: 't@t.com', password: fixture('auth_obj.json').read)
+    expect(auth_object.attrs[:password]).to eql(fixture('auth_obj.json').read)
+  end
+
+  it '#encode' do
+    auth_object = Hyperb::AuthObject.new(username: 'l', email: 't@t.com', password: fixture('auth_obj.json'))
+    expect(auth_object.encode).not_to be nil
+  end
+
+  it '#build' do
+    auth_object = Hyperb::AuthObject.new(username: 'l', email: 't@t.com', password: fixture('auth_obj.json'))
+    expect(auth_object.build).to be_a Hash
+    expect(auth_object.build.has_key?(:x_registry_auth)).to be true
+  end
+
+end

data/spec/client_spec.rb

@@ -0,0 +1,27 @@
+require "helper"
+
+RSpec.describe Hyperb::Client do
+
+  it 'simple init' do
+    client = Hyperb::Client.new do |c|
+      c.access_key = 'k'
+      c.secret_key = 's'
+    end
+    expect(client.access_key).to eq 'k'
+    expect(client.secret_key).to eq 's'
+  end
+
+  describe '#credentials?' do
+
+    it 'returns true if all credentials are set' do
+      client = Hyperb::Client.new(secret_key: 'SK', access_key: 'AK')
+      expect(client.credentials?).to be true
+    end
+
+    it 'returns false if some credential is not set' do
+      client = Hyperb::Client.new(secret_key: 'SK')
+      expect(client.credentials?).to be false
+    end
+
+  end
+end

data/spec/compose_spec.rb

@@ -0,0 +1,145 @@
+require 'helper'
+require 'http'
+
+RSpec.describe Hyperb::Compose do
+
+  before do
+    @client = Hyperb::Client.new(access_key: 'key', secret_key: '123')
+    @base_path = Hyperb::Request::BASE_URL + Hyperb::Request::VERSION + '/compose/'
+  end
+
+  describe '#compose_down' do
+
+    it 'should raise ArgumentError when project is not provided' do
+      expect { @client.compose_down }.to raise_error(ArgumentError)
+    end
+
+    it 'request to the correct path should be made' do
+      path = @base_path + 'down?project=app'
+      stub_request(:post, path)
+      .to_return(body: "")
+
+      @client.compose_down(project: 'app')
+      expect(a_request(:post, path)).to have_been_made
+    end
+
+    it 'request to the correct path should be made with rmi' do
+      path = @base_path + 'down?project=app&rmi=all'
+      stub_request(:post, path)
+      .to_return(body: "")
+
+      @client.compose_down(project: 'app', rmi: 'all')
+      expect(a_request(:post, path)).to have_been_made
+    end
+
+    it 'request to the correct path should be made with rmi' do
+      path = @base_path + 'down?project=app&rmi=local'
+      stub_request(:post, path)
+      .to_return(body: "")
+
+      @client.compose_down(project: 'app', rmi: 'local')
+      expect(a_request(:post, path)).to have_been_made
+    end
+
+    it 'request to the correct path should be made with rmorphans' do
+      path = @base_path + 'down?project=app&rmorphans=true'
+      stub_request(:post, path)
+      .to_return(body: "")
+
+      @client.compose_down(project: 'app', rmorphans: true)
+      expect(a_request(:post, path)).to have_been_made
+    end
+
+    it 'request to the correct path should be made with rmorphans' do
+      path = @base_path + 'down?project=app&vol=true'
+      stub_request(:post, path)
+      .to_return(body: "")
+
+      @client.compose_down(project: 'app', vol: true)
+      expect(a_request(:post, path)).to have_been_made
+    end
+
+  end
+
+  describe '#compose_create' do
+
+    before do
+      @serviceconfigs = {
+        'web': {
+          'image': 'rails'
+        },
+        'db': {
+          'image': 'mariadb'
+        }
+      }
+    end
+
+    it 'should raise ArgumentError when project is not provided' do
+      expect { @client.compose_create }.to raise_error(ArgumentError)
+    end
+
+    it 'request to the correct path should be made' do
+      path = @base_path + 'create?project=app'
+      stub_request(:post, path)
+      .to_return(body: fixture('compose_up.json'))
+
+      @client.compose_create(project: 'app', serviceconfigs: @serviceconfigs)
+      expect(a_request(:post, path)).to have_been_made
+    end
+  end
+
+  describe '#compose_up' do
+
+    before do
+      @serviceconfigs = {
+        'web': {
+          'image': 'rails'
+        },
+        'db': {
+          'image': 'mariadb'
+        }
+      }
+    end
+
+    it 'should raise ArgumentError when project is not provided' do
+      expect { @client.compose_up }.to raise_error(ArgumentError)
+    end
+
+    it 'request to the correct path should be made' do
+      path = @base_path + 'up?project=app'
+      stub_request(:post, path)
+      .to_return(body: fixture('compose_up.json'))
+
+      @client.compose_up(project: 'app', serviceconfigs: @serviceconfigs)
+      expect(a_request(:post, path)).to have_been_made
+    end
+  end
+
+  describe '#compose_rm' do
+
+    it 'should raise ArgumentError when project is not provided' do
+      expect { @client.compose_rm }.to raise_error(ArgumentError)
+    end
+
+    it 'correct request should be made' do
+      path = @base_path + 'rm?project=blog'
+
+      stub_request(:post, path)
+      .to_return(body: fixture('compose_rm.json'))
+
+      @client.compose_rm(project: 'blog')
+      expect(a_request(:post, path)).to have_been_made
+    end
+
+    it 'correct request should be made with rmvol' do
+      path = @base_path + 'rm?project=blog&rmvol=true'
+
+      stub_request(:post, path)
+      .to_return(body: fixture('compose_rm.json'))
+
+      @client.compose_rm(project: 'blog', rmvol: true)
+      expect(a_request(:post, path)).to have_been_made
+    end
+
+  end
+end

data/spec/container_spec.rb

@@ -0,0 +1,25 @@
+require 'helper'
+
+RSpec.describe Hyperb::Container do
+
+  describe '#created' do
+
+    it 'returns timestamp when created is set' do
+      container = Hyperb::Container.new(id: '736cbb24edca6b366feb9975aaf34f330ba0d02b181d5227f8acb4a162b8fb44', created: 1420064636)
+      expect(container.created).to be_a Fixnum
+    end
+
+    it 'returns nil when created is not set' do
+      container = Hyperb::Container.new(id: 1)
+      expect(container.created).to be_nil
+    end
+  end
+
+  describe '#running?' do
+    it 'returns false if container is not running' do
+      container = Hyperb::Container.new(id: 1, state: 'stopped')
+      expect(container.running?).to be false
+    end
+  end
+
+end

data/spec/containers_spec.rb

@@ -0,0 +1,442 @@
+require 'helper'
+require 'http'
+
+RSpec.describe Hyperb::Containers do
+
+  before do
+    @client = Hyperb::Client.new(access_key: 'key', secret_key: '123')
+
+    @containers_base_path = Hyperb::Request::BASE_URL + Hyperb::Request::VERSION + '/containers/'
+    @containers_path =  @containers_base_path + 'json'
+    @remove_container_path = @containers_base_path
+    @create_container_path = @containers_base_path + 'create'
+  end
+
+  describe '#containers' do
+
+    it 'request to the correct path should be made' do
+
+      stub_request(:get, @containers_path)
+      .to_return(body: fixture('containers.json'))
+
+      @client.containers
+      expect(a_request(:get, @containers_path)).to have_been_made
+    end
+
+    it 'request to the correct path should be made with all=true' do
+      stub_request(:get, @containers_path + '?all=true')
+      .to_return(body: fixture('containers.json'))
+
+      @client.containers(all: true)
+      expect(a_request(:get, @containers_path + '?all=true')).to have_been_made
+    end
+
+    it 'request to the correct path should be made with limit=5' do
+      stub_request(:get, @containers_path + '?limit=5')
+      .to_return(body: fixture('containers.json'))
+
+      @client.containers(limit: 5)
+      expect(a_request(:get, @containers_path + '?limit=5')).to have_been_made
+    end
+
+    it 'request to the correct path should be made with since=someId' do
+      stub_request(:get, @containers_path + '?since=3afff57')
+      .to_return(body: fixture('containers.json'))
+
+      @client.containers(since: '3afff57')
+      expect(a_request(:get, @containers_path + '?since=3afff57')).to have_been_made
+    end
+
+    it 'request to the correct path should be made with before=someId' do
+      stub_request(:get, @containers_path + '?before=3afff57')
+      .to_return(body: fixture('containers.json'))
+
+      @client.containers(before: '3afff57')
+      expect(a_request(:get, @containers_path + '?before=3afff57')).to have_been_made
+    end
+
+    it 'request to the correct path should be made with all=true and since=someId' do
+      stub_request(:get, @containers_path + '?all=true&since=3afff57')
+      .to_return(body: fixture('containers.json'))
+
+      @client.containers(all: true, since: '3afff57')
+      expect(a_request(:get, @containers_path + '?all=true&since=3afff57')).to have_been_made
+    end
+
+    it 'request to the correct path should be made with size=true' do
+      stub_request(:get, @containers_path + '?size=true')
+      .to_return(body: fixture('containers.json'))
+
+      @client.containers(size: true)
+      expect(a_request(:get, @containers_path + '?size=true')).to have_been_made
+    end
+
+    it 'return array of containers' do
+      stub_request(:get, @containers_path + '?all=true')
+      .to_return(body: fixture('containers.json'))
+
+      containers = @client.containers(all: true)
+      expect(containers).to be_a Array
+      expect(containers[0]).to be_a Hyperb::Container
+    end
+
+    it 'correct attrs' do
+      stub_request(:get, @containers_path)
+      .to_return(body: fixture('containers.json'))
+
+      @client.containers.each do |container|
+        expect(container.id).to be_a String
+        expect(container.created).to be_a Fixnum
+        expect(container.command).to be_a String
+        expect(container.networksettings).to be_a Hash
+        expect(container.hostconfig).to be_a Hash
+      end
+    end
+  end
+
+  describe '#inspect_container' do
+
+    before do
+      stub_request(:get, @containers_base_path + 'name/json')
+      .to_return(body: fixture('inspect_container.json'))
+    end
+
+    it 'should raise ArgumentError when id is missing' do
+      expect { @client.inspect_container }.to raise_error(ArgumentError)
+    end
+
+    it 'request to the correct path should be made' do
+      @client.inspect_container id: 'name'
+      expect(a_request(:get, @containers_base_path + 'name/json')).to have_been_made
+    end
+
+    it 'return a hash with symbolized attrs' do
+      res = @client.inspect_container(id: 'name')
+      expect(res).to be_a Hash
+      expect(res.has_key?(:args)).to be true
+      expect(res.has_key?(:config)).to be true
+      expect(res.has_key?(:created)).to be true
+    end
+
+  end
+
+  describe '#remove_container' do
+
+    it 'should raise ArgumentError when id is not provided' do
+      stub_request(:delete, @remove_container_path)
+      .to_return(body: fixture('remove_container.json'))
+
+      expect { @client.remove_container }.to raise_error(ArgumentError)
+    end
+
+    it 'request to the correct path should be made with id=fffff' do
+      stub_request(:delete, @remove_container_path + 'fffff')
+      .to_return(body: fixture('remove_container.json'))
+
+      @client.remove_container(id: 'fffff')
+      expect(a_request(:delete, @remove_container_path + 'fffff')).to have_been_made
+    end
+
+    it 'request to the correct path should be made with force=true' do
+      stub_request(:delete, @remove_container_path + 'fffff?force=true')
+      .to_return(body: fixture('remove_container.json'))
+
+      @client.remove_container(id: 'fffff', force: true)
+      expect(a_request(:delete, @remove_container_path + 'fffff?force=true')).to have_been_made
+    end
+
+    it 'request to the correct path should be made with v=true' do
+      stub_request(:delete, @remove_container_path + 'fffff?v=true')
+      .to_return(body: fixture('remove_container.json'))
+
+      @client.remove_container(id: 'fffff', v: true)
+      expect(a_request(:delete, @remove_container_path + 'fffff?v=true')).to have_been_made
+    end
+
+    it 'request to the correct path should be made with v=true and force=true' do
+      stub_request(:delete, @remove_container_path + 'fffff?force=true&v=true')
+      .to_return(body: fixture('remove_container.json'))
+
+      @client.remove_container(id: 'fffff', v: true, force: true)
+      expect(a_request(:delete, @remove_container_path + 'fffff?force=true&v=true')).to have_been_made
+    end
+  end
+
+  describe '#create_container' do
+
+    it 'should raise ArgumentError when image is not provided' do
+      stub_request(:post, @create_container_path)
+      .to_return(body: fixture('create_container.json'))
+
+      expect { @client.create_container }.to raise_error(ArgumentError)
+    end
+
+    it 'request to the correct path should be made with name' do
+      stub_request(:post, @create_container_path + '?name=container_name')
+      .with(body: { image: 'image', labels: { sh_hyper_instancetype: 's1' } })
+      .to_return(body: fixture('create_container.json'))
+
+      @client.create_container(image: 'image', name: 'container_name')
+      expect(a_request(:post, @create_container_path + '?name=container_name')).to have_been_made
+    end
+
+    it 'correct request should be made with hostname' do
+      path = @create_container_path + '?name=container_name'
+
+      stub_request(:post, path)
+      .with(body: { image: 'image', hostname: 'hostnamy', labels: { sh_hyper_instancetype: 's1' }})
+      .to_return(body: fixture('create_container.json'))
+
+      @client.create_container(image: 'image', name: 'container_name', hostname: 'hostnamy')
+      expect(a_request(:post, path)
+            .with(body: { image: 'image', hostname: 'hostnamy', labels: { sh_hyper_instancetype: 's1' }})).to have_been_made
+    end
+
+    it 'correct request should be made with entrypoint' do
+      path = @create_container_path
+
+      stub_request(:post, path)
+      .with(body: { image: 'image', entrypoint: 'test entry', labels: { sh_hyper_instancetype: 's1' }})
+      .to_return(body: fixture('create_container.json'))
+
+      @client.create_container(image: 'image', entrypoint: 'test entry')
+      expect(a_request(:post, path)
+            .with(body: { image: 'image', entrypoint: 'test entry', labels: { sh_hyper_instancetype: 's1' } })).to have_been_made
+    end
+
+    it 'correct request should be made with cmd' do
+      path = @create_container_path
+
+      stub_request(:post, path)
+      .with(body: { image: 'image', cmd: 'test cmd', labels: { sh_hyper_instancetype: 's1' } })
+      .to_return(body: fixture('create_container.json'))
+
+      @client.create_container(image: 'image', cmd: 'test cmd')
+      expect(a_request(:post, path)
+            .with(body: { image: 'image', cmd: 'test cmd', labels: { sh_hyper_instancetype: 's1' } })).to have_been_made
+    end
+
+    it 'correct request should be made with network mode' do
+      path = @create_container_path
+
+      stub_request(:post, path)
+      .with(body: { image: 'image', networkmode: 'bridge', labels: { sh_hyper_instancetype: 's1' } })
+      .to_return(body: fixture('create_container.json'))
+
+      @client.create_container(image: 'image', networkmode: 'bridge')
+      expect(a_request(:post, path)
+            .with(body: { image: 'image', networkmode: 'bridge', labels: { sh_hyper_instancetype: 's1' } })).to have_been_made
+    end
+
+    it 'correct request should be made with mounts' do
+      path = @create_container_path
+
+      stub_request(:post, path)
+      .with(body: { image: 'image', mounts: [], labels: { sh_hyper_instancetype: 's1' } })
+      .to_return(body: fixture('create_container.json'))
+
+      @client.create_container(image: 'image', mounts: [])
+      expect(a_request(:post, path)
+            .with(body: { image: 'image', mounts: [], labels: { sh_hyper_instancetype: 's1' } })).to have_been_made
+    end
+
+    it 'correct request should be made with exposed ports' do
+      path = @create_container_path
+
+      stub_request(:post, path)
+      .with(body: { image: 'image', exposedports: { '22/tcp': {} }, labels: { sh_hyper_instancetype: 's1' } })
+      .to_return(body: fixture('create_container.json'))
+
+      @client.create_container(image: 'image', exposedports: { '22/tcp': {} })
+      expect(a_request(:post, path)
+            .with(body: { image: 'image', exposedports: { '22/tcp': {} }, labels: { sh_hyper_instancetype: 's1' } })).to have_been_made
+    end
+
+    it 'correct request should be made with workingdir' do
+      path = @create_container_path
+
+      stub_request(:post, path)
+      .with(body: { image: 'image', workingdir: '/path/', labels: { sh_hyper_instancetype: 's1' } })
+      .to_return(body: fixture('create_container.json'))
+
+      @client.create_container(image: 'image', workingdir: '/path/')
+      expect(a_request(:post, path)
+            .with(body: { image: 'image', workingdir: '/path/', labels: { sh_hyper_instancetype: 's1' } })).to have_been_made
+    end
+  end
+
+  describe '#start_container' do
+
+    it 'should raise ArgumentError when id is not provided' do
+      expect { @client.start_container }.to raise_error(ArgumentError)
+    end
+
+    it 'correct request should be made' do
+      path = @containers_base_path + 'id/start'
+
+      stub_request(:post, path)
+      .to_return(body: "")
+
+      @client.start_container(id: 'id')
+      expect(a_request(:post, path)
+            .with(body: "")).to have_been_made
+    end
+
+  end
+
+  describe '#container_logs' do
+
+    it 'should raise ArgumentError when id is not provided' do
+      expect { @client.container_logs }.to raise_error(ArgumentError)
+    end
+
+    it 'correct request should be made with follow' do
+      path = @containers_base_path + 'id/logs?follow=true'
+
+      stub_request(:get, path)
+      .to_return(body: "")
+
+      @client.container_logs(id: 'id', follow: true)
+      expect(a_request(:get, path)
+            .with(body: "")).to have_been_made
+    end
+
+    it 'correct request should be made with stderr' do
+      path = @containers_base_path + 'id/logs?stderr=true'
+
+      stub_request(:get, path)
+      .to_return(body: "")
+
+      @client.container_logs(id: 'id', stderr: true)
+      expect(a_request(:get, path)
+            .with(body: "")).to have_been_made
+    end
+
+    it 'correct request should be made with since' do
+      path = @containers_base_path + 'id/logs?since=someid'
+
+      stub_request(:get, path)
+      .to_return(body: "")
+
+      @client.container_logs(id: 'id', since: 'someid')
+      expect(a_request(:get, path)
+            .with(body: "")).to have_been_made
+    end
+
+    it 'correct request should be made with timestamps' do
+      path = @containers_base_path + 'id/logs?timestamps=true'
+
+      stub_request(:get, path)
+      .to_return(body: "")
+
+      @client.container_logs(id: 'id', timestamps: true)
+      expect(a_request(:get, path)
+            .with(body: "")).to have_been_made
+    end
+  end
+
+  describe '#stop_container' do
+
+    it 'should raise ArgumentError when id is not provided' do
+      expect { @client.stop_container }.to raise_error(ArgumentError)
+    end
+
+    it 'correct request should be made' do
+      path = @containers_base_path + 'id/stop'
+
+      stub_request(:post, path)
+      .to_return(body: "")
+
+      @client.stop_container(id: 'id')
+      expect(a_request(:post, path)
+            .with(body: "")).to have_been_made
+    end
+
+    it 'correct request should be made with t' do
+      path = @containers_base_path + 'id/stop?t=50'
+
+      stub_request(:post, path)
+      .to_return(body: "")
+
+      @client.stop_container(id: 'id', t: 50)
+      expect(a_request(:post, path)
+            .with(body: "")).to have_been_made
+    end
+  end
+
+  describe '#container_stats' do
+
+    it 'should raise ArgumentError when id is not provided' do
+      expect { @client.container_stats }.to raise_error(ArgumentError)
+    end
+
+    it 'correct request should be made' do
+      path = @containers_base_path + 'id/stats'
+
+      stub_request(:get, path)
+      .to_return(body: fixture('container_stats.json'))
+
+      @client.container_stats(id: 'id')
+      expect(a_request(:get, path)).to have_been_made
+    end
+
+    it 'correct request should be made with stream' do
+      path = @containers_base_path + 'id/stats?stream=false'
+
+      stub_request(:get, path)
+      .to_return(body: fixture('container_stats.json'))
+
+      @client.container_stats(id: 'id', stream: false)
+      expect(a_request(:get, path)).to have_been_made
+    end
+
+  end
+
+  describe '#kill_container' do
+
+    it 'should raise ArgumentError when id is not provided' do
+      expect { @client.kill_container }.to raise_error(ArgumentError)
+    end
+
+    it 'correct request should be made' do
+      path = @containers_base_path + 'id/kill'
+
+      stub_request(:post, path)
+      .to_return(body: "")
+
+      @client.kill_container(id: 'id')
+      expect(a_request(:post, path)).to have_been_made
+    end
+
+    it 'correct request should be made with signal' do
+      path = @containers_base_path + 'id/kill?signal=signal'
+
+      stub_request(:post, path)
+      .to_return(body: "")
+
+      @client.kill_container(id: 'id', signal: 'signal')
+      expect(a_request(:post, path)).to have_been_made
+    end
+  end
+
+  describe '#rename_container' do
+
+    it 'should raise ArgumentError when id is not provided' do
+      expect { @client.rename_container id: 'id' }.to raise_error(ArgumentError)
+    end
+
+    it 'should raise ArgumentError when name is not provided' do
+      expect { @client.rename_container name: 'name' }.to raise_error(ArgumentError)
+    end
+
+    it 'correct request should be made' do
+      path = @containers_base_path + 'id/rename?name=name'
+
+      stub_request(:post, path)
+      .to_return(body: "")
+
+      @client.rename_container(id: 'id', name: 'name')
+      expect(a_request(:post, path)).to have_been_made
+    end
+  end
+end