obscenity 1.0.0

data/test/test_base.rb

@@ -0,0 +1,253 @@
+require 'helper'
+
+class TestBase < Test::Unit::TestCase
+
+  context "#respond_to?" do
+    should "respond to methods and attributes" do
+      [:blacklist, :whitelist, :profane?, :sanitize, :replacement, :offensive, :replace].each do |field|
+        assert Obscenity::Base.respond_to?(field)
+      end
+    end
+  end
+
+  context "#blacklist" do
+    context "without custom config" do
+      setup { Obscenity::Base.blacklist = :default }
+      should "use the default content file when no config is found" do
+        assert Obscenity::Base.blacklist.is_a?(Array)
+        assert_equal 565, Obscenity::Base.blacklist.size
+      end
+    end
+    context "with custom config" do
+      setup { Obscenity::Base.blacklist = ['bad', 'word'] }
+      should "respect the config options" do
+        assert_equal ['bad', 'word'], Obscenity::Base.blacklist
+      end
+    end
+  end
+  
+  context "#whitelist" do
+    context "without custom config" do
+      setup { Obscenity::Base.whitelist = :default }
+      should "use the default content file when no config is found" do
+        assert Obscenity::Base.whitelist.is_a?(Array)
+        assert Obscenity::Base.whitelist.empty?
+      end
+    end
+    context "with custom config" do
+      setup { Obscenity::Base.whitelist = ['safe', 'word'] }
+      should "respect the config options" do
+        assert_equal ['safe', 'word'], Obscenity::Base.whitelist
+      end
+    end
+  end
+  
+  context "#profane?" do
+    context "without whitelist" do
+      context "without custom config" do
+        setup { 
+          Obscenity::Base.blacklist = :default
+          Obscenity::Base.whitelist = :default
+        }
+        should "validate the profanity of a word based on the default list" do
+          assert Obscenity::Base.profane?('ass')
+          assert Obscenity::Base.profane?('biatch')
+          assert !Obscenity::Base.profane?('hello')
+        end
+      end
+      context "with custom blacklist config" do
+        setup { Obscenity::Base.blacklist = ['ass', 'word'] }
+        should "validate the profanity of a word based on the custom list" do
+          assert Obscenity::Base.profane?('ass')
+          assert Obscenity::Base.profane?('word')
+          assert !Obscenity::Base.profane?('biatch')
+        end
+      end
+    end
+    context "with whitelist" do
+      context "without custom blacklist config" do
+        setup { 
+          Obscenity::Base.blacklist = :default
+          Obscenity::Base.whitelist = ['biatch']
+        }
+        should "validate the profanity of a word based on the default list" do
+          assert Obscenity::Base.profane?('ass')
+          assert !Obscenity::Base.profane?('biatch')
+          assert !Obscenity::Base.profane?('hello')
+        end
+      end
+      context "with custom blacklist/whitelist config" do
+        setup { 
+          Obscenity::Base.blacklist = ['ass', 'word']
+          Obscenity::Base.whitelist = ['word']
+        }
+        should "validate the profanity of a word based on the custom list" do
+          assert Obscenity::Base.profane?('ass')
+          assert !Obscenity::Base.profane?('word')
+          assert !Obscenity::Base.profane?('biatch')
+        end
+      end
+    end
+  end
+  
+  context "#sanitize" do
+    context "without whitelist" do
+      context "without custom config" do
+        setup { 
+          Obscenity::Base.blacklist = :default
+          Obscenity::Base.whitelist = :default
+        }
+        should "sanitize and return a clean text based on the default list" do
+          assert_equal "Yo $@!#%, sup", Obscenity::Base.sanitize('Yo assclown, sup')
+          assert_equal "Hello world", Obscenity::Base.sanitize('Hello world')
+        end
+      end
+      context "with custom blacklist config" do
+        setup { Obscenity::Base.blacklist = ['ass', 'word'] }
+        should "sanitize and return a clean text based on a custom list" do
+          assert_equal "Yo $@!#%, sup", Obscenity::Base.sanitize('Yo word, sup')
+          assert_equal "Hello world", Obscenity::Base.sanitize('Hello world')
+        end
+      end
+    end
+    context "with whitelist" do
+      context "without custom blacklist config" do
+        setup { 
+          Obscenity::Base.blacklist = :default
+          Obscenity::Base.whitelist = ['biatch']
+        }
+        should "sanitize and return a clean text based on the default blacklist and custom whitelist" do
+          assert_equal "Yo $@!#%, sup", Obscenity::Base.sanitize('Yo assclown, sup')
+          assert_equal "Yo biatch, sup", Obscenity::Base.sanitize('Yo biatch, sup')
+        end
+      end
+      context "with custom blacklist/whitelist config" do
+        setup { 
+          Obscenity::Base.blacklist = ['clown', 'biatch']
+          Obscenity::Base.whitelist = ['biatch']
+        }
+        should "validate the profanity of a word based on the custom list" do
+          assert_equal "Yo $@!#%, sup", Obscenity::Base.sanitize('Yo clown, sup')
+          assert_equal "Yo biatch, sup", Obscenity::Base.sanitize('Yo biatch, sup')
+        end
+      end
+    end
+  end
+  
+  context "#replacement" do
+    context "without whitelist" do
+      context "without custom config" do
+        setup { 
+          Obscenity::Base.blacklist = :default
+          Obscenity::Base.whitelist = :default
+        }
+        should "sanitize and return a clean text based on the default list" do
+          assert_equal "Yo ********, sup", Obscenity::Base.replacement(:stars).sanitize('Yo assclown, sup')
+          assert_equal "Yo $@!#%, sup", Obscenity::Base.replacement(:garbled).sanitize('Yo assclown, sup')
+          assert_equal "Yo *sscl*wn, sup", Obscenity::Base.replacement(:vowels).sanitize('Yo assclown, sup')
+          assert_equal "Yo [censored], sup", Obscenity::Base.replacement('[censored]').sanitize('Yo assclown, sup')
+          assert_equal "Hello World", Obscenity::Base.replacement(:default).sanitize('Hello World')
+        end
+      end
+      context "with custom blacklist config" do
+        setup { Obscenity::Base.blacklist = ['ass', 'word'] }
+        should "sanitize and return a clean text based on a custom list" do
+          assert_equal "Yo ****, sup", Obscenity::Base.replacement(:stars).sanitize('Yo word, sup')
+          assert_equal "Yo $@!#%, sup", Obscenity::Base.replacement(:garbled).sanitize('Yo word, sup')
+          assert_equal "Yo w*rd, sup", Obscenity::Base.replacement(:vowels).sanitize('Yo word, sup')
+          assert_equal "Yo [censored], sup", Obscenity::Base.replacement('[censored]').sanitize('Yo word, sup')
+          assert_equal "Hello World", Obscenity::Base.replacement(:default).sanitize('Hello World')
+        end
+      end
+    end
+    context "with whitelist" do
+      context "without custom blacklist config" do
+        setup { 
+          Obscenity::Base.blacklist = :default
+          Obscenity::Base.whitelist = ['biatch']
+        }
+        should "sanitize and return a clean text based on the default blacklist and custom whitelist" do
+          assert_equal "Yo ********, sup", Obscenity::Base.replacement(:stars).sanitize('Yo assclown, sup')
+          assert_equal "Yo $@!#%, sup", Obscenity::Base.replacement(:garbled).sanitize('Yo assclown, sup')
+          assert_equal "Yo *sscl*wn, sup", Obscenity::Base.replacement(:vowels).sanitize('Yo assclown, sup')
+          assert_equal "Yo [censored], sup", Obscenity::Base.replacement('[censored]').sanitize('Yo assclown, sup')
+          assert_equal "Yo biatch, sup", Obscenity::Base.replacement(:default).sanitize('Yo biatch, sup')
+        end
+      end
+      context "with custom blacklist/whitelist config" do
+        setup { 
+          Obscenity::Base.blacklist = ['clown', 'biatch']
+          Obscenity::Base.whitelist = ['biatch']
+        }
+        should "validate the profanity of a word based on the custom list" do
+          assert_equal "Yo *****, sup", Obscenity::Base.replacement(:stars).sanitize('Yo clown, sup')
+          assert_equal "Yo $@!#%, sup", Obscenity::Base.replacement(:garbled).sanitize('Yo clown, sup')
+          assert_equal "Yo cl*wn, sup", Obscenity::Base.replacement(:vowels).sanitize('Yo clown, sup')
+          assert_equal "Yo [censored], sup", Obscenity::Base.replacement('[censored]').sanitize('Yo clown, sup')
+          assert_equal "Yo biatch, sup", Obscenity::Base.replacement(:default).sanitize('Yo biatch, sup')
+          assert_equal "Yo assclown, sup", Obscenity::Base.replacement(:default).sanitize('Yo assclown, sup')
+        end
+      end
+    end
+  end
+  
+  context "#offensive" do
+    context "without whitelist" do
+      context "without custom config" do
+        setup { 
+          Obscenity::Base.blacklist = :default
+          Obscenity::Base.whitelist = :default
+        }
+        should "return an array with the offensive words based on the default list" do
+          assert_equal ['assclown'], Obscenity::Base.offensive('Yo assclown, sup')
+          assert_equal [], Obscenity::Base.offensive('Hello world')
+        end
+      end
+      context "with custom blacklist config" do
+        setup { Obscenity::Base.blacklist = ['yo', 'word'] }
+        should "return an array with the offensive words based on a custom list" do
+          assert_equal ['yo', 'word'], Obscenity::Base.offensive('Yo word, sup')
+          assert_equal [], Obscenity::Base.offensive('Hello world')
+        end
+      end
+    end
+    context "with whitelist" do
+      context "without custom blacklist config" do
+        setup { 
+          Obscenity::Base.blacklist = :default
+          Obscenity::Base.whitelist = ['biatch']
+        }
+        should "return an array with the offensive words based on the default blacklist and custom whitelist" do
+          assert_equal ['assclown'], Obscenity::Base.offensive('Yo assclown, sup')
+          assert_equal [], Obscenity::Base.offensive('Yo biatch, sup')
+        end
+      end
+      context "with custom blacklist/whitelist config" do
+        setup { 
+          Obscenity::Base.blacklist = ['clown', 'biatch']
+          Obscenity::Base.whitelist = ['biatch']
+        }
+        should "return an array with the offensive words based on the custom list" do
+          assert_equal ['clown'], Obscenity::Base.offensive('Yo clown, sup')
+          assert_equal [], Obscenity::Base.offensive('Yo biatch, sup')
+        end
+      end
+    end
+  end
+  
+  context "#replace" do
+    should "replace the given word by the given replacement method" do
+      [
+        [:vowels,  {original: "Yo biatch", clean: "Yo b**tch"}],
+        [:stars,   {original: "Yo biatch", clean: "Yo ******"}],
+        [:garbled, {original: "Yo biatch", clean: "Yo $@!#%"}],
+        [:default, {original: "Yo biatch", clean: "Yo $@!#%"}],
+        ["[censored]", {original: "Yo biatch", clean: "Yo [censored]"}],
+        [nil, {original: "Yo biatch", clean: "Yo $@!#%"}]
+      ].each do |replacement_method, content|
+        assert_equal content[:clean], Obscenity::Base.replacement(replacement_method).sanitize(content[:original])
+      end
+    end
+  end
+  
+end

