id3tag 0.8.0 → 0.9.0

data/spec/lib/id3tag/id3_v2_tag_header_spec.rb

@@ -6,60 +6,144 @@ describe ID3Tag::ID3v2TagHeader do
   describe "#major_version_number" do
     context "when first bit represent 3" do
       let(:header_data) { "ID3\03\00..." }
-      its(:major_version_number) { should == 3 }
+
+      describe '#major_version_number' do
+        subject { super().major_version_number }
+        it { is_expected.to eq(3) }
+      end
     end
   end
 
   describe "#minor_version_number" do
     context "when 2nd bit represent 2" do
       let(:header_data) { "ID3\03\02..." }
-      its(:minor_version_number) { should == 2 }
+
+      describe '#minor_version_number' do
+        subject { super().minor_version_number }
+        it { is_expected.to eq(2) }
+      end
     end
   end
 
   describe "#version_number" do
     let(:header_data) { "ID3\02\03..." }
-    its(:version_number) { should == "2.3" }
+
+    describe '#version_number' do
+      subject { super().version_number }
+      it { is_expected.to eq("2.3") }
+    end
   end
 
   describe "header flags" do
     context "when flags bite is 0b10000000" do
       let(:header_data) { "ID3\03\00#{0b10000000.chr}" }
-      its(:unsynchronisation?) { should be_true }
-      its(:extended_header?) { should be_false }
-      its(:experimental?) { should be_false }
-      its(:footer_present?) { should be_false }
+
+      describe '#unsynchronisation?' do
+        subject { super().unsynchronisation? }
+        it { is_expected.to eq(true) }
+      end
+
+      describe '#extended_header?' do
+        subject { super().extended_header? }
+        it { is_expected.to eq(false) }
+      end
+
+      describe '#experimental?' do
+        subject { super().experimental? }
+        it { is_expected.to eq(false) }
+      end
+
+      describe '#footer_present?' do
+        subject { super().footer_present? }
+        it { is_expected.to eq(false) }
+      end
     end
     context "when flags bite is 0b01000000" do
       let(:header_data) { "ID3\03\00#{0b01000000.chr}" }
-      its(:unsynchronisation?) { should be_false }
-      its(:extended_header?) { should be_true }
-      its(:experimental?) { should be_false }
-      its(:footer_present?) { should be_false }
+
+      describe '#unsynchronisation?' do
+        subject { super().unsynchronisation? }
+        it { is_expected.to eq(false) }
+      end
+
+      describe '#extended_header?' do
+        subject { super().extended_header? }
+        it { is_expected.to eq(true) }
+      end
+
+      describe '#experimental?' do
+        subject { super().experimental? }
+        it { is_expected.to eq(false) }
+      end
+
+      describe '#footer_present?' do
+        subject { super().footer_present? }
+        it { is_expected.to eq(false) }
+      end
     end
     context "when flags bite is 0b00100000" do
       let(:header_data) { "ID3\03\00#{0b00100000.chr}" }
-      its(:unsynchronisation?) { should be_false }
-      its(:extended_header?) { should be_false }
-      its(:experimental?) { should be_true }
-      its(:footer_present?) { should be_false }
+
+      describe '#unsynchronisation?' do
+        subject { super().unsynchronisation? }
+        it { is_expected.to eq(false) }
+      end
+
+      describe '#extended_header?' do
+        subject { super().extended_header? }
+        it { is_expected.to eq(false) }
+      end
+
+      describe '#experimental?' do
+        subject { super().experimental? }
+        it { is_expected.to eq(true) }
+      end
+
+      describe '#footer_present?' do
+        subject { super().footer_present? }
+        it { is_expected.to eq(false) }
+      end
     end
     context "when flags bite is 0b00010000" do
       let(:header_data) { "ID3\03\00#{0b00010000.chr}" }
-      its(:unsynchronisation?) { should be_false }
-      its(:extended_header?) { should be_false }
-      its(:experimental?) { should be_false }
-      its(:footer_present?) { should be_true }
+
+      describe '#unsynchronisation?' do
+        subject { super().unsynchronisation? }
+        it { is_expected.to eq(false) }
+      end
+
+      describe '#extended_header?' do
+        subject { super().extended_header? }
+        it { is_expected.to eq(false) }
+      end
+
+      describe '#experimental?' do
+        subject { super().experimental? }
+        it { is_expected.to eq(false) }
+      end
+
+      describe '#footer_present?' do
+        subject { super().footer_present? }
+        it { is_expected.to eq(true) }
+      end
     end
   end
 
   describe "#tag_size" do
     let(:header_data) { "ID3abc\x00\x00\x01\x7F" }
