data-anonymization 0.1.2

data/spec/acceptance/rdbms_blacklist_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe "End 2 End RDBMS Blacklist Acceptance Test using SQLite database" do
+  connection_spec = {:adapter => 'sqlite3', :database => 'tmp/customer.sqlite'}
+
+  before(:each) do
+    CustomerSample.clean
+    CustomerSample.create_schema connection_spec
+    CustomerSample.insert_record connection_spec, CustomerSample::SAMPLE_DATA
+  end
+
+  it "should anonymize customer table record " do
+
+    database "Customer" do
+      strategy DataAnon::Strategy::Blacklist
+      source_db connection_spec
+
+      table 'customers' do
+        primary_key 'cust_id'
+        anonymize('email').using DataAnon::Strategy::Field::StringTemplate.new('test+#{row_number}@gmail.com')
+      end
+    end
+
+    DataAnon::Utils::SourceDatabase.establish_connection connection_spec
+    source = DataAnon::Utils::SourceTable.create 'customers', 'cust_id'
+    new_rec = source.find(CustomerSample::SAMPLE_DATA[:cust_id])
+    new_rec['email'].should == 'test+1@gmail.com'
+
+  end
+end

data/spec/acceptance/rdbms_whitelist_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+
+describe "End 2 End RDBMS Whitelist Acceptance Test using SQLite database" do
+
+  source_connection_spec = {:adapter => 'sqlite3', :database => 'tmp/customer.sqlite'}
+  dest_connection_spec = {:adapter => 'sqlite3', :database => 'tmp/customer-dest.sqlite'}
+
+  before(:each) do
+    CustomerSample.clean
+    CustomerSample.create_schema source_connection_spec
+    CustomerSample.insert_record source_connection_spec, CustomerSample::SAMPLE_DATA
+
+    CustomerSample.create_schema dest_connection_spec
+  end
+
+  it "should anonymize customer table record " do
+
+    DF = DataAnon::Strategy::Field
+
+    database "Customer" do
+      strategy DataAnon::Strategy::Whitelist
+      source_db source_connection_spec
+      destination_db dest_connection_spec
+
+      table 'customers' do
+        primary_key 'cust_id'
+        whitelist 'cust_id', 'address', 'zipcode'
+        anonymize('first_name').using DF::RandomFirstName.new
+        anonymize('last_name').using DF::RandomLastName.new
+        anonymize('state').using DF::RandomSelection.new(['Gujrat','Karnataka'])
+        anonymize('phone').using DF::RandomPhoneNumber.new
+        anonymize('email').using DF::StringTemplate.new('test+#{row_number}@gmail.com')
+      end
+    end
+
+    DataAnon::Utils::DestinationDatabase.establish_connection dest_connection_spec
+    dest_table = DataAnon::Utils::DestinationTable.create 'customers', 'cust_id'
+    new_rec = dest_table.find(CustomerSample::SAMPLE_DATA[:cust_id])
+    new_rec.first_name.should_not be("Sunit")
+    new_rec.last_name.should_not be("Parekh")
+    new_rec.birth_date.should_not be(Date.new(1977,7,8))
+    new_rec.address.should == 'F 501 Shanti Nagar'
+    ['Gujrat','Karnataka'].should include(new_rec.state)
+    new_rec.zipcode.should == '411048'
+    new_rec.phone.should_not be "9923700662"
+    new_rec.email.should == 'test+1@gmail.com'
+
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require 'rspec'
+require "pry"
+require 'data-anonymization'
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+DataAnon::Utils::Logging.logger.level = Logger::INFO
+DataAnon::Utils::Logging.progress_logger.level = Logger::WARN
+
+
+RSpec.configure do |config|
+  config.expect_with :rspec
+  config.mock_with 'rspec-mocks'
+
+  config.before(:suite) do
+  end
+
+  config.before(:each) do
+  end
+
+  config.after(:suite) do
+  end
+end
+
+
+

