my_obfuscate 0.5.2 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dbec233cd6cde0de00dcdbe9a73f83101cb45f1c
-  data.tar.gz: eceb2de80135082243e460db1b4f2942893a0a74
+  metadata.gz: 8e7f50293f88ff7eea7bdce3905110af4602229c
+  data.tar.gz: 4008d4d1bb153fde2125dabcf2afdcbef334fbdc
 SHA512:
-  metadata.gz: f25d3f9af557cfe0073d1e3281fd55b6ebdcde8a6ce3094482f37f08ca27d3ddcd4a2857abd52858be599d4a67dd3fc3b550bc82f48746844d60510310e020bb
-  data.tar.gz: 88c6afd3a7fd91b42a37a233cec81e1b66ce984c12fa6faa91e11fd006aa255e3dff9bfb7583cf85fe831711a5133948610b4165eaabf23d147ee12bacdeaa44
+  metadata.gz: 77a9e4325cabd6434e89928d6c1939f914cad6bfe0289618c4a91f67a4c6d237c27a81e98ae43a5b4913b75b1504a1723cebd0f9f1829a938bcea249dd36270c
+  data.tar.gz: b55e7c9b10453a22b77c8231a2f9665393aff73bc1fbcda9bf48959ad3a1846042943dc27d7d4a96cf8c9cb991589139d5caa4323ae753a44cc1163b0b47ed3e

data/CHANGES

@@ -1,2 +1,3 @@
+10/24/2014 - Postgres handles empty trailing fields.
 7/17/2013 - Switch Postgres to use COPY statements and refactor internals.  Thanks @samuelreh!
 3/4/2013 - Switch to the ffaker gem for speed.  Add WalkerMethod and an English language frequency dictionary for generating random texts.

data/lib/my_obfuscate/postgres.rb

@@ -10,7 +10,7 @@ class MyObfuscate
     # We wrap it in an array to keep it consistent with MySql bulk
     # obfuscation (multiple rows per insert statement)
     def rows_to_be_inserted(line)
-      row = line.split(/\t/)
+      row = line.split(/\t/, -1)
       row.last && row.last.strip!
 
       row.collect! do |value|

data/lib/my_obfuscate/version.rb

@@ -1,3 +1,3 @@
 class MyObfuscate
-  VERSION = "0.5.2"
+  VERSION = "0.5.3"
 end

data/spec/my_obfuscate/config_applicator_spec.rb

@@ -6,101 +6,101 @@ describe MyObfuscate::ConfigApplicator do
     it "should work on email addresses" do
       100.times do
         new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else"], {:a => {:type => :email}}, [:a, :b])
-        new_row.length.should == 2
-        new_row.first.should =~ /^[\w\.]+\@(\w+\.){2,3}[a-f0-9]{5}\.example\.com$/
+        expect(new_row.length).to eq(2)
+        expect(new_row.first).to match(/^[\w\.]+\@(\w+\.){2,3}[a-f0-9]{5}\.example\.com$/)
       end
     end
 
     it "should work on strings" do
       new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "something crazy"], {:b => {:type => :string, :length => 7}}, [:a, :b, :c])
-      new_row.length.should == 3
-      new_row[1].length.should == 7
-      new_row[1].should_not == "something_else"
+      expect(new_row.length).to eq(3)
+      expect(new_row[1].length).to eq(7)
+      expect(new_row[1]).not_to eq("something_else")
     end
 
     describe "conditional directives" do
       it "should honor :unless conditionals" do
         new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "5"], {:a=> {:type => :fixed, :string => "123", :unless => lambda { |row| row[:a] == "blah" }}}, [:a, :b, :c])
-        new_row[0].should_not == "123"
-        new_row[0].should == "blah"
+        expect(new_row[0]).not_to eq("123")
+        expect(new_row[0]).to eq("blah")
 
         new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "5"], {:a=> {:type => :fixed, :string => "123", :unless => lambda { |row| row[:a] == "not blah" }}}, [:a, :b, :c])
-        new_row[0].should == "123"
+        expect(new_row[0]).to eq("123")
 
         new_row = MyObfuscate::ConfigApplicator.apply_table_config([nil, "something_else", "5"], {:a=> {:type => :fixed, :string => "123", :unless => :nil}, :b=> {:type => :fixed, :string => "123", :unless => :nil}}, [:a, :b, :c])
-        new_row[0].should == nil
-        new_row[1].should == "123"
+        expect(new_row[0]).to eq(nil)
+        expect(new_row[1]).to eq("123")
 
         new_row = MyObfuscate::ConfigApplicator.apply_table_config(['', "something_else", "5"], {:a=> {:type => :fixed, :string => "123", :unless => :blank}, :b=> {:type => :fixed, :string => "123", :unless => :blank}}, [:a, :b, :c])
-        new_row[0].should == ''
-        new_row[1].should == "123"
+        expect(new_row[0]).to eq('')
+        expect(new_row[1]).to eq("123")
       end
 
       it "should honor :if conditionals" do
         new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "5"], {:a=> {:type => :fixed, :string => "123", :if => lambda { |row| row[:a] == "blah" }}}, [:a, :b, :c])
-        new_row[0].should == "123"
+        expect(new_row[0]).to eq("123")
 
         new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "5"], {:a=> {:type => :fixed, :string => "123", :if=> lambda { |row| row[:a] == "not blah" }}}, [:a, :b, :c])
-        new_row[0].should_not == "123"
-        new_row[0].should == "blah"
+        expect(new_row[0]).not_to eq("123")
+        expect(new_row[0]).to eq("blah")
 
         new_row = MyObfuscate::ConfigApplicator.apply_table_config([nil, "something_else", "5"], {:a=> {:type => :fixed, :string => "123", :if => :nil}, :b=> {:type => :fixed, :string => "123", :if => :nil}}, [:a, :b, :c])
-        new_row[0].should == "123"
-        new_row[1].should == "something_else"
+        expect(new_row[0]).to eq("123")
+        expect(new_row[1]).to eq("something_else")
 
         new_row = MyObfuscate::ConfigApplicator.apply_table_config(['', "something_else", "5"], {:a=> {:type => :fixed, :string => "123", :if => :blank}, :b=> {:type => :fixed, :string => "123", :if => :blank}}, [:a, :b, :c])