-    its(:tag_size) { should == 255 }
+
+    describe '#tag_size' do
+      subject { super().tag_size }
+      it { is_expected.to eq(255) }
+    end
   end
 
   describe "#inspect" do
     let(:header_data) { "ID3\u0003\u0000\u0000\u0000\u0000\u0000\u0000" }
-    its(:inspect) { should eq "<ID3Tag::ID3v2TagHeader version:2.3.0 size:0 unsync:false ext.header:false experimental:false footer:false>" }
+
+    describe '#inspect' do
+      subject { super().inspect }
+      it { is_expected.to eq "<ID3Tag::ID3v2TagHeader version:2.3.0 size:0 unsync:false ext.header:false experimental:false footer:false>" }
+    end
   end
 end

data/spec/lib/id3tag/id3tag_spec.rb

@@ -4,7 +4,7 @@ describe ID3Tag do
   let(:file) { mp3_fixture('id3v2.mp3') }
   describe "#read" do
     it "reads file tag" do
-      ID3Tag.read(file).should be_instance_of(ID3Tag::Tag)
+      expect(ID3Tag.read(file)).to be_instance_of(ID3Tag::Tag)
     end
 
     it "accepts block" do

data/spec/lib/id3tag/io_util_spec.rb

@@ -8,11 +8,11 @@ describe ID3Tag::IOUtil do
       let(:group_size) { 1 }
       context "when only 1 null byte present" do
         let(:io) { StringIO.new("abcd\x00ef") }
-        it { should eq("abcd") }
+        it { is_expected.to eq("abcd") }
       end
       context "when no null bytes are present" do
         let(:io) { StringIO.new("abcdef") }
-        it { should eq("abcdef") }
+        it { is_expected.to eq("abcdef") }
       end
     end
     context "when reading IO and looking for UTF-16 terminator - 2 null bytes" do
@@ -20,8 +20,8 @@ describe ID3Tag::IOUtil do
       context "when only 1 null byte present" do
         let(:io) { StringIO.new("a\x00b\x00\x00\x00c\x00") }
         it "should return content until terminator and leave cursor just right after" do
-          subject.should eq("a\x00b\x00")
-          io.read.should eq("c\x00")
+          expect(subject).to eq("a\x00b\x00")
+          expect(io.read).to eq("c\x00")
         end
       end
     end

data/spec/lib/id3tag/number_util_spec.rb

@@ -3,7 +3,7 @@ describe ID3Tag::NumberUtil do
   describe "#convert_string_to_32bit_integer" do
     context "when string with 4 bytes given" do
       it "should return integer" do
-        described_class.convert_string_to_32bit_integer("abcd").should == 1633837924
+        expect(described_class.convert_string_to_32bit_integer("abcd")).to eq(1633837924)
       end
     end
 
@@ -14,11 +14,19 @@ describe ID3Tag::NumberUtil do
         end.to raise_error(ArgumentError)
       end
     end
+
+    context "when non-string argument is given" do
+      it "should raise Argument error" do
+        expect do
+          described_class.convert_string_to_32bit_integer(Object.new)
+        end.to raise_error(ArgumentError)
+      end
+    end
   end
 
   describe "#convert_32bit_integer_to_string" do
     it "should return 4 byte string" do
-      described_class.convert_32bit_integer_to_string(1633837924).should == "abcd"
+      expect(described_class.convert_32bit_integer_to_string(1633837924)).to eq("abcd")
     end
   end
 end

data/spec/lib/id3tag/string_util_spec.rb

@@ -5,17 +5,17 @@ describe ID3Tag::StringUtil do
     subject { described_class.blank?(test_string) }
     context "when test string is like ''" do
       let(:test_string) { "" }
-      it { should be_true }
+      it { is_expected.to eq(true) }
     end
 
     context "when test string is like '   '" do
       let(:test_string) { "    " }
-      it { should be_true }
+      it { is_expected.to eq(true) }
     end
 
     context "when test string is like 'foo'" do
       let(:test_string) { "foo" }
