koala 1.8.0 → 1.9.0

data/spec/cases/uploadable_io_spec.rb

@@ -16,7 +16,7 @@ describe "Koala::UploadableIO" do
       :tempfile => tempfile,
       :original_filename => "bar"
     )
-    tempfile.stub(:respond_to?).with(:path).and_return(true)
+    allow(tempfile).to receive(:respond_to?).with(:path).and_return(true)
 
     [tempfile, uploaded_file]
   end
@@ -39,15 +39,15 @@ describe "Koala::UploadableIO" do
         end
 
         it "returns an UploadIO with the same file path" do
-          Koala::UploadableIO.new(*@koala_io_params).io_or_path.should == @path
+          expect(Koala::UploadableIO.new(*@koala_io_params).io_or_path).to eq(@path)
         end
 
         it "returns an UploadIO with the same content type" do
-          Koala::UploadableIO.new(*@koala_io_params).content_type.should == @stub_type
+          expect(Koala::UploadableIO.new(*@koala_io_params).content_type).to eq(@stub_type)
         end
 
         it "returns an UploadIO with the file's name" do
-          Koala::UploadableIO.new(*@koala_io_params).filename.should == File.basename(@path)
+          expect(Koala::UploadableIO.new(*@koala_io_params).filename).to eq(File.basename(@path))
         end
       end
 
@@ -68,16 +68,16 @@ describe "Koala::UploadableIO" do
         end
 
         it "returns an UploadIO with the same io" do
-          Koala::UploadableIO.new(*@koala_io_params).io_or_path.should == @koala_io_params[0]
+          expect(Koala::UploadableIO.new(*@koala_io_params).io_or_path).to eq(@koala_io_params[0])
         end
 
         it "returns an UploadableIO with the same content_type" do
           content_stub = @koala_io_params[1] = double('Content Type')
-          Koala::UploadableIO.new(*@koala_io_params).content_type.should == content_stub
+          expect(Koala::UploadableIO.new(*@koala_io_params).content_type).to eq(content_stub)
         end
 
         it "returns an UploadableIO with the right filename" do
-          Koala::UploadableIO.new(*@koala_io_params).filename.should == File.basename(@file.path)
+          expect(Koala::UploadableIO.new(*@koala_io_params).filename).to eq(File.basename(@file.path))
         end
       end
 
@@ -100,16 +100,16 @@ describe "Koala::UploadableIO" do
 
         it "returns an UploadIO with the same io" do
           #Problem comparing Tempfile in Ruby 1.8, REE and Rubinius mode 1.8
-          Koala::UploadableIO.new(*@koala_io_params).io_or_path.path.should == @koala_io_params[0].path
+          expect(Koala::UploadableIO.new(*@koala_io_params).io_or_path.path).to eq(@koala_io_params[0].path)
         end
 
         it "returns an UploadableIO with the same content_type" do
           content_stub = @koala_io_params[1] = double('Content Type')
-          Koala::UploadableIO.new(*@koala_io_params).content_type.should == content_stub
+          expect(Koala::UploadableIO.new(*@koala_io_params).content_type).to eq(content_stub)
         end
 
         it "returns an UploadableIO with the right filename" do
-          Koala::UploadableIO.new(*@koala_io_params).filename.should == File.basename(@file.path)
+          expect(Koala::UploadableIO.new(*@koala_io_params).filename).to eq(File.basename(@file.path))
         end
       end
 
@@ -130,18 +130,18 @@ describe "Koala::UploadableIO" do
         end
 
         it "returns an UploadableIO with the same io" do
-          Koala::UploadableIO.new(*@koala_io_params).io_or_path.should == @koala_io_params[0]
+          expect(Koala::UploadableIO.new(*@koala_io_params).io_or_path).to eq(@koala_io_params[0])
         end
 
         it "returns an UploadableIO with the same content_type" do
           content_stub = @koala_io_params[1] = double('Content Type')
