jpmobile 4.1.1 → 4.1.4

data/spec/unit/receive_mail_spec.rb

@@ -17,32 +17,32 @@ describe "Jpmobile::Mail#receive" do
     end
 
     it "subject should be parsed correctly" do
-      @mail.subject.should == "タイトルの長いメールの場合の対処を実装するためのテストケースとしてのメールに含まれている件名であるサブジェクト部分"
+      expect(@mail.subject).to eq("タイトルの長いメールの場合の対処を実装するためのテストケースとしてのメールに含まれている件名であるサブジェクト部分")
     end
 
     it "body should be parsed correctly" do
-      @mail.body.to_s.should == "本文です\n\n"
+      expect(@mail.body.to_s).to eq("本文です\n\n")
     end
 
     context "to_s" do
       it "should have subject which is same as original" do
-        ascii_8bit(@mail.to_s).should match("GyRCJT8lJCVIJWskTkQ5JCQlYSE8JWskTj5s")
+        expect(ascii_8bit(@mail.to_s)).to match("GyRCJT8lJCVIJWskTkQ5JCQlYSE8JWskTj5s")
       end
 
       it "should have body which is same as original" do
-        ascii_8bit(@mail.to_s).should match(Regexp.compile(Regexp.escape(ascii_8bit(utf8_to_jis("本文です")))))
+        expect(ascii_8bit(@mail.to_s)).to match(Regexp.compile(Regexp.escape(ascii_8bit(utf8_to_jis("本文です")))))
       end
     end
 
     context "modify and to_s" do
       it "should encode subject correctly" do
         @mail.subject = "大江戸"
-        ascii_8bit(@mail.to_s).should match("GyRCQmc5PjhNGyhC")
+        expect(ascii_8bit(@mail.to_s)).to match("GyRCQmc5PjhNGyhC")
       end
 
       it "should encode body correctly" do
         @mail.body = "会議が開催"
-        ascii_8bit(@mail.to_s).should match(Regexp.compile(Regexp.escape(ascii_8bit(utf8_to_jis("会議が開催")))))
+        expect(ascii_8bit(@mail.to_s)).to match(Regexp.compile(Regexp.escape(ascii_8bit(utf8_to_jis("会議が開催")))))
       end
     end
   end
@@ -54,16 +54,16 @@ describe "Jpmobile::Mail#receive" do
       end
 
       it "subject should be parsed correctly" do
-        @mail.subject.should == "タイトルの長いメールの場合の対処を実装するためのテストケースとしてのメールに含まれている件名であるサブジェクト部分"
+        expect(@mail.subject).to eq("タイトルの長いメールの場合の対処を実装するためのテストケースとしてのメールに含まれている件名であるサブジェクト部分")
       end
 
       it "body should be parsed correctly" do
-        @mail.body.parts.size.should == 2
-        @mail.body.parts.first.body.to_s.should == "本文です\n\n"
+        expect(@mail.body.parts.size).to eq(2)
+        expect(@mail.body.parts.first.body.to_s).to eq("本文です\n\n")
       end
 
       it "should encode correctly" do
-        ascii_8bit(@mail.to_s).should match(/GyRCJT8lJCVIJWskTkQ5JCQlYSE8JWskTj5s/)
+        expect(ascii_8bit(@mail.to_s)).to match(/GyRCJT8lJCVIJWskTkQ5JCQlYSE8JWskTj5s/)
       end
     end
 
@@ -73,12 +73,12 @@ describe "Jpmobile::Mail#receive" do
       end
 
       it "body should be parsed correctly" do
-        @mail.body.parts.size.should == 2
-        @mail.body.parts.first.body.to_s.should == "本文です\n\n"
+        expect(@mail.body.parts.size).to eq(2)
+        expect(@mail.body.parts.first.body.to_s).to eq("本文です\n\n")
       end
 
       it "should encode correctly" do