-        new_row[0].should == "123"
-        new_row[1].should == "something_else"
+        expect(new_row[0]).to eq("123")
+        expect(new_row[1]).to eq("something_else")
       end
 
       it "should supply the original row values to the conditional" do
         new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else"], {:a => {:type => :fixed, :string => "123"}, :b => {:type => :fixed, :string => "yup", :if => lambda { |row| row[:a] == "blah" }}}, [:a, :b])
-        new_row[0].should == "123"
-        new_row[1].should == "yup"
+        expect(new_row[0]).to eq("123")
+        expect(new_row[1]).to eq("yup")
       end
 
       it "should honor combined :unless and :if conditionals" do
         #both true
         new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "5"], {:a=> {:type => :fixed, :string => "123", :if => lambda { |row| row[:a] == "blah" }, :unless => lambda { |row| row[:b] == "something_else" }}}, [:a, :b, :c])
-        new_row[0].should == "blah"
+        expect(new_row[0]).to eq("blah")
 
         #both false
         new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "5"], {:a=> {:type => :fixed, :string => "123", :if => lambda { |row| row[:a] == "not blah" }, :unless => lambda { |row| row[:b] == "not something_else" }}}, [:a, :b, :c])
-        new_row[0].should == "blah"
+        expect(new_row[0]).to eq("blah")
 
         #if true, #unless false
         new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "5"], {:a=> {:type => :fixed, :string => "123", :if => lambda { |row| row[:a] == "blah" }, :unless => lambda { |row| row[:b] == "not something_else" }}}, [:a, :b, :c])
-        new_row[0].should == "123"
+        expect(new_row[0]).to eq("123")
 
         #if false, #unless true
         new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "5"], {:a=> {:type => :fixed, :string => "123", :if => lambda { |row| row[:a] == "not blah" }, :unless => lambda { |row| row[:b] == "something_else" }}}, [:a, :b, :c])
-        new_row[0].should == "blah"
+        expect(new_row[0]).to eq("blah")
       end
     end
 
     it "should be able to generate random integers in ranges" do
       new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "5"], {:c => {:type => :integer, :between => 10..100}}, [:a, :b, :c])
-      new_row.length.should == 3
-      new_row[2].to_i.to_s.should == new_row[2] # It should be an integer.
-      new_row[2].should_not == "5"
+      expect(new_row.length).to eq(3)
+      expect(new_row[2].to_i.to_s).to eq(new_row[2]) # It should be an integer.
+      expect(new_row[2]).not_to eq("5")
     end
 
     it "should be able to substitute fixed strings" do
       new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "5"], {:b => {:type => :fixed, :string => "hello"}}, [:a, :b, :c])
-      new_row.length.should == 3
-      new_row[1].should == "hello"
+      expect(new_row.length).to eq(3)
+      expect(new_row[1]).to eq("hello")
     end
 
     it "should be able to substitute a proc that returns a string" do
       new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "5"], {:b => {:type => :fixed, :string => proc { "Hello World" }}}, [:a, :b, :c])
-      new_row.length.should == 3
-      new_row[1].should == "Hello World"
+      expect(new_row.length).to eq(3)
+      expect(new_row[1]).to eq("Hello World")
     end
 
     it "should provide the row to the proc" do
       new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "5"], {:b => {:type => :fixed, :string => proc { |a| a[:b] }}}, [:a, :b, :c])
-      new_row.length.should == 3
-      new_row[1].should == "something_else"
+      expect(new_row.length).to eq(3)
+      expect(new_row[1]).to eq("something_else")
     end
 
     it "should be able to substitute fixed strings from a random set" do
@@ -109,154 +109,154 @@ describe MyObfuscate::ConfigApplicator do
       guard = 0
       while !looking_for.empty? && guard < 1000
         new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "5"], {:a => {:type => :fixed, :one_of => ["hello", "world"]}}, [:a, :b, :c])
-        new_row.length.should == 3
-        original_looking_for.should include(new_row[0])
+        expect(new_row.length).to eq(3)
+        expect(original_looking_for).to include(new_row[0])
         looking_for.delete new_row[0]
         guard += 1
       end
-      looking_for.should be_empty
+      expect(looking_for).to be_empty
     end
 
     it "should treat a symbol in the column definition as an implicit { :type => symbol }" do
       new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "5"], {:b => :null, :a => :keep}, [:a, :b, :c])
-      new_row.length.should == 3
-      new_row[0].should == "blah"
-      new_row[1].should == nil
+      expect(new_row.length).to eq(3)
+      expect(new_row[0]).to eq("blah")
+      expect(new_row[1]).to eq(nil)
     end
 
     it "should be able to set things NULL" do
       new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "5"], {:b => {:type => :null}}, [:a, :b, :c])
-      new_row.length.should == 3
-      new_row[1].should == nil
+      expect(new_row.length).to eq(3)
+      expect(new_row[1]).to eq(nil)
     end
 
     it "should be able to :keep the value the same" do
       new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "5"], {:b => {:type => :keep}}, [:a, :b, :c])
-      new_row.length.should == 3
-      new_row[1].should == "something_else"
+      expect(new_row.length).to eq(3)
+      expect(new_row[1]).to eq("something_else")
     end
 
     it "should keep the value when given an unknown type, but should display a warning" do
       $stderr = error_output = StringIO.new
       new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "5"], {:b => {:type => :unknown_type}}, [:a, :b, :c])
       $stderr = STDERR
-      new_row.length.should == 3
-      new_row[1].should == "something_else"
+      expect(new_row.length).to eq(3)
+      expect(new_row[1]).to eq("something_else")
       error_output.rewind
-      error_output.read.should =~ /Keeping a column value by.*?unknown_type/
+      expect(error_output.read).to match(/Keeping a column value by.*?unknown_type/)
     end
 
     it "should be able to substitute lorem ipsum text" do
       new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "5"], {:a => :lorem, :b => {:type => :lorem, :number => 2}}, [:a, :b, :c])
