opsicle 0.1.0 → 0.2.0

data/lib/opsicle/stack.rb

@@ -0,0 +1,22 @@
+module Opsicle
+  class Stack
+
+    def initialize(client)
+      @client = client
+    end
+
+    def stack_summary(options={})
+      # Only call the API again if you need to
+      @stack_summary = nil if options[:reload]
+      @deployment ||= @client.api_call('describe_stack_summary',
+                                       :stack_id => @client.config.opsworks_config[:stack_id]
+                                      )[:stack_summary]
+    end
+    private :stack_summary
+
+    def name
+      stack_summary[:name]
+    end
+
+  end
+end

data/lib/opsicle/version.rb

@@ -1,3 +1,3 @@
 module Opsicle
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/opsicle.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec", "3.0.0.beta1" # Pinning to beta1 until https://github.com/guard/guard-rspec/pull/250 is closed
   spec.add_development_dependency "guard"
   spec.add_development_dependency "guard-rspec"
 end

data/spec/opsicle/client_spec.rb

@@ -8,16 +8,16 @@ module Opsicle
     let(:config) { double }
     before do
       ow_stub = double
-      config.stub(:opsworks_config).and_return({ stack_id: 'stack', app_id: 'app' })
-      ow_stub.stub(:client).and_return(aws_client)
-      Config.stub(:new).and_return(config)
-      AWS::OpsWorks.stub(:new).and_return(ow_stub)
+      allow(config).to receive(:opsworks_config).and_return({ stack_id: 'stack', app_id: 'app' })
+      allow(ow_stub).to receive(:client).and_return(aws_client)
+      allow(Config).to receive(:new).and_return(config)
+      allow(AWS::OpsWorks).to receive(:new).and_return(ow_stub)
     end
 
     context "#run_command" do
       it "calls out to the aws client with all the config options" do
