lame 0.0.3 → 0.0.4

data/spec/decoding/stream_decoder_spec.rb

@@ -6,32 +6,32 @@ module LAME
 
       subject(:decoder) { StreamDecoder.new(decode_flags, mp3_data, stream) }
 
-      let(:decode_flags) { stub("decode flags") }
-      let(:mp3_data) { stub("mp3 data") }
+      let(:decode_flags) { double("decode flags") }
+      let(:mp3_data) { double("mp3 data") }
 
       let(:stream) { StringIO.new(stream_string) }
       let(:stream_string) { "a" * 1024 + "b" * 1024}
 
       it "creates a single frame decoder" do
-        SingleFrameDecoder.should_receive(:new).with(decode_flags, mp3_data)
+        expect(SingleFrameDecoder).to receive(:new).with(decode_flags, mp3_data)
         decoder
       end
 
       it "it passes chunks of stream into the single frame decoder" do
-        single_frame_decoder = stub
-        SingleFrameDecoder.stub(:new).and_return(single_frame_decoder)
+        single_frame_decoder = double("single_frame_decoder")
+        allow(SingleFrameDecoder).to receive(:new).and_return(single_frame_decoder)
 
-        single_frame_decoder.should_receive(:decode).exactly(:twice)
+        expect(single_frame_decoder).to receive(:decode).exactly(:twice)
 
         decoder.each_decoded_frame
       end
 
       it "yields the decoded frame" do
-        single_frame_decoder = stub
-        SingleFrameDecoder.stub(:new).and_return(single_frame_decoder)
+        single_frame_decoder = double("single frame decoder")
+        allow(SingleFrameDecoder).to receive(:new).and_return(single_frame_decoder)
 