-        ascii_8bit(@mail.to_s).should match(/GODlhAQABAIAAAAAAAP/)
+        expect(ascii_8bit(@mail.to_s)).to match(/GODlhAQABAIAAAAAAAP/)
       end
     end
 
@@ -88,18 +88,18 @@ describe "Jpmobile::Mail#receive" do
       end
 
       it "subject should be parsed correctly" do
-        @mail.subject.should == "テスト"
+        expect(@mail.subject).to eq("テスト")
       end
 
       it "body should be parsed correctly" do
-        @mail.body.parts.size.should == 1
+        expect(@mail.body.parts.size).to eq(1)
         @mail.body.parts.first.parts.size == 2
-        @mail.body.parts.first.parts.first.body.should match("テストです")
-        @mail.body.parts.first.parts.last.body.raw_source.should match("テストです")
+        expect(@mail.body.parts.first.parts.first.body).to match("テストです")
+        expect(@mail.body.parts.first.parts.last.body.raw_source).to match("テストです")
       end
 
       it "should encode correctly" do
-        @mail.to_s.should match(Regexp.escape("g2WDWINn+ZE"))
+        expect(@mail.to_s).to match(Regexp.escape("g2WDWINn+ZE"))
       end
     end
 
@@ -109,18 +109,18 @@ describe "Jpmobile::Mail#receive" do
       end
 
       it "subject should be parsed correctly" do
-        @mail.subject.should == "テスト"
+        expect(@mail.subject).to eq("テスト")
       end
 
       it "body should be parsed correctly" do
-        @mail.body.parts.size.should == 1
+        expect(@mail.body.parts.size).to eq(1)
         @mail.body.parts.first.parts.size == 1
-        @mail.body.parts.first.parts.first.body.to_s.should match("テストです")
-        @mail.body.parts.first.parts.last.body.raw_source.should match("テストです")
+        expect(@mail.body.parts.first.parts.first.body.to_s).to match("テストです")
+        expect(@mail.body.parts.first.parts.last.body.raw_source).to match("テストです")
       end
 
       it "should encode correctly" do
-        ascii_8bit(@mail.to_s).should match(Regexp.escape("GyRCJUYlOSVIdk8bKEI="))
+        expect(ascii_8bit(@mail.to_s)).to match(Regexp.escape("GyRCJUYlOSVIdk8bKEI="))
       end
     end
 
@@ -131,16 +131,16 @@ describe "Jpmobile::Mail#receive" do
         end
 
         it "subject should be parsed correctly" do
-          @mail.subject.should == "テスト"
+          expect(@mail.subject).to eq("テスト")
         end
 
         it "body should be parsed correctly" do
-          @mail.body.parts.size.should == 2
-          @mail.body.parts.first.body.to_s.should == "テストです"
+          expect(@mail.body.parts.size).to eq(2)
+          expect(@mail.body.parts.first.body.to_s).to eq("テストです")
         end
 
         it "should encode correctly" do
-          @mail.to_s.should match(Regexp.escape("g2WDWINn98H3w/fB"))
+          expect(@mail.to_s).to match(Regexp.escape("g2WDWINn98H3w/fB"))
         end
       end
 
@@ -150,16 +150,16 @@ describe "Jpmobile::Mail#receive" do
         end
 
         it "subject should be parsed correctly" do
-          @mail.subject.should == "テストです"
+          expect(@mail.subject).to eq("テストです")
         end
 
         it "body should be parsed correctly" do
-          @mail.body.parts.size.should == 2
-          @mail.body.parts.first.body.raw_source.should == "テストです"
+          expect(@mail.body.parts.size).to eq(2)
+          expect(@mail.body.parts.first.body.raw_source).to eq("テストです")
         end
 
         it "should encode correctly to Shift_JIS" do
-          @mail.to_s.should match(Regexp.escape("g2WDWINngsWCt/fB"))
+          expect(@mail.to_s).to match(Regexp.escape("g2WDWINngsWCt/fB"))
         end
       end
     end