data/test/test_config.rb

@@ -0,0 +1,66 @@
+require 'helper'
+
+class TestConfig < Test::Unit::TestCase
+
+  context "#respond_to?" do
+    should "respond to methods and attributes" do
+      Obscenity::Config.new do |config|
+        [:blacklist, :whitelist, :replacement].each do |field|
+          assert config.respond_to?(field)
+        end
+      end
+    end
+  end
+  
+  should "properly set the config parameters" do
+    blacklist   = ['ass', 'shit', 'penis']
+    whitelist   = ['penis']
+    replacement = :stars
+    
+    config = Obscenity::Config.new do |config|
+      config.blacklist   = blacklist
+      config.whitelist   = whitelist
+      config.replacement = replacement
+    end
+    
+    assert_equal blacklist, config.blacklist
+    assert_equal whitelist, config.whitelist
+    assert_equal replacement, config.replacement
+  end
+
+  should "return default values if none is set" do
+    config = Obscenity::Config.new
+    assert_equal [], config.whitelist
+    assert_equal :garbled, config.replacement
+    assert_match /config\/blacklist.yml/, config.blacklist
+  end
+
+  should "return default values when default values are set" do
+    config = Obscenity::Config.new do |config|
+      config.blacklist   = :default
+      config.replacement = :default
+    end
+    assert_equal [], config.whitelist
+    assert_equal :default, config.replacement
+    assert_match /config\/blacklist.yml/, config.blacklist
+  end
+  
+  should "properly validate the config options" do
+    [:blacklist, :whitelist].each do |field|
+      exceptions = [
+        [Obscenity::UnkownContent, {}], 
+        [Obscenity::UnkownContent, ":unkown"], 
+        [Obscenity::EmptyContentList, []], 
+        [Obscenity::UnkownContentFile, "'path/to/file'"], 
+        [Obscenity::UnkownContentFile, Pathname.new("'path/to/file'")]
+      ].each do |klass, value|
+        assert_raise(klass){
+          Obscenity::Config.new do |config|
+            config.instance_eval "config.#{field} = #{value}"
+          end
+        }
+      end
+    end
+  end
+  
+end