data/spec/strategy/field/anonymize_time_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe DataAnon::Strategy::Field::AnonymizeTime do
+
+  AnonymizeTime = DataAnon::Strategy::Field::AnonymizeTime
+  let(:field) { DataAnon::Core::Field.new('date', Time.new(2000,1,1,12,12,12), 1, nil) }
+
+  describe 'providing true only for month should randomize only the month field' do
+
+    let(:anonymized_time) { AnonymizeTime.new(true,false,false,false,false).anonymize(field) }
+
+    it {
+      anonymized_time.year.should be 2000
+      anonymized_time.day.should be 1
+      anonymized_time.hour.should be 12
+      anonymized_time.min.should be 12
+      anonymized_time.sec.should be 12
+
+      anonymized_time.month.should be_between(1,12)
+    }
+  end
+
+end

data/spec/strategy/field/date_time_delta_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe DataAnon::Strategy::Field::DateTimeDelta do
+
+  DateTimeDelta = DataAnon::Strategy::Field::DateTimeDelta
+  let(:field) { DataAnon::Core::Field.new('date', DateTime.new(2000,1,1), 1, nil) }
+
+  describe 'datetime should not remain the same' do
+
+    let(:anonymized_value) { DateTimeDelta.new().anonymize(field) }
+    let(:date_difference) {anonymized_value.to_i - field.value.to_i}
+
+    it {date_difference.should_not be 0 }
+  end
+
+  describe 'datetime should not change when provided with 0 delta for both date and time' do
+
+    let(:anonymized_value) { DateTimeDelta.new(0,0).anonymize(field) }
+    let(:date_difference) {anonymized_value.to_i - field.value.to_i}
+
+    it {date_difference.should be 0 }
+
+  end
+
+  describe 'date should be anonymized within provided delta' do
+
+    let(:anonymized_value) { DateTimeDelta.new(5,0).anonymize(field) }
+    let(:date_difference) {anonymized_value.to_i - field.value.to_i}
+
+    it { date_difference.should be_between(-5.days, 5.days) }
+
+  end
+
+  describe 'time should be anonymized within provided delta' do
+
+    let(:anonymized_value) { DateTimeDelta.new(0,10).anonymize(field) }
+    let(:date_difference) {anonymized_value.to_i - field.value.to_i}
+
+    it { date_difference.should be_between(-10.minutes, 10.minutes)}
+  end
+
+
+end

data/spec/strategy/field/distinct_column_values_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe DataAnon::Strategy::Field::DistinctColumnValues do
+
+  before(:each) do
+    source = {:adapter => 'sqlite3', :database => 'sample-data/chinook.sqlite'}
+    DataAnon::Utils::SourceDatabase.establish_connection source
+  end
+
+  DistinctColumnValues = DataAnon::Strategy::Field::DistinctColumnValues
+  let(:field) { DataAnon::Core::Field.new('name', 'Abcd', 1, nil) }
+
+  describe 'more than one values in predefined list' do
+
+    let(:anonymized_value) { DistinctColumnValues.new('MediaType','Name').anonymize(field) }
+
+    it { anonymized_value.should_not be('Abcd') }
+    it { anonymized_value.should_not be_empty }
+
+  end
+
+end

data/spec/strategy/field/gmail_template_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+
+describe DataAnon::Strategy::Field::GmailTemplate do
+
+  GmailTemplate = DataAnon::Strategy::Field::GmailTemplate
+  let(:field) {DataAnon::Core::Field.new('email','user@company.com',456,nil)}
+
+  describe 'generated email must be compliant with the provided template' do
+
+    let(:anonymized_email) {GmailTemplate.new("fake@gmail.com").anonymize(field)}
+
+    it {anonymized_email.should eq('fake+456@gmail.com')}
+  end
+end