-      it { should be_false }
+      it { is_expected.to eq(false) }
     end
   end
 
@@ -25,11 +25,11 @@ describe ID3Tag::StringUtil do
 
     context "when a false synchronization is present" do
       let(:input) { "\xFF\xEE" }
-      it { should eq("\xFF\x00\xEE") }
+      it { is_expected.to eq("\xFF\x00\xEE") }
     end
     context "when a false synchronization is not present" do
       let(:input) { "\xEE\xEE" }
-      it { should eq("\xEE\xEE") }
+      it { is_expected.to eq("\xEE\xEE") }
     end
   end
 
@@ -39,11 +39,11 @@ describe ID3Tag::StringUtil do
 
     context "when unsynchronization in present" do
       let(:input) { "\xFF\x00\xEE\xEE" }
-      it { should eq("\xFF\xEE\xEE") }
+      it { is_expected.to eq("\xFF\xEE\xEE") }
     end
     context "when unsynchronization in not present" do
       let(:input) { "\xEE\xEE" }
-      it { should eq("\xEE\xEE") }
+      it { is_expected.to eq("\xEE\xEE") }
     end
   end
 
@@ -52,15 +52,15 @@ describe ID3Tag::StringUtil do
     subject { described_class.split_by_null_byte(input) }
     context "when content have only 1 null byte" do
       let(:input) { "a\u0000b" }
-      it { should eq(["a", "b"]) }
+      it { is_expected.to eq(["a", "b"]) }
     end
     context "when content have multiple null bytes" do
       let(:input) { "a\u0000\u0000b" }
-      it { should eq(["a", "\u0000b"]) }
+      it { is_expected.to eq(["a", "\u0000b"]) }
     end
     context "when content have multiple null bytes" do
       let(:input) { "abc" }
-      it { should eq(["abc", ""]) }
+      it { is_expected.to eq(["abc", ""]) }
     end
   end
 end

data/spec/lib/id3tag/synchsafe_integer_spec.rb

@@ -1,14 +1,14 @@
 require "spec_helper"
 describe ID3Tag::SynchsafeInteger do
   it "encodes regular integers" do
-    described_class.encode(255).should eq(383)
-    described_class.encode(5).should eq(5)
-    described_class.encode(128).should eq(256)
+    expect(described_class.encode(255)).to eq(383)
+    expect(described_class.encode(5)).to eq(5)
+    expect(described_class.encode(128)).to eq(256)
   end
 
   it "decodes synchsafe integers" do
-    described_class.decode(383).should eq(255)
-    described_class.decode(5).should eq(5)
-    described_class.decode(256).should eq(128)
+    expect(described_class.decode(383)).to eq(255)
+    expect(described_class.decode(5)).to eq(5)
+    expect(described_class.decode(256)).to eq(128)
   end
 end

data/spec/lib/id3tag/tag_spec.rb

@@ -7,7 +7,7 @@ describe ID3Tag::Tag do
     subject { described_class.read(nil) }
     context "when more that one frame by that ID exists" do
       before :each do
-        subject.stub(:get_frames) { [:frame, :frame] }
+        allow(subject).to receive(:get_frames) { [:frame, :frame] }
       end
       it "should raise MultipleFrameError" do
         expect { subject.get_frame(:some_unique_frame) }.to raise_error(ID3Tag::Tag::MultipleFrameError)
@@ -16,10 +16,10 @@ describe ID3Tag::Tag do
 
     context "when only one frame by that ID exists" do
       before :each do
-        subject.stub(:get_frames) { [:frame] }
+        allow(subject).to receive(:get_frames) { [:frame] }
       end
       it "should return the frame" do
-        subject.get_frame(:some_unique_frame).should eq(:frame)
+        expect(subject.get_frame(:some_unique_frame)).to eq(:frame)
       end
     end
   end
@@ -30,21 +30,21 @@ describe ID3Tag::Tag do
     let(:a2) { ID3Tag::Frames::V1::TextFrame.new(:A, 'a2') }
     let(:b) { ID3Tag::Frames::V1::TextFrame.new(:B, 'b') }
     before :each do
-      subject.stub(:frames) { [a1, a2, b] }
+      allow(subject).to receive(:frames) { [a1, a2, b] }
     end
     it "returns frames with specific IDs" do
