tools-cf-plugin 2.0.0 → 2.1.0

data/spec/tunnel/multi_line_stream_spec.rb

@@ -2,12 +2,12 @@ require "spec_helper"
 
 module CFTools::Tunnel
   describe MultiLineStream do
-    let(:director) { stub }
+    let(:director) { double }
     let(:deployment) { "some-deployment" }
     let(:gateway_user) { "vcap" }
     let(:gateway_host) { "vcap.me" }
 
-    let(:gateway) { stub }
+    let(:gateway) { double }
     let(:entries) { Queue.new }
 
     subject do
@@ -15,10 +15,10 @@ module CFTools::Tunnel
     end
 
     before do
-      stub(subject).create_ssh_user { ["1.2.3.4", "some_user_1"] }
-      stub(subject).gateway { gateway }
-      stub(subject).entry_queue { entries }
-      stub(Thread).new { |blk| blk.call }
+      subject.stub(:create_ssh_user => ["1.2.3.4", "some_user_1"])
+      subject.stub(:gateway => gateway)
+      subject.stub(:entry_queue => entries)
+      Thread.stub(:new).and_yield
     end
 
     describe "#stream" do
@@ -36,14 +36,14 @@ module CFTools::Tunnel
       end
 
       it "spawns a SSH tunnel for each location" do
-        mock(Thread).new { |blk| blk.call }.ordered
-        mock(Thread).new { |blk| blk.call }.ordered
+        expect(Thread).to receive(:new).ordered
+        expect(Thread).to receive(:new).ordered
 
-        mock(subject).create_ssh_user("foo", 0, entries) { ["1.2.3.4", "some_user_1"] }
-        mock(subject).create_ssh_user("bar", 0, entries) { ["1.2.3.5", "some_user_2"] }
+        expect(subject).to receive(:create_ssh_user).with("foo", 0, entries) { ["1.2.3.4", "some_user_1"] }
+        expect(subject).to receive(:create_ssh_user).with("bar", 0, entries) { ["1.2.3.5", "some_user_2"] }
 
-        mock(gateway).ssh("1.2.3.4", "some_user_1")
-        mock(gateway).ssh("1.2.3.5", "some_user_2")
+        expect(gateway).to receive(:ssh).with("1.2.3.4", "some_user_1")
+        expect(gateway).to receive(:ssh).with("1.2.3.5", "some_user_2")
 
         entries << nil
 
@@ -51,7 +51,7 @@ module CFTools::Tunnel
       end
 
       it "streams from each location" do