-          Koala::UploadableIO.new(*@koala_io_params).content_type.should == content_stub
+          expect(Koala::UploadableIO.new(*@koala_io_params).content_type).to eq(content_stub)
         end
       end
 
       describe "and no content type" do
         it "raises an exception" do
-          lambda { Koala::UploadableIO.new(*@koala_io_params) }.should raise_exception(Koala::KoalaError)
+          expect { Koala::UploadableIO.new(*@koala_io_params) }.to raise_exception(Koala::KoalaError)
         end
       end
     end
@@ -153,18 +153,18 @@ describe "Koala::UploadableIO" do
 
       it "gets the path from the tempfile associated with the UploadedFile" do
         expected_path = double('Tempfile')
-        @tempfile.should_receive(:path).and_return(expected_path)
-        Koala::UploadableIO.new(@uploaded_file).io_or_path.should == expected_path
+        expect(@tempfile).to receive(:path).and_return(expected_path)
+        expect(Koala::UploadableIO.new(@uploaded_file).io_or_path).to eq(expected_path)
       end
 
       it "gets the content type via the content_type method" do
         expected_content_type = double('Content Type')
-        @uploaded_file.should_receive(:content_type).and_return(expected_content_type)
-        Koala::UploadableIO.new(@uploaded_file).content_type.should == expected_content_type
+        expect(@uploaded_file).to receive(:content_type).and_return(expected_content_type)
+        expect(Koala::UploadableIO.new(@uploaded_file).content_type).to eq(expected_content_type)
       end
 
       it "gets the filename from the UploadedFile" do
-        Koala::UploadableIO.new(@uploaded_file).filename.should == @uploaded_file.original_filename
+        expect(Koala::UploadableIO.new(@uploaded_file).filename).to eq(@uploaded_file.original_filename)
       end
     end
 
@@ -178,7 +178,7 @@ describe "Koala::UploadableIO" do
         @file_hash[:tempfile] = expected_file
 
         uploadable = Koala::UploadableIO.new(@file_hash)
-        uploadable.io_or_path.should == expected_file
+        expect(uploadable.io_or_path).to eq(expected_file)
       end
 
       it "gets the content type from the :type key" do
@@ -186,12 +186,12 @@ describe "Koala::UploadableIO" do
         @file_hash[:type] = expected_content_type
 
         uploadable = Koala::UploadableIO.new(@file_hash)
-        uploadable.content_type.should == expected_content_type
+        expect(uploadable.content_type).to eq(expected_content_type)
       end
 
       it "gets the content type from the :type key" do
         uploadable = Koala::UploadableIO.new(@file_hash)
-        uploadable.filename.should == @file_hash[:filename]
+        expect(uploadable.filename).to eq(@file_hash[:filename])
       end
     end
 
@@ -199,12 +199,12 @@ describe "Koala::UploadableIO" do
       # what that means is tested below
       it "should accept a file object alone" do
         params = [BEACH_BALL_PATH]
-        lambda { Koala::UploadableIO.new(*params) }.should_not raise_exception
+        expect { Koala::UploadableIO.new(*params) }.not_to raise_exception
       end
 
       it "should accept a file path alone" do
         params = [BEACH_BALL_PATH]
-        lambda { Koala::UploadableIO.new(*params) }.should_not raise_exception
+        expect { Koala::UploadableIO.new(*params) }.not_to raise_exception
       end
     end
   end
@@ -212,20 +212,20 @@ describe "Koala::UploadableIO" do
   describe "getting an UploadableIO" do
     before(:each) do
       @upload_io = double("UploadIO")
-      UploadIO.stub(:new).with(anything, anything, anything).and_return(@upload_io)
+      allow(UploadIO).to receive(:new).with(anything, anything, anything).and_return(@upload_io)
     end
 
     context "if no filename was provided" do
       it "should call the constructor with the content type, file name, and a dummy file name" do