-      subject.get_frames(:A).should eq([a1, a2])
+      expect(subject.get_frames(:A)).to eq([a1, a2])
     end
   end
 
   describe "#frames" do
     subject { described_class.read(nil) }
     before do
-      subject.stub(:v1_frames) { [:v1_frame1, :v1_frame2] }
-      subject.stub(:v2_frames) { [:v2_frame1, :v2_frame2] }
+      allow(subject).to receive(:v1_frames) { [:v1_frame1, :v1_frame2] }
+      allow(subject).to receive(:v2_frames) { [:v2_frame1, :v2_frame2] }
     end
     it "returns v2 frames and v1 frames" do
-      subject.frames.should eq([:v2_frame1, :v2_frame2, :v1_frame1, :v1_frame2])
+      expect(subject.frames).to eq([:v2_frame1, :v2_frame2, :v1_frame1, :v1_frame2])
     end
   end
 
@@ -53,10 +53,10 @@ describe ID3Tag::Tag do
     let(:frame_1) { ID3Tag::Frames::V1::TextFrame.new(:AA, 'a1') }
     let(:frame_2) { ID3Tag::Frames::V1::TextFrame.new(:BB, 'a2') }
     before do
-      subject.stub(:frames) { [frame_1, frame_2] }
+      allow(subject).to receive(:frames) { [frame_1, frame_2] }
     end
     it "returns frames ids" do
-      subject.frame_ids.should eq([:AA, :BB])
+      expect(subject.frame_ids).to eq([:AA, :BB])
     end
   end
 
@@ -65,22 +65,22 @@ describe ID3Tag::Tag do
       subject { described_class.read(nil, :v1) }
       context "when file has v1 tag" do
         before do
-          ID3Tag::AudioFile.any_instance.stub(:v1_tag_present?) { true }
-          ID3Tag::AudioFile.any_instance.stub(:v1_tag_body) { '' }
-          ID3Tag::ID3V1FrameParser.any_instance.stub(:frames) { [:v1_frame] }
+          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v1_tag_present?) { true }
+          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v1_tag_body) { '' }
+          allow_any_instance_of(ID3Tag::ID3V1FrameParser).to receive(:frames) { [:v1_frame] }
         end
         it "reads v1 tags" do
-          subject.v1_frames.should eq([:v1_frame])
+          expect(subject.v1_frames).to eq([:v1_frame])
         end
       end
 
       context "when file does not have v1 tag" do
         before do
-          ID3Tag::AudioFile.any_instance.stub(:v1_tag_present?) { false }
-          ID3Tag::AudioFile.any_instance.stub(:v1_tag_body) { '' }
+          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v1_tag_present?) { false }
+          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v1_tag_body) { '' }
         end
         it "returns empty array" do
-          subject.v1_frames.should eq([])
+          expect(subject.v1_frames).to eq([])
         end
       end
     end
@@ -89,11 +89,11 @@ describe ID3Tag::Tag do
       subject { described_class.read(nil, :v2) }
       context "when file has v1 tag" do
         before do
-          ID3Tag::AudioFile.any_instance.stub(:v1_tag_present?) { true }
-          ID3Tag::AudioFile.any_instance.stub(:v1_tag_body) { '' }
+          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v1_tag_present?) { true }
+          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v1_tag_body) { '' }
         end
         it "reads v1 tags" do
-          subject.v1_frames.should eq([])
+          expect(subject.v1_frames).to eq([])
         end
       end
     end
@@ -102,12 +102,12 @@ describe ID3Tag::Tag do
       subject { described_class.read(nil, :all) }
       context "when file has v1 tag" do
         before do
-          ID3Tag::AudioFile.any_instance.stub(:v1_tag_present?) { true }
-          ID3Tag::AudioFile.any_instance.stub(:v1_tag_body) { '' }
-          ID3Tag::ID3V1FrameParser.any_instance.stub(:frames) { [:v1_frame] }
+          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v1_tag_present?) { true }
+          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v1_tag_body) { '' }
+          allow_any_instance_of(ID3Tag::ID3V1FrameParser).to receive(:frames) { [:v1_frame] }
         end
         it "reads v1 tags" do
-          subject.v1_frames.should eq([:v1_frame])
+          expect(subject.v1_frames).to eq([:v1_frame])
         end
       end
     end
