urban 0.1.3 → 1.0.0

data/test/minitest/stop_light.rb

@@ -0,0 +1,57 @@
+class MiniTest::StopLight
+  ESC = "\e["
+  NND = "#{ESC}0m"
+
+  attr_reader :io
+
+  def initialize io
+    @io = io
+  end
+
+  def red str
+    normal_color(31, str)
+  end
+
+  def yellow str
+    normal_color(33, str)
+  end
+
+  def green str
+    normal_color(32, str)
+  end
+
+  def normal_color(color_code, str)
+   "#{ESC}#{color_code}m#{str}#{NND}"
+  end
+
+  def print(o)
+    case o
+      when '.'; io.print green(o)
+      when 'E', 'F'; io.print red(o)
+      when 'S'; io.print yellow(o)
+      else; io.print o
+    end
+  end
+
+  def puts(*o)
+    o.map! do |str|
+      case str
+        when /Failure:/, /Error:/, /[1-9]+ failures/, /[1-9]+ errors/;
+          red(str)
+        when /Skipped:/
+          yellow(str)
+        when /0 failures, 0 errors/;
+          green(str).gsub(/([1-9]+ skips)/, yellow('\1'))
+        else;
+          str.gsub(/([1-9]+ skips)/, yellow('\1'))
+      end
+    end
+    super
+  end
+
+  def method_missing(msg, *args)
+    io.send(msg, *args)
+  end
+end
+
+MiniTest::Unit.output = MiniTest::StopLight.new(MiniTest::Unit.output)

data/test/test_helper.rb

@@ -1,34 +1,28 @@
 $LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
 
 require 'rubygems'
+gem 'minitest' if RUBY_VERSION > '1.9'
 require 'minitest/autorun'
 require 'urban'
 require 'urban/cli'
+require 'minitest/stop_light'
+require 'ostruct'
 
-TEST_PHRASE = OpenStruct.new({
-  :word => 'impromptu',
-  :definitions => [
-    'Something that is made up on the spot and given little time to gather and present. Usually referring to speeches that are given only a few minutes to prepare for.',
+TEST_ENTRY = Urban::Dictionary::Entry.new('impromptu',
+  [ 'Something that is made up on the spot and given little time to gather and present. Usually referring to speeches that are given only a few minutes to prepare for.',
     'On the spot',
-    'Something that is made up on the spot.  Can also mean a speech that was made with little or no preparation.'
-]})
+    'Something that is made up on the spot.  Can also mean a speech that was made with little or no preparation.' ],
+    'http://www.urbandictionary.com/define.php?term=impromptu')
+
+EMPTY_ENTRY = Urban::Dictionary::Entry.new('gubble', nil, nil)
 
 def load_file(filename)
   IO.read(File.expand_path("../data/#{filename}", __FILE__))
 end
 