-        single_frame_decoder.stub(:decode).with("a"*1024).and_yield(:one)
-        single_frame_decoder.stub(:decode).with("b"*1024).and_yield(:two).and_yield(:three)
+        allow(single_frame_decoder).to receive(:decode).with("a"*1024).and_yield(:one)
+        allow(single_frame_decoder).to receive(:decode).with("b"*1024).and_yield(:two).and_yield(:three)
 
         expect { |block|
           decoder.each_decoded_frame(&block)

data/spec/delegation_spec.rb

@@ -14,7 +14,7 @@ module LAME
 
   describe Delegation do
 
-    let(:global_flags) { stub }
+    let(:global_flags) { double("global_flags") }
     subject { FakeEncoder.new }
 
     before do
@@ -23,71 +23,71 @@ module LAME
 
     context "#delegate_alias_to_lame" do
       it "delegates #foo= to LAME" do
-        LAME.should_receive(:lame_set_bar).with(global_flags, anything)
-        subject.foo = stub
+        expect(LAME).to receive(:lame_set_bar).with(global_flags, anything)
+        subject.foo = double("delegate")
       end
 
       it "delegates #foo to LAME" do
-        LAME.should_receive(:lame_get_bar).with(global_flags)
+        expect(LAME).to receive(:lame_get_bar).with(global_flags)
         subject.foo
       end
 
       it "delegates #foo? to LAME" do
-        LAME.should_receive(:lame_get_bar).with(global_flags)
+        expect(LAME).to receive(:lame_get_bar).with(global_flags)
         subject.foo?
       end
     end
 
     context "#delegate_to_lame" do
       it "delegates #baz= to LAME" do
-        LAME.should_receive(:lame_set_baz).with(global_flags, anything)
-        subject.baz = stub
+        expect(LAME).to receive(:lame_set_baz).with(global_flags, anything)
+        subject.baz = double("delegate")
       end
 
       it "delegates #baz to LAME" do
-        LAME.should_receive(:lame_get_baz).with(global_flags)
+        expect(LAME).to receive(:lame_get_baz).with(global_flags)
         subject.baz
       end
 
       it "delegates #baz? to LAME" do
-        LAME.should_receive(:lame_get_baz).with(global_flags)
+        expect(LAME).to receive(:lame_get_baz).with(global_flags)
         subject.baz?
       end
     end
 
     context "#delegate_id3_to_lame" do
       it "delegates #qux= to LAME" do
-        LAME.should_receive(:id3tag_set_qux).with(global_flags, anything)
-        subject.qux = stub
+        expect(LAME).to receive(:id3tag_set_qux).with(global_flags, anything)
+        subject.qux = double("delegate")
       end
     end
 
     context "type conversion" do
       it "converts the input type" do
-        value = stub
-        Delegation::TypeConvertor.should_receive(:convert).with(value)
-        LAME.stub(:lame_set_baz)
+        value = double("value")
+        expect(Delegation::TypeConvertor).to receive(:convert).with(value)
+        allow(LAME).to receive(:lame_set_baz)
         subject.baz = value
       end
 
       it "passes on converted value to setter" do
-        value = stub
-        converted_value = stub
-        Delegation::TypeConvertor.stub(:convert).and_return(converted_value)
-        LAME.should_receive(:lame_set_baz).with(global_flags, converted_value)
+        value = double("value")
+        converted_value = double("converted_value")
+        allow(Delegation::TypeConvertor).to receive(:convert).and_return(converted_value)
+        expect(LAME).to receive(:lame_set_baz).with(global_flags, converted_value)
         subject.baz = value
       end
 
       it "converts question mark style getters to return booleans" do
-        LAME.stub(:lame_get_baz).and_return(0)
-        Delegation::TypeConvertor.should_receive(:convert_return).with(0)
+        allow(LAME).to receive(:lame_get_baz).and_return(0)
+        expect(Delegation::TypeConvertor).to receive(:convert_return).with(0)
         subject.baz?
       end
 
       it "converts question mark style getters to return booleans" do
-        LAME.stub(:lame_get_baz)
-        Delegation::TypeConvertor.stub(:convert_return).and_return(false)
-        subject.baz?.should eql false
+        allow(LAME).to receive(:lame_get_baz)
+        allow(Delegation::TypeConvertor).to receive(:convert_return).and_return(false)
+        expect(subject.baz?).to be_falsy
       end
     end
 
@@ -99,45 +99,45 @@ module LAME
 
     describe "#convert" do
       it "converts true to 1" do
-        converter.convert(true).should eql 1
+        expect(converter.convert(true)).to eql 1
       end
 
       it "converts false to 0" do
-        converter.convert(false).should eql 0
+        expect(converter.convert(false)).to eql 0
       end
 
       it "converts a string to a pointer with correct value" do
         input = "some string"
         value = converter.convert(input)
-        value.should be_a(::FFI::MemoryPointer)
-        value.get_string(0).should eql input
+        expect(value).to be_a(::FFI::MemoryPointer)
+        expect(value.get_string(0)).to eql input
       end
 
       it "does not convert other values" do
-        converter.convert(:foo).should eql :foo
-        converter.convert(1.2).should eql 1.2
+        expect(converter.convert(:foo)).to eql :foo
+        expect(converter.convert(1.2)).to eql 1.2
       end
     end
 
     describe "#convert_return" do
       it "converts 1 to true" do
-        converter.convert_return(1).should eql true
+        expect(converter.convert_return(1)).to eql true
       end
 
       it "converts 0 to false" do
-        converter.convert_return(0).should eql false
+        expect(converter.convert_return(0)).to eql false
       end
 
       it "converts 0.0 to false" do
-        converter.convert_return(0.0).should eql false
+        expect(converter.convert_return(0.0)).to eql false
       end
 
       it "returns truthy to true" do
-        converter.convert_return(:truthy).should eql true
-        converter.convert_return("truthy").should eql true
-        converter.convert_return(Object).should eql true
-        converter.convert_return(Object.new).should eql true
-        converter.convert_return(4.2).should eql true
+        expect(converter.convert_return(:truthy)).to eql true
+        expect(converter.convert_return("truthy")).to eql true
+        expect(converter.convert_return(Object)).to eql true
+        expect(converter.convert_return(Object.new)).to eql true
+        expect(converter.convert_return(4.2)).to eql true
       end
     end
 

data/spec/encoder_spec.rb

@@ -8,7 +8,7 @@ module LAME
     context "initialization" do
 
       it "initializes GlobalFlags" do
-        FFI::GlobalFlags.should_receive(:new)
+        expect(FFI::GlobalFlags).to receive(:new)
         Encoder.new
       end
 
@@ -16,14 +16,14 @@ module LAME
 
     context "configuration" do
 
-      let(:configuration) { stub(Configuration).as_null_object }
+      let(:configuration) { double(Configuration).as_null_object }
 
       before do
-        Configuration.stub(:new).and_return(configuration)
+        allow(Configuration).to receive(:new).and_return(configuration)
       end
 
       it "initializes a Configuration object" do
-        Configuration.should_receive(:new).with(kind_of(GlobalFlags))
+        expect(Configuration).to receive(:new).with(kind_of(GlobalFlags))
         encoder.configure { }
       end
 
@@ -35,18 +35,18 @@ module LAME
 
       it "assigns the Configuration object" do
         encoder.configure { }
-        encoder.configuration.should eql configuration
+        expect(encoder.configuration).to eql configuration
       end
 
       it "applies the configuration" do
-        configuration.stub(:applied?).and_return(false)
-        configuration.should_receive(:apply!)
+        allow(configuration).to receive(:applied?).and_return(false)
+        expect(configuration).to receive(:apply!)
         encoder.configure { }
       end
 
       it "gets the framesize" do
-        configuration.should_receive(:framesize).and_return(1234)
-        encoder.framesize.should eql 1234
+        expect(configuration).to receive(:framesize).and_return(1234)
+        expect(encoder.framesize).to eql 1234
       end
     end
 
@@ -57,54 +57,54 @@ module LAME
       let(:samples) { [0,0] }
 
       let(:global_flags) { subject.global_flags }
-      let(:configuration) { stub(Configuration, :framesize => 100) }
+      let(:configuration) { double(Configuration, :framesize => 100) }
 
       before do
-        Configuration.stub(:new).and_return(configuration)
-        configuration.stub(:applied?).and_return(true)
+        allow(Configuration).to receive(:new).and_return(configuration)
+        allow(configuration).to receive(:applied?).and_return(true)
       end
 
       describe "#encode_short" do
 
         before do
-          Encoding::ShortBufferEncoder.stub(:new).and_return(stub.as_null_object)
+          allow(Encoding::ShortBufferEncoder).to receive(:new).and_return(double.as_null_object)
         end
 
         it "applies the configuration if not done already" do
-          configuration.stub(:applied?).and_return(false)
-          configuration.should_receive(:apply!)
+          allow(configuration).to receive(:applied?).and_return(false)
+          expect(configuration).to receive(:apply!)
           encoder.encode_short(left, right) { }
         end
 
         it "does not apply the configuration if already applied" do
-          configuration.stub(:applied?).and_return(true)
-          configuration.should_not_receive(:apply!)
+          allow(configuration).to receive(:applied?).and_return(true)
+          expect(configuration).to_not receive(:apply!)
           encoder.encode_short(left, right) { }
         end
 
         context "delegation" do
-          let(:short_encoder) { stub.as_null_object }
+          let(:short_encoder) { double.as_null_object }
 
           before do
-            Encoding::ShortBufferEncoder.stub(:new).and_return(short_encoder)
+            allow(Encoding::ShortBufferEncoder).to receive(:new).and_return(short_encoder)
           end
 
           it "create a short encoder with configuration" do
-            Encoding::ShortBufferEncoder.should_receive(:new).with(configuration)
+            expect(Encoding::ShortBufferEncoder).to receive(:new).with(configuration)
 
             encoder.encode_short(left, right) { }
           end
 
           it "delegates encoding to the short encoder" do
-            left.stub(:length => 100) # exactly framesize
-            short_encoder.should_receive(:encode_frame).with(left, right)
+            allow(left).to receive_messages(:length => 100) # exactly framesize
+            expect(short_encoder).to receive(:encode_frame).with(left, right)
 
             encoder.encode_short(left, right) { }
           end
 
           it "yields the encoder results" do
-            mp3_data = stub
-            short_encoder.stub(:encode_frame).and_return(mp3_data)
+            mp3_data = double("mp3_data")
+            allow(short_encoder).to receive(:encode_frame).and_return(mp3_data)
 
             expect { |block|
               encoder.encode_short(left, right, &block)
@@ -114,26 +114,26 @@ module LAME
           it "delegates multiple times for large input" do
             right = left = [0]*150 # larger than framesize
 
-            short_encoder.should_receive(:encode_frame) do |left_frame, right_frame|
-              left_frame.length.should eql 100
-              right_frame.length.should eql 100
+            expect(short_encoder).to receive(:encode_frame) do |left_frame, right_frame|
+              expect(left_frame.length).to eql 100
+              expect(right_frame.length).to eql 100
             end
 
-            short_encoder.should_receive(:encode_frame) do |left_frame, right_frame|
-              left_frame.length.should eql 50
-              right_frame.length.should eql 50
+            expect(short_encoder).to receive(:encode_frame) do |left_frame, right_frame|
+              expect(left_frame.length).to eql 50
+              expect(right_frame.length).to eql 50
             end
 
             encoder.encode_short(left, right) { }
           end
 
           it "yields multiple times for large input" do
-            mp3_data1 = stub("frame1")
-            mp3_data2 = stub("frame2")
+            mp3_data1 = double("frame1")
+            mp3_data2 = double("frame2")
 
             left = [0]*150 # larger than framesize
 
-            short_encoder.stub(:encode_frame).and_return(mp3_data1, mp3_data2)
+            allow(short_encoder).to receive(:encode_frame).and_return(mp3_data1, mp3_data2)
 
             expect { |block|
               encoder.encode_short(left, right, &block)
@@ -144,8 +144,8 @@ module LAME
 
       describe "#encode_float" do
         it "create a float encoder" do
-          Encoding::FloatBufferEncoder.stub(:new).and_return(stub.as_null_object)
-          Encoding::FloatBufferEncoder.should_receive(:new).with(configuration)
+          allow(Encoding::FloatBufferEncoder).to receive(:new).and_return(double.as_null_object)
+          expect(Encoding::FloatBufferEncoder).to receive(:new).with(configuration)
 
           encoder.encode_float(left, right) { }
         end
@@ -153,8 +153,8 @@ module LAME
 
       describe "#encode_long" do
         it "create a long encoder" do
-          Encoding::LongBufferEncoder.stub(:new).and_return(stub.as_null_object)
-          Encoding::LongBufferEncoder.should_receive(:new).with(configuration)
+          allow(Encoding::LongBufferEncoder).to receive(:new).and_return(double.as_null_object)
+          expect(Encoding::LongBufferEncoder).to receive(:new).with(configuration)
 
           encoder.encode_long(left, right) { }
         end
@@ -163,44 +163,44 @@ module LAME
       describe "#encode_interleaved_short" do
 
         before do
-          Encoding::InterleavedShortBufferEncoder.stub(:new).and_return(stub.as_null_object)
+          allow(Encoding::InterleavedShortBufferEncoder).to receive(:new).and_return(double.as_null_object)
         end
 
         it "applies the configuration if not done already" do
-          configuration.stub(:applied?).and_return(false)
-          configuration.should_receive(:apply!)
+          allow(configuration).to receive(:applied?).and_return(false)
+          expect(configuration).to receive(:apply!)
           encoder.encode_interleaved_short(samples) { }
         end
 
         it "does not apply the configuration if already applied" do
-          configuration.stub(:applied?).and_return(true)
-          configuration.should_not_receive(:apply!)
+          allow(configuration).to receive(:applied?).and_return(true)
+          expect(configuration).to_not receive(:apply!)
           encoder.encode_interleaved_short(samples) { }
         end
 
         context "delegation" do
-          let(:interleaved_short_encoder) { stub.as_null_object }
+          let(:interleaved_short_encoder) { double.as_null_object }
 
           before do
-            Encoding::InterleavedShortBufferEncoder.stub(:new).and_return(interleaved_short_encoder)
+            allow(Encoding::InterleavedShortBufferEncoder).to receive(:new).and_return(interleaved_short_encoder)
           end
 
           it "create a short encoder with configuration" do
-            Encoding::InterleavedShortBufferEncoder.should_receive(:new).with(configuration)
+            expect(Encoding::InterleavedShortBufferEncoder).to receive(:new).with(configuration)
 
             encoder.encode_interleaved_short(samples) { }
           end
 
           it "delegates encoding to the short encoder" do
-            samples.stub(:length => 200) # exactly framesize
-            interleaved_short_encoder.should_receive(:encode_frame).with(samples)
+            allow(samples).to receive_messages(:length => 200) # exactly framesize
+            expect(interleaved_short_encoder).to receive(:encode_frame).with(samples)
 
             encoder.encode_interleaved_short(samples) { }
           end
 
           it "yields the encoder results" do
-            mp3_data = stub
-            interleaved_short_encoder.stub(:encode_frame).and_return(mp3_data)
+            mp3_data = double("mp3_data")
+            allow(interleaved_short_encoder).to receive(:encode_frame).and_return(mp3_data)
 
             expect { |block|
               encoder.encode_interleaved_short(samples, &block)
@@ -210,24 +210,24 @@ module LAME
           it "delegates multiple times for large input" do
             samples = [0]*300 # larger than framesize
 
-            interleaved_short_encoder.should_receive(:encode_frame) do |samples|
-              samples.length.should eql 200
+            expect(interleaved_short_encoder).to receive(:encode_frame) do |samples|
+              expect(samples.length).to eql 200
             end
 
-            interleaved_short_encoder.should_receive(:encode_frame) do |samples|
-              samples.length.should eql 100
+            expect(interleaved_short_encoder).to receive(:encode_frame) do |samples|
+              expect(samples.length).to eql 100
             end
 
             encoder.encode_interleaved_short(samples) { }
           end
 
           it "yields multiple times for large input" do
-            mp3_data1 = stub("frame1")
-            mp3_data2 = stub("frame2")
+            mp3_data1 = double("frame1")
+            mp3_data2 = double("frame2")
 
             samples = [0]*300 # larger than framesize
 
-            interleaved_short_encoder.stub(:encode_frame).and_return(mp3_data1, mp3_data2)
+            allow(interleaved_short_encoder).to receive(:encode_frame).and_return(mp3_data1, mp3_data2)
 
             expect { |block|
               encoder.encode_interleaved_short(samples, &block)
@@ -238,8 +238,8 @@ module LAME
 
       describe "#encode_interleaved_float" do
         it "create a float encoder" do
-          Encoding::InterleavedFloatBufferEncoder.stub(:new).and_return(stub.as_null_object)
-          Encoding::InterleavedFloatBufferEncoder.should_receive(:new).with(configuration)
+          allow(Encoding::InterleavedFloatBufferEncoder).to receive(:new).and_return(double.as_null_object)
+          expect(Encoding::InterleavedFloatBufferEncoder).to receive(:new).with(configuration)
 
           encoder.encode_interleaved_float(samples) { }
         end
@@ -250,28 +250,28 @@ module LAME
     context "flushing" do
 
       let(:global_flags) { subject.global_flags }
-      let(:configuration) { stub(Configuration) }
-      let(:flusher) { stub(Encoding::Flusher).as_null_object }
+      let(:configuration) { double(Configuration) }
+      let(:flusher) { double(Encoding::Flusher).as_null_object }
 
       before do
-        Configuration.stub(:new).and_return(configuration)
-        configuration.stub(:applied?).and_return(true)
-        Encoding::Flusher.stub(:new).and_return(flusher)
+        allow(Configuration).to receive(:new).and_return(configuration)
+        allow(configuration).to receive(:applied?).and_return(true)
+        allow(Encoding::Flusher).to receive(:new).and_return(flusher)
       end
 
       it "creates a flusher" do
-        Encoding::Flusher.should_receive(:new).with(configuration)
+        expect(Encoding::Flusher).to receive(:new).with(configuration)
         encoder.flush { }
       end
 
       it "flushes the final frame" do
-        flusher.should_receive(:flush)
+        expect(flusher).to receive(:flush)
         encoder.flush { }
       end
 
       it "yields the flushed mp3 data" do
-        mp3_data = stub
-        flusher.stub(:flush).and_return(mp3_data)
+        mp3_data = double("mp3_data")
+        allow(flusher).to receive(:flush).and_return(mp3_data)
 
         expect { |block|
           encoder.flush(&block)
@@ -279,9 +279,9 @@ module LAME
       end
 
       it "returns the flushed data if no block was given" do
-        mp3_data = stub
-        flusher.stub(:flush).and_return(mp3_data)
-        encoder.flush.should eql mp3_data
+        mp3_data = double("mp3_data")
+        allow(flusher).to receive(:flush).and_return(mp3_data)
+        expect(encoder.flush).to eql mp3_data
       end
 
     end
@@ -289,28 +289,28 @@ module LAME
     context "lametag frame" do
 
       let(:global_flags) { subject.global_flags }
-      let(:configuration) { stub(Configuration) }
-      let(:vbr_info) { stub(Encoding::VBRInfo).as_null_object }
+      let(:configuration) { double(Configuration) }
+      let(:vbr_info) { double(Encoding::VBRInfo).as_null_object }
 
       before do
-        Configuration.stub(:new).and_return(configuration)
-        configuration.stub(:applied?).and_return(true)
-        Encoding::VBRInfo.stub(:new).and_return(vbr_info)
+        allow(Configuration).to receive(:new).and_return(configuration)
+        allow(configuration).to receive(:applied?).and_return(true)
+        allow(Encoding::VBRInfo).to receive(:new).and_return(vbr_info)
       end
 
       it "creates vbr info" do
-        Encoding::VBRInfo.should_receive(:new).with(configuration)
+        expect(Encoding::VBRInfo).to receive(:new).with(configuration)
         encoder.vbr_frame { }
       end
 
       it "creates the vbr frame" do
-        vbr_info.should_receive(:frame)
+        expect(vbr_info).to receive(:frame)
         encoder.vbr_frame { }
       end
 
       it "yields the vbr frame" do
-        mp3_data = stub
-        vbr_info.stub(:frame).and_return(mp3_data)
+        mp3_data = double("mp3_data")
+        allow(vbr_info).to receive(:frame).and_return(mp3_data)
 
         expect { |block|
           encoder.vbr_frame(&block)
@@ -318,38 +318,38 @@ module LAME
       end
 
       it "returns the vbr frame if no block was given" do
-        mp3_data = stub
-        vbr_info.stub(:frame).and_return(mp3_data)
-        encoder.vbr_frame.should eql mp3_data
+        mp3_data = double("mp3_data")
+        allow(vbr_info).to receive(:frame).and_return(mp3_data)
+        expect(encoder.vbr_frame).to eql mp3_data
       end
 
     end
 
     context "id3" do
       let(:global_flags) { subject.global_flags }
-      let(:configuration) { stub(Configuration) }
-      let(:id3) { stub(Encoding::Id3).as_null_object }
+      let(:configuration) { double(Configuration) }
+      let(:id3) { double(Encoding::Id3).as_null_object }
 
       before do
-        Configuration.stub(:new).and_return(configuration)
-        configuration.stub(:applied?).and_return(true)
-        Encoding::Id3.stub(:new).and_return(id3)
+        allow(Configuration).to receive(:new).and_return(configuration)
+        allow(configuration).to receive(:applied?).and_return(true)
+        allow(Encoding::Id3).to receive(:new).and_return(id3)
       end
 
       it "creates vbr info" do
-        Encoding::Id3.should_receive(:new).with(configuration)
+        expect(Encoding::Id3).to receive(:new).with(configuration)
         encoder.id3v1 { }
       end
 
       context "v1" do
         it "creates the id3v1 frame" do
-          id3.should_receive(:v1)
+          expect(id3).to receive(:v1)
           encoder.id3v1 { }
         end
 
         it "yields the vbr frame" do
-          mp3_data = stub
-          id3.stub(:v1).and_return(mp3_data)
+          mp3_data = double("mp3_data")
+          allow(id3).to receive(:v1).and_return(mp3_data)
 
           expect { |block|
             encoder.id3v1(&block)
@@ -357,21 +357,21 @@ module LAME
         end
 
         it "returns the vbr frame if no block was given" do
-          mp3_data = stub
-          id3.stub(:v1).and_return(mp3_data)
-          encoder.id3v1.should eql mp3_data
+          mp3_data = double("mp3_data")
+          allow(id3).to receive(:v1).and_return(mp3_data)
+          expect(encoder.id3v1).to eql mp3_data
         end
       end
 
       context "v2" do
         it "creates the id3v2 frame" do
-          id3.should_receive(:v2)
+          expect(id3).to receive(:v2)
           encoder.id3v2 { }
         end
 
         it "yields the vbr frame" do
-          mp3_data = stub
-          id3.stub(:v2).and_return(mp3_data)
+          mp3_data = double("mp3_data")
+          allow(id3).to receive(:v2).and_return(mp3_data)
 
           expect { |block|
             encoder.id3v2(&block)
@@ -379,9 +379,9 @@ module LAME
         end
 
         it "returns the vbr frame if no block was given" do
-          mp3_data = stub
-          id3.stub(:v2).and_return(mp3_data)
-          encoder.id3v2.should eql mp3_data
+          mp3_data = double("mp3_data")
+          allow(id3).to receive(:v2).and_return(mp3_data)
+          expect(encoder.id3v2).to eql mp3_data
         end
       end
     end