@@ -115,28 +115,29 @@ describe ID3Tag::Tag do
 
   describe "#v2_frames" do
     before do
-      ID3Tag::AudioFile.any_instance.stub(:v2_tag_major_version_number) { 3 }
+      allow_any_instance_of(ID3Tag::AudioFile).to receive(:v2_tag_major_version_number) { 3 }
     end
     context "when tag reading initialized with v2 tag only" do
       subject { described_class.read(nil, :v2) }
       context "when file has v2 tag" do
         before do
-          ID3Tag::AudioFile.any_instance.stub(:v2_tag_present?) { true }
-          ID3Tag::AudioFile.any_instance.stub(:v2_tag_body) { '' }
-          ID3Tag::ID3V2FrameParser.any_instance.stub(:frames) { [:v2_frame] }
+          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v2_tag_present?) { true }
+          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v2_tag_body) { '' }
+          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v2_tag_size) { 120 }
+          allow_any_instance_of(ID3Tag::ID3V2FrameParser).to receive(:frames) { [:v2_frame] }
         end
         it "reads v2 tags" do
-          subject.v2_frames.should eq([:v2_frame])
+          expect(subject.v2_frames).to eq([:v2_frame])
         end
       end
 
       context "when file does not have v2 tag" do
         before do
-          ID3Tag::AudioFile.any_instance.stub(:v2_tag_present?) { false }
-          ID3Tag::AudioFile.any_instance.stub(:v2_tag_body) { '' }
+          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v2_tag_present?) { false }
+          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v2_tag_body) { '' }
         end
         it "returns empty array" do
-          subject.v2_frames.should eq([])
+          expect(subject.v2_frames).to eq([])
         end
       end
     end
@@ -145,11 +146,11 @@ describe ID3Tag::Tag do
       subject { described_class.read(nil, :v1) }
       context "when file has v2 tag" do
         before do
-          ID3Tag::AudioFile.any_instance.stub(:v2_tag_present?) { true }
-          ID3Tag::AudioFile.any_instance.stub(:v2_tag_body) { '' }
+          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v2_tag_present?) { true }
+          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v2_tag_body) { '' }
         end
         it "returns empty array" do
-          subject.v2_frames.should eq([])
+          expect(subject.v2_frames).to eq([])
         end
       end
     end
@@ -158,12 +159,13 @@ describe ID3Tag::Tag do
       subject { described_class.read(nil, :all) }
       context "when file has v2 tag" do
         before do
-          ID3Tag::AudioFile.any_instance.stub(:v2_tag_present?) { true }
-          ID3Tag::AudioFile.any_instance.stub(:v2_tag_body) { '' }
-          ID3Tag::ID3V2FrameParser.any_instance.stub(:frames) { [:v2_frame] }
+          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v2_tag_present?) { true }
+          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v2_tag_body) { '' }
+          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v2_tag_size) { 120 }
+          allow_any_instance_of(ID3Tag::ID3V2FrameParser).to receive(:frames) { [:v2_frame] }
         end
         it "reads v2 tags" do
-          subject.v2_frames.should eq([:v2_frame])
+          expect(subject.v2_frames).to eq([:v2_frame])
         end
       end
     end
@@ -172,78 +174,177 @@ describe ID3Tag::Tag do
   describe "Tests with real-world tags" do
     let(:audio_file) { double("Fake Audio file") }
 
-    context "signals_1.mp3.v2_3_tag_body" do
-      before(:each) do
-        subject.stub(:audio_file) { audio_file }
-        audio_file.stub({
-          :v1_tag_present? => true,
-          :v2_tag_present? => true,
-          :v2_tag_body => mp3_fixture("signals_1.mp3.v2_3_tag_body").read,
-          :v2_tag_major_version_number => 3
-        })
+    subject do
+      described_class.new(nil, scope_version).tap do |obj|
+        allow(obj).to receive(:audio_file) { audio_file }
       end
