console-vmc-plugin 0.1.0 → 0.1.1

data/lib/console-vmc-plugin/console.rb

@@ -5,11 +5,10 @@ require "tunnel-vmc-plugin/tunnel"
 
 
 class CFConsole < CFTunnel
-  def initialize(client, app, port = 10000, v2 = false)
+  def initialize(client, app, port = 10000)
     @client = client
     @app = app
     @port = port
-    @v2 = v2
   end
 
   def get_connection_info(auth)
@@ -28,11 +27,7 @@ class CFConsole < CFTunnel
   end
 
   def get_credentials
-    if @v2
-      YAML.load(@app.file("cf-rails-console", ".consoleaccess"))
-    else
-      YAML.load(@app.file("app", "cf-rails-console", ".consoleaccess"))
-    end
+    YAML.load(@app.file("app", "cf-rails-console", ".consoleaccess"))
   end
 
   def start_console

data/lib/console-vmc-plugin/plugin.rb

@@ -11,7 +11,7 @@ module VMCConsole
     def console
       app = input[:app]
 
-      console = CFConsole.new(client, app, nil, v2?)
+      console = CFConsole.new(client, app)
       port = console.pick_port!(input[:port])
 
       with_progress("Opening console on port #{c(port, :name)}") do
@@ -24,7 +24,6 @@ module VMCConsole
 
     filter(:start, :start_app) do |app|
       if app.framework.name == "rails3" || app.framework.name == "buildpack"
-        puts "Setting console to true"
         app.console = true
       end
 

data/lib/console-vmc-plugin/version.rb

@@ -1,3 +1,3 @@
 module VMCConsole
-  VERSION = "0.1.0".freeze
+  VERSION = "0.1.1".freeze
 end

data/spec/console_spec.rb

@@ -2,198 +2,183 @@ require "spec_helper"
 require "console-vmc-plugin/plugin"
 
 describe "CFConsole" do
+  before do
+    @app = mock("app")
+    @console = CFConsole.new(nil, @app)
+  end
 
-  context "V1" do
-    before do
-      @app = mock("app")
-      @console = CFConsole.new(nil, @app)
-    end
+  it "should return connection info for apps that have a console ip and port" do
+    instance = mock("instance")
+    mock(@app).instances { [instance] }
+    mock(instance).console { {:ip => "192.168.1.1", :port => 3344} }
 
-    it "should return connection info for apps that have a console ip and port" do
-      instance = mock("instance")
-      mock(@app).instances { [instance] }
-      mock(instance).console { {:ip => "192.168.1.1", :port => 3344} }
+    @console.get_connection_info(nil).should == {
+      "hostname" => "192.168.1.1",
+      "port" => 3344
+    }
+  end
 
-      @console.get_connection_info(nil).should == {
-        "hostname" => "192.168.1.1",
-        "port" => 3344
-      }
-    end
+  it "should raise error when no app instances found" do
+    mock(@app).instances { [] }
+
+    expect {
+      @console.get_connection_info(nil)
+    }.to raise_error("App has no running instances; try starting it.")
+  end
 
-    it "should raise error when no app instances found" do
-      mock(@app).instances { [] }
+  it "should raise error when app does not have console access" do
+    instance = mock("instance")
+    mock(@app).instances { [instance] }
+    mock(instance).console { nil }
+
+    expect {
+      @console.get_connection_info(nil)
+    }.to raise_error("App does not have console access; try restarting it.")
+  end
 
-      expect {
-        @console.get_connection_info(nil)
-      }.to raise_error("App has no running instances; try starting it.")
+  describe "start_console" do
+    before do
+      @creds = {
+        :path => %w(app cf-rails-console .consoleaccess),
+        :yaml => "username: cfuser\npassword: testpw",
+        :telnet => {"Name" => "cfuser", "Password" => "testpw"}
+      }
     end
 
-    it "should raise error when app does not have console access" do
-      instance = mock("instance")
-      mock(@app).instances { [instance] }
-      mock(instance).console { nil }
+    context "when console credentials cannot be obtained" do
+      it "should raise error" do
+        mock(@app).file(*@creds[:path]) { "username: cfuser" }
 
