params_sanitizer 0.0.1

data/spec/params_sanitizer/sanitizers/accept_regex_spec.rb

@@ -0,0 +1,72 @@
+require 'rspec'
+
+describe ParamsSanitizer::Sanitizers::AcceptRegex do
+
+  context 'after include' do
+    before(:each) do
+      class Sanitizer
+        include ParamsSanitizer::Sanitizers::AcceptRegex
+      end
+      Sanitizer.stub(:check_duplicated_definition!)
+    end
+
+    it 'have accept_regex methods.' do
+      expect(Sanitizer.private_method_defined?(:sanitize_accept_regex!)).to be_true
+      expect(Sanitizer.methods.include?(:accept_regex)).to                  be_true
+    end
+
+    it 'accept_regex method call check_duplicated_definition!' do
+      Sanitizer.stub(:definitions).and_return(Hash.new)
+      Sanitizer.should_receive(:check_duplicated_definition!).with(:anime)
+      Sanitizer.accept_regex(:anime, '100', /^\d+$/)
+    end
+
+    it 'accept_regex method add rule.' do
+      definition = Hash.new
+      Sanitizer.stub(:definitions).and_return(definition)
+
+      expect {
+        Sanitizer.accept_regex(:anime, '100', /^\d+$/)
+      }.to change{definition.count}.by(1)
+
+      expect(definition.eql?(
+        {
+          accept_regex: { 'anime' => { default_value: '100', regex: /^\d+$/ } }
+        })).to be_true
+    end
+
+    context 'after define rule' do
+      before(:each) do
+        definitions = Hash.new
+        Sanitizer.stub(:definitions).and_return(definitions)
+
+        Sanitizer.accept_regex(:anime, '100', /^\d+$/)
+        @rule = definitions[:accept_regex]
+      end
+
+      it 'sanitize_accept_regex! method sanitizes missing params.' do
+        params = {'anime' => '-'}
+        Sanitizer.new.send(:sanitize_accept_regex!, params, @rule)
+        expect(params.eql?({'anime' => '100'})).to be_true
+
+        params = {'anime' => '-100'}
+        Sanitizer.new.send(:sanitize_accept_regex!, params, @rule)
+        expect(params.eql?({'anime' => '100'})).to be_true
+
+        params = {'anime' => 'あいうえお'}
+        Sanitizer.new.send(:sanitize_accept_regex!, params, @rule)
+        expect(params.eql?({'anime' => '100'})).to be_true
+      end
+
+      it 'sanitize_accept_regex! method does not sanitize params.' do
+        params = {'anime' => '9999'}
+        Sanitizer.new.send(:sanitize_accept_regex!, params, @rule)
+        expect(params.eql?({'anime' => '9999'})).to be_true
+
+        params = {'anime' => '1234567890'}
+        Sanitizer.new.send(:sanitize_accept_regex!, params, @rule)
+        expect(params.eql?({'anime' => '1234567890'})).to be_true
+      end
+    end
+  end
+end

data/spec/params_sanitizer/sanitizers/accept_value_spec.rb

@@ -0,0 +1,63 @@
+require 'rspec'
+
+describe ParamsSanitizer::Sanitizers::AcceptValue do
+
+  context 'after include' do
+    before(:each) do
+      class Sanitizer
+        include ParamsSanitizer::Sanitizers::AcceptValue
+      end
+      Sanitizer.stub(:check_duplicated_definition!)
+    end
+
+    it 'have accept_value methods.' do
+      expect(Sanitizer.private_method_defined?(:sanitize_accept_value!)).to be_true
+      expect(Sanitizer.methods.include?(:accept_value)).to                  be_true
+    end
+
+    it 'accept_value method call check_duplicated_definition!' do
+      Sanitizer.stub(:definitions).and_return(Hash.new)
+      Sanitizer.should_receive(:check_duplicated_definition!).with(:anime)
+      Sanitizer.accept_value(:anime, 'nyaruko', ['nyaruko', 'kmb'])
+    end
+
+    it 'accept_value method add rule.' do
+      definition = Hash.new
+      Sanitizer.stub(:definitions).and_return(definition)
+
+      expect {
+        Sanitizer.accept_value(:anime, 'nyaruko', ['nyaruko', 'kmb'])
+      }.to change{definition.count}.by(1)
+
+      expect(definition.eql?(
+        {
+          accept_value: { 'anime' => { default_value: 'nyaruko', accept_values: ['nyaruko', 'kmb'] } }
+        })).to be_true
+    end
+
+    context 'after define rule' do
+      before(:each) do
+        definitions = Hash.new
+        Sanitizer.stub(:definitions).and_return(definitions)
+
+        Sanitizer.accept_value(:anime, 'nyaruko', ['nyaruko', 'kmb'])
+        @rule = definitions[:accept_value]
+      end
+
+      it 'sanitize_accept_value! method sanitizes missing params.' do
+        params = {'anime' => 'boku ha tomodachi ga suku nai.'}
+        Sanitizer.new.send(:sanitize_accept_value!, params, @rule)
+
+        expect(params.eql?({'anime' => 'nyaruko'})).to be_true
+      end
+
+      it 'sanitize_accept_value! method does not sanitize params.' do
+        params = {'anime' => 'kmb'}
+        Sanitizer.new.send(:sanitize_accept_value!, params, @rule)
+
+        expect(params.eql?({'anime' => 'kmb'})).to be_true
+      end
+
+    end
+  end
+end