+    end
+
+    before do
+      allow(audio_file).to receive_messages({
+                          :v1_tag_present?             => v1_tag_present_flag,
+                          :v2_tag_present?             => v2_tag_present_flag,
+                          :v1_tag_body                 => v1_tag_body,
+                          :v1_tag_size                 => v1_tag_body.to_s.size,
+                          :v2_tag_body                 => v2_tag_body,
+                          :v2_tag_size                 => v2_tag_body.to_s.size,
+                          :v2_tag_major_version_number => v2_tag_major_version_number
+                      })
+    end
+
+    context "signals_1.mp3.v2_3_tag_body" do
+      let(:v1_tag_present_flag) { true }
+      let(:v2_tag_present_flag) { true }
+      let(:v1_tag_body) {  }
+      let(:v2_tag_body) { mp3_fixture("signals_1.mp3.v2_3_tag_body").read }
+      let(:v2_tag_major_version_number) { 3 }
+
       context "Reading only v2" do
-        subject { described_class.new(nil, :v2) }
-        its(:artist) { should eq("Sabled Sun") }
-        its(:title) { should eq("Sabled Sun - Signals I") }
-        its(:album) { should eq("Signals I") }
-        its(:year) { should eq("2013") }
-        its(:track_nr) { should eq "1" }
-        its(:genre) { should eq "Jazz" }
-        its(:comments) { should eq("Visit http://cryochamber.bandcamp.com") }
+        let(:scope_version) { :v2 }
+
+        describe '#artist' do
+          subject { super().artist }
+          it { is_expected.to eq("Sabled Sun") }
+        end
+
+        describe '#title' do
+          subject { super().title }
+          it { is_expected.to eq("Sabled Sun - Signals I") }
+        end
+
+        describe '#album' do
+          subject { super().album }
+          it { is_expected.to eq("Signals I") }
+        end
+
+        describe '#year' do
+          subject { super().year }
+          it { is_expected.to eq("2013") }
+        end
+
+        describe '#track_nr' do
+          subject { super().track_nr }
+          it { is_expected.to eq "1" }
+        end
+
+        describe '#genre' do
+          subject { super().genre }
+          it { is_expected.to eq "Jazz" }
+        end
+
+        describe '#comments' do
+          subject { super().comments }
+          it { is_expected.to eq("Visit http://cryochamber.bandcamp.com") }
+        end
         it "should return eng comment" do
-          subject.comments(:eng).should eq("Visit http://cryochamber.bandcamp.com")
+          expect(subject.comments(:eng)).to eq("Visit http://cryochamber.bandcamp.com")
         end
         it "should read private frames" do
-          subject.get_frames(:PRIV).find { |f| f.owner_identifier.force_encoding(Encoding::UTF_8) == "WM/MediaClassPrimaryID" }.should be_kind_of(ID3Tag::Frames::V2::PrivateFrame)
+          expect(subject.get_frames(:PRIV).find { |f| f.owner_identifier.force_encoding(Encoding::UTF_8) == "WM/MediaClassPrimaryID" }).to be_kind_of(ID3Tag::Frames::V2::PrivateFrame)
         end
       end
     end
 
     context "pov_20131018-2100a.mp3" do
-      before(:each) do
-        subject.stub(:audio_file) { audio_file }
-        audio_file.stub({
-          :v1_tag_present? => true,
-          :v2_tag_present? => true,
-          :v1_tag_body => mp3_fixture("pov_20131018-2100a.mp3.v1_tag_body").read,
-          :v2_tag_body => mp3_fixture("pov_20131018-2100a.mp3.v2_3_tag_body").read,
-          :v2_tag_major_version_number => 3
-        })
-      end
+      let(:v1_tag_present_flag) { true }
+      let(:v2_tag_present_flag) { true }
+      let(:v1_tag_body) { mp3_fixture("pov_20131018-2100a.mp3.v1_tag_body").read }
+      let(:v2_tag_body) { mp3_fixture("pov_20131018-2100a.mp3.v2_3_tag_body").read }
+      let(:v2_tag_major_version_number) { 3 }
+
       context "Reading only v1" do