-        UploadIO.should_receive(:new).with(BEACH_BALL_PATH, "content/type", anything).and_return(@upload_io)
-        Koala::UploadableIO.new(BEACH_BALL_PATH, "content/type").to_upload_io.should == @upload_io
+        expect(UploadIO).to receive(:new).with(BEACH_BALL_PATH, "content/type", anything).and_return(@upload_io)
+        expect(Koala::UploadableIO.new(BEACH_BALL_PATH, "content/type").to_upload_io).to eq(@upload_io)
       end
     end
 
     context "if a filename was provided" do
       it "should call the constructor with the content type, file name, and the filename" do
         filename = "file"
-        UploadIO.should_receive(:new).with(BEACH_BALL_PATH, "content/type", filename).and_return(@upload_io)
+        expect(UploadIO).to receive(:new).with(BEACH_BALL_PATH, "content/type", filename).and_return(@upload_io)
         Koala::UploadableIO.new(BEACH_BALL_PATH, "content/type", filename).to_upload_io
       end
     end
@@ -234,33 +234,33 @@ describe "Koala::UploadableIO" do
   describe "getting a file" do
     it "returns the File if initialized with a file" do
       f = File.new(BEACH_BALL_PATH)
-      Koala::UploadableIO.new(f).to_file.should == f
+      expect(Koala::UploadableIO.new(f).to_file).to eq(f)
     end
 
     it "should open up and return a file corresponding to the path if io_or_path is a path" do
       result = double("File")
-      File.should_receive(:open).with(BEACH_BALL_PATH).and_return(result)
-      Koala::UploadableIO.new(BEACH_BALL_PATH).to_file.should == result
+      expect(File).to receive(:open).with(BEACH_BALL_PATH).and_return(result)
+      expect(Koala::UploadableIO.new(BEACH_BALL_PATH).to_file).to eq(result)
     end
   end
 
   describe ".binary_content?" do
     it "returns true for Rails 3 file uploads" do
-      Koala::UploadableIO.binary_content?(rails_3_mocks.last).should be_true
+      expect(Koala::UploadableIO.binary_content?(rails_3_mocks.last)).to be_truthy
     end
 
     it "returns true for Sinatra file uploads" do
-      Koala::UploadableIO.binary_content?(rails_3_mocks.last).should be_true
+      expect(Koala::UploadableIO.binary_content?(rails_3_mocks.last)).to be_truthy
     end
 
     it "returns true for File objects" do
-      Koala::UploadableIO.binary_content?(File.open(BEACH_BALL_PATH)).should be_true
+      expect(Koala::UploadableIO.binary_content?(File.open(BEACH_BALL_PATH))).to be_truthy
     end
 
     it "returns false for everything else" do
-      Koala::UploadableIO.binary_content?(StringIO.new).should be_false
-      Koala::UploadableIO.binary_content?(BEACH_BALL_PATH).should be_false
-      Koala::UploadableIO.binary_content?(nil).should be_false
+      expect(Koala::UploadableIO.binary_content?(StringIO.new)).to be_falsey
+      expect(Koala::UploadableIO.binary_content?(BEACH_BALL_PATH)).to be_falsey
+      expect(Koala::UploadableIO.binary_content?(nil)).to be_falsey
     end
   end
 end  # describe UploadableIO

data/spec/cases/utils_spec.rb

@@ -4,29 +4,29 @@ describe Koala::Utils do
   describe ".deprecate" do    
     before :each do
       # unstub deprecate so we can test it
-      Koala::Utils.unstub(:deprecate)
+       allow(Koala::Utils).to receive(:deprecate).and_call_original
     end
     
     it "has a deprecation prefix that includes the words Koala and deprecation" do
-      Koala::Utils::DEPRECATION_PREFIX.should =~ /koala/i
-      Koala::Utils::DEPRECATION_PREFIX.should =~ /deprecation/i      
+      expect(Koala::Utils::DEPRECATION_PREFIX).to match(/koala/i)
+      expect(Koala::Utils::DEPRECATION_PREFIX).to match(/deprecation/i)      
     end
     
     it "prints a warning with Kernel.warn" do
       message = Time.now.to_s + rand.to_s