data/test/test_obscenity.rb

@@ -0,0 +1,68 @@
+require 'helper'
+
+class TestObscenity < Test::Unit::TestCase
+  
+  context "#respond_to?" do
+    should "respond to methods and attributes" do
+      [:configure, :config, :profane?, :sanitize, :offensive, :replacement].each do |field|
+        assert Obscenity.respond_to?(field)
+      end
+    end
+  end
+  
+  # More comprehensive test in test_config.rb
+  context "#configure" do
+    should "accept a configuration block " do
+      assert_nothing_raised{
+        Obscenity.configure do |config|
+          config.blacklist   = :default
+          config.replacement = :garbled
+        end
+      }      
+    end
+  end
+  
+  # More comprehensive test in test_config.rb
+  context "#config" do
+    should "return the current config object" do
+      assert_not_nil Obscenity.config
+    end
+  end
+  
+  # More comprehensive test in test_base.rb
+  context "#profane?" do
+    should "validate the profanity of the given content" do
+      assert Obscenity.profane?('Yo, check that ass out')
+      assert !Obscenity.profane?('Hello world')
+    end
+  end
+  
+  # More comprehensive test in test_base.rb
+  context "#sanitize" do
+    should "sanitize the given content" do
+      assert_equal "Yo, check that $@!#% out", Obscenity.sanitize('Yo, check that ass out')
+      assert_equal "Hello world", Obscenity.sanitize('Hello world')
+    end
+  end
+  
+  # More comprehensive test in test_base.rb
+  context "#offensive" do
+    should "return the offensive words for the given content" do
+      assert_equal ['ass', 'biatch'], Obscenity.offensive('Yo, check that ass biatch')
+      assert_equal [], Obscenity.offensive('Hello world')
+    end
+  end
+  
+  # More comprehensive test in test_base.rb
+  context "#replacement" do
+    should "sanitize the given content based on the given replacement" do
+      assert_equal "Yo, check that $@!#% out", Obscenity.replacement(:garbled).sanitize('Yo, check that ass out')
+      assert_equal "Yo, check that $@!#% out", Obscenity.replacement(:default).sanitize('Yo, check that ass out')
+      assert_equal "Yo, check that *ss out", Obscenity.replacement(:vowels).sanitize('Yo, check that ass out')
+      assert_equal "Yo, check that *** out", Obscenity.replacement(:stars).sanitize('Yo, check that ass out')
+      assert_equal "Yo, check that [censored] out", Obscenity.replacement("[censored]").sanitize('Yo, check that ass out')
+      assert_equal "Hello world", Obscenity.sanitize('Hello world')
+    end
+  end
+  
+end