data/spec/strategy/field/lorem_ipsum_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe DataAnon::Strategy::Field::LoremIpsum do
+
+  LoremIpsum = DataAnon::Strategy::Field::LoremIpsum
+  let(:field) { DataAnon::Core::Field.new('state', 'New Delhi', 1, nil) }
+
+  describe 'should return same length value using default text' do
+
+    let(:anonymized_value) { LoremIpsum.new.anonymize(field) }
+
+    it { anonymized_value.length.should_not be('New Delhi') }
+    it { anonymized_value.length.should == 'New Delhi'.length }
+
+  end
+
+  describe 'should return same length value using set text' do
+
+    let(:anonymized_value) { LoremIpsum.new("Sunit Parekh").anonymize(field) }
+
+    it { anonymized_value.length.should_not be('New Delhi') }
+    it { anonymized_value.should == 'Sunit Par' }
+
+  end
+
+
+end

data/spec/strategy/field/random_boolean_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+describe DataAnon::Strategy::Field::RandomBoolean do
+
+  RandomBoolean = DataAnon::Strategy::Field::RandomBoolean
+  let(:field) {DataAnon::Core::Field.new('boolean_field',true,1,nil)}
+
+  describe 'anonymized value should be a boolean' do
+    let(:anonymized_boolean) {RandomBoolean.new.anonymize(field)}
+
+    it {
+      is_boolean = anonymized_boolean.is_a?(TrueClass) || anonymized_boolean.is_a?(FalseClass)
+      is_boolean.should be true
+    }
+  end
+end

data/spec/strategy/field/random_email_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+describe DataAnon::Strategy::Field::RandomEmail do
+
+  RandomEmail = DataAnon::Strategy::Field::RandomEmail
+  let(:field) {DataAnon::Core::Field.new('email','real@email.com',1,nil)}
+
+
+  describe 'anonymized email must be different from original email' do
+
+    let(:anonymized_value) {RandomEmail.new.anonymize(field)}
+
+    it {anonymized_value.should_not equal field.value}
+    it {anonymized_value.should match '^\S+@\S+\.\S+$'}
+
+  end
+
+end

data/spec/strategy/field/random_first_name_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+
+describe DataAnon::Strategy::Field::RandomFirstName do
+
+  RandomFirstName = DataAnon::Strategy::Field::RandomFirstName
+  let(:field) {DataAnon::Core::Field.new('firstname','fakeFirstName',1,nil)}
+
+  describe 'anonymized name must not be the same as provided name' do
+    let(:anonymized_value) {RandomFirstName.new().anonymize(field.value)}
+
+    it {anonymized_value.should_not equal field.value}
+  end
+
+end

data/spec/strategy/field/random_float_delta_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe DataAnon::Strategy::Field::RandomFloatDelta do
+
+  RandomFloatDelta = DataAnon::Strategy::Field::RandomFloatDelta
+  let(:field) {DataAnon::Core::Field.new('float_field',5.5,1,nil)}
+
+  describe 'anonymized float should not be the same as original value' do
+    let(:anonymized_float) {RandomFloatDelta.new(5).anonymize(field)}
+
+    it {anonymized_float.should_not equal field.value}
+  end
+
+  describe 'anonymized value returned should be a float' do
+    let(:anonymized_float) {RandomFloatDelta.new(5).anonymize(field)}
+
+    it { is_float = anonymized_float.is_a? Float
+         is_float.should be true
+    }
+  end
+end

data/spec/strategy/field/random_full_name_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe DataAnon::Strategy::Field::RandomFullName do
+
+  RandomFullName = DataAnon::Strategy::Field::RandomFullName
+  let(:field) {DataAnon::Core::Field.new('name','Fake User',1,nil)}
+
+  describe 'anonymized name should be the same as original' do
+
+    let(:anonymized_name) {RandomFullName.new().anonymize(field)}
+
+    it {anonymized_name.should_not equal field.value}
+  end
+
+  describe 'anonymized name should have same number of words as original' do
+
+    let(:field) {DataAnon::Core::Field.new('name','Fake User Longer Name Test',1,nil)}
+    let(:anonymized_name) {RandomFullName.new().anonymize(field)}
+
+    it {anonymized_name.split(' ').size.should equal field.value.split(' ').size}
+  end
+
+end