@@ -167,8 +167,8 @@ describe "Jpmobile::Mail#receive" do
     context 'bounced mail' do
       it 'should parse sub-part charset correctly' do
         @mail = Mail.new(open(File.join(File.expand_path(File.dirname(__FILE__)), "email-fixtures/bounce_with_utf8_part.eml")).read)
-        @mail.parts.first.charset.should match(/iso-2022-jp/i)
-        @mail.parts.last.charset.should  match(/utf-8/i)
+        expect(@mail.parts.first.charset).to match(/iso-2022-jp/i)
+        expect(@mail.parts.last.charset).to  match(/utf-8/i)
       end
     end
   end
@@ -179,32 +179,32 @@ describe "Jpmobile::Mail#receive" do
     end
 
     it "subject should be parsed correctly" do
-      @mail.subject.should == "題名"
+      expect(@mail.subject).to eq("題名")
     end
 
     it "body should be parsed correctly" do
-      @mail.body.to_s.should == "本文\nFor docomo\n\n"
+      expect(@mail.body.to_s).to eq("本文\nFor docomo\n\n")
     end
 
     context "to_s" do
       it "should have subject which is same as original" do
-        @mail.to_s.should match(Regexp.escape("keiWvPjX"))
+        expect(@mail.to_s).to match(Regexp.escape("keiWvPjX"))
       end
 
       it "should have body which is same as original" do
-        @mail.to_s.should match(sjis_regexp(utf8_to_sjis("本文")))
+        expect(@mail.to_s).to match(sjis_regexp(utf8_to_sjis("本文")))
       end
     end
 
     context "modify and to_s" do
       it "should encode subject correctly" do
         @mail.subject = "大江戸"
-        @mail.to_s.should match(Regexp.escape("keWNXYzL+J8="))
+        expect(@mail.to_s).to match(Regexp.escape("keWNXYzL+J8="))
       end
 
       it "should encode body correctly" do
         @mail.body = "会議が開催"
-        @mail.to_s.should match(sjis_regexp(sjis("\x89\xEF\x8Bc\x82\xAA\x8AJ\x8D\xC3\xF8\xA7")))
+        expect(@mail.to_s).to match(sjis_regexp(sjis("\x89\xEF\x8Bc\x82\xAA\x8AJ\x8D\xC3\xF8\xA7")))
       end
     end
   end
@@ -216,85 +216,85 @@ describe "Jpmobile::Mail#receive" do
       end
 
       it "subject should be parsed correctly" do
-        @mail.subject.should == "題名"
+        expect(@mail.subject).to eq("題名")
       end
 
       it "body should be parsed correctly" do
-        @mail.body.to_s.should == "本文\nFor au\n\n"
+        expect(@mail.body.to_s).to eq("本文\nFor au\n\n")
       end
 
       context "to_s" do
         it "should have subject which is same as original" do
-          ascii_8bit(@mail.to_s).should match(Regexp.escape("GyRCQmpMPnZeGyhC"))
+          expect(ascii_8bit(@mail.to_s)).to match(Regexp.escape("GyRCQmpMPnZeGyhC"))
         end
 
         it "should have body which is same as original" do
-          ascii_8bit(@mail.to_s).should match(Regexp.compile(Regexp.escape(ascii_8bit("\e\x24\x42\x4B\x5C\x4A\x38\x76\x7D\e\x28\x42"))))
+          expect(ascii_8bit(@mail.to_s)).to match(Regexp.compile(Regexp.escape(ascii_8bit("\e\x24\x42\x4B\x5C\x4A\x38\x76\x7D\e\x28\x42"))))
         end
       end
 
       context "modify and to_s" do
         it "should encode subject correctly" do
           @mail.subject = "大江戸"
