honkster-my_obfuscate 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,6 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+.idea

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009 Honk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,55 @@
+= my_obfuscate
+
+Standalone Ruby code for the selective rewriting of MySQL dumps in order to protect user privacy.
+
+= Example Usage
+
+Make an obfuscator.rb script:
+
+  #!/usr/bin/env ruby
+  require "rubygems"
+  require "my_obfuscate"
+
+  obfuscator = MyObfuscate.new({
+    :people => {
+      :email                     => { :type => :email, :skip_regexes => [/^[\w\.\_]+@my_company\.com$/i] },
+      :ethnicity                 => { :type => :null },
+      :crypted_password          => { :type => :fixed, :string => "SOME_FIXED_PASSWORD_FOR_EASE_OF_DEBUGGING" },
+      :salt                      => { :type => :fixed, :string => "SOME_THING" },
+      :remember_token            => { :type => :null },
+      :remember_token_expires_at => { :type => :null },
+      :photo_file_name           => { :type => :null },
+      :photo_content_type        => { :type => :null },
+      :photo_file_size           => { :type => :null },
+      :photo_updated_at          => { :type => :null },
+      :postal_code               => { :type => :fixed, :string => "94109" },
+      :name                      => { :type => :fixed, :string => "Production User" },
+      :relationship_status       => { :type => :fixed, :one_of => ["Single", "Divorced", "Married", "Engaged", "In a Relationship"] },
+      :has_children              => { :type => :integer, :between => 0..1 },
+    },
+
+    :invites                     => :truncate,
+    :invite_requests             => :truncate,
+
+    :relationships => {
+      :account_id                => { :type => :string, :length => 8, :chars => DatabaseDumpObfuscator::NUMBER_CHARS },
+      :code                      => { :type => :string, :length => 8, :chars => DatabaseDumpObfuscator::USERNAME_CHARS }
+    }
+  })
+  obfuscator.obfuscate(STDIN, STDOUT)
+
+And to get an obfuscated dump:
+  mysqldump -c --add-drop-table -u user -p database | ruby obfuscator.rb > obfuscated_dump.sql
+Note that the -c option on mysqldump is required to use my_obfuscator.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.  (If you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 Honk. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "my_obfuscate"
+    gem.summary = %Q{Standalone Ruby code for the selective rewriting of MySQL dumps in order to protect user privacy.}
+    gem.description = %Q{Standalone Ruby code for the selective rewriting of MySQL dumps in order to protect user privacy.}
+    gem.email = "andrew@pivotallabs.com"
+    gem.homepage = "http://github.com/honkster/myobfuscate"
+    gem.authors = ["Andrew Cantino", "Dave Willett", "Mike Grafton", "Mason Glaves"]
+    gem.add_development_dependency "rspec"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "my_obfuscate #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/my_obfuscate.rb

@@ -0,0 +1,173 @@
+# This can parse mysqldump outputs when the dumps have option -c, which includes column names in the insert statements.
+require 'jcode'
+
+class MyObfuscate
+  attr_accessor :config
+
+  INSERT_REGEX = /^\s*INSERT INTO `(.*?)` \((.*?)\) VALUES\s*/i
+  NUMBER_CHARS = "1234567890"
+  USERNAME_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_" + NUMBER_CHARS
+  SENSIBLE_CHARS = USERNAME_CHARS + '+-=[{]}/?|!@#$%^&*()`~'
+
+  def initialize(configuration = {})
+    @config = configuration
+  end
+
+  # We assume that every INSERT INTO line occupies one line in the file, with no internal linebreaks.
+  def obfuscate(input_io, output_io)
+    input_io.each do |line|
+      if regex_result = INSERT_REGEX.match(line)
+        table_name = regex_result[1].to_sym
+        columns = regex_result[2].split(/`\s*,\s*`/).map { |col| col.gsub('`',"").to_sym }
+        if config[table_name]
+          output_io.puts obfuscate_line(line, table_name, columns)
+        else
+          output_io.write line
+        end
+      else
+        output_io.write line
+      end
+    end
+  end
+
+  def self.reasembling_each_insert(line, table_name, columns)
+    line = line.gsub(INSERT_REGEX, '').gsub(/\s*;\s*$/, '')
+    output = context_aware_mysql_string_split(line).map do |sub_insert|
+      result = yield(sub_insert)
+      result = result.map do |i|
+        if i.nil?
+          "NULL"
+        else
+          "'" + i + "'"
+        end
+      end
+      result = result.join(",")
+      "(" + result + ")"
+    end.join(",")
+    "INSERT INTO `#{table_name}` (`#{columns.join('`, `')}`) VALUES #{output};"
+  end
+
+  # Note: Strings must be quoted in single quotes!
+  def self.context_aware_mysql_string_split(string)
+    in_sub_insert = false
+    in_quoted_string = false
+    escaped = false
+    current_field = nil
+    length = string.length
+    index = 0
+    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
+      index += 1
+    end
+    fields << current_field unless current_field.nil?
+    output << fields unless fields.length == 0
+    output
+  end
+
+  def self.apply_table_config(row, table_config, columns)
+    return row unless table_config.is_a?(Hash)
+
+    table_config.each do |column, definition|
+      # Don't change email addresses when they end in @honk.com.
+      index = columns.index(column)
+
+      if definition[:skip_regexes]
+        next if definition[:skip_regexes].any? {|regex| row[index] =~ regex}
+      end
+
+      row[index.to_i] = case definition[:type]
+        when :email
+          random_string(4..10, USERNAME_CHARS) + "@example.com"
+        when :string
+          random_string(definition[:length], definition[:chars] || SENSIBLE_CHARS)
+        when :integer
+          random_integer(definition[:between] || (0..1000)).to_s
+        when :fixed
+          if definition[:one_of]
+            definition[:one_of][(rand * definition[:one_of].length).to_i]
+          else
+            definition[:string]
+          end
+        when :null
+          nil
+        else
+          row[index]
+      end
+    end
+    row
+  end
+
+  def self.random_integer(between)
+    (between.min + (between.max - between.min) * rand).round
+  end
+
+  def self.random_string(length_or_range, chars)
+    length_or_range = (length_or_range..length_or_range) if length_or_range.is_a?(Fixnum)
+    times = random_integer(length_or_range)
+    out = ""
+    times.times { out << chars[rand * chars.length] }
+    out
+  end
+
+  def check_for_missing_columns(table_name, columns)
+    missing_columns = config[table_name].keys - columns
+    unless missing_columns.length == 0
+      error_message = missing_columns.map do |missing_column|
+        "Column '#{missing_column}' could not be found in table '#{table_name}', please fix your obfuscator config."
+      end.join("\n")
+       raise RuntimeError.new(error_message)
+    end
+  end
+
+  def obfuscate_line(line, table_name, columns)
+    table_config = config[table_name]
+    if table_config == :truncate
+      ""
+    else
+      check_for_missing_columns(table_name, columns)
+      # Note: Remember to SQL escape strings in what you pass back.
+      MyObfuscate.reasembling_each_insert(line, table_name, columns) do |row|
+        MyObfuscate.apply_table_config(row, table_config, columns)
+      end
+    end
+  end
+end

data/spec/my_obfuscate_spec.rb

@@ -0,0 +1,196 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe MyObfuscate do
+  describe "MyObfuscate.context_aware_mysql_string_split" do
+    it "should split a mysql string into fields" do
+      string = "('bob@bob.com','bob', 'somethingelse1', 25, '2', 10,    'hi')"
+      fields = [['bob@bob.com', 'bob', 'somethingelse1', '25', '2', '10', "hi"]]
+      MyObfuscate.context_aware_mysql_string_split(string).should == fields
+    end
+
+    it "should work ok with escaped characters" do
+      string = "('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"]]
+      MyObfuscate.context_aware_mysql_string_split(string).should == fields
+    end
+
+    it "should work with multiple subinserts" do
+      string = "(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"]]
+      MyObfuscate.context_aware_mysql_string_split(string).should == fields
+    end
+
+    it "should work ok with NULL values" do
+      string = "(NULL    , 'bob@bob.com','bob', NULL, 25, '2', NULL,    'hi', NULL  )"
+      fields = [[nil, 'bob@bob.com', 'bob', nil, '25', '2', nil, "hi", nil]]
+      MyObfuscate.context_aware_mysql_string_split(string).should == fields
+    end
+
+    it "should work with empty strings" do
+      string = "(NULL    , '', ''      , '', 25, '2','',    'hi','')"
+      fields = [[nil, '', '', '', '25', '2', '', "hi", '']]
+      MyObfuscate.context_aware_mysql_string_split(string).should == fields
+    end
+  end
+
+  describe "MyObfuscate.reasembling_each_insert" do
+    before do
+      @column_names = [:a, :b, :c, :d]
+      @test_insert = "INSERT INTO `some_table` (`a`, `b`, `c`, `d`) VALUES ('(\\'bob@bob.com','b()ob','some(thingelse1','25)('),('joe@joe.com','joe','somethingelse2','54');"
+      @test_insert_passes = [
+        ["(\\'bob@bob.com","b()ob", "some(thingelse1", "25)("],
+        ["joe@joe.com","joe", "somethingelse2", "54"]
+      ]
+    end
+
+    it "should yield each subinsert and reassemble the result" do
+      count = 0
+      reassembled = MyObfuscate.reasembling_each_insert(@test_insert, "some_table", @column_names) do |sub_insert|
+        sub_insert.should == @test_insert_passes.shift
+        count += 1
+        sub_insert
+      end
+      count.should == 2
+      reassembled.should == @test_insert
+    end
+  end
+
+  describe "MyObfuscate.apply_table_config" do
+    it "should work on email addresses" 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+\.\w+$/
+    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
+
+    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 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
+      end
+      looking_for.should be_empty
+    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
+
+  end
+
+  describe "#obfuscate" 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
+        ddo = MyObfuscate.new
+        string = "hello, world\nsup?"
+        input = StringIO.new(string)
+        output = StringIO.new
+        ddo.obfuscate(input, output)
+        input.rewind
+        output.rewind
+        output.read.should == string
+      end
+    end
+
+    context "when the dump to obfuscate is missing columns" do
+      before do
+        @database_dump = StringIO.new(<<-SQL)
+          INSERT INTO `some_table` (`email`, `name`, `something`, `age`) VALUES ('bob@honk.com','bob', 'some\\'thin,ge())lse1', 25),('joe@joe.com','joe', 'somethingelse2', 54);
+        SQL
+        @ddo = MyObfuscate.new({
+          :some_table => {
+            :email => { :type => :email, :honk_email_skip => true },
+            :name => { :type => :string, :length => 8, :chars => MyObfuscate::USERNAME_CHARS },
+            :gender => { :type => :fixed, :string => "m" }
+          }})
+        @output = StringIO.new
+      end
+
+      it "should raise an error if a column name can't be found" do
+        lambda {
+          @ddo.obfuscate(@database_dump, @output)
+        }.should raise_error
+      end
+    end
+
+    context "when there is something to obfuscate" do
+      before do
+        @database_dump = StringIO.new(<<-SQL)
+          INSERT INTO `some_table` (`email`, `name`, `something`, `age`) VALUES ('bob@honk.com','bob', 'some\\'thin,ge())lse1', 25),('joe@joe.com','joe', 'somethingelse2', 54),('dontmurderme@direwolf.com','direwolf', 'somethingelse3', 44);
+          INSERT INTO `another_table` (`a`, `b`, `c`, `d`) VALUES (1,2,3,4), (5,6,7,8);
+          INSERT INTO `one_more_table` (`a`, `password`, `c`, `d,d`) VALUES ('hello','kjhjd^&dkjh', 'aawefjkafe'), ('hello1','kjhj!', 892938), ('hello2','moose!!', NULL);
+          INSERT INTO `an_ignored_table` (`col`, `col2`) VALUES ('hello','kjhjd^&dkjh'), ('hello1','kjhj!'), ('hello2','moose!!');
+        SQL
+
+        @ddo = 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 }
+          },
+          :another_table => :truncate,
+          :one_more_table => {
+            # Note: fixed strings must be pre-SQL escaped!
+            :password => { :type => :fixed, :string => "monkey" },
+            :c => { :type => :null }
+          }
+        })
+        @output = StringIO.new
+        @ddo.obfuscate(@database_dump, @output)
+        @output.rewind
+        @output_string = @output.read
+      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`")
+      end
+
+      it "should ignore tables that it doesn't know about" do
+        @output_string.should include("INSERT INTO `an_ignored_table` (`col`, `col2`) VALUES ('hello','kjhjd^&dkjh'), ('hello1','kjhj!'), ('hello2','moose!!');")
+      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);")
+      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("('bob@honk.com',")
+        @output_string.should include("('dontmurderme@direwolf.com',")
+        @output_string.should_not include("joe@joe.com")
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rubygems'
+require 'my_obfuscate'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: honkster-my_obfuscate
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Andrew Cantino
+- Dave Willett
+- Mike Grafton
+- Mason Glaves
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-23 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Standalone Ruby code for the selective rewriting of MySQL dumps in order to protect user privacy.
+email: andrew@pivotallabs.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/my_obfuscate.rb
+- spec/my_obfuscate_spec.rb
+- spec/spec_helper.rb
+has_rdoc: false
+homepage: http://github.com/honkster/myobfuscate
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+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_spec.rb
+- spec/spec_helper.rb