my_obfuscate 0.4.2 → 0.5.0

data/spec/my_obfuscate_spec.rb

@@ -23,259 +23,91 @@ describe MyObfuscate do
     end
   end
 
-  describe "MyObfuscate.apply_table_config" do
-    it "should work on email addresses" do
-      100.times do
-        new_row = MyObfuscate.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$/
-      end
-    end
-
-    it "should work on strings" do
-      new_row = MyObfuscate.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"
-    end
-
-    describe "conditional directives" do
-      it "should honor :unless conditionals" do
-        new_row = MyObfuscate.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"
-
-        new_row = MyObfuscate.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"
-
-        new_row = MyObfuscate.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"
+  describe "#obfuscate" do
 
-        new_row = MyObfuscate.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"
+    describe "when using Postgres" do
+      let(:dump) do
+        StringIO.new(<<-SQL)
+COPY some_table (id, email, name, something, age) FROM stdin;
+1	hello	monkey	moose	14
+\.
+
+COPY single_column_table (id) FROM stdin;
+1
+2
+\\N
+\.
+
+COPY another_table (a, b, c, d) FROM stdin;
+1	2	3	4
+1	2	3	4
+\.
+
+COPY some_table_to_keep (a, b) FROM stdin;
+5	6
+\.
+        SQL
       end
 
-      it "should honor :if conditionals" do
-        new_row = MyObfuscate.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"
-
-        new_row = MyObfuscate.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"
-
-        new_row = MyObfuscate.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"
-
-        new_row = MyObfuscate.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"
+      let(:obfuscator) do
+        MyObfuscate.new({
+          :some_table => {
+            :email => {:type => :email, :skip_regexes => [/^[\w\.\_]+@honk\.com$/i, /^dontmurderme@direwolf.com$/]},
+            :name => {:type => :string, :length => 8, :chars => MyObfuscate::USERNAME_CHARS},
+            :age => {:type => :integer, :between => 10...80, :unless => :nil },
+          },
+          :single_column_table => {
+            :id => {:type => :integer, :between => 1...8, :unless => :nil}
+          },
+          :another_table => :truncate,
+          :some_table_to_keep => :keep
+        }).tap do |obfuscator|
+          obfuscator.database_type = :postgres
+        end
       end
 
-      it "should supply the original row values to the conditional" do
-        new_row = MyObfuscate.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"
+      let(:output_string) do
+        output = StringIO.new
+        obfuscator.obfuscate(dump, output)
+        output.rewind
+        output.read
       end
 
-      it "should honor combined :unless and :if conditionals" do
-        #both true
-        new_row = MyObfuscate.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"
-
-        #both false
-        new_row = MyObfuscate.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"
-
-        #if true, #unless false
-        new_row = MyObfuscate.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"
-
-        #if false, #unless true
-        new_row = MyObfuscate.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"
+      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/)
       end
-    end
-
-    it "should be able to generate random integers in ranges" do
-      new_row = MyObfuscate.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"
-    end
-
-    it "should be able to substitute fixed strings" do
-      new_row = MyObfuscate.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"
-    end
-
-    it "should be able to substitute a proc that returns a string" do
-      new_row = MyObfuscate.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"
-    end
-
-    it "should provide the row to the proc" do
-      new_row = MyObfuscate.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"
-    end
 
-    it "should be able to substitute fixed strings from a random set" do
-      looking_for = ["hello", "world"]
-      original_looking_for = looking_for.dup
-      guard = 0
-      while !looking_for.empty? && guard < 1000
-        new_row = MyObfuscate.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])
-        looking_for.delete new_row[0]
-        guard += 1
+      it "is able to truncate tables" do
+        output_string.should_not include("1\t2\t3\t4")
       end
-      looking_for.should be_empty
-    end
-
-    it "should treat a symbol in the column definition as an implicit { :type => symbol }" do
-      new_row = MyObfuscate.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
-    end
-
-    it "should be able to set things NULL" do
-      new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:b => {:type => :null}}, [:a, :b, :c])
-      new_row.length.should == 3
-      new_row[1].should == nil
-    end
 