-          ascii_8bit(@mail.to_s).should match(/\?GyRCQmc5PjhNdUEbKEI=/)
+          expect(ascii_8bit(@mail.to_s)).to match(/\?GyRCQmc5PjhNdUEbKEI=/)
         end
 
         it "should encode body correctly" do
           @mail.body = "会議が開催"
-          ascii_8bit(@mail.to_s).should match(Regexp.compile(Regexp.escape(ascii_8bit("\x1b\x24\x42\x32\x71\x35\x44\x24\x2C\x33\x2B\x3A\x45\x75\x48\x1b\x28\x42"))))
+          expect(ascii_8bit(@mail.to_s)).to match(Regexp.compile(Regexp.escape(ascii_8bit("\x1b\x24\x42\x32\x71\x35\x44\x24\x2C\x33\x2B\x3A\x45\x75\x48\x1b\x28\x42"))))
         end
       end
     end
 
     it "should not be raised when parsing incoming email #41" do
-      lambda {
+      expect {
         @mail = Mail.new(open(File.join(File.expand_path(File.dirname(__FILE__)), "email-fixtures/au-email.eml")).read)
-      }.should_not raise_error
+      }.not_to raise_error
     end
 
     it "should not be raised when parsing incoming email #45" do
-      lambda {
+      expect {
         @mail = Mail.new(open(File.join(File.expand_path(File.dirname(__FILE__)), "email-fixtures/au-decomail2.eml")).read)
-      }.should_not raise_error
+      }.not_to raise_error
     end
 
     it "should not be raised when parsing incoming email - include kigou" do
-      lambda {
+      expect {
         @mail = Mail.new(open(File.join(File.expand_path(File.dirname(__FILE__)), "email-fixtures/au-kigou.eml")).read)
-      }.should_not raise_error
+      }.not_to raise_error
     end
 
     context 'From au iPhone' do
       it 'charset should be UTF-8' do
         @mail = Mail.new(open(File.join(File.expand_path(File.dirname(__FILE__)), "email-fixtures/iphone-message.eml")).read)
-        @mail.mobile.should be_a(Jpmobile::Mobile::Au)
-        @mail.charset.should match(/utf-8/i)
+        expect(@mail.mobile).to be_a(Jpmobile::Mobile::Au)
+        expect(@mail.charset).to match(/utf-8/i)
       end
 
       it 'should be encoded correctly' do
         @mail = Mail.new(open(File.join(File.expand_path(File.dirname(__FILE__)), "email-fixtures/iphone-message.eml")).read)
-        @mail.encoded.should match(Regexp.escape("%[\e$B1`;yL>\e(B]%\e$B$N\e(B%[\e$BJ]8n<TL>\e(B]%"))
+        expect(@mail.encoded).to match(Regexp.escape("%[\e$B1`;yL>\e(B]%\e$B$N\e(B%[\e$BJ]8n<TL>\e(B]%"))
       end
     end
 
     context 'From iPad' do
       it 'charset should be UTF-8' do
         @mail = Mail.new(open(File.join(File.expand_path(File.dirname(__FILE__)), "email-fixtures/iphone-mail3.eml")).read)
-        @mail.mobile.should be_a(Jpmobile::Mobile::AbstractMobile)
-        @mail.charset.should match(/utf-8/i)
+        expect(@mail.mobile).to be_a(Jpmobile::Mobile::AbstractMobile)
+        expect(@mail.charset).to match(/utf-8/i)
       end
 
       it 'should be encoded correctly' do
         @mail = Mail.new(open(File.join(File.expand_path(File.dirname(__FILE__)), "email-fixtures/iphone-mail3.eml")).read)