-      new_row.length.should == 3
-      new_row[0].should_not == "blah"
-      new_row[0].should_not =~ /\w\.(?!\Z)/
-      new_row[1].should_not == "something_else"
-      new_row[1].should =~ /\w\.(?!\Z)/
+      expect(new_row.length).to eq(3)
+      expect(new_row[0]).not_to eq("blah")
+      expect(new_row[0]).not_to match(/\w\.(?!\Z)/)
+      expect(new_row[1]).not_to eq("something_else")
+      expect(new_row[1]).to match(/\w\.(?!\Z)/)
     end
 
     it "should be able to generate an :company" do
       new_row = MyObfuscate::ConfigApplicator.apply_table_config(["Smith and Sons", "something_else", "5"], {:a => :company}, [:a, :b, :c])
-      new_row.length.should == 3
-      new_row[0].should_not == "Smith and Sons"
-      new_row[0].should =~ /\w+/
+      expect(new_row.length).to eq(3)
+      expect(new_row[0]).not_to eq("Smith and Sons")
+      expect(new_row[0]).to match(/\w+/)
     end
 
     it "should be able to generate an :url" do
       new_row = MyObfuscate::ConfigApplicator.apply_table_config(["http://mystuff.blogger.com", "something_else", "5"], {:a => :url}, [:a, :b, :c])
-      new_row.length.should == 3
-      new_row[0].should_not == "http://mystuff.blogger.com"
-      new_row[0].should =~ /http:\/\/\w+/
+      expect(new_row.length).to eq(3)
+      expect(new_row[0]).not_to eq("http://mystuff.blogger.com")
+      expect(new_row[0]).to match(/http:\/\/\w+/)
     end
 
     it "should be able to generate an :ipv4" do
       new_row = MyObfuscate::ConfigApplicator.apply_table_config(["1.2.3.4", "something_else", "5"], {:a => :ipv4}, [:a, :b, :c])
-      new_row.length.should == 3
-      new_row[0].should_not == "1.2.3.4"
-      new_row[0].should =~ /\d+\.\d+\.\d+\.\d+/
+      expect(new_row.length).to eq(3)
+      expect(new_row[0]).not_to eq("1.2.3.4")
+      expect(new_row[0]).to match(/\d+\.\d+\.\d+\.\d+/)
     end
 
     it "should be able to generate an :ipv6" do
       new_row = MyObfuscate::ConfigApplicator.apply_table_config(["fe80:0000:0000:0000:0202:b3ff:fe1e:8329", "something_else", "5"], {:a => :ipv6}, [:a, :b, :c])
-      new_row.length.should == 3
-      new_row[0].should_not == "fe80:0000:0000:0000:0202:b3ff:fe1e:8329"
-      new_row[0].should =~ /[0-9a-f:]+/
+      expect(new_row.length).to eq(3)
+      expect(new_row[0]).not_to eq("fe80:0000:0000:0000:0202:b3ff:fe1e:8329")
+      expect(new_row[0]).to match(/[0-9a-f:]+/)
     end
 
     it "should be able to generate an :address" do
       new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "5"], {:a => :address}, [:a, :b, :c])
-      new_row.length.should == 3
-      new_row[0].should_not == "blah"
-      new_row[0].should =~ /\d+ \w/
+      expect(new_row.length).to eq(3)
+      expect(new_row[0]).not_to eq("blah")
+      expect(new_row[0]).to match(/\d+ \w/)
     end
 
     it "should be able to generate a :name" do
       new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "5"], {:a => :name}, [:a, :b, :c])
-      new_row.length.should == 3
-      new_row[0].should_not == "blah"
-      new_row[0].should =~ / /
+      expect(new_row.length).to eq(3)
+      expect(new_row[0]).not_to eq("blah")
+      expect(new_row[0]).to match(/ /)
     end
 
     it "should be able to generate just a street address" do
       new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "5"], {:a => :street_address}, [:a, :b, :c])
-      new_row.length.should == 3
-      new_row[0].should_not == "blah"
-      new_row[0].should =~ /\d+ \w/
+      expect(new_row.length).to eq(3)
+      expect(new_row[0]).not_to eq("blah")
+      expect(new_row[0]).to match(/\d+ \w/)
     end
 
     it "should be able to generate a city" do
       new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "5"], {:a => :city}, [:a, :b, :c])
-      new_row.length.should == 3
-      new_row[0].should_not == "blah"
+      expect(new_row.length).to eq(3)
+      expect(new_row[0]).not_to eq("blah")
     end
 
     it "should be able to generate a state" do
       new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "5"], {:a => :state}, [:a, :b, :c])
-      new_row.length.should == 3
-      new_row[0].should_not == "blah"
+      expect(new_row.length).to eq(3)
+      expect(new_row[0]).not_to eq("blah")
     end
 
     it "should be able to generate a zip code" do
       new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "5"], {:a => :zip_code}, [:a, :b, :c])
-      new_row.length.should == 3
-      new_row[0].should_not == "blah"
-      new_row[0].should =~ /\d+/
+      expect(new_row.length).to eq(3)
+      expect(new_row[0]).not_to eq("blah")
+      expect(new_row[0]).to match(/\d+/)
     end
 
     it "should be able to generate a phone number" do
       new_row = MyObfuscate::ConfigApplicator.apply_table_config(["blah", "something_else", "5"], {:a => :phone}, [:a, :b, :c])
-      new_row.length.should == 3
-      new_row[0].should_not == "blah"
-      new_row[0].should =~ /\d+/
+      expect(new_row.length).to eq(3)
+      expect(new_row[0]).not_to eq("blah")
+      expect(new_row[0]).to match(/\d+/)
     end
 
     describe "when faker generates values with quotes in them" do
       before do
-        Faker::Address.stub(:city).and_return("O'ReillyTown")
-        Faker::Name.stub(:name).and_return("Foo O'Reilly")
-        Faker::Name.stub(:first_name).and_return("O'Foo")
-        Faker::Name.stub(:last_name).and_return("O'Reilly")
-        Faker::Lorem.stub(:sentences).with(any_args).and_return(["Foo bar O'Thingy"])
+        allow(Faker::Address).to receive(:city).and_return("O'ReillyTown")
+        allow(Faker::Name).to receive(:name).and_return("Foo O'Reilly")
+        allow(Faker::Name).to receive(:first_name).and_return("O'Foo")
+        allow(Faker::Name).to receive(:last_name).and_return("O'Reilly")
+        allow(Faker::Lorem).to receive(:sentences).with(any_args).and_return(["Foo bar O'Thingy"])
       end
 
       it "should remove single quotes from the value" do
         new_row = MyObfuscate::ConfigApplicator.apply_table_config(["address", "city", "first", "last", "fullname", "some text"],
                   {:a => :address, :b => :city, :c => :first_name, :d => :last_name, :e => :name, :f => :lorem},
                   [:a, :b, :c, :d, :e, :f])
