tugboat 2.2.2 → 2.2.3

data/spec/config_spec.rb

@@ -1,28 +1,28 @@
 require 'spec_helper'
 
 describe Tugboat::Configuration do
-  include_context "spec"
+  include_context 'spec'
 
-  let(:tmp_path)             { project_path + "/tmp/tugboat" }
+  let(:tmp_path) { project_path + '/tmp/tugboat' }
 
-  after :each do
+  after do
     # Clean up the temp file.
-    File.delete(project_path + "/tmp/tugboat") if File.exist?(project_path + "/tmp/tugboat")
+    File.delete(project_path + '/tmp/tugboat') if File.exist?(project_path + '/tmp/tugboat')
   end
 
-  it "is a singleton" do
-    expect(Tugboat::Configuration).to be_a Class
+  it 'is a singleton' do
+    expect(described_class).to be_a Class
     expect do
-      Tugboat::Configuration.new
-    end.to raise_error(NoMethodError, /private method `new' called/)
+      described_class.new
+    end.to raise_error(NoMethodError, %r{private method `new' called})
   end
 
-  it "has a data attribute" do
-    config = Tugboat::Configuration.instance
+  it 'has a data attribute' do
+    config = described_class.instance
     expect(config.data).to be
   end
 
-  describe "the file" do
+  describe 'the file' do
     let(:access_token)       { 'foo' }
     let(:ssh_user)           { 'root' }
     let(:ssh_key_path)       { '~/.ssh/id_rsa2' }
@@ -35,128 +35,127 @@ describe Tugboat::Configuration do
     let(:backups_enabled)    { 'false' }
     let(:ip6)                { 'false' }
 
-    let(:config)           { config = Tugboat::Configuration.instance }
+    let(:config) { described_class.instance }
 
-    before :each do
+    before do
       # Create a temporary file
       config.create_config_file(access_token, ssh_key_path, ssh_user, ssh_port, region, image, size, ssh_key_id, private_networking, backups_enabled, ip6)
     end
 
-    it "can be created" do
+    it 'can be created' do
       expect(File.exist?(tmp_path)).to be_true
     end
 
-    it "can be loaded" do
+    it 'can be loaded' do
       data = config.load_config_file
-      expect(data).to_not be_nil
+      expect(data).not_to be_nil
     end
 
-    describe "the file format"
-    let(:data)  { YAML.load_file(tmp_path) }
+    describe 'the file format'
+    let(:data) { YAML.load_file(tmp_path) }
 
-    it "should have authentication at the top level" do
-      expect(data).to have_key("authentication")
+    it 'has authentication at the top level' do
+      expect(data).to have_key('authentication')
     end
 
-    it "should have ssh at the top level" do
-      expect(data).to have_key("ssh")
+    it 'has ssh at the top level' do
+      expect(data).to have_key('ssh')
     end
 
-    it "should have an access token" do
-      auth = data["authentication"]
-      expect(auth).to have_key("access_token")
+    it 'has an access token' do
+      auth = data['authentication']
+      expect(auth).to have_key('access_token')
     end
 
-    it "should have an ssh key path" do
-      ssh = data["ssh"]
-      expect(ssh).to have_key("ssh_key_path")
+    it 'has an ssh key path' do
+      ssh = data['ssh']
+      expect(ssh).to have_key('ssh_key_path')
     end
 
-    it "should have an ssh user" do
-      ssh = data["ssh"]
-      expect(ssh).to have_key("ssh_user")
+    it 'has an ssh user' do
+      ssh = data['ssh']
+      expect(ssh).to have_key('ssh_user')
     end
 
-    it "should have an ssh port" do
-      ssh = data["ssh"]
-      expect(ssh).to have_key("ssh_port")
+    it 'has an ssh port' do
+      ssh = data['ssh']
+      expect(ssh).to have_key('ssh_port')
     end
 
-    it "should have private_networking set" do
-      private_networking = data["defaults"]
-      expect(private_networking).to have_key("private_networking")
+    it 'has private_networking set' do
+      private_networking = data['defaults']
+      expect(private_networking).to have_key('private_networking')
     end
 
-    it "should have backups_enabled set" do
-      backups_enabled = data["defaults"]
-      expect(backups_enabled).to have_key("backups_enabled")
+    it 'has backups_enabled set' do
+      backups_enabled = data['defaults']
+      expect(backups_enabled).to have_key('backups_enabled')
     end
   end
-  describe "backwards compatible" do
+  describe 'backwards compatible' do
     let(:client_key)       { 'foo' }
     let(:api_key)          { 'bar' }
     let(:ssh_user)         { 'baz' }
     let(:ssh_key_path)     { '~/.ssh/id_rsa2' }
     let(:ssh_port)         { '22' }
 
-    let(:config)                    { config = Tugboat::Configuration.instance }
+    let(:config)                    { described_class.instance }
     let(:config_default_region)     { Tugboat::Configuration::DEFAULT_REGION }
     let(:config_default_image)      { Tugboat::Configuration::DEFAULT_IMAGE }
     let(:config_default_size)       { Tugboat::Configuration::DEFAULT_SIZE }
     let(:config_default_ssh_key)    { Tugboat::Configuration::DEFAULT_SSH_KEY }
     let(:config_default_networking) { Tugboat::Configuration::DEFAULT_PRIVATE_NETWORKING }
     let(:config_default_backups)    { Tugboat::Configuration::DEFAULT_BACKUPS_ENABLED }
-    let(:config_default_ip6)    	{ Tugboat::Configuration::DEFAULT_IP6 }
-    let(:backwards_config) {
+    let(:config_default_ip6)	{ Tugboat::Configuration::DEFAULT_IP6 }
+    let(:backwards_config) do
       {
-                'authentication' => { 'client_key' => client_key, 'api_key' => api_key },
-                'ssh' => { 'ssh_user' => ssh_user, 'ssh_key_path' => ssh_key_path , 'ssh_port' => ssh_port},
+        'authentication' => { 'client_key' => client_key, 'api_key' => api_key },
+        'ssh' => { 'ssh_user' => ssh_user, 'ssh_key_path' => ssh_key_path, 'ssh_port' => ssh_port }
       }
-    }
+    end
 
-    before :each do
+    before do
       config.instance_variable_set(:@data, backwards_config)
     end
 
-    it "should load a backwards compatible config file" do
+    it 'loads a backwards compatible config file' do
       data_file = config.instance_variable_get(:@data)
       expect(data_file).to eql backwards_config
     end
 
-    it "should use default region if not in configuration" do
+    it 'uses default region if not in configuration' do
       region = config.default_region
       expect(region).to eql config_default_region
     end
 
-    it "should use default image if not in configuration" do
+    it 'uses default image if not in configuration' do
       image = config.default_image
       expect(image).to eql config_default_image
     end
 
-    it "should use default size if not in configuration" do
+    it 'uses default size if not in configuration' do
       size = config.default_size
       expect(size).to eql config_default_size
     end
 
-    it "should use default ssh key if not in configuration" do
+    it 'uses default ssh key if not in configuration' do
       ssh_key = config.default_ssh_key
       expect(ssh_key).to eql config_default_ssh_key
     end
 
-    it "should use default private networking option if not in configuration" do
+    it 'uses default private networking option if not in configuration' do
       private_networking = config.default_private_networking
       expect(private_networking).to eql config_default_networking
     end
 
-    it "should use default backups_enabled if not in the configuration" do
+    it 'uses default backups_enabled if not in the configuration' do
       backups_enabled = config.default_backups_enabled
       expect(backups_enabled).to eql config_default_backups
     end
 
-    it "should use default ip6 if not in the configuration" do
+    it 'uses default ip6 if not in the configuration' do
       ip6 = config.default_ip6
       expect(ip6).to eql config_default_ip6
     end
-
   end
 end

data/spec/middleware/base_spec.rb

@@ -1,15 +1,14 @@
 require 'spec_helper'
 
 describe Tugboat::Middleware::Base do
-  include_context "spec"
+  include_context 'spec'
 
-  let(:klass)      { described_class }
+  let(:klass) { described_class }
 
-  describe ".initialize" do
-    it "prints a clear line" do
-      expect($stdout).to receive(:print).with("")
+  describe '.initialize' do
+    it 'prints a clear line' do
+      expect($stdout).to receive(:print).with('')
       klass.new({})
     end
   end
-
 end

data/spec/middleware/check_configuration_spec.rb

@@ -1,16 +1,14 @@
 require 'spec_helper'
 
 describe Tugboat::Middleware::CheckConfiguration do
-  include_context "spec"
-
-  describe ".call" do
-    it "raises SystemExit with no configuration" do
+  include_context 'spec'
 
+  describe '.call' do
+    it 'raises SystemExit with no configuration' do
       # Delete the temp configuration file.
-      File.delete(project_path + "/tmp/tugboat")
+      File.delete(project_path + '/tmp/tugboat')
 
-      expect {described_class.new(app).call(env) }.to raise_error(SystemExit)
+      expect { described_class.new(app).call(env) }.to raise_error(SystemExit)
     end
   end
-
 end

data/spec/middleware/check_credentials_spec.rb

@@ -1,21 +1,20 @@
 require 'spec_helper'
 
 describe Tugboat::Middleware::CheckCredentials do
-  include_context "spec"
+  include_context 'spec'
 
-  describe ".call" do
-    it "raises SystemExit with no configuration" do
-      stub_request(:get, "https://api.digitalocean.com/v2/droplets?page=1&per_page=1").
-         with(:headers => {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'Authorization'=>'Bearer foo', 'Content-Type'=>'application/json', 'User-Agent'=>'Faraday v0.9.2'}).
-         to_return(:headers => {'Content-Type' => 'application/json'}, :status => 401, :body => fixture('401'))
+  describe '.call' do
+    it 'raises SystemExit with no configuration' do
+      stub_request(:get, 'https://api.digitalocean.com/v2/droplets?page=1&per_page=1').
+        with(headers: { 'Accept' => '*/*', 'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'Authorization' => 'Bearer foo', 'Content-Type' => 'application/json', 'User-Agent' => 'Faraday v0.11.0' }).
+        to_return(headers: { 'Content-Type' => 'application/json' }, status: 401, body: fixture('401'))
 
       # Inject the client.
-      env["barge"] = ocean
+      env['barge'] = ocean
 
-      expect {described_class.new(app).call(env) }.to raise_error(SystemExit)
-      expect(a_request(:get, "https://api.digitalocean.com/v2/droplets?page=1&per_page=1")).
+      expect { described_class.new(app).call(env) }.to raise_error(SystemExit)
+      expect(a_request(:get, 'https://api.digitalocean.com/v2/droplets?page=1&per_page=1')).
         to have_been_made
     end
   end
-
 end

data/spec/middleware/check_droplet_active_spec.rb

@@ -1,15 +1,13 @@
 require 'spec_helper'
 
 describe Tugboat::Middleware::CheckDropletActive do
-  include_context "spec"
+  include_context 'spec'
 
-  describe ".call" do
-    it "raises an error when droplet is not active" do
+  describe '.call' do
+    it 'raises an error when droplet is not active' do
+      env['droplet_status'] = 'off'
 
-      env["droplet_status"] = "off"
-
-      expect {described_class.new(app).call(env) }.to raise_error(SystemExit)
+      expect { described_class.new(app).call(env) }.to raise_error(SystemExit)
     end
   end
-
 end

data/spec/middleware/check_droplet_inactive_spec.rb

@@ -1,15 +1,13 @@
 require 'spec_helper'
 
 describe Tugboat::Middleware::CheckDropletInactive do
-  include_context "spec"
+  include_context 'spec'
 
-  describe ".call" do
-    it "raises an error when droplet is active" do
+  describe '.call' do
+    it 'raises an error when droplet is active' do
+      env['droplet_status'] = 'active'
 
-      env["droplet_status"] = "active"
-
-      expect {described_class.new(app).call(env) }.to raise_error(SystemExit)
+      expect { described_class.new(app).call(env) }.to raise_error(SystemExit)
     end
   end
-
 end

data/spec/middleware/find_droplet_spec.rb

@@ -1,16 +1,15 @@
 require 'spec_helper'
 
 describe Tugboat::Middleware::FindDroplet do
-  include_context "spec"
+  include_context 'spec'
 
-  describe ".call" do
-    it "raises SystemExit with no droplet data" do
-      expect {described_class.new(app).call(env) }.to raise_error(SystemExit)
+  describe '.call' do
+    it 'raises SystemExit with no droplet data' do
+      expect { described_class.new(app).call(env) }.to raise_error(SystemExit)
 
       expect($stdout.string).to include 'Tugboat attempted to find a droplet with no arguments'
       expect($stdout.string).to include 'For more help run: '
       expect($stdout.string).to include 'Try running `tugboat '
     end
   end
-
 end

data/spec/middleware/find_image_spec.rb

@@ -1,16 +1,15 @@
 require 'spec_helper'
 
 describe Tugboat::Middleware::FindImage do
-  include_context "spec"
+  include_context 'spec'
 
-  describe ".call" do
-    it "raises SystemExit with no image data" do
-      expect {described_class.new(app).call(env) }.to raise_error(SystemExit)
+  describe '.call' do
+    it 'raises SystemExit with no image data' do
+      expect { described_class.new(app).call(env) }.to raise_error(SystemExit)
 
       expect($stdout.string).to include 'Tugboat attempted to find an image with no arguments'
       expect($stdout.string).to include 'For more help run: '
       expect($stdout.string).to include 'Try running `tugboat '
     end
   end
-
 end

data/spec/middleware/inject_client_spec.rb

@@ -1,29 +1,26 @@
 require 'spec_helper'
 
 describe Tugboat::Middleware::InjectClient do
-  include_context "spec"
+  include_context 'spec'
 
-  let(:tmp_path)             { project_path + "/tmp/tugboat" }
+  let(:tmp_path) { project_path + '/tmp/tugboat' }
 
-  before :each do
+  before do
     config = Tugboat::Configuration.instance
-    env["config"] = config
+    env['config'] = config
   end
 
-  describe ".call" do
-
-    it "loads the client into the environment" do
+  describe '.call' do
+    it 'loads the client into the environment' do
       described_class.new(app).call(env)
 
-      env["barge"].should be_a Barge::Client
+      env['barge'].should be_a Barge::Client
     end
 
-    it "creates a client with values from config file" do
-      Barge::Client.should_receive(:new).with(hash_including(:access_token=>"foo"))
+    it 'creates a client with values from config file' do
+      Barge::Client.should_receive(:new).with(hash_including(access_token: 'foo'))
 
       described_class.new(app).call(env)
     end
-
   end
-
 end

data/spec/middleware/inject_configuration_spec.rb

@@ -1,16 +1,13 @@
 require 'spec_helper'
 
 describe Tugboat::Middleware::InjectConfiguration do
-  include_context "spec"
+  include_context 'spec'
 
-  describe ".call" do
-
-    it "loads the configuration into the environment" do
+  describe '.call' do
+    it 'loads the configuration into the environment' do
       described_class.new(app).call(env)
 
-      expect(env["config"]).to eq(config)
+      expect(env['config']).to eq(config)
     end
-
   end
-
 end

data/spec/middleware/ssh_droplet_spec.rb

@@ -1,111 +1,108 @@
 require 'spec_helper'
 
 describe Tugboat::Middleware::SSHDroplet do
-  include_context "spec"
+  include_context 'spec'
 
   before do
     allow(Kernel).to receive(:exec)
   end
 
-  describe ".call" do
+  describe '.call' do
+    it 'exec ssh with correct options' do
+      expect(Kernel).to receive(:exec).with('ssh',
+                                            '-o', 'LogLevel=ERROR',
+                                            '-o', 'StrictHostKeyChecking=no',
+                                            '-o', 'UserKnownHostsFile=/dev/null',
+                                            '-o', 'IdentitiesOnly=yes',
+                                            '-i', File.expand_path(ssh_key_path),
+                                            '-p', ssh_port,
+                                            "#{ssh_user}@#{droplet_ip}")
 
-    it "exec ssh with correct options" do
-      expect(Kernel).to receive(:exec).with("ssh",
-                        "-o", "LogLevel=ERROR",
-                        "-o", "StrictHostKeyChecking=no",
-                        "-o", "UserKnownHostsFile=/dev/null",
-                        "-o", "IdentitiesOnly=yes",
-                        "-i", File.expand_path(ssh_key_path),
-                        "-p", ssh_port,
-                        "#{ssh_user}@#{droplet_ip}")
-
-      env["droplet_ip"] = droplet_ip
-      env["config"] = config
+      env['droplet_ip'] = droplet_ip
+      env['config'] = config
 
       described_class.new(app).call(env)
     end
 
-    it "exec ssh with IdentitiesOnly=no if no ssh_key_path in config" do
-      expect(Kernel).to receive(:exec).with("ssh",
-                        "-o", "LogLevel=ERROR",
-                        "-o", "StrictHostKeyChecking=no",
-                        "-o", "UserKnownHostsFile=/dev/null",
-                        "-o", "IdentitiesOnly=no",
-                        "-p", ssh_port,
-                        "#{ssh_user}@#{droplet_ip}")
+    it 'exec ssh with IdentitiesOnly=no if no ssh_key_path in config' do
+      expect(Kernel).to receive(:exec).with('ssh',
+                                            '-o', 'LogLevel=ERROR',
+                                            '-o', 'StrictHostKeyChecking=no',
+                                            '-o', 'UserKnownHostsFile=/dev/null',
+                                            '-o', 'IdentitiesOnly=no',
+                                            '-p', ssh_port,
+                                            "#{ssh_user}@#{droplet_ip}")
 
-      env["droplet_ip"] = droplet_ip
+      env['droplet_ip'] = droplet_ip
 
       config.data['ssh']['ssh_key_path'] = nil
 
-      env["config"] = config
+      env['config'] = config
 
       described_class.new(app).call(env)
     end
 
-    it "executes ssh with custom options" do
-      expect(Kernel).to receive(:exec).with("ssh",
-                        "-o", "LogLevel=ERROR",
-                        "-o", "StrictHostKeyChecking=no",
-                        "-o", "UserKnownHostsFile=/dev/null",
-                        "-o", "IdentitiesOnly=yes",
-                        "-i", File.expand_path(ssh_key_path),
-                        "-p", ssh_port,
-                        "-e",
-                        "-q",
-                        "-X",
-                        "#{ssh_user}@#{droplet_ip}",
-                        "echo hello")
-
-      env["droplet_ip"] = droplet_ip
-      env["droplet_ip_private"] = droplet_ip_private
-      env["config"] = config
-      env["user_droplet_ssh_command"] = "echo hello"
-      env["user_droplet_use_public_ip"] = true
-      env["user_droplet_ssh_opts"] = "-e -q -X"
+    it 'executes ssh with custom options' do
+      expect(Kernel).to receive(:exec).with('ssh',
+                                            '-o', 'LogLevel=ERROR',
+                                            '-o', 'StrictHostKeyChecking=no',
+                                            '-o', 'UserKnownHostsFile=/dev/null',
+                                            '-o', 'IdentitiesOnly=yes',
+                                            '-i', File.expand_path(ssh_key_path),
+                                            '-p', ssh_port,
+                                            '-e',
+                                            '-q',
+                                            '-X',
+                                            "#{ssh_user}@#{droplet_ip}",
+                                            'echo hello')
+
+      env['droplet_ip'] = droplet_ip
+      env['droplet_ip_private'] = droplet_ip_private
+      env['config'] = config
+      env['user_droplet_ssh_command'] = 'echo hello'
+      env['user_droplet_use_public_ip'] = true
+      env['user_droplet_ssh_opts'] = '-e -q -X'
 
       described_class.new(app).call(env)
     end
 
-    it "executes ssh with private IP if option chosen" do
-      expect(Kernel).to receive(:exec).with("ssh",
-                        "-o", "LogLevel=ERROR",
-                        "-o", "StrictHostKeyChecking=no",
-                        "-o", "UserKnownHostsFile=/dev/null",
-                        "-o", "IdentitiesOnly=yes",
-                        "-i", File.expand_path(ssh_key_path),
-                        "-p", ssh_port,
-                        "-e",
-                        "-q",
-                        "-X",
-                        "#{ssh_user}@#{droplet_ip_private}",
-                        "echo hello")
-
-      env["droplet_ip"] = droplet_ip
-      env["droplet_ip_private"] = droplet_ip_private
-      env["config"] = config
-      env["user_droplet_ssh_command"] = "echo hello"
-      env["user_droplet_use_private_ip"] = true
-      env["user_droplet_ssh_opts"] = "-e -q -X"
+    it 'executes ssh with private IP if option chosen' do
+      expect(Kernel).to receive(:exec).with('ssh',
+                                            '-o', 'LogLevel=ERROR',
+                                            '-o', 'StrictHostKeyChecking=no',
+                                            '-o', 'UserKnownHostsFile=/dev/null',
+                                            '-o', 'IdentitiesOnly=yes',
+                                            '-i', File.expand_path(ssh_key_path),
+                                            '-p', ssh_port,
+                                            '-e',
+                                            '-q',
+                                            '-X',
+                                            "#{ssh_user}@#{droplet_ip_private}",
+                                            'echo hello')
+
+      env['droplet_ip'] = droplet_ip
+      env['droplet_ip_private'] = droplet_ip_private
+      env['config'] = config
+      env['user_droplet_ssh_command'] = 'echo hello'
+      env['user_droplet_use_private_ip'] = true
+      env['user_droplet_ssh_opts'] = '-e -q -X'
 
       described_class.new(app).call(env)
     end
 
-    it "errors if private IP option given but no Private IP on Droplet" do
-      env["droplet_ip"] = droplet_ip
-      env["config"] = config
-      env["user_droplet_ssh_command"] = "echo hello"
-      env["user_droplet_use_private_ip"] = true
-      env["user_droplet_ssh_opts"] = "-e -q -X"
+    it 'errors if private IP option given but no Private IP on Droplet' do
+      env['droplet_ip'] = droplet_ip
+      env['config'] = config
+      env['user_droplet_ssh_command'] = 'echo hello'
+      env['user_droplet_use_private_ip'] = true
+      env['user_droplet_ssh_opts'] = '-e -q -X'
 
-      expect {described_class.new(app).call(env)}.to raise_error(SystemExit)
+      expect { described_class.new(app).call(env) }.to raise_error(SystemExit)
 
       expect($stdout.string).to eq <<-eos
 Executing SSH on Droplet ...
 You asked to ssh to the private IP, but no Private IP found!
       eos
     end
-
   end
-
 end