-        config.should_receive(:configure_aws!)
-        aws_client.should_receive(:create_deployment).with(
+        expect(config).to receive(:configure_aws!)
+        expect(aws_client).to receive(:create_deployment).with(
           hash_including(
             command: { name: 'deploy' },
             stack_id: 'stack',

data/spec/opsicle/commands/deploy_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+require "opsicle/commands/deploy"
+require "opsicle/monitor"
+
+module Opsicle
+  describe Deploy do
+    subject { Deploy.new('derp') }
+
+    context "#execute" do
+      let(:client) { double }
+      let(:monitor) { double(:start => nil) }
+      before do
+        allow(Client).to receive(:new).with('derp').and_return(client)
+        allow(client).to receive(:run_command).with('deploy').and_return({deployment_id: 'derp'})
+
+        allow(Monitor::App).to receive(:new).and_return(monitor)
+        allow(monitor).to receive(:start)
+      end
+
+      it "creates a new deployment" do
+        expect(client).to receive(:run_command).with('deploy').and_return({deployment_id: 'derp'})
+
+        subject.execute
+      end
+
+      it "runs the Opsicle Stack Monitor by default" do
+        expect(Monitor::App).to receive(:new).and_return(monitor)
+        expect(monitor).to receive(:start)
+        expect(subject).to_not receive(:open_deploy)
+
+        subject.execute
+      end
+
+      it "opens the OpsWorks deployments screen if browser option is given" do
+        expect(subject).to receive(:open_deploy)
+        expect(Monitor::App).to_not receive(:new)
+
+        subject.execute({browser: true})
+      end
+    end
+
+    context "#client" do
+      it "generates a new aws client from the given configs" do
+        expect(Client).to receive(:new).with('derp')
+        subject.client
+      end
+    end
+
+  end
+end

data/spec/opsicle/{list_spec.rb → commands/list_spec.rb}

@@ -1,5 +1,5 @@
 require "spec_helper"
-require "opsicle/list"
+require "opsicle/commands/list"
 
 module Opsicle
   describe List do
@@ -10,19 +10,20 @@ module Opsicle
       let(:stack_ids) { [1,2,3] }
       let(:apps) { [{ name: 'test', stack_id: 1, app_id: 1}, { name: 'test2', stack_id: 2, app_id: 2}, { name: 'test3', stack_id: 3, app_id: 3 }] }
       before do
-        Client.stub(:new).with('derp').and_return(client)
+        allow(Client).to receive(:new).with('derp').and_return(client)
       end
 
-      it "creates a new deployment" do
-        subject.should_receive(:get_stacks).and_return(stack_ids)
-        subject.should_receive(:get_apps).with(stack_ids).and_return(apps)
+      it "shows a table with all of the apps/stacks from OpsWorks" do
+        expect(subject).to receive(:get_stacks).and_return(stack_ids)
+        expect(subject).to receive(:get_apps).with(stack_ids).and_return(apps)
+        expect(subject).to receive(:print).with(apps)
         subject.execute
       end
     end
 
     context "#client" do
       it "generates a new aws client from the given configs" do
-        Client.should_receive(:new).with('derp')
+        expect(Client).to receive(:new).with('derp')
         subject.client
       end
     end

data/spec/opsicle/commands/ssh_key_spec.rb

@@ -0,0 +1,75 @@
+require "spec_helper"
+require "opsicle/commands/ssh_key"
+
+module Opsicle
+  describe SSHKey do
+    let(:valid_key) { "my-valid-public-key" }
+    subject { SSHKey.new("derp", valid_key) }
+    let(:client) { double(config: double(opsworks_config: {stack_id: "1234"})) }
+    let(:api_call) { double }
+
+    before do
+      allow(Client).to receive(:new).with("derp").and_return(client)
+    end
+
+    context "#execute" do
+      context "valid ssh key" do
+        it "confirms that the given file is a public ssh key" do
+          expect(subject).to receive(:validate!)
+          expect(subject).to receive(:say).with(/success/)
+          allow(subject).to receive(:update)
+          subject.execute
+        end
+
+        it "updates the user's ssh-key on opsworks" do
+          allow(subject).to receive(:validate!)
+          expect(subject).to receive(:say).with(/success/)
+          expect(subject).to receive(:update)
+          subject.execute
+        end
+      end
+    end
+
+    context "#validate!" do
+      it "validates a valid ssh key" do
+        allow(File).to receive(:exists?).and_return(true)
+        allow(subject).to receive(:valid_key_file?).and_return(true)
+        allow(subject).to receive(:public_key?).and_return(true)
+
+        expect { subject.validate! }.to_not raise_error
+      end
+
+      it "raises an error for a private ssh key" do
+        allow(File).to receive(:exists?).and_return(true)
+        allow(subject).to receive(:valid_key_file?).and_return(true)
+        allow(subject).to receive(:public_key?).and_return(false)
+
+        expect { subject.validate! }.to raise_error
+      end
+
+      it "raises an error for a non-key file" do
+        allow(File).to receive(:exists?).and_return(true)
+        allow(subject).to receive(:valid_key_file?).and_return(false)
+        allow(subject).to receive(:public_key?).and_return(true)
+
+        expect { subject.validate! }.to raise_error(InvalidKeyFile)
+      end
+
+      it "raises an error if no key file exists" do
+        allow(File).to receive(:exists?).and_return(false)
+        allow(subject).to receive(:valid_key_file?).and_return(true)
+        allow(subject).to receive(:public_key?).and_return(true)
+
+        expect { subject.validate! }.to raise_error(KeyFileNotFound)
+      end
+    end
+
+    context "#update" do
+      it "updates the users ssh key via the aws api" do
+        allow(subject).to receive(:key).and_return(valid_key)
+        expect(client).to receive(:api_call).with(:update_my_user_profile, {ssh_public_key: valid_key }).and_return(api_call)
+        subject.update
+      end
+    end
+  end
+end

data/spec/opsicle/{ssh_spec.rb → commands/ssh_spec.rb}

@@ -1,5 +1,5 @@
 require "spec_helper"
-require "opsicle/ssh"
+require "opsicle/commands/ssh"
 
 module Opsicle
   describe SSH do
@@ -7,78 +7,78 @@ module Opsicle
     let(:client) { double(config: double(opsworks_config: {stack_id: "1234"})) }
     let(:api_call) { double }
     before do
-      Client.stub(:new).with('derp').and_return(client)
+      allow(Client).to receive(:new).with('derp').and_return(client)
     end
 
     context "#execute" do
       before do
-        subject.stub(:say) { "What instance do you want, huh?" }
-        subject.stub(:ask).and_return(2)
-        subject.stub(:ssh_username) {"mrderpyman2014"}
+        allow(subject).to receive(:say) { "What instance do you want, huh?" }
+        allow(subject).to receive(:ask).and_return(2)
+        allow(subject).to receive(:ssh_username) {"mrderpyman2014"}
       end
 
-      it "should execute ssh with a selected Opsworks instance IP" do
-        subject.stub(:instances) {[
+      it "executes ssh with a selected Opsworks instance IP" do
+        allow(subject).to receive(:instances) {[
                                     { hostname: "host1", elastic_ip: "123.123.123.123" },
                                     { hostname: "host2", elastic_ip: "789.789.789.789" }
                                   ]}
 
-        subject.should_receive(:system).with("ssh mrderpyman2014@789.789.789.789")
+        expect(subject).to receive(:system).with("ssh mrderpyman2014@789.789.789.789")
         subject.execute
       end
 
-      it "should execute ssh with public_ip listings as well as elastic_ip" do
-        subject.stub(:instances) {[
+      it "executes ssh with public_ip listings as well as elastic_ip" do
+        allow(subject).to receive(:instances) {[
                                     { hostname: "host1", elastic_ip: "678.678.678.678" },
                                     { hostname: "host2", public_ip: "987.987.987.987" }
                                   ]}
 
-        subject.should_receive(:system).with("ssh mrderpyman2014@987.987.987.987")
+        expect(subject).to receive(:system).with("ssh mrderpyman2014@987.987.987.987")
         subject.execute
       end
 
-      it "should execute ssh favoring an elastic_ip over a public_ip if both exist" do
-        subject.stub(:instances) {[
+      it "executes ssh favoring an elastic_ip over a public_ip if both exist" do
+        allow(subject).to receive(:instances) {[
                                     { hostname: "host1", elastic_ip: "678.678.678.678" },
                                     { hostname: "host2", public_ip: "987.987.987.987", elastic_ip: "132.132.132.132" }
                                   ]}
 
-        subject.should_receive(:system).with("ssh mrderpyman2014@132.132.132.132")
+        expect(subject).to receive(:system).with("ssh mrderpyman2014@132.132.132.132")
         subject.execute
       end
 
-      it "should execute ssh right away if there is only one Opsworks instance available" do
-        subject.stub(:instances) {[
+      it "executes ssh right away if there is only one Opsworks instance available" do
+        allow(subject).to receive(:instances) {[
                                     { hostname: "host3", elastic_ip: "456.456.456.456" }
                                   ]}
 
-        subject.should_receive(:system).with("ssh mrderpyman2014@456.456.456.456")
-        subject.should_not_receive(:ask)
+        expect(subject).to receive(:system).with("ssh mrderpyman2014@456.456.456.456")
+        expect(subject).not_to receive(:ask)
         subject.execute
       end
     end
 
     context "#client" do
       it "generates a new aws client from the given configs" do
-        Client.should_receive(:new).with('derp')
+        expect(Client).to receive(:new).with('derp')
         subject.client
       end
     end
 
     context "#instances" do
       it "makes a describe_instances API call" do
-        client.stub(:api_call).with(:describe_instances, {stack_id: "1234"})
+        expect(client).to receive(:api_call).with(:describe_instances, {stack_id: "1234"})
           .and_return(api_call)
-        api_call.should_receive(:data).and_return(instances: {:foo => :bar})
-        subject.instances.should == {:foo => :bar}
+        expect(api_call).to receive(:data).and_return(instances: {:foo => :bar})
+        expect(subject.instances).to eq({:foo => :bar})
       end
     end
 
     context "#ssh_username" do
       it "makes a describe_my_user_profile API call" do
-        client.stub(:api_call).with(:describe_my_user_profile)
+        allow(client).to receive(:api_call).with(:describe_my_user_profile)
           .and_return({user_profile: {:ssh_username => "captkirk01"}})
-        subject.ssh_username.should == "captkirk01"
+        expect(subject.ssh_username).to eq("captkirk01")
       end
     end
 

data/spec/opsicle/config_spec.rb

@@ -1,39 +1,40 @@
 require "spec_helper"
 require "opsicle/config"
+
 module Opsicle
   describe Config do
     subject { Config.new('derp') }
     context "with a valid config" do
       before do
-        File.stub(:exist?).with(File.expand_path '~/.fog').and_return(true)
-        File.stub(:exist?).with('./.opsicle').and_return(true)
-        YAML.stub(:load_file).with(File.expand_path '~/.fog').and_return({'derp' => { 'aws_access_key_id' => 'key', 'aws_secret_access_key' => 'secret'}})
-        YAML.stub(:load_file).with('./.opsicle').and_return({'derp' => { 'app_id' => 'app', 'stack_id' => 'stack'}})
+        allow(File).to receive(:exist?).with(File.expand_path '~/.fog').and_return(true)
+        allow(File).to receive(:exist?).with('./.opsicle').and_return(true)
+        allow(YAML).to receive(:load_file).with(File.expand_path '~/.fog').and_return({'derp' => { 'aws_access_key_id' => 'key', 'aws_secret_access_key' => 'secret'}})
+        allow(YAML).to receive(:load_file).with('./.opsicle').and_return({'derp' => { 'app_id' => 'app', 'stack_id' => 'stack'}})
       end
 
       context "#aws_config" do
         it "should contain access_key_id" do
-          subject.aws_config.should have_key(:access_key_id)
+          expect(subject.aws_config).to have_key(:access_key_id)
         end
 
         it "should contain secret_access_key" do
-          subject.aws_config.should have_key(:secret_access_key)
+          expect(subject.aws_config).to have_key(:secret_access_key)
         end
       end
 
       context "#opsworks_config" do
         it "should contain stack_id" do
-          subject.opsworks_config.should have_key(:stack_id)
+          expect(subject.opsworks_config).to have_key(:stack_id)
         end
 
         it "should contain app_id" do
-          subject.opsworks_config.should have_key(:app_id)
+          expect(subject.opsworks_config).to have_key(:app_id)
         end
       end
 
       context "#configure_aws!" do
         it "should load the config into the AWS module" do
-          AWS.should_receive(:config).with(hash_including(access_key_id: 'key', secret_access_key: 'secret'))
+          expect(AWS).to receive(:config).with(hash_including(access_key_id: 'key', secret_access_key: 'secret'))
           subject.configure_aws!
         end
       end
@@ -41,8 +42,8 @@ module Opsicle
 
     context "missing configs" do
       before do
-        File.stub(:exist?).with(File.expand_path '~/.fog').and_return(false)
-        File.stub(:exist?).with('./.opsicle').and_return(false)
+        allow(File).to receive(:exist?).with(File.expand_path '~/.fog').and_return(false)
+        allow(File).to receive(:exist?).with('./.opsicle').and_return(false)
       end
 
       context "#aws_config" do

data/spec/opsicle/monitor/app_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+require "opsicle/monitor/app"
+require "opsicle/monitor/screen"
+
+describe Opsicle::Monitor::App do
+
+  before do
+    @screen = double(
+      :close     => nil,
+      :refresh   => nil,
+      :next_key  => nil,
+      :refresh_spies => nil,
+      :missized? => nil
+    )
+
+    @client = double
+
+    allow(Opsicle::Monitor::Screen).to receive(:new).and_return(@screen)
+    allow(Opsicle::Client).to receive(:new).and_return(@client)
+
+    @app = Opsicle::Monitor::App.new("staging", {})
+  end
+
+  it "sets status not-running" do
+    expect(@app.running).to equal(false)
+  end
+
+  it "sets status not-restarting" do
+    expect(@app.restarting).to equal(false)
+  end
+
+  describe "#restart" do
+    before do
+      @app.instance_variable_set(:@restarting, false)
+    end
+
+    it "sets status restarting" do
+      @app.restart
+
+      expect(@app.restarting).to equal(true)
+    end
+  end
+
+  describe "#do_command" do
+    before do
+      @app.instance_variable_set(:@running, true)
+      @app.instance_variable_set(:@screen, @screen)
+    end
+
+    it "<d> switches to Deployments panel" do
+      expect(@screen).to receive(:panel_main=).with(:deployments)
+
+      @app.do_command('d')
+    end
+
+    it "<h> switches to Help panel" do
+      expect(@screen).to receive(:panel_main=).with(:help)
+
+      @app.do_command('h')
+    end
+  end
+
+end