-      expect {
-        @console.get_connection_info(nil)
-      }.to raise_error("App does not have console access; try restarting it.")
+        expect {
+          @console.start_console
+        }.to raise_error("Unable to verify console credentials.")
+      end
     end
 
-    describe "start_console" do
+    context "when console credentials can be obtained" do
       before do
-        @creds = {
-          :path => %w(app cf-rails-console .consoleaccess),
-          :yaml => "username: cfuser\npassword: testpw",
-          :telnet => {"Name" => "cfuser", "Password" => "testpw"}
-        }
+        mock(@app).file(*@creds[:path]) { @creds[:yaml] }
+        @telnet = Object.new
+        mock(@console).telnet_client { @telnet }
       end
 
-      context "when console credentials cannot be obtained" do
-        it "should raise error" do
-          mock(@app).file(*@creds[:path]) { "username: cfuser" }
+      it "should raise error if authentication fails" do
+        mock(@telnet).login(@creds[:telnet]) { "Login failed" }
+        mock(@telnet).close
 
-          expect {
-            @console.start_console
-          }.to raise_error("Unable to verify console credentials.")
-        end
+        expect { @console.start_console }.to raise_error("Login failed")
       end
 
-      context "when console credentials can be obtained" do
-        before do
-          mock(@app).file(*@creds[:path]) { @creds[:yaml] }
-          @telnet = Object.new
-          mock(@console).telnet_client { @telnet }
-        end
-
-        it "should raise error if authentication fails" do
-          mock(@telnet).login(@creds[:telnet]) { "Login failed" }
-          mock(@telnet).close
+      it "should retry authentication on timeout" do
+        mock(@telnet).login(@creds[:telnet]){ raise TimeoutError }
+        mock(@telnet).login(@creds[:telnet]) { "Switch to inspect mode\nirb():001:0> " }
+        verify_console_exit("irb():001:0> ")
 
-          expect { @console.start_console }.to raise_error("Login failed")
-        end
-
-        it "should retry authentication on timeout" do
-          mock(@telnet).login(@creds[:telnet]) { raise TimeoutError }
-          mock(@telnet).login(@creds[:telnet]) { "Switch to inspect mode\nirb():001:0> " }
-          verify_console_exit("irb():001:0> ")
+        @console.start_console
+      end
 
-          @console.start_console
-        end
+      it "should retry authentication on EOF" do
+        mock(@console).telnet_client { @telnet }
+        mock(@telnet).login(@creds[:telnet]) { raise EOFError }
+        mock(@telnet).close
+        mock(@telnet).login(@creds[:telnet]) { "irb():001:0> " }
+        verify_console_exit("irb():001:0> ")
 
-        it "should retry authentication on EOF" do
-          mock(@console).telnet_client { @telnet }
-          mock(@telnet).login(@creds[:telnet]) { raise EOFError }
-          mock(@telnet).close
-          mock(@telnet).login(@creds[:telnet]) { "irb():001:0> " }
-          verify_console_exit("irb():001:0> ")
+        @console.start_console
+      end
 
-          @console.start_console
-        end
+      it "should operate console interactively" do
+        mock(@telnet).login(@creds[:telnet]) { "irb():001:0> " }
+        mock(Readline).readline("irb():001:0> ") { "puts 'hi'" }
+        mock(Readline::HISTORY).push("puts 'hi'")
+        mock(@telnet).cmd("puts 'hi'") { "nil" + "\n" + "irb():002:0> " }
+        mock(@console).puts("nil")
+        verify_console_exit("irb():002:0> ")
 
-        it "should operate console interactively" do
-          mock(@telnet).login(@creds[:telnet]) { "irb():001:0> " }
-          mock(Readline).readline("irb():001:0> ") { "puts 'hi'" }
-          mock(Readline::HISTORY).push("puts 'hi'")
-          mock(@telnet).cmd("puts 'hi'") { "nil" + "\n" + "irb():002:0> " }
-          mock(@console).puts("nil")
-          verify_console_exit("irb():002:0> ")
+        @console.start_console
+      end
 
