urban 1.0.0 → 2.0.0

data/test/fixtures/screens/definition.txt

@@ -0,0 +1,5 @@
+
+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.
+

data/test/fixtures/screens/definition_with_url.txt

@@ -0,0 +1,7 @@
+
+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.
+
+URL: http://www.urbandictionary.com/define.php?term=impromptu
+

data/test/fixtures/screens/definitions.txt

@@ -0,0 +1,9 @@
+
+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.
+

data/test/fixtures/screens/help.txt

@@ -0,0 +1,19 @@
+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
+
+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
+

data/test/fixtures/screens/invalid_option_error.txt

@@ -0,0 +1,2 @@
+urban: invalid option: -b
+Try `urban --help' for more information.

data/test/fixtures/screens/missing_phrase_error.txt

@@ -0,0 +1 @@
+urban: no definitions found for GUBBLE.

data/test/fixtures/screens/no_internet_error.txt

@@ -0,0 +1 @@
+urban: no internet connection available.

data/test/test_helper.rb

@@ -1,28 +1,35 @@
 $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'
+require "rubygems"
+require "minitest/autorun"
+require "minitest/pride"
+require "minitest/hell"
+require "urban"
+require "ostruct"
 
-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.' ],
-    'http://www.urbandictionary.com/define.php?term=impromptu')
+class Urban::Test < Minitest::Test
 
-EMPTY_ENTRY = Urban::Dictionary::Entry.new('gubble', nil, nil)
+  def load_fixture(filename)
+    IO.read(File.expand_path("../fixtures/#{filename}", __FILE__))
+  end
 
-def load_file(filename)
-  IO.read(File.expand_path("../data/#{filename}", __FILE__))
-end
+  def empty_entry
+    @empty_entry ||= Urban::Dictionary::Entry.new('gubble', nil, nil)
+  end
 
-module Stub
-  def stub(name, &block)
-    singleton_class = class << self; self; end
-    singleton_class.send(:define_method, name, &block)
+  def test_entry
+    @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."
+      ],
+      "http://www.urbandictionary.com/define.php?term=impromptu"
+    )
   end
+
 end

data/test/urban/cli_test.rb

@@ -1,212 +1,154 @@
-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
+require "test_helper"
+require "shellwords"
+require "urban/cli"
 
-  def setup
-    @program = Urban::CLI.new
-  end
+class CLITest < Urban::Test
+
+  attr_accessor :program, :dictionary
 
-  # 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)) }
+  def nothing; "" end
+
+  def assert_program_output(stdout, stderr, args)
+    assert_output stdout, stderr do
+      program.run(Shellwords.shellwords(args))
     end
   end
 
+  def setup
+    self.program = Urban::CLI.new
+    self.dictionary = Urban::Dictionary.new
+
+    program.dictionary = dictionary
+  end
+
   class CLIArgumentParsingTest < CLITest
 
-    # 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))
+        options = program.send(:parse, [args])
+        assert options.send(name)
       end
     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
+      options = program.send(:parse, [])
+      refute options.help
+      refute options.version
+      refute options.random
+      refute options.all
+      assert_empty options.phrase
     end
 
     def test_phrase
-      assert_silent do
-        options = @program.send(:parse, ['foo bar'])
-        assert_equal('foo bar', options.phrase)
-      end
-    end
-
-    def test_help_flag
-      assert_silent do
-        assert_flag_is_set('help')
-      end
+      options = program.send :parse, ["foo bar"]
+      assert_equal "foo bar", options.phrase
     end
 
     def test_version_flag
-      assert_silent do
-        assert_flag_is_set('version')
-      end
+      assert_flag_is_set "version"
     end
 
     def test_random_flag
-      assert_silent do
-        assert_flag_is_set('random')
-      end
+      assert_flag_is_set "random"
     end
 
     def test_all_flag
-      assert_silent do
-        assert_flag_is_set('all')
-      end
+      assert_flag_is_set "all"
     end
 
-    def test_all_flag
-      assert_silent do
-        assert_flag_is_set('url')
-      end
+    def test_url_flag
+      assert_flag_is_set "url"
     end
   end
 
   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
       super
-      @dictionary = MiniTest::Mock.new
     end
 
-    # Tests
     def test_help_flag_prints_help
-      assert_output(HELP_SCREEN) { @program.run([]) }
+      help_screen = load_fixture "screens/help.txt"
+      assert_program_output help_screen, nothing, nothing
     end
 
     def test_version_flag_prints_version
-      ['-v', '--v'].each do |args|
-        assert_output("Urban #{Urban::VERSION} (c) Thomas Miller\n") { @program.run([args]) }
-      end
+      version_screen = "Urban #{Urban::VERSION} (c) Thomas Miller\n"
+      assert_program_output version_screen, nothing, "--version"
     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
+      single_definition = load_fixture "screens/definition.txt"
+
+      dictionary.stub(:random, test_entry) do
+        assert_program_output single_definition, nothing, "--random"
+      end
     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
+      single_definition = load_fixture "screens/definition.txt"
+      dictionary.stub(:search, test_entry) do
+        assert_program_output single_definition, nothing, "impromptu"
+      end
     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
+      multiple_definitions = load_fixture "screens/definitions.txt"
+      dictionary.stub(:random, test_entry) do
+        assert_program_output multiple_definitions, nothing, "--all --random"
+      end
     end
 
     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
+      multiple_definitions = load_fixture "screens/definitions.txt"
+      dictionary.stub(:search, test_entry) do
+        assert_program_output multiple_definitions, nothing, "--all impromptu"
+      end
     end
 
     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
+      definition_with_url = load_fixture "screens/definition_with_url.txt"
+      dictionary.stub(:random, test_entry) do
+        assert_program_output definition_with_url, nothing, "--url --random"
+      end
     end
 
     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
+      definition_with_url = load_fixture "screens/definition_with_url.txt"
+      dictionary.stub(:search, test_entry) do
+        assert_program_output definition_with_url, nothing, "--url impromptu"
+      end
     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
+      missing_phrase_error = load_fixture "screens/missing_phrase_error.txt"
+
+      dictionary.stub :search, empty_entry do
+        assert_program_output nothing, missing_phrase_error, "gubble"
+      end
     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)
+
+    def test_search_with_no_internet_prints_error
+      no_internet_error = load_fixture "screens/no_internet_error.txt"
+      raise_socket_error = Proc.new { raise SocketError }
+
+      dictionary.stub :search, raise_socket_error do
+        assert_program_output nothing, no_internet_error, "gubble"
+      end
     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)
+      invalid_option_error = load_fixture "screens/invalid_option_error.txt"
+      assert_program_output nothing, invalid_option_error, "-b"
     end
   end
 end

data/test/urban/dictionary_test.rb

@@ -1,37 +1,47 @@
-require 'test_helper'
+require "test_helper"
+require "urban/dictionary"
 
-class DictionaryTest < MiniTest::Unit::TestCase
+class DictionaryTest < Urban::Test
+
+  attr_accessor :web_service, :dictionary, :response
 
   def setup
-    @web_service = MiniTest::Mock.new
-    @dictionary = Urban::Dictionary
+    self.web_service = MiniTest::Mock.new
+    self.dictionary = Urban::Dictionary.new
+
+    dictionary.web_service = web_service
 
-    @response = OpenStruct.new
-    @response.url = 'http://www.urbandictionary.com/define.php?term=impromptu'
-    @response.stream = load_file('impromptu.html')
+    self.response = OpenStruct.new(
+      :url => "http://www.urbandictionary.com/define.php?term=impromptu",
+      :stream => load_fixture("impromptu.html")
+    )
   end
 
   def test_process_extracts_elements_from_html
-    entry = @dictionary.send(:process, @response )
-    assert_equal(TEST_ENTRY, entry)
+    entry = dictionary.send(:process, response )
+    assert_equal(test_entry, entry)
   end
 
   def test_dictionary_calls_random
-    @dictionary.web_service = @web_service.expect(:random, @response)
-    assert_equal(TEST_ENTRY, @dictionary.random)
-    @web_service.verify
+    web_service.expect(:random, response)
+
+    assert_equal(test_entry, dictionary.random)
+    web_service.verify
   end
 
   def test_dictionary_calls_search
-   @dictionary.web_service = @web_service.expect(:search, @response, ['impromptu'])
-   assert_equal(TEST_ENTRY, @dictionary.search('impromptu'))
-   @web_service.verify
+   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
+    response.stream = load_fixture 'missing.html'
+    web_service.expect(:search, response, ['gubble'])
+
+    assert_equal(empty_entry, dictionary.search('gubble'))
+    web_service.verify
   end
+
 end