-['refute', 'assert'].each do |action|
-  eval <<-EOM
-    def #{action}_cli_prints(matches, &block)
-      out, err = capture_io(&block)
-      [*matches].each { |match| #{action}_match(match, out) }
-    end
-  EOM
-end
-
 module Stub
   def stub(name, &block)
-    self.class.send(:remove_method, name) if respond_to?(name)
-    self.class.send(:define_method, name, &block)
+    singleton_class = class << self; self; end
+    singleton_class.send(:define_method, name, &block)
   end
 end

data/test/urban/cli_test.rb

@@ -1,101 +1,212 @@
 require 'test_helper'
+require 'open-uri'
+require 'socket'
+require 'shellwords'
 
 class CLITest < MiniTest::Unit::TestCase
 
+  HELP_SCREEN = <<-EOS
+Usage: urban [OPTION]... [PHRASE]
+Search http://urbandictionary.com for definitions of phrases
+
+Options:
+    -a, --all                        List all definitions
+    -r, --random                     Return a random phrase and definition
+    -u, --url                        Print the definition's url after the definition
+    -h, --help                       Show this message
+    -v, --version                    Show version information
+    -l, --list                       DEPRECATED please use --all or -a instead
+
+Examples:
+    urban cookie monster        Search for "cookie monster" and print its
+                                first definition
+    urban -a cookie monster     Search for "cookie monster" and print all of
+                                its available definitions
+    urban -r                    Print a random phrase and its first definition
+    urban -ra                   Print a random phrase and all of its available
+                                definitions
+
+EOS
+
   def setup
     @program = Urban::CLI.new
   end
 
-  def test_parse_prints_help
-    expectations = [
-      /Usage: urban \[OPTION\]\.\.\. \[PHRASE\]/,
-      /Search http:\/\/urbandictionary\.com for definitions/,
-      /-l, --list\s*List all definitions/,
-      /-r, --random\s*Find random word on urban dictionary/,
-      /-h, --help\s*Show this message/,
-      /-version\s*Show version/
-    ]
-    assert_cli_prints(expectations) { @program.run(["-h"]) }
+  # Helpers
+  def assert_program_output(argument_variations, stdout=nil, stderr=nil)
+    argument_variations.each do |args|
+      assert_output(stdout, stderr) { @program.run(Shellwords.shellwords(args)) }
+    end
   end
 
-  def test_parse_prints_version_info
-    args = ['-v']
-    assert_cli_prints(/^Urban \d+\.\d+\.\d+ \(c\) Thomas Miller$/) { @program.run(args) }
-  end
+  class CLIArgumentParsingTest < CLITest
 
-  def test_no_args_prints_help
-    args = []
-    assert_cli_prints(/Usage: urban \[OPTION\]\.\.\. \[PHRASE\]/) { @program.run(args) }
-  end
+    # Helpers
+    def assert_flag_is_set(name)
+      ["-#{name.chars.first}", "--#{name}"].each do |args|
+        options = @program.send(:parse, [args])
+        assert_equal(true, options.send(name))
+      end
+    end
 
-  def test_no_args_with_list_option_prints_help
-    args = ['-l']
-    assert_cli_prints(/Usage: urban \[OPTION\]\.\.\. \[PHRASE\]/) { @program.run(args) }
-  end
+    # Tests
+    def test_defaults
+      assert_silent do
+        options = @program.send(:parse, [])
+        assert_equal(false, options.help)
+        assert_equal(false, options.version)
+        assert_equal(false, options.random)
+        assert_equal(false, options.all)
+        assert_equal('', options.phrase)
+      end
+    end
 
-  def test_parse_returns_random
-    capture_io do
-      actual = @program.send(:parse, ['-r'])
-      assert(actual.random, 'Args -r; Expected true, returned false')
-      actual = @program.send(:parse, ['--random'])
-      assert(actual.random, 'Args --random Expected true, returned false')
+    def test_phrase
+      assert_silent do
+        options = @program.send(:parse, ['foo bar'])
+        assert_equal('foo bar', options.phrase)
+      end
     end
-  end
 
-  def test_parse_returns_list
-    capture_io do
-      actual = @program.send(:parse, ['-l'])
-      assert(actual.list, 'Args: -l; Expected true, returned false')
-      actual = @program.send(:parse, ['--list'])
-      assert(actual.list, 'Args: --list; Expected true, returned false')
+    def test_help_flag
+      assert_silent do
+        assert_flag_is_set('help')
+      end
     end
-  end
 
-  def test_parse_returns_phrase
-    capture_io do
-      actual = @program.send(:parse, ['Cookie', 'monster'])
-      assert_equal('Cookie monster', actual.phrase)
-      actual = @program.send(:parse, ['Cookie monster'])
-      assert_equal('Cookie monster', actual.phrase)
+    def test_version_flag
+      assert_silent do
+        assert_flag_is_set('version')
+      end
+    end
+
+    def test_random_flag
+      assert_silent do
+        assert_flag_is_set('random')
+      end
+    end
+
+    def test_all_flag
+      assert_silent do
+        assert_flag_is_set('all')
+      end
+    end
+
+    def test_all_flag
+      assert_silent do
+        assert_flag_is_set('url')
+      end
     end
   end
 
-  class CLIDefinintionOutputTest < CLITest
+  class CLIRunnerStandardOutputTest < CLITest
+
+    SINGLE_DEFINITION = "\n#{TEST_ENTRY.phrase.upcase}\n\n#{TEST_ENTRY.definitions.first}\n\n"
+    MULTIPLE_DEFINITIONS = "\n#{TEST_ENTRY.phrase.upcase}\n\n#{TEST_ENTRY.definitions.join("\n\n")}\n\n"
+    DEFINITION_WITH_URL = "\n#{TEST_ENTRY.phrase.upcase}\n\n#{TEST_ENTRY.definitions.first}\n\nURL: #{TEST_ENTRY.url}\n\n"
+
     def setup
-      @dictionary = MiniTest::Mock.new
       super
+      @dictionary = MiniTest::Mock.new
+    end
+
+    # Tests
+    def test_help_flag_prints_help
+      assert_output(HELP_SCREEN) { @program.run([]) }
     end
 
-    def test_cli_prints_random_definition
-      args = ['-r']
-      expected = [ "#{TEST_PHRASE.word.upcase}", TEST_PHRASE.definitions.first ]
-      @program.dictionary = @dictionary.expect(:random, TEST_PHRASE)
-      assert_cli_prints(expected) { @program.run(args) }
+    def test_version_flag_prints_version
+      ['-v', '--v'].each do |args|
+        assert_output("Urban #{Urban::VERSION} (c) Thomas Miller\n") { @program.run([args]) }
+      end
+    end
+
+    def test_random_flag_prints_single_definition
+      @program.dictionary = @dictionary.expect(:random, TEST_ENTRY)
+      argument_variations = ['-r', '--random']
+      assert_program_output(argument_variations, SINGLE_DEFINITION)
+      @dictionary.verify
+    end
+
+    def test_phrase_prints_single_definition
+      @program.dictionary = @dictionary.expect(:search, TEST_ENTRY, ['impromptu'])
+      argument_variations = ['impromptu']
+      assert_program_output(argument_variations, SINGLE_DEFINITION)
+      @dictionary.verify
+    end
+
+    def test_random_and_all_flag_prints_multiple_definitions
+      @program.dictionary = @dictionary.expect(:random, TEST_ENTRY)
+      argument_variations = ['-ra', '-r -a', '--random -a', '-r --all', '--all --random']
+      assert_program_output(argument_variations, MULTIPLE_DEFINITIONS)
       @dictionary.verify
     end
 
-    def test_cli_prints_random_definition_list
-      args = ['-rl']
-      expected = [ "#{TEST_PHRASE.word.upcase}", *TEST_PHRASE.definitions ]
-      @program.dictionary = @dictionary.expect(:random, TEST_PHRASE)
-      assert_cli_prints(expected) { @program.run(args) }
+    def test_phrase_and_all_flag_prints_multiple_definitions
+      @program.dictionary = @dictionary.expect(:search, TEST_ENTRY, ['impromptu'])
+      argument_variations = ['impromptu -a', '--all impromptu']
+      assert_program_output(argument_variations, MULTIPLE_DEFINITIONS)
       @dictionary.verify
     end
 
-    def test_cli_prints_definition
-      args = ['impromptu']
-      expected = [ "#{TEST_PHRASE.word.upcase}", TEST_PHRASE.definitions.first ]
-      @program.dictionary = @dictionary.expect(:search, TEST_PHRASE, ['impromptu'])
-      assert_cli_prints(expected) { @program.run(['impromptu']) }
+    def test_random_and_url_flag_prints_definition_with_url
+      @program.dictionary = @dictionary.expect(:random, TEST_ENTRY)
+      argument_variations = ['-ru', '-r -u', '--random -u', '-r --url', '--url --random']
+      assert_program_output(argument_variations, DEFINITION_WITH_URL)
       @dictionary.verify
     end
 
-    def test_cli_prints_definition_list
-      args = ['-l', 'impromptu']
-      expected = [ "#{TEST_PHRASE.word.upcase}", *TEST_PHRASE.definitions ]
-      @program.dictionary = @dictionary.expect(:search, TEST_PHRASE, ['impromptu'])
-      assert_cli_prints(expected) { @program.run(args) }
+    def test_phrase_and_url_flag_prints_definition_with_url
+      @program.dictionary = @dictionary.expect(:search, TEST_ENTRY, ['impromptu'])
+      argument_variations = ['impromptu -u', '--url impromptu']
+      assert_program_output(argument_variations, DEFINITION_WITH_URL)
       @dictionary.verify
     end
+
+    def test_list_flag_prints_deprecation_warning
+      expected = /WARNING: --list and -l are deprecated please use --all or -a instead/
+      @program.dictionary = @dictionary.expect(:search, TEST_ENTRY, ['impromptu'])
+      @program.dictionary = @dictionary.expect(:random, TEST_ENTRY)
+      stdout, stederr = capture_io { @program.run(Shellwords.shellwords('--list impromptu')) }
+      assert_match expected, stdout
+      stdou, stederr  = capture_io { @program.run(Shellwords.shellwords('-rl')) }
+      assert_match expected, stdout
+    end
+  end
+
+  class CLIRunnerErrorOutputTest < CLITest
+
+    ERROR_MISSING_PHRASE = "urban: no definitions found for #{EMPTY_ENTRY.phrase.upcase}.\n"
+    ERROR_NO_INTERNET = "urban: no internet connection available.\n"
+    ERROR_INVALID_OPTION = <<-EOE
+urban: invalid option: -b
+Try `urban --help' for more information.
+    EOE
+
+    def setup
+      super
+    end
+
+    # Tests
+    def test_search_missing_phrase_prints_error
+      dictionary = MiniTest::Mock.new
+      @program.dictionary = dictionary.expect(:search, EMPTY_ENTRY, ['gubble'])
+      assert_program_output(['gubble'], nil, ERROR_MISSING_PHRASE)
+      dictionary.verify
+    end
+
+    def test_search_missing_phrase_prints_error
+      dictionary = (Object.new).extend Stub
+      dictionary.stub(:search) { |phrase| raise SocketError }
+      @program.dictionary = dictionary
+      assert_program_output(['gubble'], nil, ERROR_NO_INTERNET)
+    end
+
+    def test_invalid_option_prints_help
+      dictionary = (Object.new).extend Stub
+      dictionary.stub(:search) { |phrase| raise OptionParser::InvalidOption }
+      @program.dictionary = dictionary
+      assert_program_output(['-b'], nil, ERROR_INVALID_OPTION)
+    end
   end
 end

data/test/urban/dictionary_test.rb

@@ -4,18 +4,34 @@ class DictionaryTest < MiniTest::Unit::TestCase
 
   def setup
     @web_service = MiniTest::Mock.new
-    @dictionary = Urban::Dictionary.new
+    @dictionary = Urban::Dictionary
+
+    @response = OpenStruct.new
+    @response.url = 'http://www.urbandictionary.com/define.php?term=impromptu'
+    @response.stream = load_file('impromptu.html')
+  end
+
+  def test_process_extracts_elements_from_html
+    entry = @dictionary.send(:process, @response )
+    assert_equal(TEST_ENTRY, entry)
   end
 
   def test_dictionary_calls_random
-    @dictionary.web_service = @web_service.expect(:query, load_file('impromptu.html') ,[:random])
-    assert_equal(TEST_PHRASE, @dictionary.random)
+    @dictionary.web_service = @web_service.expect(:random, @response)
+    assert_equal(TEST_ENTRY, @dictionary.random)
     @web_service.verify
   end
 
-  def test_dictionary_calls_define
-    @dictionary.web_service = @web_service.expect(:query, load_file('impromptu.html'), [:define, 'impromptu'])
-    assert_equal(TEST_PHRASE, @dictionary.search('impromptu'))
+  def test_dictionary_calls_search
+   @dictionary.web_service = @web_service.expect(:search, @response, ['impromptu'])
+   assert_equal(TEST_ENTRY, @dictionary.search('impromptu'))
+   @web_service.verify
+  end
+
+  def test_dictionary_returns_empty_for_missing_phrases
+    @response.stream = load_file('missing.html')
+    @dictionary.web_service = @web_service.expect(:search, @response, ['gubble'])
+    assert_equal(EMPTY_ENTRY, @dictionary.search('gubble'))
     @web_service.verify
   end
 end

data/test/urban/web_test.rb

@@ -3,19 +3,54 @@ require 'test_helper'
 class WebTest < MiniTest::Unit::TestCase
 
   def setup
-    @web_service = (Urban::Web.new).extend Stub
-    @web_service.stub(:open) { |arg| return arg; }
+    @web_module = (Object.new).extend(Urban::Web).extend(Stub)
   end
 
-  def test_web_sends_request_to_random
-    expected = 'http://www.urbandictionary.com/random.php'
-    actual = @web_service.query(:random)
-    assert_equal(expected, actual)
+  class WebFetchTest < WebTest
+    def setup
+      super
+      @web_module.stub(:open) { |arg| arg }
+    end
+
+    def test_fetch_with_no_params
+      expected = 'http://www.urbandictionary.com/test.php'
+      actual = @web_module.fetch('test.php')
+      assert_equal(expected, actual)
+    end
+
+    def test_fetch_with_params
+      expected = /http:\/\/www\.urbandictionary\.com\/test\.php\?\w+=\w+&\w+=\w+/
+      actual = @web_module.fetch('test.php', :name => 'foo', :term => 'bar')
+      assert_match(expected, actual)
+    end
   end
 
-  def test_web_sends_request_to_define_with_phrase
-    expected = 'http://www.urbandictionary.com/define.php?term=Cookie%20monster'
-    actual = @web_service.query(:define, 'Cookie monster')
-    assert_equal(expected, actual)
+  class WebInterfaceTest < WebTest
+
+    def setup
+      super
+      @expected = OpenStruct.new
+      @expected.base_uri = 'http://www.urbandictionary.com/define.php?term=impromptu'
+
+      @web_module.stub(:open) do |arg|
+        result = OpenStruct.new
+        result.base_uri = 'http://www.urbandictionary.com/define.php?term=impromptu'
+        result
+      end
+    end
+
+    def test_returns_response_for_random_word
+      actual = @web_module.random
+
+      assert_equal(@expected.base_uri, actual.url)
+      assert_equal(@expected, actual.stream)
+    end
+
+    def test_returns_response_for_define_with_phrase
+      actual = @web_module.search('cookie monster')
+
+      assert_equal(@expected.base_uri, actual.url)
+      assert_equal(@expected, actual.stream)
+    end
   end
 end