-          @console.start_console
-        end
+      it "should not crash if command times out" do
+        mock(@telnet).login(@creds[:telnet]) { "irb():001:0> " }
+        mock(Readline).readline("irb():001:0> ") { "puts 'hi'" }
+        mock(Readline::HISTORY).push("puts 'hi'")
+        mock(@telnet).cmd("puts 'hi'") { raise TimeoutError }
+        mock(@console).puts("Timed out sending command to server.")
+        verify_console_exit("irb():001:0> ")
 
-        it "should not crash if command times out" do
-          mock(@telnet).login(@creds[:telnet]) { "irb():001:0> " }
-          mock(Readline).readline("irb():001:0> ") { "puts 'hi'" }
-          mock(Readline::HISTORY).push("puts 'hi'")
-          mock(@telnet).cmd("puts 'hi'") { raise TimeoutError }
-          mock(@console).puts("Timed out sending command to server.")
-          verify_console_exit("irb():001:0> ")
+        @console.start_console
+      end
 
-          @console.start_console
-        end
-
-        it "should raise error if an EOF is received" do
-          mock(@telnet).login(@creds[:telnet]) { "Switch to inspect mode\nirb():001:0> " }
-          mock(Readline).readline("irb():001:0> ") { "puts 'hi'" }
-          mock(Readline::HISTORY).push("puts 'hi'")
-          mock(@telnet).cmd("puts 'hi'") { raise EOFError }
-
-          expect {
-            @console.start_console
-          }.to raise_error("The console connection has been terminated. Perhaps the app was stopped or deleted?")
-        end
-
-        it "should not keep blank lines in history" do
-          mock(@telnet).login(@creds[:telnet]) { "irb():001:0> " }
-          mock(Readline).readline("irb():001:0> ") { "" }
-          dont_allow(Readline::HISTORY).push("")
-          mock(@telnet).cmd("") { "irb():002:0*> " }
-          verify_console_exit("irb():002:0*> ")
+      it "should raise error if an EOF is received" do
+        mock(@telnet).login(@creds[:telnet]) { "Switch to inspect mode\nirb():001:0> " }
+        mock(Readline).readline("irb():001:0> ") { "puts 'hi'" }
+        mock(Readline::HISTORY).push("puts 'hi'")
+        mock(@telnet).cmd("puts 'hi'") { raise EOFError }
 
+        expect {
           @console.start_console
-        end
+        }.to raise_error("The console connection has been terminated. Perhaps the app was stopped or deleted?")
+      end
 
-        it "should not keep identical commands in history" do
-          mock(@telnet).login(@creds[:telnet]) { "irb():001:0> " }
-          mock(Readline).readline("irb():001:0> ") { "puts 'hi'" }
-          mock(Readline::HISTORY).to_a { ["puts 'hi'"] }
-          dont_allow(Readline::HISTORY).push("puts 'hi'")
-          mock(@telnet).cmd("puts 'hi'") { "nil" + "\n" + "irb():002:0> " }
-          mock(@console).puts("nil")
-          verify_console_exit("irb():002:0> ")
+      it "should not keep blank lines in history" do
+        mock(@telnet).login(@creds[:telnet]) { "irb():001:0> " }
+        mock(Readline).readline("irb():001:0> ") { "" }
+        dont_allow(Readline::HISTORY).push("")
+        mock(@telnet).cmd("") { "irb():002:0*> " }
+        verify_console_exit("irb():002:0*> ")
 
-          @console.start_console
-        end
+        @console.start_console
+      end
 
-        it "should return tab completion data" do
-          mock(@telnet).login(@creds[:telnet]) { "Switch to inspect mode\nirb():001:0> " }
-          mock(@telnet).cmd("String" => "app.\t", "Match" => /\S*\n$/, "Timeout" => 10) { "to_s,nil?\n" }
-          verify_console_exit("irb():001:0> ")
+      it "should not keep identical commands in history" do
+        mock(@telnet).login(@creds[:telnet]) { "irb():001:0> " }
+        mock(Readline).readline("irb():001:0> ") { "puts 'hi'" }
+        mock(Readline::HISTORY).to_a { ["puts 'hi'"] }
+        dont_allow(Readline::HISTORY).push("puts 'hi'")
+        mock(@telnet).cmd("puts 'hi'") { "nil" + "\n" + "irb():002:0> " }
+        mock(@console).puts("nil")
+        verify_console_exit("irb():002:0> ")
 
