beaker 4.38.1 → 5.0.0

data/spec/beaker/dsl/helpers/web_helpers_spec.rb

@@ -9,101 +9,95 @@ class ClassMixedWithDSLHelpers
   def logger
     RSpec::Mocks::Double.new('logger').as_null_object
   end
-
 end
 
 describe ClassMixedWithDSLHelpers do
-  let( :logger  ) { double("Beaker::Logger", :notify => nil , :debug => nil ) }
-  let( :url     ) { "http://beaker.tool" }
-  let( :name    ) { "name" }
-  let( :destdir ) { "destdir" }
+  let(:logger) { double("Beaker::Logger", :notify => nil, :debug => nil) }
+  let(:url) { "http://example.com" }
+  let(:name) { "name" }
+  let(:destdir) { "destdir" }
 
   def fetch_allows
-    allow( subject ).to receive( :logger )  { logger }
-    allow( subject ).to receive( :options ) { options }
+    allow(subject).to receive(:logger)  { logger }
+    allow(subject).to receive(:options) { options }
   end
 
   describe "#fetch_http_file" do
-    let( :presets ) { Beaker::Options::Presets.new }
-    let( :options ) { presets.presets.merge(presets.env_vars) }
+    let(:presets) { Beaker::Options::Presets.new }
+    let(:options) { presets.presets.merge(presets.env_vars) }
 
     before do
       fetch_allows
     end
 
     describe "given valid arguments" do
-
       it "returns its second and third arguments concatenated." do
         concat_path = "#{destdir}/#{name}"
         create_files([concat_path])
         allow(logger).to receive(:notify)
-        allow(subject).to receive(:open)
+        allow(URI).to receive(:open).with("#{url}/#{name}").and_return(status: 200)
         result = subject.fetch_http_file url, name, destdir
         expect(result).to eq(concat_path)
       end
 
       it 'doesn\'t cache by default' do
-        expect( logger ).to receive( :notify ).with( /^Fetching/ ).ordered
-        expect( logger ).to receive( :notify ).with( /^\ \ and\ saving\ to\ / ).ordered
-        expect( subject ).to receive( :open )
+        expect(logger).to receive(:notify).with(/^Fetching/).ordered
+        expect(logger).to receive(:notify).with(/^\ \ and\ saving\ to\ /).ordered
+        allow(URI).to receive(:open).with("#{url}/#{name}").and_return(status: 200)
+        expect(URI).to receive(:open)
 
-        subject.fetch_http_file( url, name, destdir )
+        subject.fetch_http_file(url, name, destdir)
       end
 
       context ':cache_files_locally option is set' do
         it 'caches if the file exists locally' do
           options[:cache_files_locally] = true
-          allow(File).to receive(:exists?).and_return(true)
+          allow(File).to receive(:exist?).and_return(true)
 
-          expect( logger ).to receive( :notify ).with( /^Already\ fetched\ / )
-          expect( subject ).not_to receive( :open )
+          expect(logger).to receive(:notify).with(/^Already\ fetched\ /)
+          expect(subject).not_to receive(:open)
 
-          subject.fetch_http_file( url, name, destdir )
+          subject.fetch_http_file(url, name, destdir)
         end
 
         it 'doesn\'t cache if the file doesn\'t exist locally' do
           options[:cache_files_locally] = true
-          allow(File).to receive(:exists?).and_return(false)
+          allow(File).to receive(:exist?).and_return(false)
 
-          expect( logger ).to receive( :notify ).with( /^Fetching/ ).ordered
-          expect( logger ).to receive( :notify ).with( /^\ \ and\ saving\ to\ / ).ordered
-          expect( subject ).to receive( :open )
+          expect(logger).to receive(:notify).with(/^Fetching/).ordered
+          expect(logger).to receive(:notify).with(/^\ \ and\ saving\ to\ /).ordered
+          allow(URI).to receive(:open).with("#{url}/#{name}").and_return(status: 200)
+          expect(URI).to receive(:open)
 