-        new_row.each {|value| value.should_not include("'")}
+        new_row.each {|value| expect(value).not_to include("'")}
       end
     end
   end
 
   describe ".row_as_hash" do
     it "will map row values into a hash with column names as keys" do
-      MyObfuscate::ConfigApplicator.row_as_hash([1, 2, 3, 4], [:a, :b, :c, :d]).should == {:a => 1, :b => 2, :c => 3, :d => 4}
+      expect(MyObfuscate::ConfigApplicator.row_as_hash([1, 2, 3, 4], [:a, :b, :c, :d])).to eq({:a => 1, :b => 2, :c => 3, :d => 4})
     end
   end
 
   describe ".random_english_sentences" do
     before do
-      File.should_receive(:read).once.and_return("hello 2")
+      expect(File).to receive(:read).once.and_return("hello 2")
     end
 
     after do
@@ -269,7 +269,7 @@ describe MyObfuscate::ConfigApplicator do
     end
 
     it "should make random sentences" do
-      MyObfuscate::ConfigApplicator.random_english_sentences(2).should =~ /^(Hello( hello)+\.\s*){2}$/
+      expect(MyObfuscate::ConfigApplicator.random_english_sentences(2)).to match(/^(Hello( hello)+\.\s*){2}$/)
     end
   end
 

data/spec/my_obfuscate/mysql_spec.rb

@@ -6,74 +6,74 @@ describe MyObfuscate::Mysql do
     it "should split a mysql string into fields" do
       string = "INSERT INTO `some_table` (thing1,thing2) VALUES ('bob@bob.com','bob', 'somethingelse1', 25, '2', 10,    'hi')  ;  "
       fields = [['bob@bob.com', 'bob', 'somethingelse1', '25', '2', '10', "hi"]]
-      subject.rows_to_be_inserted(string).should == fields
+      expect(subject.rows_to_be_inserted(string)).to eq(fields)
     end
 
     it "should work ok with escaped characters" do
       string = "INSERT INTO `some_table` (thing1,thing2) VALUES ('bob,@bob.c  , om', 'bo\\', b', 'some\"thin\\gel\\\\\\'se1', 25, '2', 10,    'hi', 5)  ; "
       fields = [['bob,@bob.c  , om', 'bo\\\', b', 'some"thin\\gel\\\\\\\'se1', '25', '2', '10', "hi", "5"]]
-      subject.rows_to_be_inserted(string).should == fields
+      expect(subject.rows_to_be_inserted(string)).to eq(fields)
     end
 
     it "should work with multiple subinserts" do
       string = "INSERT INTO `some_table` (thing1,thing2) VALUES (1,2,3, '((m))(oo()s,e'), ('bob,@bob.c  , om', 'bo\\', b', 'some\"thin\\gel\\\\\\'se1', 25, '2', 10,    'hi', 5) ;"
       fields = [["1", "2", "3", "((m))(oo()s,e"], ['bob,@bob.c  , om', 'bo\\\', b', 'some"thin\\gel\\\\\\\'se1', '25', '2', '10', "hi", "5"]]
-      subject.rows_to_be_inserted(string).should == fields
+      expect(subject.rows_to_be_inserted(string)).to eq(fields)
     end
 
     it "should work ok with NULL values" do
       string = "INSERT INTO `some_table` (thing1,thing2) VALUES (NULL    , 'bob@bob.com','bob', NULL, 25, '2', NULL,    'hi', NULL  ); "
       fields = [[nil, 'bob@bob.com', 'bob', nil, '25', '2', nil, "hi", nil]]
-      subject.rows_to_be_inserted(string).should == fields
+      expect(subject.rows_to_be_inserted(string)).to eq(fields)
     end
 
     it "should work with empty strings" do
       string = "INSERT INTO `some_table` (thing1,thing2) VALUES (NULL    , '', ''      , '', 25, '2','',    'hi','') ;"
       fields = [[nil, '', '', '', '25', '2', '', "hi", '']]
-      subject.rows_to_be_inserted(string).should == fields
+      expect(subject.rows_to_be_inserted(string)).to eq(fields)
     end
 
     it "should work with hex encoded blobs" do
       string = "INSERT INTO `some_table` (thing1,thing2) VALUES ('bla' , 'blobdata', 'blubb' , 0xACED00057372001F6A6176612E7574696C2E436F6C6C656) ;"
       fields = [['bla', 'blobdata', 'blubb', '0xACED00057372001F6A6176612E7574696C2E436F6C6C656']]
-      subject.rows_to_be_inserted(string).should == fields
+      expect(subject.rows_to_be_inserted(string)).to eq(fields)
     end
   end
 
   describe "#make_valid_value_string" do
     it "should work with nil values" do
       value = nil
-      subject.make_valid_value_string(value).should == 'NULL'
+      expect(subject.make_valid_value_string(value)).to eq('NULL')
     end
 
     it "should work with hex-encoded blob data"  do
       value = "0xACED00057372001F6A6176612E7574696C2E436F6C6C656"
-      subject.make_valid_value_string(value).should == '0xACED00057372001F6A6176612E7574696C2E436F6C6C656'
+      expect(subject.make_valid_value_string(value)).to eq('0xACED00057372001F6A6176612E7574696C2E436F6C6C656')
     end
 
     it "should quote hex-encoded ALIKE data"  do
       value = "40x17x7"
-      subject.make_valid_value_string(value).should == "'40x17x7'"
+      expect(subject.make_valid_value_string(value)).to eq("'40x17x7'")
     end
 
     it "should quote all other values" do
       value = "hello world"
-      subject.make_valid_value_string(value).should == "'hello world'"
+      expect(subject.make_valid_value_string(value)).to eq("'hello world'")
     end
   end
 
   describe "#parse_insert_statement" do
     it "should return nil for other SQL syntaxes (MS SQL Server)" do
-      subject.parse_insert_statement("INSERT [dbo].[TASKS] ([TaskID], [TaskName]) VALUES (61, N'Report Thing')").should be_nil
+      expect(subject.parse_insert_statement("INSERT [dbo].[TASKS] ([TaskID], [TaskName]) VALUES (61, N'Report Thing')")).to be_nil
     end
 
     it "should return nil for MySQL non-insert statements" do