-      Kernel.should_receive(:warn)
+      expect(Kernel).to receive(:warn)
       Koala::Utils.deprecate(message)
     end
 
     it "prints the deprecation prefix and the warning" do
       message = Time.now.to_s + rand.to_s
-      Kernel.should_receive(:warn).with(Koala::Utils::DEPRECATION_PREFIX + message)
+      expect(Kernel).to receive(:warn).with(Koala::Utils::DEPRECATION_PREFIX + message)
       Koala::Utils.deprecate(message)
     end
     
     it "only prints each unique message once" do
       message = Time.now.to_s + rand.to_s
-      Kernel.should_receive(:warn).once
+      expect(Kernel).to receive(:warn).once
       Koala::Utils.deprecate(message)
       Koala::Utils.deprecate(message)
     end
@@ -34,20 +34,20 @@ describe Koala::Utils do
   
   describe ".logger" do
     it "has an accessor for logger" do
-      Koala::Utils.methods.map(&:to_sym).should include(:logger)
-      Koala::Utils.methods.map(&:to_sym).should include(:logger=)
+      expect(Koala::Utils.methods.map(&:to_sym)).to include(:logger)
+      expect(Koala::Utils.methods.map(&:to_sym)).to include(:logger=)
     end
     
     it "defaults to the standard ruby logger with level set to ERROR" do |variable|
-      Koala::Utils.logger.should be_kind_of(Logger)
-      Koala::Utils.logger.level.should == Logger::ERROR
+      expect(Koala::Utils.logger).to be_kind_of(Logger)
+      expect(Koala::Utils.logger.level).to eq(Logger::ERROR)
     end
     
     logger_methods = [:debug, :info, :warn, :error, :fatal]
     
     logger_methods.each do |logger_method|
       it "should delegate #{logger_method} to the attached logger" do
-        Koala::Utils.logger.should_receive(logger_method)
+        expect(Koala::Utils.logger).to receive(logger_method)
         Koala::Utils.send(logger_method, "Test #{logger_method} message")
       end
     end

data/spec/spec_helper.rb

@@ -1,22 +1,3 @@
-if RUBY_VERSION == '1.9.2' && RUBY_PATCHLEVEL < 290 && RUBY_ENGINE != "macruby"
-  # In Ruby 1.9.2 versions before patchlevel 290, the default Psych
-  # parser has an issue with YAML merge keys, which
-  # fixtures/mock_facebook_responses.yml relies heavily on.
-  #
-  # Anyone using an earlier version will see missing mock response
-  # errors when running the test suite similar to this:
-  #
-  # RuntimeError:
-  #   Missing a mock response for graph_api: /me/videos: source=[FILE]: post: with_token
-  #   API PATH: /me/videos?source=[FILE]&format=json&access_token=*
-  #
-  # For now, it seems the best fix is to just downgrade to the old syck YAML parser
-  # for these troubled versions.
-  #
-  # See https://github.com/tenderlove/psych/issues/8 for more details
-  YAML::ENGINE.yamler = 'syck'
-end
-
 # load the library
 require 'koala'
 

data/spec/support/custom_matchers.rb

@@ -7,14 +7,14 @@ RSpec::Matchers.define :match_url do |url|
     original_query_hash = query_to_params(original_query_string)
 
     # the base URLs need to match
-    base.should == original_base
+    expect(base).to eq(original_base)
     
     # the number of parameters should match (avoid one being a subset of the other)
-    query_hash.values.length.should == original_query_hash.values.length
+    expect(query_hash.values.length).to eq(original_query_hash.values.length)
     
     # and ensure all the keys and values match
     query_hash.each_pair do |key, value|
-      original_query_hash[key].should == value
+      expect(original_query_hash[key]).to eq(value)
     end
   end