-        @mail.encoded.should match(/BK\\J82~9T\$J\$7!2#5#1#2J8;z!2/)
+        expect(@mail.encoded).to match(/BK\\J82~9T\$J\$7!2#5#1#2J8;z!2/)
       end
     end
 
     it 'should not raise when parsing attached email' do
-      lambda {
+      expect {
         @mail = Mail.new(open(File.join(File.expand_path(File.dirname(__FILE__)), "email-fixtures/au-attached.eml")).read)
-        @mail.encoded.should match('/9j/4AAQSkZJRgABAgAAZABkAAD/7AARRHVja3kAAQAEAAAAPQAA')
-      }.should_not raise_error
+        expect(@mail.encoded).to match('/9j/4AAQSkZJRgABAgAAZABkAAD/7AARRHVja3kAAQAEAAAAPQAA')
+      }.not_to raise_error
     end
   end
 
@@ -304,32 +304,32 @@ describe "Jpmobile::Mail#receive" do
     end
 
     it "subject should be parsed correctly" do
-      @mail.subject.should == "題名&#xf03c;"
+      expect(@mail.subject).to eq("題名&#xf03c;")
     end
 
     it "body should be parsed correctly" do
-      @mail.body.to_s.should == "本文&#xf21c;\nFor softbank\n\n"
+      expect(@mail.body.to_s).to eq("本文&#xf21c;\nFor softbank\n\n")
     end
 
     context "to_s" do
       it "should have subject which is same as original" do
-        @mail.to_s.should match(sjis_regexp("keiWvPl8"))
+        expect(@mail.to_s).to match(sjis_regexp("keiWvPl8"))
       end
 
       it "should have body which is same as original" do
-        @mail.to_s.should match(sjis_regexp(utf8_to_sjis("本文")))
+        expect(@mail.to_s).to match(sjis_regexp(utf8_to_sjis("本文")))
       end
     end
 
     context "modify and to_s" do
       it "should encode subject correctly" do
         @mail.subject = "大江戸&#xe63e;"
-        @mail.to_s.should match(Regexp.escape("keWNXYzL+Ys="))
+        expect(@mail.to_s).to match(Regexp.escape("keWNXYzL+Ys="))
       end
 
       it "should encode body correctly" do
         @mail.body = "会議が開催&#xe646;"
-        @mail.to_s.should match(sjis_regexp(utf8_to_sjis("会議が開催") + sjis("\xf7\xdf")))
+        expect(@mail.to_s).to match(sjis_regexp(utf8_to_sjis("会議が開催") + sjis("\xf7\xdf")))
       end
     end
   end
@@ -340,11 +340,11 @@ describe "Jpmobile::Mail#receive" do
     end
 
     it "subject should be parsed correctly" do
-      @mail.subject.should be_blank
+      expect(@mail.subject).to be_blank
     end
 
     it "body should be parsed correctly" do
-      @mail.body.to_s.should be_blank
+      expect(@mail.body.to_s).to be_blank
     end
   end
 
@@ -355,11 +355,11 @@ describe "Jpmobile::Mail#receive" do
       end
 
       it "subject should be parsed correctly" do
-        @mail.subject.should == "テスト"
+        expect(@mail.subject).to eq("テスト")
       end
 
       it "body should be parsed correctly" do
-        @mail.body.to_s.should == "テスト本文\n\n"
+        expect(@mail.body.to_s).to eq("テスト本文\n\n")
       end
     end
   end
@@ -371,7 +371,7 @@ describe "Jpmobile::Mail#receive" do
       end
 
       it "mobile should abstract mobile" do
-        @mail.mobile.should be_a Jpmobile::Mobile::AbstractMobile
+        expect(@mail.mobile).to be_a Jpmobile::Mobile::AbstractMobile
       end
     end
   end
@@ -383,8 +383,8 @@ describe "Jpmobile::Mail#receive" do
       end
 
       it "mobile should be nil" do
-        @mail.mobile.should be_nil
-        @mail.parts.first.charset.should == 'us-ascii'
+        expect(@mail.mobile).to be_nil
+        expect(@mail.parts.first.charset).to eq('us-ascii')
       end
     end
 
@@ -394,8 +394,8 @@ describe "Jpmobile::Mail#receive" do
       end
 
       it "mobile should be nil" do
-        @mail.mobile.should be_nil
-        @mail.parts.first.charset.should == 'iso-8859-1'
+        expect(@mail.mobile).to be_nil
+        expect(@mail.parts.first.charset).to eq('iso-8859-1')
       end
     end
   end

data/spec/unit/util_spec.rb

@@ -7,106 +7,106 @@ describe Jpmobile::Util do
   include Jpmobile::Util
 
   it 'nilのときはnilを返すこと' do
-    deep_apply(nil) {|obj| obj }.should equal(nil)
+    expect(deep_apply(nil) {|obj| obj }).to equal(nil)
   end
 
   it 'trueのときはtrueを返すこと' do
-    deep_apply(true) {|obj| obj }.should equal(true)
+    expect(deep_apply(true) {|obj| obj }).to equal(true)
   end
 
   it 'falseのときはそのまま値を返すこと' do
-    deep_apply(false) {|obj| obj }.should equal(false)
+    expect(deep_apply(false) {|obj| obj }).to equal(false)
   end
 
   it 'Tempfileのインスタンスのときはそのまま値を返すこと' do
     temp = Tempfile.new('test')
-    deep_apply(temp) {|obj| obj}.object_id.should equal(temp.object_id)
+    expect(deep_apply(temp) {|obj| obj}.object_id).to equal(temp.object_id)
     # 本来 deep_apply(temp) {|obj| obj }.should equal(temp) が通るべきのような。
     # 参考 http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-list/41720
   end
 
   it 'StringIOのインスタンスのときはそのまま値を返すこと' do
     string_io = StringIO.new('test')
-    deep_apply(string_io) {|obj| obj }.should equal(string_io)
+    expect(deep_apply(string_io) {|obj| obj }).to equal(string_io)
   end
 
   it "utf8_to_sjis で変換できない文字列が含んでいた場合?に変換される" do
-    utf8_to_sjis("اللغة العربية").should == sjis("????? ???????")
+    expect(utf8_to_sjis("اللغة العربية")).to eq(sjis("????? ???????"))
   end
 
   it "utf8_to_sjis ですべての改行コードが CRLF に変更されること" do
-    utf8_to_sjis("UTF8\rSAMPLE\nTEXT\r\n").should == sjis("UTF8\r\nSAMPLE\r\nTEXT\r\n")
+    expect(utf8_to_sjis("UTF8\rSAMPLE\nTEXT\r\n")).to eq(sjis("UTF8\r\nSAMPLE\r\nTEXT\r\n"))
   end
 
   it "0x8150がU+FFE3に変換されること" do
-    sjis_to_utf8(sjis("\x81\x50")).should == [0xffe3].pack("U")
+    expect(sjis_to_utf8(sjis("\x81\x50"))).to eq([0xffe3].pack("U"))
   end
 
   it "U+FFE3が0x8150に変換されること" do
-    utf8_to_sjis([0xffe3].pack("U")).should == sjis("\x81\x50")
+    expect(utf8_to_sjis([0xffe3].pack("U"))).to eq(sjis("\x81\x50"))
   end
 
   it "U+203Eが0x8150に変換されること" do
-    utf8_to_sjis([0x203e].pack("U")).should == sjis("\x81\x50")
+    expect(utf8_to_sjis([0x203e].pack("U"))).to eq(sjis("\x81\x50"))
   end
 
   it "U+2014が0x815Cに変換されること" do
-    utf8_to_sjis([0x2014].pack("U")).should == sjis("\x81\x5C")
+    expect(utf8_to_sjis([0x2014].pack("U"))).to eq(sjis("\x81\x5C"))
   end
 
   it "U+2212が0x817Cに変換されること" do
-    utf8_to_sjis([0x2212].pack("U")).should == sjis("\x81\x7C")
+    expect(utf8_to_sjis([0x2212].pack("U"))).to eq(sjis("\x81\x7C"))
   end
 
   it "jis_string_regexpでISO-2022-JPの文字列がマッチすること" do
-    jis_string_regexp.match(ascii_8bit(utf8_to_jis("abcしからずんばこじをえずdef"))).should_not be_nil
-    jis_to_utf8(jis("\x1b\x24\x42#{$1}\x1b\x28\x42")).should == "しからずんばこじをえず"
+    expect(jis_string_regexp.match(ascii_8bit(utf8_to_jis("abcしからずんばこじをえずdef")))).not_to be_nil
+    expect(jis_to_utf8(jis("\x1b\x24\x42#{$1}\x1b\x28\x42"))).to eq("しからずんばこじをえず")
   end
 
   it "sjis_to_utf8 ですべての改行コードが LF に変更されること" do
-    sjis_to_utf8("SJIS\rSAMPLE\nTEXT\r\n").should == utf8("SJIS\nSAMPLE\nTEXT\n")
+    expect(sjis_to_utf8("SJIS\rSAMPLE\nTEXT\r\n")).to eq(utf8("SJIS\nSAMPLE\nTEXT\n"))
   end
 
   it "utf8_to_sjis で変換できない文字列が含んでいた場合?に変換される" do
-    utf8_to_jis("اللغة العربية").should == jis("????? ???????")
+    expect(utf8_to_jis("اللغة العربية")).to eq(jis("????? ???????"))
   end
 
   it "utf8_to_jis ですべての改行コードが CRLF に変更されること" do
-    utf8_to_jis("UTF8\rSAMPLE\nTEXT\r\n").should == jis("UTF8\r\nSAMPLE\r\nTEXT\r\n")
+    expect(utf8_to_jis("UTF8\rSAMPLE\nTEXT\r\n")).to eq(jis("UTF8\r\nSAMPLE\r\nTEXT\r\n"))
   end
 
   it "jis_to_utf8 ですべての改行コードが LF に変更されること" do
-    jis_to_utf8("JIS\rSAMPLE\nTEXT\r\n").should == utf8("JIS\nSAMPLE\nTEXT\n")
+    expect(jis_to_utf8("JIS\rSAMPLE\nTEXT\r\n")).to eq(utf8("JIS\nSAMPLE\nTEXT\n"))
   end
 
   it "fold_textでUTF-8の日本語文字列が指定文字数で折り返された配列で返ること" do
-    fold_text('長い日本語の題名で折り返されるかようにするには事前に分割していないとダメなことがわかりましたよ', 15).should == [
+    expect(fold_text('長い日本語の題名で折り返されるかようにするには事前に分割していないとダメなことがわかりましたよ', 15)).to eq([
       '長い日本語の題名で折り返される',
       'かようにするには事前に分割して',
       'いないとダメなことがわかりまし',
       'たよ'
-    ]
+    ])
   end
 
   it "fold_textでUTF-8の短い文字列は折り返されないこと" do
-    fold_text('短い', 15).should == ['短い']
+    expect(fold_text('短い', 15)).to eq(['短い'])
   end
 
   it "split_textでUTF-8の日本語文字列が指定文字数で2つに分割されること" do
-    split_text('長い日本語の題名で折り返されるかようにするには事前に分割していないとダメなことがわかりましたよ', 15).should == [
+    expect(split_text('長い日本語の題名で折り返されるかようにするには事前に分割していないとダメなことがわかりましたよ', 15)).to eq([
       '長い日本語の題名で折り返される',
       'かようにするには事前に分割していないとダメなことがわかりましたよ'
-    ]
+    ])
   end
 
   it "split_textでnilかblankの場合はnilが返ること" do
-    split_text('', 15).should be_nil
-    split_text(nil, 15).should be_nil
+    expect(split_text('', 15)).to be_nil
+    expect(split_text(nil, 15)).to be_nil
   end
 
   it "全角チルダがjisに適切に変換されること" do
-    ascii_8bit(utf8_to_jis("\xef\xbd\x9e")).should == ascii_8bit("\x1b\x24\x42\x21\x41\x1b\x28\x42")
-    ascii_8bit(encode("\xef\xbd\x9e", "ISO-2022-JP")).should == ascii_8bit("\x1b\x24\x42\x21\x41\x1b\x28\x42")
+    expect(ascii_8bit(utf8_to_jis("\xef\xbd\x9e"))).to eq(ascii_8bit("\x1b\x24\x42\x21\x41\x1b\x28\x42"))
+    expect(ascii_8bit(encode("\xef\xbd\x9e", "ISO-2022-JP"))).to eq(ascii_8bit("\x1b\x24\x42\x21\x41\x1b\x28\x42"))
   end
 
   describe 'invert_table' do
@@ -117,8 +117,8 @@ describe Jpmobile::Util do
           0xFE00B => 0x3013,
           0xFE010 => 0xE6B3,
           0xFE038 => 0xE73F})