-        subject { described_class.new(nil, :v1) }
-        its(:artist) { should eq("") }
-        its(:title) { should eq("pov_20131018-2100a.mp3") }
-        its(:album) { should eq("") }
-        its(:year) { should eq("") }
-        its(:track_nr) { should be_nil }
-        its(:genre) { should eq("Blues") }
-        its(:comments) { should be_nil }
-        its(:frame_ids) { should eq [:title, :artist, :album, :year, :comments, :genre] }
+        let(:scope_version) { :v1 }
+
+        describe '#artist' do
+          subject { super().artist }
+          it { is_expected.to eq("") }
+        end
+
+        describe '#title' do
+          subject { super().title }
+          it { is_expected.to eq("pov_20131018-2100a.mp3") }
+        end
+
+        describe '#album' do
+          subject { super().album }
+          it { is_expected.to eq("") }
+        end
+
+        describe '#year' do
+          subject { super().year }
+          it { is_expected.to eq("") }
+        end
+
+        describe '#track_nr' do
+          subject { super().track_nr }
+          it { is_expected.to be_nil }
+        end
+
+        describe '#genre' do
+          subject { super().genre }
+          it { is_expected.to eq("Blues") }
+        end
+
+        describe '#comments' do
+          subject { super().comments }
+          it { is_expected.to be_nil }
+        end
+
+        describe '#frame_ids' do
+          subject { super().frame_ids }
+          it { is_expected.to eq [:title, :artist, :album, :year, :comments, :genre] }
+        end
       end
       context "Reading only v2" do
-        subject { described_class.new(nil, :v2) }
-        its(:artist) { should eq("BBC Radio 4") }
-        its(:title) { should eq("PoV: Lisa Jardine: Machine Intelligence: 18 Oct 13") }
-        its(:album) { should eq("A Point of View") }
-        its(:year) { should eq("2013") }
-        its(:track_nr) { should be_nil }
+        let(:scope_version) { :v2 }
+
+        describe '#artist' do
+          subject { super().artist }
+          it { is_expected.to eq("BBC Radio 4") }
+        end
+
+        describe '#title' do
+          subject { super().title }
+          it { is_expected.to eq("PoV: Lisa Jardine: Machine Intelligence: 18 Oct 13") }
+        end
+
+        describe '#album' do
+          subject { super().album }
+          it { is_expected.to eq("A Point of View") }
+        end
+
+        describe '#year' do
+          subject { super().year }
+          it { is_expected.to eq("2013") }
+        end
+
+        describe '#track_nr' do
+          subject { super().track_nr }
+          it { is_expected.to be_nil }
+        end
         it "should return nil for genre as this tag have incorect genre frame" do
-          subject.genre.should eq("")
+          expect(subject.genre).to eq("")
+        end
+
+        describe '#comments' do
+          subject { super().comments }
+          it { is_expected.to eq("Lisa Jardine compares the contributions of Ada Lovelace and Alan Turing a century later to computer science and contrasts their views on the potential of and limits to machine intelligence. \r\nProducer: Sheila Cook") }
         end
-        its(:comments) { should eq("Lisa Jardine compares the contributions of Ada Lovelace and Alan Turing a century later to computer science and contrasts their views on the potential of and limits to machine intelligence. \r\nProducer: Sheila Cook") }
         it "should return eng comment" do
-          subject.comments(:eng).should eq("Lisa Jardine compares the contributions of Ada Lovelace and Alan Turing a century later to computer science and contrasts their views on the potential of and limits to machine intelligence. \r\nProducer: Sheila Cook")
+          expect(subject.comments(:eng)).to eq("Lisa Jardine compares the contributions of Ada Lovelace and Alan Turing a century later to computer science and contrasts their views on the potential of and limits to machine intelligence. \r\nProducer: Sheila Cook")
         end
         it "should return blank string for latvian comments" do
-          subject.comments(:lav).should be_nil
+          expect(subject.comments(:lav)).to be_nil
+        end
+
+        describe '#frame_ids' do
+          subject { super().frame_ids }
+          it { is_expected.to eq [:TALB, :TPE1, :COMM, :USLT, :TCON, :TIT2, :TYER, :TCOP, :APIC] }
         end
-        its(:frame_ids) { should eq [:TALB, :TPE1, :COMM, :USLT, :TCON, :TIT2, :TYER, :TCOP, :APIC] }
         it "should have comments frame with short desc and language code" do
-          subject.get_frames(:COMM).size.should eq(1)
-          subject.get_frame(:COMM).language.should eq("eng")
-          subject.get_frame(:COMM).description.should eq("")
+          expect(subject.get_frames(:COMM).size).to eq(1)
+          expect(subject.get_frame(:COMM).language).to eq("eng")
+          expect(subject.get_frame(:COMM).description).to eq("")
         end
       end
     end