data/test/test_rack.rb

@@ -0,0 +1,199 @@
+require 'helper'
+require 'rack/mock'
+require 'obscenity/rack'
+
+class TestRack < Test::Unit::TestCase
+  
+  context "Rack::Obscenity" do
+    setup do
+      @env     = {}
+      @body    = 'hello'
+      @status  = 200
+      @headers = { 'Content-Type' => 'text/plain' }
+      @app     = lambda { |env| [@status, @headers, [@body]] }
+    end
+    
+    def mock_env(options = {})
+      @env = Rack::MockRequest.env_for('/', options)
+    end
+    
+    def middleware(options = {})
+      Rack::Obscenity.new(@app, options)
+    end
+    
+    def get(params = {})
+      { 'QUERY_STRING' => Rack::Utils.build_query(params) }
+    end
+    
+    def get_response_params
+      Rack::Utils.parse_query(@env['QUERY_STRING'], "&")
+    end
+    
+    def post(params = {})
+      { 'rack.input' => StringIO.new(Rack::Utils.build_query(params)) }
+    end
+    
+    def post_response_params
+      Rack::Utils.parse_query(@env['rack.input'].read, "&")
+    end
+    
+    def assert_success_response(status, headers, body)
+      assert_equal @status, status
+      assert_equal @headers, headers
+      assert_equal [@body], body
+    end
+    
+    context "default configuration" do
+      should "not evaluate the profanity of parameters" do
+        app = middleware
+        status, headers, body = app.call(mock_env)
+        assert_success_response status, headers, body
+      end
+    end
+    
+    context "rejecting requests" do
+      should "not reject if parameter values don't contain profanity" do
+        app = middleware(reject: true)
+        status, headers, body = app.call(mock_env(get(foo: 'bar')))
+        assert_success_response status, headers, body
+      end
+
+      should "reject if GET parameter values contain profanity" do
+        app = middleware(reject: true)
+        status, headers, body = app.call(mock_env(get(foo: 'bar', baz: 'shit')))
+        assert_equal 422, status
+        assert_equal [''], body
+      end
+
+      should "reject if POST parameter values contain profanity" do
+        app = middleware(reject: true)
+        status, headers, body = app.call(mock_env(post(foo: 'bar', baz: 'ass')))
+        assert_equal 422, status
+        assert_equal [''], body
+      end
+
+      should "reject if given parameter values contain profanity" do
+        app = middleware(reject: { params: [:foo] })
+        [ get(foo: 'ass', baz: 'shit'), 
+          post(foo: 'ass').merge(get(foo: 'nice', baz: 'shit'))
+        ].each do |options|
+          status, headers, body = app.call(mock_env(options))
+          assert_equal 422, status
+          assert_equal [''], body
+        end
+      end
+
+      should "not reject if other parameter values contain profanity" do
+        app = middleware(reject: { params: [:foo] })
+        status, headers, body = app.call(mock_env(get(foo: 'nice', baz: 'shit')))
+        assert_success_response status, headers, body
+      end
+
+      should "reject if parameter values contain profanity" do
+        app = middleware(reject: { params: :all })
+        status, headers, body = app.call(mock_env(get(foo: 'ass')))
+        assert_equal 422, status
+        assert_equal [''], body
+      end
+
+      should "reject if parameter values contain profanity and display a custom message" do
+        app = middleware(reject: { message: "We don't accept profanity" })
+        status, headers, body = app.call(mock_env(get(foo: 'ass')))
+        assert_equal 422, status
+        assert_equal ["We don't accept profanity"], body
+      end
+
+      should "reject if parameter values contain profanity and render a custom file" do
+        app = middleware(reject: { path: "test/static/422.html" })
+        status, headers, body = app.call(mock_env(get(foo: 'ass')))
+        assert_equal 422, status
+        assert_equal ["We don't accept profanity"], body
+      end
+
+      should "reject parameter values when they're a hash and contain profanity" do
+        app = middleware(reject: true)
+        status, headers, body = app.call(mock_env(get(foo: 'clean', bar: {one: 'ass'})))
+        assert_equal 422, status
+        assert_equal [''], body
+      end
+    end
+    
+    context "sanitizing requests" do
+      should "not sanitize if parameter values don't contain profanity" do
+        app = middleware(sanitize: true)
+        status, headers, body = app.call(mock_env(get(foo: 'bar')))
+        assert_success_response status, headers, body
+        request_params = get_response_params
+        assert_equal 'bar', request_params['foo']
+      end
+
+      should "sanitize if GET parameter values contain profanity" do
+        app = middleware(sanitize: true)
+        status, headers, body = app.call(mock_env(get(foo: 'bar', baz: 'shit')))
+        assert_success_response status, headers, body
+        request_params = get_response_params
+        assert_equal 'bar', request_params['foo']
+        assert_equal '$@!#%', request_params['baz']
+      end
+      
+      should "sanitize if POST parameter values contain profanity" do
+        app = middleware(sanitize: true)
+        status, headers, body = app.call(mock_env(post(foo: 'bar', baz: 'ass')))
+        assert_success_response status, headers, body
+        request_params = post_response_params
+        assert_equal 'bar', request_params['foo']
+        assert_equal '$@!#%', request_params['baz']
+      end
+
+      should "not sanitize if other parameter values contain profanity" do
+        app = middleware(sanitize: { params: [:foo] })
+        status, headers, body = app.call(mock_env(get(foo: 'nice', baz: 'shit')))
+        assert_success_response status, headers, body
+        request_params = get_response_params
+        assert_equal 'nice', request_params['foo']
+        assert_equal 'shit', request_params['baz']
+      end
+
+      should "sanitize if parameter values contain profanity" do
+        app = middleware(sanitize: { params: :all })
+        status, headers, body = app.call(mock_env(get(foo: 'ass')))
+        assert_success_response status, headers, body
+        request_params = get_response_params
+        assert_equal '$@!#%', request_params['foo']
+      end
+      
+      should "sanitize the title using the :garbled replacement" do
+        app = middleware(sanitize: { replacement: :garbled })
+        status, headers, body = app.call(mock_env(get(foo: 'ass')))
+        assert_success_response status, headers, body
+        request_params = get_response_params
+        assert_equal '$@!#%', request_params['foo']
+      end
+
+      should "sanitize the title using the :stars replacement" do
+        app = middleware(sanitize: { replacement: :stars })
+        status, headers, body = app.call(mock_env(get(foo: 'ass')))
+        assert_success_response status, headers, body
+        request_params = get_response_params
+        assert_equal '***', request_params['foo']
+      end
+
+      should "sanitize the title using the :vowels replacement" do
+        app = middleware(sanitize: { replacement: :vowels })
+        status, headers, body = app.call(mock_env(get(foo: 'ass')))
+        assert_success_response status, headers, body
+        request_params = get_response_params
+        assert_equal '*ss', request_params['foo']
+      end
+
+      should "sanitize the title using a custom replacement" do
+        app = middleware(sanitize: { replacement: "[censored]" })
+        status, headers, body = app.call(mock_env(get(foo: 'text with ass')))
+        assert_success_response status, headers, body
+        request_params = get_response_params
+        assert_equal 'text with [censored]', request_params['foo']
+      end
+    end
+  end
+
+end