-      hash[0xE63E].should == 0xFE009
-      hash[0x3013].should == 0xFE00B
+      expect(hash[0xE63E]).to eq(0xFE009)
+      expect(hash[0x3013]).to eq(0xFE00B)
     end
 
     it 'should not raise error when hash has Array keys' do
@@ -128,27 +128,27 @@ describe Jpmobile::Util do
           0x1F526            => 0xE6FB,
           [0x0023, 0x20E3]   => 0xE6E0,
           0x1F354            => 0xE673})
-      hash[0x3013].should == [0x1F1E8, 0x1F1F3]
-      hash[0xE6FB].should == 0x1F526
+      expect(hash[0x3013]).to eq([0x1F1E8, 0x1F1F3])
+      expect(hash[0xE6FB]).to eq(0x1F526)
     end
   end
 
   describe 'check_charset' do
     it 'returns true if compatible' do
       str = 'ABC'.force_encoding('ASCII-8BIT')
-      check_charset(str, 'UTF-8').should be_truthy
+      expect(check_charset(str, 'UTF-8')).to be_truthy
     end
 
     it 'returns false if incompatible' do
       str = '再現'.encode('ISO-2022-JP')
-      check_charset(str, 'UTF-8').should be_falsey
+      expect(check_charset(str, 'UTF-8')).to be_falsey
     end
   end
 
   describe 'correct_encoding' do
     it 'updates encoding correctly' do
       str = '再現'.force_encoding('ISO-2022-JP')
-      correct_encoding(str).encoding.should == Encoding::UTF_8
+      expect(correct_encoding(str).encoding).to eq(Encoding::UTF_8)
     end
   end
 end

data/spec/unit/valid_ip_spec.rb

@@ -18,7 +18,7 @@ describe 'Jpmobile::Mobile::valid_ip?' do
     [ '117.55.1.254'    , :Emobile   ],
   ].each do |remote_ip, carrier|
     it "should be return true if #{remote_ip} is in #{:carrier} address" do
-      Jpmobile::Mobile.const_get(carrier).valid_ip?(remote_ip).should == true
+      expect(Jpmobile::Mobile.const_get(carrier).valid_ip?(remote_ip)).to eq(true)
     end
   end
 
@@ -45,7 +45,7 @@ describe 'Jpmobile::Mobile::valid_ip?' do
     [ '117.55.1.223'    , :Emobile   ],
   ].each do |remote_ip, carrier|
     it 'should not be return true if #{:remote_ip} is in #{carrier} address' do
-      Jpmobile::Mobile.const_get(carrier).valid_ip?(remote_ip).should_not == true
+      expect(Jpmobile::Mobile.const_get(carrier).valid_ip?(remote_ip)).not_to eq(true)
     end
   end
 end