data/spec/strategy/field/random_int_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe DataAnon::Strategy::Field::RandomInt do
+
+  RandomInt = DataAnon::Strategy::Field::RandomInt
+  let(:field) { DataAnon::Core::Field.new('age', 25, 1, nil) }
+
+  describe 'verify age range between 18 and 70' do
+
+    let(:anonymized_int) { RandomInt.new(18, 70).anonymize(field) }
+
+    it { anonymized_int.should >= 18 }
+    it { anonymized_int.should <= 70 }
+
+  end
+
+  describe 'default range between 0 and 100' do
+
+    let(:anonymized_int) { RandomInt.new.anonymize(field) }
+
+    it { anonymized_int.should >= 0 }
+    it { anonymized_int.should <= 100 }
+
+  end
+
+
+
+end

data/spec/strategy/field/random_integer_delta_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe DataAnon::Strategy::Field::RandomIntegerDelta do
+
+  RandomIntegerDelta = DataAnon::Strategy::Field::RandomIntegerDelta
+  let(:field) {DataAnon::Core::Field.new('integer_field',100,1,nil)}
+
+  describe "anonymized value returned should be an integer" do
+    let(:anonymized_integer) {RandomIntegerDelta.new(10).anonymize(field)}
+
+    it { is_integer = anonymized_integer.is_a? Integer
+         is_integer.should be true
+    }
+
+  end
+
+  describe "anonymized integer should be within delta from original integer" do
+    let(:anonymized_integer) {RandomIntegerDelta.new(10).anonymize(field)}
+
+    it{anonymized_integer.should be_between(90,110)}
+  end
+
+end

data/spec/strategy/field/random_last_name_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+
+describe DataAnon::Strategy::Field::RandomLastName do
+
+  RandomLastName = DataAnon::Strategy::Field::RandomLastName
+  let(:field) {DataAnon::Core::Field.new('lastname','fakeLastName',1,nil)}
+
+  describe 'anonymized name must not be the same as provided name' do
+    let(:anonymized_value) {RandomLastName.new().anonymize(field.value)}
+
+    it {anonymized_value.should_not equal field.value}
+  end
+
+end

data/spec/strategy/field/random_mailinator_email_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe DataAnon::Strategy::Field::RandomMailinatorEmail do
+
+  RandomMailinatorEmail = DataAnon::Strategy::Field::RandomMailinatorEmail
+  let(:field) {DataAnon::Core::Field.new('email','user@company.com',1,nil)}
+
+  describe 'anonymized email should not be the same as original email' do
+
+    let(:anonymized_email) {RandomMailinatorEmail.new().anonymize(field)}
+
+    it {anonymized_email.should_not equal field.value}
+  end
+
+  describe 'anonymized email should be a mailinator email address' do
+
+    let(:anonymized_email) {RandomMailinatorEmail.new().anonymize(field)}
+
+    it {anonymized_email.should match '^\S+@\mailinator\.com$'}
+  end
+end

data/spec/strategy/field/random_phone_number_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+describe DataAnon::Strategy::Field::RandomPhoneNumber do
+
+  RandomPhoneNumber = DataAnon::Strategy::Field::RandomPhoneNumber
+  let(:field) {DataAnon::Core::Field.new('phone_number',"+0 (123) 456-7890",1,nil)}
+
+  describe 'anonymized phone number should not be the same as original phone number' do
+    let(:anonymized_number) {RandomPhoneNumber.new().anonymize(field)}
+
+    it {anonymized_number.should_not equal field.value}
+  end
+
+  describe 'anonymized phone number should be the same formatting as original phone number' do
+
+    it {
+      anonymized_number = RandomPhoneNumber.new().anonymize(field)
+      original_number = field.value
+      counter = 0
+      @number_similarity = true
+      anonymized_number.each_char do |char|
+        original_number_char = original_number[counter]
+        if /\d/.match(original_number_char).nil?
+          if !char.eql? original_number_char
+            @number_similarity = false
+            break
+          end
+        end
+
+      @number_similarity.should be true
+      end
+    }
+  end
+
+end