-    it "should be able to :keep the value the same" do
-      new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:b => {:type => :keep}}, [:a, :b, :c])
-      new_row.length.should == 3
-      new_row[1].should == "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.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"
-      error_output.rewind
-      error_output.read.should =~ /Keeping a column value by.*?unknown_type/
-    end
-
-    it "should be able to substitute lorem ipsum text" do
-      new_row = MyObfuscate.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)/
-    end
-
-    it "should be able to generate an :company" do
-      new_row = MyObfuscate.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+/
-    end
-
-    it "should be able to generate an :url" do
-      new_row = MyObfuscate.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+/
-    end
-
-    it "should be able to generate an :ipv4" do
-      new_row = MyObfuscate.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+/
-    end
-
-    it "should be able to generate an :ipv6" do
-      new_row = MyObfuscate.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:]+/
-    end
-
-    it "should be able to generate an :address" do
-      new_row = MyObfuscate.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/
-    end
-
-    it "should be able to generate a :name" do
-      new_row = MyObfuscate.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 =~ / /
-    end
-
-    it "should be able to generate just a street address" do
-      new_row = MyObfuscate.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/
-    end
-
-    it "should be able to generate a city" do
-      new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:a => :city}, [:a, :b, :c])
-      new_row.length.should == 3
-      new_row[0].should_not == "blah"
-    end
-
-    it "should be able to generate a state" do
-      new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:a => :state}, [:a, :b, :c])
-      new_row.length.should == 3
-      new_row[0].should_not == "blah"
-    end
-
-    it "should be able to generate a zip code" do
-      new_row = MyObfuscate.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+/
-    end
-
-    it "should be able to generate a phone number" do
-      new_row = MyObfuscate.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+/
-    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/)
+      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"])
+      it "can skip nils" do
+        output_string.should match(/\d\n\d\n\\N/)
       end
 
-      it "should remove single quotes from the value" do
-        new_row = MyObfuscate.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("'")}
+      it "is able to keep tables" do
+        output_string.should include("5\t6")
       end
-    end
-  end
 
-  describe "MyObfuscate.row_as_hash" do
-    it "will map row values into a hash with column names as keys" do
-      MyObfuscate.row_as_hash([1, 2, 3, 4], [:a, :b, :c, :d]).should == {:a => 1, :b => 2, :c => 3, :d => 4}
+      context "when dump contains INSERT statement" do
+        let(:dump) do
+          StringIO.new(<<-SQL)
+          INSERT INTO some_table (email, name, something, age) VALUES ('','', '', 25);
+          SQL
+        end
+
+        it "raises an error if using postgres with insert statements" do
+          expect { output_string }.to raise_error RuntimeError
+        end
+      end
     end
-  end
 
-  describe "#obfuscate" do
     describe "when using MySQL" do
       context "when there is nothing to obfuscate" do
         it "should accept an IO object for input and output, and copy the input to the output" do
@@ -560,22 +392,4 @@ describe MyObfuscate do
     end
   end
 
-  describe "MyObfuscate.random_english_sentences" do
-    before do
-      File.should_receive(:read).once.and_return("hello 2")
-    end
-
-    after do
-      MyObfuscate.class_variable_set(:@@walker_method, nil)
-    end
-
-    it "should only load file data once" do
-      MyObfuscate.random_english_sentences(1)
-      MyObfuscate.random_english_sentences(1)
-    end
-
-    it "should make random sentences" do
-      MyObfuscate.random_english_sentences(2).should =~ /^(Hello( hello)+\.\s*){2}$/
-    end
-  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: my_obfuscate
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -14,7 +14,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-19 00:00:00.000000000 Z
+date: 2013-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffaker
@@ -81,14 +81,16 @@ files:
 - README.rdoc
 - Rakefile
 - lib/my_obfuscate.rb
+- lib/my_obfuscate/config_applicator.rb
+- lib/my_obfuscate/copy_statement_parser.rb
 - lib/my_obfuscate/data/en_50K.txt
-- lib/my_obfuscate/database_helper_shared.rb
+- lib/my_obfuscate/insert_statement_parser.rb
 - lib/my_obfuscate/mysql.rb
 - lib/my_obfuscate/postgres.rb
 - lib/my_obfuscate/sql_server.rb
 - lib/my_obfuscate/version.rb
 - my_obfuscate.gemspec