-          @console.start_console
-          Readline.completion_proc.call("app.").should == ["to_s", "nil?"]
-        end
+        @console.start_console
+      end
 
-        it "should return tab completion data receiving empty completion string" do
-          mock(@telnet).login(@creds[:telnet]) { "irb():001:0> " }
-          mock(@telnet).cmd("String" => "app.\t", "Match" => /\S*\n$/, "Timeout" => 10) { "\n" }
-          verify_console_exit("irb():001:0> ")
+      it "should return tab completion data" do
+        mock(@telnet).login(@creds[:telnet]) { "Switch to inspect mode\nirb():001:0> " }
+        mock(@telnet).cmd("String" => "app.\t", "Match" => /\S*\n$/, "Timeout" => 10) { "to_s,nil?\n" }
+        verify_console_exit("irb():001:0> ")
 
-          @console.start_console
-          Readline.completion_proc.call("app.").should == []
-        end
+        @console.start_console
+        Readline.completion_proc.call("app.").should == ["to_s","nil?"]
+      end
 
-        it "should not crash on timeout of remote tab completion data" do
-          mock(@telnet).login(@creds[:telnet]) { "Switch to inspect mode\nirb():001:0> " }
-          mock(@telnet).cmd("String" => "app.\t", "Match" => /\S*\n$/, "Timeout" => 10) { raise TimeoutError }
-          verify_console_exit("irb():001:0> ")
+      it "should return tab completion data receiving empty completion string" do
+        mock(@telnet).login(@creds[:telnet]) { "irb():001:0> " }
+        mock(@telnet).cmd("String" => "app.\t", "Match" => /\S*\n$/, "Timeout" => 10) { "\n" }
+        verify_console_exit("irb():001:0> ")
 
-          @console.start_console
-          Readline.completion_proc.call("app.").should == []
-        end
+        @console.start_console
+        Readline.completion_proc.call("app.").should == []
+      end
 
-        it "should properly initialize Readline for tab completion" do
-          mock(@telnet).login(@creds[:telnet]) { "irb():001:0> " }
-          mock(Readline).respond_to?("basic_word_break_characters=") { true }
-          mock(Readline).basic_word_break_characters=(" \t\n`><=;|&{(")
-          mock(Readline).completion_append_character=(nil)
-          mock(Readline).completion_proc=(anything)
-          verify_console_exit("irb():001:0> ")
+      it "should not crash on timeout of remote tab completion data" do
+        mock(@telnet).login(@creds[:telnet]) { "Switch to inspect mode\nirb():001:0> " }
+        mock(@telnet).cmd("String" => "app.\t", "Match" => /\S*\n$/, "Timeout" => 10) { raise TimeoutError }
+        verify_console_exit("irb():001:0> ")
 
-          @console.start_console
-        end
+        @console.start_console
+        Readline.completion_proc.call("app.").should == []
       end
-    end
-  end
 
-  context "V2" do
-    before do
-      @app = mock("app")
-      @console = CFConsole.new(nil, @app, nil, true)
-    end
+      it "should properly initialize Readline for tab completion" do
+        mock(@telnet).login(@creds[:telnet]) { "irb():001:0> " }
+        mock(Readline).respond_to?("basic_word_break_characters=") { true }
+        mock(Readline).basic_word_break_characters=(" \t\n`><=;|&{(")
+        mock(Readline).completion_append_character=(nil)
+        mock(Readline).completion_proc=(anything)
+        verify_console_exit("irb():001:0> ")
 
-    it "reads console credentials from correct file" do
-      mock(@app).file(*%w(cf-rails-console .consoleaccess)) { "username: cfuser\npassword: testpw" }
-      @console.get_credentials
+        @console.start_console
+      end
     end
   end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: console-vmc-plugin
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: 
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Alex Suraci