-      subject.parse_insert_statement("CREATE TABLE `some_table`;").should be_nil
+      expect(subject.parse_insert_statement("CREATE TABLE `some_table`;")).to be_nil
     end
 
     it "should return a hash of table name, column names for MySQL insert statements" do
       hash = subject.parse_insert_statement("INSERT INTO `some_table` (`email`, `name`, `something`, `age`) VALUES ('bob@honk.com','bob', 'some\\'thin,ge())lse1', 25),('joe@joe.com','joe', 'somethingelse2', 54);")
-      hash.should == {:table_name => :some_table, :column_names => [:email, :name, :something, :age]}
+      expect(hash).to eq({:table_name => :some_table, :column_names => [:email, :name, :something, :age]})
     end
   end
 

data/spec/my_obfuscate/postgres_spec.rb

@@ -7,42 +7,47 @@ describe MyObfuscate::Postgres do
   describe "#rows_to_be_inserted" do
     it 'splits tab seperated values' do
       line = "1	2	3	4"
-      helper.rows_to_be_inserted(line).should == [["1","2","3","4"]]
+      expect(helper.rows_to_be_inserted(line)).to eq([["1","2","3","4"]])
+    end
+
+    it "preserves empty strings at the end of a line" do
+      line = "1	2	3	4	"
+      expect(helper.rows_to_be_inserted(line)).to eq([["1","2","3","4",""]])
     end
 
     it 'ignores the newline character at the end of string' do
       line = "1	2	3	4\n"
-      helper.rows_to_be_inserted(line).should == [["1","2","3","4"]]
+      expect(helper.rows_to_be_inserted(line)).to eq([["1","2","3","4"]])
     end
 
     it "doesn't ignore newlines due to empty strings" do
       line = "1	2	3	\n"
-      helper.rows_to_be_inserted(line).should == [["1","2","3",""]]
+      expect(helper.rows_to_be_inserted(line)).to eq([["1","2","3",""]])
     end
 
     it "doesn't ignore newline characters in the string" do
       line = "1	2	3\n4	5"
-      helper.rows_to_be_inserted(line).should == [["1","2","3\n4","5"]]
+      expect(helper.rows_to_be_inserted(line)).to eq([["1","2","3\n4","5"]])
     end
 
     it "preserves empty strings in the middle of the string" do
       line = "1	2		4"
-      helper.rows_to_be_inserted(line).should == [["1","2","","4"]]
+      expect(helper.rows_to_be_inserted(line)).to eq([["1","2","","4"]])
     end
 
     it "preserves newline characters in the middle of the string" do
       line = "1	2	\n	4"
-      helper.rows_to_be_inserted(line).should == [["1","2","\n","4"]]
+      expect(helper.rows_to_be_inserted(line)).to eq([["1","2","\n","4"]])
     end
 
     it "replaces \\N with nil" do
       line = "1	2	\\N	4"
-      helper.rows_to_be_inserted(line).should == [["1","2",nil,"4"]]
+      expect(helper.rows_to_be_inserted(line)).to eq([["1","2",nil,"4"]])
     end
 
     it "replaces \\N\n with nil" do
       line = "1	2	3	\\N\n"
-      helper.rows_to_be_inserted(line).should == [["1","2","3",nil]]
+      expect(helper.rows_to_be_inserted(line)).to eq([["1","2","3",nil]])
     end
   end
 
@@ -50,14 +55,14 @@ describe MyObfuscate::Postgres do
     it 'parses table name and column names' do
       line = "COPY some_table (id, email, name, something) FROM stdin;"
       hash = helper.parse_copy_statement(line)
-      hash[:table_name].should == :some_table
-      hash[:column_names].should == [:id, :email, :name, :something]
+      expect(hash[:table_name]).to eq(:some_table)
+      expect(hash[:column_names]).to eq([:id, :email, :name, :something])
     end
   end
 
   describe "#make_insert_statement" do
     it 'creates a string with tab delminted' do
-      helper.make_insert_statement(:some_table, [:id, :name], ['1', '2']).should == "1	2"
+      expect(helper.make_insert_statement(:some_table, [:id, :name], ['1', '2'])).to eq("1	2")
     end
   end
 end

data/spec/my_obfuscate/sql_server_spec.rb

@@ -4,15 +4,15 @@ describe MyObfuscate::SqlServer do
   describe "#parse_insert_statement" do
     it "should return a hash of table_name, column_names for SQL Server input statements" do
       hash = subject.parse_insert_statement("INSERT [dbo].[TASKS] ([TaskID], [TaskName]) VALUES (61, N'Report Thing')")
-      hash.should == { :table_name => :TASKS, :column_names => [:TaskID, :TaskName] }
+      expect(hash).to eq({ :table_name => :TASKS, :column_names => [:TaskID, :TaskName] })
     end
 
     it "should return nil for SQL Server non-insert statements" do
-      subject.parse_insert_statement("CREATE TABLE [dbo].[WORKFLOW](").should be_nil
+      expect(subject.parse_insert_statement("CREATE TABLE [dbo].[WORKFLOW](")).to be_nil
     end
 
     it "should return nil for non-SQL Server insert statements (MySQL)" do
-      subject.parse_insert_statement("INSERT INTO `some_table` (`email`, `name`, `something`, `age`) VALUES ('bob@honk.com','bob', 'some\\'thin,ge())lse1', 25),('joe@joe.com','joe', 'somethingelse2', 54);").should be_nil
+      expect(subject.parse_insert_statement("INSERT INTO `some_table` (`email`, `name`, `something`, `age`) VALUES ('bob@honk.com','bob', 'some\\'thin,ge())lse1', 25),('joe@joe.com','joe', 'somethingelse2', 54);")).to be_nil
     end
   end
 
@@ -20,39 +20,39 @@ describe MyObfuscate::SqlServer do
     it "should split a SQL Server string into fields" do
       string = "INSERT [dbo].[some_table] ([thing1],[thing2]) VALUES (N'bob@bob.com',N'bob', N'somethingelse1',25, '2', 10,    'hi', CAST(0x00009E1A00000000 AS DATETIME))  ;  "
       fields = [['bob@bob.com', 'bob', 'somethingelse1', '25', '2', '10', "hi", "CAST(0x00009E1A00000000 AS DATETIME)"]]