data/spec/params_sanitizer/sanitizers/exist_value_spec.rb

@@ -0,0 +1,64 @@
+require 'rspec'
+
+describe ParamsSanitizer::Sanitizers::ExistValue do
+
+  context 'after include' do
+    before(:each) do
+      class Sanitizer
+        include ParamsSanitizer::Sanitizers::ExistValue
+      end
+      Sanitizer.stub(:check_duplicated_definition!)
+    end
+
+    it 'have exist_value methods.' do
+      expect(Sanitizer.private_method_defined?(:sanitize_exist_value!)).to be_true
+      expect(Sanitizer.methods.include?(:exist_value)).to                  be_true
+    end
+
+    it 'exist_value method call check_duplicated_definition!' do
+      Sanitizer.stub(:definitions).and_return(Hash.new)
+      Sanitizer.should_receive(:check_duplicated_definition!).with(:anime)
+      Sanitizer.exist_value(:anime, 'nyaruko')
+    end
+
+    it 'exist_value method add rule.' do
+      definition = Hash.new
+      Sanitizer.stub(:definitions).and_return(definition)
+
+      expect {
+        Sanitizer.exist_value(:anime, 'nyaruko')
+      }.to change{definition.count}.by(1)
+
+      expect(definition.eql?(
+        {
+          exist_value: { 'anime' => { default_value: 'nyaruko' } }
+        })).to be_true
+    end
+
+    context 'after define rule' do
+      before(:each) do
+        definitions = Hash.new
+        Sanitizer.stub(:definitions).and_return(definitions)
+
+        Sanitizer.exist_value(:anime, 'nyaruko')
+        @rule = definitions[:exist_value]
+      end
+
+      it 'sanitize_exist_value! method sanitizes missing params.' do
+        params = {'anime' => nil}
+        Sanitizer.new.send(:sanitize_exist_value!, params, @rule)
+        expect(params.eql?({'anime' => 'nyaruko'})).to be_true
+
+        params = {}
+        Sanitizer.new.send(:sanitize_exist_value!, params, @rule)
+        expect(params.eql?({'anime' => 'nyaruko'})).to be_true
+      end
+
+      it 'sanitize_exist_value! method does not sanitize params.' do
+        params = {'anime' => 'kmb'}
+        Sanitizer.new.send(:sanitize_exist_value!, params, @rule)
+        expect(params.eql?({'anime' => 'kmb'})).to be_true
+      end
+    end
+  end
+end

data/spec/params_sanitizer/sanitizers/reject_range_spec.rb