-        ssh = stub
+        ssh = double
 
         locations = {
           "1.2.3.4" => [
@@ -65,16 +65,32 @@ module CFTools::Tunnel
 
         locations.each do |_, locs|
           locs.each do |loc|
-            mock(loc).stream_lines(ssh)
+            expect(loc).to receive(:stream_lines).with(ssh)
           end
         end
 
-        stub(gateway).ssh { |_, _, blk| blk.call(ssh) }
+        gateway.stub(:ssh).and_yield(ssh)
 
         entries << nil
 
         subject.stream(locations)
       end
+
+      context "when streaming fails" do
+        it "retries" do
+          called = 0
+          subject.stub(:stream_location) do
+            called += 1
+            raise "boom" if called == 1
+          end
+
+          entries << nil
+
+          subject.stream("1.2.3.4" => [])
+
+          expect(called).to eq(2)
+        end
+      end
     end
   end
 end

data/spec/tunnel/stream_location_spec.rb

@@ -23,15 +23,15 @@ describe CFTools::Tunnel::StreamLocation do
   end
 
   describe "#stream_lines" do
-    let(:ssh) { stub }
+    let(:ssh) { double }
 
     it "tails the file under /var/vcap/sys/log" do
-      mock(ssh).exec("tail -f /var/vcap/sys/log/#{path}")
+      expect(ssh).to receive(:exec).with("tail -f /var/vcap/sys/log/#{path}")
       subject.stream_lines(ssh)
     end
 
     it "yields log entries as lines come through the channel" do
-      stub(ssh).exec { |_, blk| blk.call({}, :stdout, "foo\nbar\n") }
+      ssh.stub(:exec).and_yield({}, :stdout, "foo\nbar\n")
 
       lines = []
       subject.stream_lines(ssh) do |entry|
@@ -43,10 +43,7 @@ describe CFTools::Tunnel::StreamLocation do
 
     it "merges chunks that form a complete line" do
       channel = {}
-      stub(ssh).exec do |_, blk|
-        blk.call(channel, :stdout, "fo")
-        blk.call(channel, :stdout, "o\nbar\n")
-      end
+      ssh.stub(:exec).and_yield(channel, :stdout, "fo").and_yield(channel, :stdout, "o\nbar\n")
 
       lines = []
       subject.stream_lines(ssh) do |entry|

data/spec/tunnel/tunnel-nats_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 module CFTools::Tunnel
   describe TunnelNATS do
-    let(:director) { mock }
+    let(:director) { double :director, :director_uri => "http://example.com" }
 
     let(:deployments) do
       [{ "name" => "some-deployment",  "releases" => [{ "name" => "cf-release" }] }]
@@ -26,55 +26,46 @@ MANIFEST
 
     let(:tunneled_port) { 65535 }
 
-    let(:initial_client) { stub }
+    let(:initial_client) { double }
 
     before do
-      stub(initial_client).token { CFoundry::AuthToken.new("initial token") }
+      initial_client.stub(:token => CFoundry::AuthToken.new("initial token"))
 
-      any_instance_of(described_class) do |cli|
-        stub(cli).connected_director { director }
-        stub(cli).client { initial_client }
-        stub(cli).tunnel_to { tunneled_port }
-      end
+      described_class.any_instance.stub(:connected_director => director)
+      described_class.any_instance.stub(:client => initial_client)
+      described_class.any_instance.stub(:tunnel_to => tunneled_port)
 
-      any_instance_of(CFoundry::V2::Client) do |cf|
-        stub(cf).login { CFoundry::AuthToken.new(nil) }
-      end
+      CFoundry::V2::Client.any_instance.stub(:login => CFoundry::AuthToken.new(nil))
 
-      stub(director).list_deployments { deployments }
-      stub(director).get_deployment { { "manifest" => deployment } }
+      director.stub(:list_deployments => deployments)
+      director.stub(:get_deployment => { "manifest" => deployment })
     end
 
     it "connects to the given director" do
-      any_instance_of(described_class) do |cli|
-        mock(cli).connected_director(
-            "some-director.com", "someuser@somehost.com") do
-          director
-        end
-      end
+      expect_any_instance_of(described_class).to \
+        receive(:connected_director).with("some-director.com", "someuser@somehost.com").
+        and_return(director)
 
       cf %W[tunnel-nats some-director.com help --gateway someuser@somehost.com]
     end
 
     it "tunnels to the NATS server through the director" do
-      any_instance_of(described_class) do |cli|
-        mock(cli).tunnel_to("1.2.3.4", 5678, "someuser@somehost.com") do
-          tunneled_port
-        end
-      end
+      expect_any_instance_of(described_class).to \
+        receive(:tunnel_to).with("1.2.3.4", 5678, "someuser@somehost.com").
+        and_return(tunneled_port)
 
       cf %W[tunnel-nats some-director.com help --gateway someuser@somehost.com]
     end
 
     it "logs in as the admin user from the deployment" do
-      client = mock
-      stub(client).token { CFoundry::AuthToken.new("bar") }
+      client = double
+      client.stub(:token => CFoundry::AuthToken.new("bar"))
 
-      mock(CFoundry::V2::Client).new("https://api.cf.museum") do
+      expect(CFoundry::V2::Client).to receive(:new).with("https://api.cf.museum") do
         client
       end
 
-      mock(client).login("someadmin", "somepass") do
+      expect(client).to receive(:login).with("someadmin", "somepass") do
         CFoundry::AuthToken.new("foo")
       end
 
@@ -82,14 +73,20 @@ MANIFEST
     end
 
     it "invokes the given command with the NATS credentials" do
-      stub.proxy.instance_of(described_class).execute
-      mock.instance_of(described_class).execute(
+      cmd = described_class.new
+      described_class.stub(:new => cmd)
+
+      cmd.stub(:execute).and_call_original
+
+      expect(cmd).to receive(:execute).with(Mothership.commands[:tunnel_nats], anything, anything)
+
+      expect(cmd).to receive(:execute).with(
         Mothership.commands[:target],
         %w[
           some-arg --flag some-val --user natsuser
           --password natspass --port 65535
         ],
-        is_a(Mothership::Inputs))
+        anything)
 
       cf %W[tunnel-nats some-director.com target some-arg --flag some-val]
     end

data/spec/tunnel/watch-logs_spec.rb

@@ -6,7 +6,7 @@ module CFTools::Tunnel
 
     let(:director) { Bosh::Cli::Director.new(director_uri) }
 
-    let(:stream) { stub }
+    let(:stream) { double }
 
     let(:vms) do
       [ { "ips" => ["1.2.3.4"], "job_name" => "cloud_controller", "index" => 0 },
@@ -32,29 +32,29 @@ module CFTools::Tunnel
     end
 
     before do
-      stub(director).list_deployments { deployments }
-      stub(director).fetch_vm_state { vms }
-      stub_cli.connected_director { director }
+      director.stub(:list_deployments => deployments)
+      director.stub(:fetch_vm_state => vms)
+      described_class.any_instance.stub(:connected_director => director)
 
-      stub(stream).stream
-      stub_cli.stream_for { stream }
+      stream.stub(:stream)
+      described_class.any_instance.stub(:stream_for => stream)
     end
 
     it "connects to the given director" do
-      mock_cli.connected_director(
-          "some-director.com", "someuser@somehost.com") do
-        director
-      end
+      expect_any_instance_of(described_class).to \
+        receive(:connected_director).with(
+          "some-director.com", "someuser@somehost.com").
+        and_return(director)
 
       cf %W[watch-logs some-director.com --gateway someuser@somehost.com]
     end
 
     context "when no gateway user/host is specified" do
       it "defaults to vcap@director" do
-        mock_cli.connected_director(
-            "some-director.com", "vcap@some-director.com") do
-          director
-        end
+        expect_any_instance_of(described_class).to \
+          receive(:connected_director).with(
+            "some-director.com", "vcap@some-director.com").
+            and_return(director)
 
         cf %W[watch-logs some-director.com]
       end
@@ -71,11 +71,10 @@ module CFTools::Tunnel
 
     context "when there are jobs to log" do
       it "streams their locations" do
-        mock(stream).stream(anything) do |locations, blk|
-          expect(locations).to include(["cloud_controller", 0])
-          expect(locations).to include(["dea_next", 0])
-          expect(locations).to include(["dea_next", 1])
-        end
+        expect(stream).to receive(:stream).with(hash_including(
+          ["cloud_controller", 0] => anything,
+          ["dea_next", 0] => anything,
+          ["dea_next", 1] => anything))
 
         cf %W[watch-logs some-director.com]
       end
@@ -100,11 +99,7 @@ module CFTools::Tunnel
           %Q[{"message":"c","timestamp":#{entry3_time.to_f},"log_level":"error"}],
           :stdout)
 
-        mock(stream).stream(anything) do |locations, blk|
-          blk.call(entry1)
-          blk.call(entry2)
-          blk.call(entry3)
-        end
+        expect(stream).to receive(:stream).and_yield(entry1).and_yield(entry2).and_yield(entry3)
 
         cf %W[watch-logs some-director.com]
 
@@ -112,6 +107,13 @@ module CFTools::Tunnel
         expect(output).to say("dea_next/1           01:02:04 AM  warn    b\n")
         expect(output).to say("dea_next/0           01:02:05 AM  error   c\n")
       end
+
+      context "and components were specified" do
+        it "streams their locations" do
+          expect(stream).to receive(:stream).with(["cloud_controller", 0] => anything)
+          cf %W[watch-logs some-director.com cloud_controller]
+        end
+      end
     end
   end
 end