-      subject.rows_to_be_inserted(string).should == fields
+      expect(subject.rows_to_be_inserted(string)).to eq(fields)
     end
 
     it "should work ok with single quote escape" do
       string = "INSERT [dbo].[some_table] ([thing1],[thing2]) VALUES (N'bob,@bob.c  , om', 'bo'', b', N'some\"thingel''se1', 25, '2', 10,    'hi', 5)  ; "
       fields = [['bob,@bob.c  , om', "bo'', b", "some\"thingel''se1", '25', '2', '10', "hi", "5"]]
-      subject.rows_to_be_inserted(string).should == fields
+      expect(subject.rows_to_be_inserted(string)).to eq(fields)
     end
 
     it "should work ok with NULL values" do
       string = "INSERT [dbo].[some_table] ([thing1],[thing2]) VALUES (NULL    , N'bob@bob.com','bob', NULL, 25, N'2', NULL,    'hi', NULL  ); "
       fields = [[nil, 'bob@bob.com', 'bob', nil, '25', '2', nil, "hi", nil]]
-      subject.rows_to_be_inserted(string).should == fields
+      expect(subject.rows_to_be_inserted(string)).to eq(fields)
     end
 
     it "should work with empty strings" do
       string = "INSERT [dbo].[some_table] ([thing1],[thing2]) VALUES (NULL    , N'', ''      , '', 25, '2','',    N'hi','') ;"
       fields = [[nil, '', '','', '25', '2', '', "hi", '']]
-      subject.rows_to_be_inserted(string).should == fields
+      expect(subject.rows_to_be_inserted(string)).to eq(fields)
     end
   end
 
   describe "#make_valid_value_string" do
     it "should output 'NULL' when the value is nil" do
-      subject.make_valid_value_string(nil).should == "NULL"
+      expect(subject.make_valid_value_string(nil)).to eq("NULL")
     end
 
     it "should enclose the value in quotes if it's a string" do
-      subject.make_valid_value_string("something").should == "N'something'"
+      expect(subject.make_valid_value_string("something")).to eq("N'something'")
     end
 
     it "should not enclose the value in quotes if it is a method call" do
-      subject.make_valid_value_string("CAST(0x00009E1A00000000 AS DATETIME)").should == "CAST(0x00009E1A00000000 AS DATETIME)"
+      expect(subject.make_valid_value_string("CAST(0x00009E1A00000000 AS DATETIME)")).to eq("CAST(0x00009E1A00000000 AS DATETIME)")
     end
   end
 end

data/spec/my_obfuscate_spec.rb

@@ -14,12 +14,12 @@ describe MyObfuscate do
     it "should yield each subinsert and reassemble the result" do
       count = 0
       reassembled = MyObfuscate.new.reassembling_each_insert(@test_insert, "some_table", @column_names) do |sub_insert|
-        sub_insert.should == @test_insert_passes.shift
+        expect(sub_insert).to eq(@test_insert_passes.shift)
         count += 1
         sub_insert
       end
-      count.should == 2
-      reassembled.should == @test_insert
+      expect(count).to eq(2)
+      expect(reassembled).to eq(@test_insert)
     end
   end
 
@@ -74,25 +74,25 @@ COPY some_table_to_keep (a, b) FROM stdin;
       end
 
       it "is able to obfuscate single column tables" do
-        output_string.should_not include("1\n2\n")
-        output_string.should match(/\d\n\d\n/)
+        expect(output_string).not_to include("1\n2\n")
+        expect(output_string).to match(/\d\n\d\n/)
       end
 
       it "is able to truncate tables" do
-        output_string.should_not include("1\t2\t3\t4")
+        expect(output_string).not_to include("1\t2\t3\t4")
       end
 
       it "can obfuscate the tables" do
-        output_string.should include("COPY some_table (id, email, name, something, age) FROM stdin;\n")
-        output_string.should match(/1\t.*\t\S{8}\tmoose\t\d{2}\n/)
+        expect(output_string).to include("COPY some_table (id, email, name, something, age) FROM stdin;\n")
+        expect(output_string).to match(/1\t.*\t\S{8}\tmoose\t\d{2}\n/)
       end
 
       it "can skip nils" do
-        output_string.should match(/\d\n\d\n\\N/)
+        expect(output_string).to match(/\d\n\d\n\\N/)
       end
 
       it "is able to keep tables" do
-        output_string.should include("5\t6")
+        expect(output_string).to include("5\t6")
       end
 
       context "when dump contains INSERT statement" do
@@ -118,7 +118,7 @@ COPY some_table_to_keep (a, b) FROM stdin;
           ddo.obfuscate(input, output)
           input.rewind
           output.rewind
-          output.read.should == string
+          expect(output.read).to eq(string)
         end
       end
 
@@ -137,9 +137,9 @@ COPY some_table_to_keep (a, b) FROM stdin;
         end
 
         it "should raise an error if a column name can't be found" do
-          lambda {
+          expect {
             @ddo.obfuscate(@database_dump, @output)
-          }.should raise_error
+          }.to raise_error
         end
       end
 
@@ -176,35 +176,35 @@ COPY some_table_to_keep (a, b) FROM stdin;
         end
 
         it "should be able to truncate tables" do
-          @output_string.should_not include("INSERT INTO `another_table`")
-          @output_string.should include("INSERT INTO `one_more_table`")
+          expect(@output_string).not_to include("INSERT INTO `another_table`")
+          expect(@output_string).to include("INSERT INTO `one_more_table`")
         end
 
         it "should be able to declare tables to keep" do
-          @output_string.should include("INSERT INTO `some_table_to_keep` (`a`, `b`, `c`, `d`) VALUES (1,2,3,4), (5,6,7,8);")
+          expect(@output_string).to include("INSERT INTO `some_table_to_keep` (`a`, `b`, `c`, `d`) VALUES (1,2,3,4), (5,6,7,8);")
         end
 
         it "should ignore tables that it doesn't know about, but should warn" do