@@ -0,0 +1,116 @@
+require 'rspec'
+
+describe ParamsSanitizer::Sanitizers::RejectRange do
+
+  context 'after include' do
+    before(:each) do
+      class Sanitizer
+        include ParamsSanitizer::Sanitizers::RejectRange
+      end
+      Sanitizer.stub(:check_duplicated_definition!)
+    end
+
+    it 'have reject_range methods.' do
+      expect(Sanitizer.private_method_defined?(:sanitize_reject_range!)).to be_true
+      expect(Sanitizer.methods.include?(:reject_range)).to                  be_true
+    end
+
+    it 'reject_range method call check_duplicated_definition!' do
+      Sanitizer.stub(:definitions).and_return(Hash.new)
+      Sanitizer.should_receive(:check_duplicated_definition!).with(:anime)
+      Sanitizer.reject_range(:anime, 50, 0, 100)
+    end
+
+    it 'reject_range method add rule.' do
+      definition = Hash.new
+      Sanitizer.stub(:definitions).and_return(definition)
+
+      expect {
+        Sanitizer.reject_range(:anime, 50, 0, 100)
+      }.to change{definition.count}.by(1)
+
+      expect(definition.eql?(
+        {
+          reject_range: { 'anime' => { default_value: 50, min: 0, max: 100 } }
+        })).to be_true
+    end
+
+    context 'after define rule' do
+      before(:each) do
+        definitions = Hash.new
+        Sanitizer.stub(:definitions).and_return(definitions)
+
+        Sanitizer.reject_range(:anime, 50, 0, 100)
+        @rule = definitions[:reject_range]
+      end
+
+      it 'sanitize_reject_range! method does not sanitize missing params.' do
+        params = {'anime' => '0'}
+        Sanitizer.new.send(:sanitize_reject_range!, params, @rule)
+        expect(params.eql?({'anime' => 50})).to be_true
+
+        params = {'anime' => '40'}
+        Sanitizer.new.send(:sanitize_reject_range!, params, @rule)
+        expect(params.eql?({'anime' => 50})).to be_true
+
+        params = {'anime' => '80'}
+        Sanitizer.new.send(:sanitize_reject_range!, params, @rule)
+        expect(params.eql?({'anime' => 50})).to be_true
+
+        params = {'anime' => '100'}
+        Sanitizer.new.send(:sanitize_reject_range!, params, @rule)
+        expect(params.eql?({'anime' => 50})).to be_true
+      end
+
+      it 'sanitize_reject_range! method sanitizes params.' do
+        params = {'anime' => '-50'}
+        Sanitizer.new.send(:sanitize_reject_range!, params, @rule)
+        expect(params.eql?({'anime' => -50})).to be_true
+
+        params = {'anime' => '-1'}
+        Sanitizer.new.send(:sanitize_reject_range!, params, @rule)
+        expect(params.eql?({'anime' => -1})).to be_true
+
+        params = {'anime' => '101'}
+        Sanitizer.new.send(:sanitize_reject_range!, params, @rule)
+        expect(params.eql?({'anime' => 101})).to be_true
+
+        params = {'anime' => '150'}
+        Sanitizer.new.send(:sanitize_reject_range!, params, @rule)
+        expect(params.eql?({'anime' => 150})).to be_true
+      end
+    end
+
+    context 'after define rule of one limit free.' do
+      before(:each) do
+        definitions = Hash.new
+        Sanitizer.stub(:definitions).and_return(definitions)
+
+        Sanitizer.reject_range(:minnil, 50, nil, 100)
+        Sanitizer.reject_range(:maxnil, 50, 0, nil)
+        @rule = definitions[:reject_range]
+      end
+
+      it 'sanitize_reject_range! method does not sanitize missing params.' do
+        params = {'minnil' => '-999'}
+        Sanitizer.new.send(:sanitize_reject_range!, params, @rule)
+        expect(params.eql?({'minnil' => 50, 'maxnil' => 50})).to be_true
+
+        params = {'maxnil' => '999'}
+        Sanitizer.new.send(:sanitize_reject_range!, params, @rule)
+        expect(params.eql?({'minnil' => 50, 'maxnil' => 50})).to be_true
+      end
+
+      it 'sanitize_reject_range! method sanitizes params.' do
+        params = {'minnil' => '150'}
+        Sanitizer.new.send(:sanitize_reject_range!, params, @rule)
+        expect(params.eql?({'minnil' => 150, 'maxnil' => 50})).to be_true
+
+        params = {'maxnil' => '-50'}
+        Sanitizer.new.send(:sanitize_reject_range!, params, @rule)
+        expect(params.eql?({'minnil' => 50, 'maxnil' => -50})).to be_true
+      end
+    end
+
+  end
+end

data/spec/params_sanitizer/sanitizers/reject_regex_spec.rb