-- spec/my_obfuscate/database_helper_shared_examples.rb
+- spec/my_obfuscate/config_applicator_spec.rb
 - spec/my_obfuscate/mysql_spec.rb
 - spec/my_obfuscate/postgres_spec.rb
 - spec/my_obfuscate/sql_server_spec.rb
@@ -106,12 +108,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -3837317956098697569
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -3837317956098697569
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25
@@ -120,7 +128,7 @@ specification_version: 3
 summary: Standalone Ruby code for the selective rewriting of MySQL dumps in order
   to protect user privacy.
 test_files:
-- spec/my_obfuscate/database_helper_shared_examples.rb
+- spec/my_obfuscate/config_applicator_spec.rb
 - spec/my_obfuscate/mysql_spec.rb
 - spec/my_obfuscate/postgres_spec.rb
 - spec/my_obfuscate/sql_server_spec.rb

data/lib/my_obfuscate/database_helper_shared.rb

@@ -1,76 +0,0 @@
-class MyObfuscate
-  module DatabaseHelperShared
-
-    def rows_to_be_inserted(line)
-      line = line.gsub(insert_regex, '').gsub(/\s*;\s*$/, '')
-      context_aware_mysql_string_split(line)
-    end
-
-    def make_valid_value_string(value)
-      if value.nil?
-        "NULL"
-      elsif value =~ /^0x[0-9a-fA-F]+$/
-        value
-      else
-        "'" + value + "'"
-      end
-    end
-
-    # Be aware, strings must be quoted in single quotes!
-    def context_aware_mysql_string_split(string)
-      in_sub_insert = false
-      in_quoted_string = false
-      escaped = false
-      current_field = nil
-      length = string.length
-      fields = []
-      output = []
-
-      string.each_char do |i|
-        if escaped
-          escaped = false
-          current_field ||= ""
-          current_field << i
-        else
-          if i == "\\"
-            escaped = true
-            current_field ||= ""
-            current_field << i
-          elsif i == "(" && !in_quoted_string && !in_sub_insert
-            in_sub_insert = true
-          elsif i == ")" && !in_quoted_string && in_sub_insert
-            fields << current_field unless current_field.nil?
-            output << fields unless fields.length == 0
-            in_sub_insert = false
-            fields = []
-            current_field = nil
-          elsif i == "'" && !in_quoted_string
-            fields << current_field unless current_field.nil?
-            current_field = ''
-            in_quoted_string = true
-          elsif i == "'" && in_quoted_string
-            fields << current_field unless current_field.nil?
-            current_field = nil
-            in_quoted_string = false
-          elsif i == "," && !in_quoted_string && in_sub_insert
-            fields << current_field unless current_field.nil?
-            current_field = nil
-          elsif i == "L" && !in_quoted_string && in_sub_insert && current_field == "NUL"
-            current_field = nil
-            fields << current_field
-          elsif (i == " " || i == "\t") && !in_quoted_string
-            # Don't add whitespace not in a string
-          elsif in_sub_insert
-            current_field ||= ""
-            current_field << i
-          end
-        end
-      end
-
-      fields << current_field unless current_field.nil?
-      output << fields unless fields.length == 0
-      output
-    end
-
-  end
-end

data/spec/my_obfuscate/database_helper_shared_examples.rb

@@ -1,63 +0,0 @@
-shared_examples MyObfuscate::DatabaseHelperShared do
-
-  describe "#rows_to_be_inserted" 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
-    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
-    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
-    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
-    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
-    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
-    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'
-    end
-
-    it "should work with hex-encoded blob data"  do
-      value = "0xACED00057372001F6A6176612E7574696C2E436F6C6C656"
-      subject.make_valid_value_string(value).should == '0xACED00057372001F6A6176612E7574696C2E436F6C6C656'
-    end
-
-    it "should quote hex-encoded ALIKE data"  do
-      value = "40x17x7"
-      subject.make_valid_value_string(value).should == "'40x17x7'"
-    end
-
-    it "should quote all other values" do
-      value = "hello world"
-      subject.make_valid_value_string(value).should == "'hello world'"
-    end
-  end
-
-end