-          @output_string.should include("INSERT INTO `an_ignored_table` (`col`, `col2`) VALUES ('hello','kjhjd^&dkjh'), ('hello1','kjhj!'), ('hello2','moose!!');")
+          expect(@output_string).to include("INSERT INTO `an_ignored_table` (`col`, `col2`) VALUES ('hello','kjhjd^&dkjh'), ('hello1','kjhj!'), ('hello2','moose!!');")
           @error_output.rewind
-          @error_output.read.should =~ /an_ignored_table was not specified in the config/
+          expect(@error_output.read).to match(/an_ignored_table was not specified in the config/)
         end
 
         it "should obfuscate the tables" do
-          @output_string.should include("INSERT INTO `some_table` (`email`, `name`, `something`, `age`) VALUES (")
-          @output_string.should include("INSERT INTO `one_more_table` (`a`, `password`, `c`, `d,d`) VALUES (")
-          @output_string.should include("'some\\'thin,ge())lse1'")
-          @output_string.should include("INSERT INTO `one_more_table` (`a`, `password`, `c`, `d,d`) VALUES ('hello','monkey',NULL),('hello1','monkey',NULL),('hello2','monkey',NULL);")
-          @output_string.should_not include("INSERT INTO `one_more_table` (`a`, `password`, `c`, `d,d`) VALUES ('hello','kjhjd^&dkjh', 'aawefjkafe'), ('hello1','kjhj!', 892938), ('hello2','moose!!', NULL);")
-          @output_string.should_not include("INSERT INTO `one_more_table` (`a`, `password`, `c`, `d,d`) VALUES ('hello','kjhjd^&dkjh','aawefjkafe'),('hello1','kjhj!',892938),('hello2','moose!!',NULL);")
-          @output_string.should_not include("INSERT INTO `some_table` (`email`, `name`, `something`, `age`) VALUES ('bob@honk.com','bob', 'some\\'thin,ge())lse1', 25),('joe@joe.com','joe', 'somethingelse2', 54);")
+          expect(@output_string).to include("INSERT INTO `some_table` (`email`, `name`, `something`, `age`) VALUES (")
+          expect(@output_string).to include("INSERT INTO `one_more_table` (`a`, `password`, `c`, `d,d`) VALUES (")
+          expect(@output_string).to include("'some\\'thin,ge())lse1'")
+          expect(@output_string).to include("INSERT INTO `one_more_table` (`a`, `password`, `c`, `d,d`) VALUES ('hello','monkey',NULL),('hello1','monkey',NULL),('hello2','monkey',NULL);")
+          expect(@output_string).not_to include("INSERT INTO `one_more_table` (`a`, `password`, `c`, `d,d`) VALUES ('hello','kjhjd^&dkjh', 'aawefjkafe'), ('hello1','kjhj!', 892938), ('hello2','moose!!', NULL);")
+          expect(@output_string).not_to include("INSERT INTO `one_more_table` (`a`, `password`, `c`, `d,d`) VALUES ('hello','kjhjd^&dkjh','aawefjkafe'),('hello1','kjhj!',892938),('hello2','moose!!',NULL);")
+          expect(@output_string).not_to include("INSERT INTO `some_table` (`email`, `name`, `something`, `age`) VALUES ('bob@honk.com','bob', 'some\\'thin,ge())lse1', 25),('joe@joe.com','joe', 'somethingelse2', 54);")
         end
 
         it "honors a special case: on the people table, rows with skip_regexes that match are skipped" do
-          @output_string.should include("('bob@honk.com',")
-          @output_string.should include("('dontmurderme@direwolf.com',")
-          @output_string.should_not include("joe@joe.com")
-          @output_string.should include("example.com")
+          expect(@output_string).to include("('bob@honk.com',")
+          expect(@output_string).to include("('dontmurderme@direwolf.com',")
+          expect(@output_string).not_to include("joe@joe.com")
+          expect(@output_string).to include("example.com")
         end
       end
 
@@ -225,16 +225,16 @@ COPY some_table_to_keep (a, b) FROM stdin;
         end
 
         it "should raise an exception when an unspecified column is found" do
-          lambda {
+          expect {
             @ddo.obfuscate(@database_dump, StringIO.new)
-          }.should raise_error(/column 'something' defined/i)
+          }.to raise_error(/column 'something' defined/i)
         end
 
         it "should accept columns defined in globally_kept_columns" do
           @ddo.globally_kept_columns = %w[something]
-          lambda {
+          expect {
             @ddo.obfuscate(@database_dump, StringIO.new)
-          }.should_not raise_error
+          }.not_to raise_error
         end
       end
     end
@@ -250,7 +250,7 @@ COPY some_table_to_keep (a, b) FROM stdin;
           ddo.obfuscate(input, output)
           input.rewind
           output.rewind
-          output.read.should == string
+          expect(output.read).to eq(string)
         end
       end
 
@@ -270,9 +270,9 @@ COPY some_table_to_keep (a, b) FROM stdin;
         end
 
         it "should raise an error if a column name can't be found" do
-          lambda {
+          expect {
             @ddo.obfuscate(@database_dump, @output)
-          }.should raise_error
+          }.to raise_error
         end
       end
 
@@ -320,42 +320,42 @@ COPY some_table_to_keep (a, b) FROM stdin;
         end
 
         it "should be able to truncate tables" do
-          @output_string.should_not include("INSERT [dbo].[another_table]")
-          @output_string.should include("INSERT [dbo].[one_more_table]")
+          expect(@output_string).not_to include("INSERT [dbo].[another_table]")
+          expect(@output_string).to include("INSERT [dbo].[one_more_table]")
         end
 
         it "should be able to declare tables to keep" do
-          @output_string.should include("INSERT [dbo].[some_table_to_keep] ([a], [b], [c], [d]) VALUES (1,2,3,4);")
-          @output_string.should include("INSERT [dbo].[some_table_to_keep] ([a], [b], [c], [d]) VALUES (5,6,7,8);")
+          expect(@output_string).to include("INSERT [dbo].[some_table_to_keep] ([a], [b], [c], [d]) VALUES (1,2,3,4);")
+          expect(@output_string).to include("INSERT [dbo].[some_table_to_keep] ([a], [b], [c], [d]) VALUES (5,6,7,8);")
         end
 
         it "should ignore tables that it doesn't know about, but should warn" do