@@ -0,0 +1,72 @@
+require 'rspec'
+
+describe ParamsSanitizer::Sanitizers::RejectRegex do
+
+  context 'after include' do
+    before(:each) do
+      class Sanitizer
+        include ParamsSanitizer::Sanitizers::RejectRegex
+      end
+      Sanitizer.stub(:check_duplicated_definition!)
+    end
+
+    it 'have reject_regex methods.' do
+      expect(Sanitizer.private_method_defined?(:sanitize_reject_regex!)).to be_true
+      expect(Sanitizer.methods.include?(:reject_regex)).to                  be_true
+    end
+
+    it 'reject_regex method call check_duplicated_definition!' do
+      Sanitizer.stub(:definitions).and_return(Hash.new)
+      Sanitizer.should_receive(:check_duplicated_definition!).with(:anime)
+      Sanitizer.reject_regex(:anime, '100', /^\d+$/)
+    end
+
+    it 'reject_regex method add rule.' do
+      definition = Hash.new
+      Sanitizer.stub(:definitions).and_return(definition)
+
+      expect {
+        Sanitizer.reject_regex(:anime, '100', /^\d+$/)
+      }.to change{definition.count}.by(1)
+
+      expect(definition.eql?(
+        {
+          reject_regex: { 'anime' => { default_value: '100', regex: /^\d+$/ } }
+        })).to be_true
+    end
+
+    context 'after define rule' do
+      before(:each) do
+        definitions = Hash.new
+        Sanitizer.stub(:definitions).and_return(definitions)
+
+        Sanitizer.reject_regex(:anime, '100', /^\d+$/)
+        @rule = definitions[:reject_regex]
+      end
+
+      it 'sanitize_reject_regex! method does not sanitize params.' do
+        params = {'anime' => '9999'}
+        Sanitizer.new.send(:sanitize_reject_regex!, params, @rule)
+        expect(params.eql?({'anime' => '100'})).to be_true
+
+        params = {'anime' => '1234567890'}
+        Sanitizer.new.send(:sanitize_reject_regex!, params, @rule)
+        expect(params.eql?({'anime' => '100'})).to be_true
+      end
+
+      it 'sanitize_reject_regex! method sanitizes missing params.' do
+        params = {'anime' => '-'}
+        Sanitizer.new.send(:sanitize_reject_regex!, params, @rule)
+        expect(params.eql?({'anime' => '-'})).to be_true
+
+        params = {'anime' => '-100'}
+        Sanitizer.new.send(:sanitize_reject_regex!, params, @rule)
+        expect(params.eql?({'anime' => '-100'})).to be_true
+
+        params = {'anime' => 'あいうえお'}
+        Sanitizer.new.send(:sanitize_reject_regex!, params, @rule)
+        expect(params.eql?({'anime' => 'あいうえお'})).to be_true
+      end
+    end
+  end
+end

data/spec/params_sanitizer/sanitizers/reject_value_spec.rb

@@ -0,0 +1,63 @@
+require 'rspec'
+
+describe ParamsSanitizer::Sanitizers::RejectValue do
+
+  context 'after include' do
+    before(:each) do
+      class Sanitizer
+        include ParamsSanitizer::Sanitizers::RejectValue
+      end
+      Sanitizer.stub(:check_duplicated_definition!)
+    end
+
+    it 'have reject_value methods.' do
+      expect(Sanitizer.private_method_defined?(:sanitize_reject_value!)).to be_true
+      expect(Sanitizer.methods.include?(:reject_value)).to                  be_true
+    end
+
+    it 'reject_value method call check_duplicated_definition!' do
+      Sanitizer.stub(:definitions).and_return(Hash.new)
+      Sanitizer.should_receive(:check_duplicated_definition!).with(:anime)
+      Sanitizer.reject_value(:anime, 'nyaruko', ['hoge', 'fuga'])
+    end
+
+    it 'reject_value method add rule.' do
+      definition = Hash.new
+      Sanitizer.stub(:definitions).and_return(definition)
+
+      expect {
+        Sanitizer.reject_value(:anime, 'nyaruko', ['hoge', 'fuga'])
+      }.to change{definition.count}.by(1)
+
+      expect(definition.eql?(
+        {
+          reject_value: { 'anime' => { default_value: 'nyaruko', reject_values: ['hoge', 'fuga'] } }
+        })).to be_true
+    end
+
+    context 'after define rule' do
+      before(:each) do
+        definitions = Hash.new
+        Sanitizer.stub(:definitions).and_return(definitions)
+
+        Sanitizer.reject_value(:anime, 'nyaruko', ['hoge', 'fuga'])
+        @rule = definitions[:reject_value]
+      end
+
+      it 'sanitize_reject_value! method sanitizes missing params.' do
+        params = {'anime' => 'hoge'}
+        Sanitizer.new.send(:sanitize_reject_value!, params, @rule)
+
+        expect(params.eql?({'anime' => 'nyaruko'})).to be_true
+      end
+
+      it 'sanitize_reject_value! method does not sanitize params.' do
+        params = {'anime' => 'kmb'}
+        Sanitizer.new.send(:sanitize_reject_value!, params, @rule)
+
+        expect(params.eql?({'anime' => 'kmb'})).to be_true
+      end
+
+    end
+  end
+end