-          subject.fetch_http_file( url, name, destdir )
+          subject.fetch_http_file(url, name, destdir)
         end
       end
-
     end
 
     describe 'given invalid arguments' do
-
       it 'chomps correctly when given a URL ending with a / character' do
-        expect( subject ).to receive( :open ).with( "#{url}/#{name}", anything )
-        subject.fetch_http_file( url, name, destdir )
+        allow(URI).to receive(:open).with("#{url}/#{name}").and_return(status: 200)
+        expect(URI).to receive(:open).with("#{url}/#{name}")
+        subject.fetch_http_file("#{url}/", name, destdir)
       end
-
     end
-
   end
 
   describe "#fetch_http_dir" do
-    let( :logger) { double("Beaker::Logger", :notify => nil , :debug => nil ) }
-    let( :result) { double(:each_line => []) }
-    let( :status) { double('Process::Status', success?: true) }
+    let(:logger) { double("Beaker::Logger", :notify => nil, :debug => nil) }
+    let(:result) { double(:each_line => []) }
+    let(:status) { double('Process::Status', success?: true) }
 
     before do
       fetch_allows
     end
 
     describe "given valid arguments" do
-
       it "returns basename of first argument concatenated to second." do
         expect(Open3).to receive(:capture2e).with(/^wget.*/).ordered { result }.and_return(['', status])
         result = subject.fetch_http_dir "#{url}/beep", destdir
         expect(result).to eq("#{destdir}/beep")
       end
-
     end
-
   end
 end

data/spec/beaker/dsl/outcomes_spec.rb

@@ -6,38 +6,39 @@ end
 
 describe ClassMixedWithDSLOutcomes do
   let(:logger) { double }
-  before { allow( subject ).to receive( :logger ).and_return( logger ) }
+
+  before { allow(subject).to receive(:logger).and_return(logger) }
 
   describe '#pass_test' do
     it "logs the notification passed to it and raises PassTest" do
-      expect( logger ).to receive( :notify ).with( /blah/ )
-      expect { subject.pass_test('blah') }.
-        to raise_error Beaker::DSL::Outcomes::PassTest
+      expect(logger).to receive(:notify).with(/blah/)
+      expect { subject.pass_test('blah') }
+        .to raise_error Beaker::DSL::Outcomes::PassTest
     end
   end
 
   describe '#skip_test' do
     it "logs the notification passed to it and raises SkipTest" do
-      expect( logger ).to receive( :notify ).with( /blah/ )
-      expect { subject.skip_test('blah') }.
-        to raise_error Beaker::DSL::Outcomes::SkipTest
+      expect(logger).to receive(:notify).with(/blah/)
+      expect { subject.skip_test('blah') }
+        .to raise_error Beaker::DSL::Outcomes::SkipTest
     end
   end
 
   describe '#pending_test' do
     it "logs the notification passed to it and raises PendingTest" do
-      expect( logger ).to receive( :warn ).with( /blah/ )
-      expect { subject.pending_test('blah') }.
-        to raise_error Beaker::DSL::Outcomes::PendingTest
+      expect(logger).to receive(:warn).with(/blah/)
+      expect { subject.pending_test('blah') }
+        .to raise_error Beaker::DSL::Outcomes::PendingTest
     end
   end
 
   describe '#fail_test' do
     it "logs the notification passed to it and raises FailTest" do
-      expect( logger ).to receive( :warn )
-      expect( logger ).to receive( :pretty_backtrace )
-      expect { subject.fail_test('blah') }.
-        to raise_error Beaker::DSL::Outcomes::FailTest
+      expect(logger).to receive(:warn)
+      expect(logger).to receive(:pretty_backtrace)
+      expect { subject.fail_test('blah') }
+        .to raise_error Beaker::DSL::Outcomes::FailTest
     end
   end
 end