-          @output_string.should include("INSERT [dbo].[an_ignored_table] ([col], [col2]) VALUES (N'hello',N'kjhjd^&dkjh');")
-          @output_string.should include("INSERT [dbo].[an_ignored_table] ([col], [col2]) VALUES (N'hello1',N'kjhj!');")
-          @output_string.should include("INSERT [dbo].[an_ignored_table] ([col], [col2]) VALUES (N'hello2',N'moose!!');")
+          expect(@output_string).to include("INSERT [dbo].[an_ignored_table] ([col], [col2]) VALUES (N'hello',N'kjhjd^&dkjh');")
+          expect(@output_string).to include("INSERT [dbo].[an_ignored_table] ([col], [col2]) VALUES (N'hello1',N'kjhj!');")
+          expect(@output_string).to include("INSERT [dbo].[an_ignored_table] ([col], [col2]) VALUES (N'hello2',N'moose!!');")
           @error_output.rewind
-          @error_output.read.should =~ /an_ignored_table was not specified in the config/
+          expect(@error_output.read).to match(/an_ignored_table was not specified in the config/)
         end
 
         it "should obfuscate the tables" do
-          @output_string.should include("INSERT [dbo].[some_table] ([email], [name], [something], [age], [bday]) VALUES (")
-          @output_string.should include("CAST(0x00009E1A00000000 AS DATETIME)")
-          @output_string.should include("INSERT [dbo].[one_more_table] ([a], [password], [c], [d,d]) VALUES (")
-          @output_string.should include("'some''thin,ge())lse1'")
-          @output_string.should include("INSERT [dbo].[one_more_table] ([a], [password], [c], [d,d]) VALUES (N'hello',N'monkey',NULL);")
-          @output_string.should include("INSERT [dbo].[one_more_table] ([a], [password], [c], [d,d]) VALUES (N'hello1',N'monkey',NULL);")
-          @output_string.should include("INSERT [dbo].[one_more_table] ([a], [password], [c], [d,d]) VALUES (N'hello2',N'monkey',NULL);")
-          @output_string.should_not include("INSERT [dbo].[one_more_table] ([a], [password], [c], [d,d]) VALUES (N'hello',N'kjhjd^&dkjh', N'aawefjkafe');")
-          @output_string.should_not include("INSERT [dbo].[one_more_table] ([a], [password], [c], [d,d]) VALUES (N'hello1',N'kjhj!', 892938);")
-          @output_string.should_not include("INSERT [dbo].[one_more_table] ([a], [password], [c], [d,d]) VALUES (N'hello2',N'moose!!', NULL);")
-          @output_string.should_not include("INSERT [dbo].[some_table] ([email], [name], [something], [age]) VALUES (N'bob@honk.com',N'bob', N'some''thin,ge())lse1', 25, CAST(0x00009E1A00000000 AS DATETIME));")
-          @output_string.should_not include("INSERT [dbo].[some_table] ([email], [name], [something], [age]) VALUES (N'joe@joe.com',N'joe', N'somethingelse2', 54, CAST(0x00009E1A00000000 AS DATETIME));")
+          expect(@output_string).to include("INSERT [dbo].[some_table] ([email], [name], [something], [age], [bday]) VALUES (")
+          expect(@output_string).to include("CAST(0x00009E1A00000000 AS DATETIME)")
+          expect(@output_string).to include("INSERT [dbo].[one_more_table] ([a], [password], [c], [d,d]) VALUES (")
+          expect(@output_string).to include("'some''thin,ge())lse1'")
+          expect(@output_string).to include("INSERT [dbo].[one_more_table] ([a], [password], [c], [d,d]) VALUES (N'hello',N'monkey',NULL);")
+          expect(@output_string).to include("INSERT [dbo].[one_more_table] ([a], [password], [c], [d,d]) VALUES (N'hello1',N'monkey',NULL);")
+          expect(@output_string).to include("INSERT [dbo].[one_more_table] ([a], [password], [c], [d,d]) VALUES (N'hello2',N'monkey',NULL);")
+          expect(@output_string).not_to include("INSERT [dbo].[one_more_table] ([a], [password], [c], [d,d]) VALUES (N'hello',N'kjhjd^&dkjh', N'aawefjkafe');")
+          expect(@output_string).not_to include("INSERT [dbo].[one_more_table] ([a], [password], [c], [d,d]) VALUES (N'hello1',N'kjhj!', 892938);")
+          expect(@output_string).not_to include("INSERT [dbo].[one_more_table] ([a], [password], [c], [d,d]) VALUES (N'hello2',N'moose!!', NULL);")
+          expect(@output_string).not_to include("INSERT [dbo].[some_table] ([email], [name], [something], [age]) VALUES (N'bob@honk.com',N'bob', N'some''thin,ge())lse1', 25, CAST(0x00009E1A00000000 AS DATETIME));")
+          expect(@output_string).not_to include("INSERT [dbo].[some_table] ([email], [name], [something], [age]) VALUES (N'joe@joe.com',N'joe', N'somethingelse2', 54, CAST(0x00009E1A00000000 AS DATETIME));")
         end
 
         it "honors a special case: on the people table, rows with anything@honk.com in a slot marked with :honk_email_skip do not change this slot" do
-          @output_string.should include("(N'bob@honk.com',")
-          @output_string.should include("(N'dontmurderme@direwolf.com',")
-          @output_string.should_not include("joe@joe.com")
+          expect(@output_string).to include("(N'bob@honk.com',")
+          expect(@output_string).to include("(N'dontmurderme@direwolf.com',")
+          expect(@output_string).not_to include("joe@joe.com")
         end
       end
 
@@ -377,16 +377,16 @@ COPY some_table_to_keep (a, b) FROM stdin;
         end
 
         it "should raise an exception when an unspecified column is found" do
-          lambda {
+          expect {
             @ddo.obfuscate(@database_dump, StringIO.new)
-          }.should raise_error(/column 'something' defined/i)
+          }.to raise_error(/column 'something' defined/i)
         end
 
         it "should accept columns defined in globally_kept_columns" do
           @ddo.globally_kept_columns = %w[something]
-          lambda {
+          expect {
             @ddo.obfuscate(@database_dump, StringIO.new)
-          }.should_not raise_error
+          }.not_to raise_error
         end
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: my_obfuscate
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.5.3
 platform: ruby
 authors:
 - Andrew Cantino
@@ -13,7 +13,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-19 00:00:00.000000000 Z
+date: 2014-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffaker