mitchellh-rubyuw 0.7.2 → 0.99.0

data/test/mocked/curriculum_enrollment_test.rb

@@ -1,87 +1,158 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class MockedCurriculumEnrollmentTest < Test::Unit::TestCase
-  context "fetching curriculum enrollment information" do
-    setup do
-      @myuw = MyUW.new
-      @myuw.stubs(:logged_in?).returns(true)
-      @browser = @myuw.browser
-      @browser.follow_meta_refresh = false
-      @curriculum = @myuw.curriculum_enrollment("CSE", "AUT+2009")
-    end
-    
-    should "return a MyUW::CurriculumEnrollment object when calling MyUW.curriculum" do
-      curric_obj = @myuw.curriculum_enrollment("CSE", "AUT+2009")
-      assert curric_obj.kind_of?(MyUW::CurriculumEnrollment)
-      assert_equal "CSE", curric_obj.curriculum
-      assert_equal "AUT+2009", curric_obj.term
-    end
-    
-    should "raise a NotLoggedInError if not logged in and requesting enrollment information" do
-      @myuw.stubs(:logged_in?).returns(false)
+class CurriculumEnrollmentTest < Test::Unit::TestCase
+  setup do
+    RubyUW::CurriculumEnrollment.publicize_singleton_methods
+  end
+  
+  teardown do
+    RubyUW::CurriculumEnrollment.protect_singleton_methods
+  end
+  
+  context "finding an SLN" do
+    context "with authentication" do
+      should "raise an error if not authenticated" do
+        RubyUW::Base.expects(:authenticated?).returns(false)
+        assert_raises(RubyUW::Errors::NotLoggedInError) { RubyUW::CurriculumEnrollment.find("foo", "bar") }
+      end
       
-      assert_raise MyUW::NotLoggedInError do
-        @curriculum.data_by_sln("foo", true)
+      should "not raise an error if authenticated" do
+        RubyUW::Base.expects(:authenticated?).returns(true)
+        assert_nothing_raised { RubyUW::CurriculumEnrollment.find("foo", "bar") }
       end
     end
     
-    should "raise an ArgumentError if a curriculum is not set" do
-      @curriculum.curriculum = nil
-      assert !@curriculum.curriculum
+    context "with checking if a curriculum exists or not" do
+      should "return false if the curric does not exist string is found" do
+        mocked_page = RubyUW::Base.connection.get(path_to_html("curric_no_curric_found"))
+        
+        assert !RubyUW::CurriculumEnrollment.curriculum_exists?(mocked_page)
+      end
       
-      assert_raise ArgumentError do
-        @curriculum.data_by_sln("foo", true)
+      should "return true if the string is not found" do
+        mocked_page = RubyUW::Base.connection.get(path_to_html("curric_courses"))
+        
+        assert RubyUW::CurriculumEnrollment.curriculum_exists?(mocked_page)
       end
     end
     
-    should "raise an ArgumentError if a term is not set" do
-      @curriculum.term = nil
-      assert !@curriculum.term
+    context "raising exceptions on failures" do
+      setup do
+        RubyUW::Base.stubs(:authenticated?).returns(true)
+        RubyUW::CurriculumEnrollment.stubs(:curriculum_exists?).returns(true)
+        
+        page = mock('page')
+        RubyUW::Base.connection.stubs(:get).returns(page)
+        
+        @term = "bar"
+        @curric = "foo"
+      end
       
-      assert_raise ArgumentError do
-        @curriculum.data_by_sln("foo", true)
+      should "raise CurriculumDoesNotExistError if curric does not exist" do
+        RubyUW::CurriculumEnrollment.expects(:curriculum_exists?).returns(false)
+        assert_raises(RubyUW::Errors::CurriculumDoesNotExistError) { RubyUW::CurriculumEnrollment.find(@curric, @term) }
       end
-    end
-    
-    should "raise an InvalidCurriculumError if it can't find the curriculum info" do
-      fixture_page = @browser.get(path_to_html("curric_no_curric_found"))
-      @browser.expects(:get).returns(fixture_page)
       
-      assert_raise MyUW::InvalidCurriculumError do
-        @curriculum.get_dept_page
+      should "raise CurriculumDoesNotExistError if mechanize throws a response code error" do
+        error = mock('error')
+        error.stubs(:code).returns("404")
+        RubyUW::Base.connection.stubs(:get).raises(WWW::Mechanize::ResponseCodeError, error)
+        assert_raises(RubyUW::Errors::CurriculumDoesNotExistError) { RubyUW::CurriculumEnrollment.find(@curric, @term) }
       end
     end
-  end
-  
-  context "extracting all course data" do
-    setup do
-      @myuw = MyUW.new
-      @browser = @myuw.browser
-      @browser.follow_meta_refresh = false
-      @curriculum = @myuw.curriculum_enrollment("CSE", "AUT+2009")
-      @fixture_page = @browser.get(path_to_html("curric_courses"))
-    end
     
-    should "raise InvalidPageError if no rows are found for extracting information" do
-      fixture_page = @browser.get(path_to_html("curric_no_courses"))
+    context "extracting courses from page" do
+      setup do
+        @page = mock('page')
+        @page.stubs(:search).returns([])
+        
+        @term = "AUT+2009"
+      end
+      
+      should "run a search on page and run extract_node on each result" do
+        extract_sequence = sequence('extract')
+        
+        mocks = []
+        3.times do
+          result = mock('result')
+          mocks << result
+
+          RubyUW::CurriculumEnrollment.expects(:extract_course).with(result).returns({}).in_sequence(extract_sequence)
+        end
+        
+        @page.expects(:search).returns(mocks)
+        
+        RubyUW::CurriculumEnrollment.extract_courses(@page, @term)
+      end
+      
+      should "return a hash when extracting courses" do
+        result = RubyUW::CurriculumEnrollment.extract_courses(@page, @term)
+        assert result.kind_of?(Hash)
+      end
       
-      assert_raise MyUW::InvalidPageError do
-        @curriculum.get_all_courses_data(fixture_page)
+      should "turn results from extract_course into a RubyUW::SLN object" do
+        sln = "123456"
+        data = { :foo => :bar }
+        RubyUW::CurriculumEnrollment.expects(:extract_course).returns([sln, data])
+        @page.expects(:search).returns([:whatever])
+        
+        result = RubyUW::CurriculumEnrollment.extract_courses(@page, @term)
+        assert_equal 1, result.length
+        assert result.values[0].is_a?(RubyUW::SLN)
       end
     end
     
-    should "call get_course_data on each node" do
-      @curriculum.expects(:get_course_data).at_least(1).returns({
-        :sln => "123456"
-      })
-      assert_nothing_raised { @curriculum.get_all_courses_data(@fixture_page) }
+    context "extracting a single course" do
+      setup do
+        @node = mock('node')
+        
+        RubyUW::CurriculumEnrollment.send(:public, *(RubyUW::CurriculumEnrollment.protected_instance_methods)) 
+      end
+      
+      should "strip out the leading > of quiz sections" do
+        RubyUW::Base.expects(:extract).returns({
+          :sln => ">foo"
+        })
+        
+        results = RubyUW::CurriculumEnrollment.extract_course(@node)
+        assert_equal "foo", results[0]
+      end
     end
     
-    should "successfully extract and store course data" do
-      assert_nothing_raised { @curriculum.get_all_courses_data(@fixture_page) }
+    context "finding SLNs on the mocked page" do
+      setup do
+        @page = expect_get("curric_courses")
+        RubyUW::Base.stubs(:authenticated?).returns(true)
+        
+        @curric = "foo"
+        @term = "bar"
+        
+        @results = RubyUW::CurriculumEnrollment.find(@curric, @term)
+      end
       
-      # Random test
-      assert_equal "54", @curriculum.data["11633"][:current_enrollment]
+      should "get the correct number of courses" do
+        assert @results.is_a?(Hash) # sanity
+        assert_equal 226, @results.length
+      end
+      
+      should "properly extract courses with all columns filled" do
+        course = @results["11635"]
+        assert !course.nil?
+        assert course.is_a?(RubyUW::SLN) # sanity
+              
+        course_info = {
+          :course   => "CHEM   110",
+          :section  => "AB",
+          :type     => "QZ",
+          :title    => "INTRO TO GEN CHEM",
+          :room_capacity => "50",
+          :space_available => "--"
+        }
+        
+        course_info.each do |k,v|
+          assert_equal v, course.data(k)
+        end
+      end
     end
   end
 end

data/test/mocked/sln_test.rb

@@ -1,181 +1,145 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class MockedSlnTest < Test::Unit::TestCase
-  context "fetching SLN information" do
+class SLNTest < Test::Unit::TestCase
+  setup do
+    RubyUW::SLN.publicize_singleton_methods
+  end
+  
+  teardown do
+    RubyUW::SLN.protect_singleton_methods
+  end
+  
+  context "SLN instance" do
     setup do
-      @myuw = MyUW.new
-      @myuw.stubs(:logged_in?).returns(true)
-      @browser = @myuw.browser
-      @browser.follow_meta_refresh = false
-      @sln = @myuw.sln("123456", "AUT+2009")
-    end
-    
-    should "return a MyUW::SLNInfo object when calling MyUW.sln" do
-      sln_obj = @myuw.sln("123456", "AUT+2009")
-      assert sln_obj.kind_of?(MyUW::SLNInfo)
-      assert_equal sln_obj.sln, "123456"
-      assert_equal sln_obj.term, "AUT+2009"
-    end
-    
-    should "raise a NotLoggedInError if not logged in and requesting an SLN" do
-      @myuw.stubs(:logged_in?).returns(false)
+      @sln = "foo"
+      @term = "bar"
+      @data = {
+        :one => "1",
+        :two => "2"
+      }
       
-      assert_raise MyUW::NotLoggedInError do
-        @sln.course
-      end
+      @sln_obj = RubyUW::SLN.new(@sln, @term, @data)
     end
     
-    should "raise a ArgumentError if there is no SLN set" do
-      @sln.sln = nil
-      assert @sln.term # Sanity
-      
-      assert_raise ArgumentError do
-        @sln.course
+    should "return data values from the field method" do
+      @data.each do |k,v|
+        assert_equal v, @sln_obj.data(k)
       end
     end
     
-    should "raise a ArgumentError if there is no term set" do
-      @sln.term = nil
-      assert @sln.sln
-      
-      assert_raise ArgumentError do
-        @sln.course
+    should "convert to symbols so accessing by string works too" do
+      @data.each do |k,v|
+        assert_equal v, @sln_obj.data(k.to_s)
       end
     end
-    
-    should "raise a InvalidSLNError if an invalid SLN is requested" do
-      fixture_page = @browser.get(path_to_html("sln_does_not_exist"))
-      @browser.expects(:get).returns(fixture_page)
+  end
+  
+  context "finding an SLN" do
+    context "with authentication" do
+      setup do
+        expect_get("bad_request", nil, :stubs)
+        RubyUW::SLN.stubs(:extract_data_from_page).returns({})
+      end
       
-      assert_raise MyUW::InvalidSLNError do
-        @sln.get_sln_page
+      should "raise an error if not authenticated" do
+        RubyUW::Base.expects(:authenticated?).returns(false)
+        assert_raises(RubyUW::Errors::NotLoggedInError) { RubyUW::SLN.find("foo", "bar") }
       end
-    end    
-    
-    should "raise a RequestSLNTooSoonError if an SLN is requested again too soon" do
-      fixture_page = @browser.get(path_to_html("bad_request"))
-      fixture_page.uri = "http://www.washington.edu/students/timeschd/badrequest.html"
-      @browser.expects(:get).with("https://sdb.admin.washington.edu/timeschd/uwnetid/sln.asp?QTRYR=#{@sln.term}&SLN=#{@sln.sln}").returns(fixture_page)
-    
-      assert_raise MyUW::RequestSLNTooSoonError do
-        @sln.get_sln_page
+      
+      should "not raise an error if authenticated" do
+        RubyUW::Base.expects(:authenticated?).returns(true)
+        assert_nothing_raised { RubyUW::SLN.find("foo", "bar") }
       end
     end
     
-    should "raise an InvalidPageError if it can't find the course info" do
-      fixture_page = @browser.get(path_to_html("sln_no_course_info"))
-
-      e = assert_raise MyUW::InvalidPageError do
-        @sln.get_course_info(fixture_page)
+    context "with checking if an SLN was requested too soon" do
+      should "return true if the URI matches the badrequest page" do
+        page = mock('page')
+        page.stubs(:uri).returns("http://www.washington.edu/students/timeschd/badrequest.html")
+        
+        assert RubyUW::SLN.requested_too_soon?(page)
       end
       
-      assert !e.page.nil?
-    end
-    
-    should "raise an InvalidPageError if it can't find the enrollment info" do
-      fixture_page = @browser.get(path_to_html("sln_no_enrollment_info"))
-
-      e = assert_raise MyUW::InvalidPageError do
-        @sln.get_enrollment_info(fixture_page)
+      should "convert URI to string before checking" do
+        uri = mock('uri')
+        uri.expects(:to_s).returns("http://www.washington.edu/students/timeschd/badrequest.html")
+        
+        page = mock('page')
+        page.stubs(:uri).returns(uri)
+        
+        assert RubyUW::SLN.requested_too_soon?(page)
       end
       
-      assert !e.page.nil?
+      should "return false if the URI is anything else" do
+        page = mock('page')
+        page.stubs(:uri).returns("foo")
+        
+        assert !RubyUW::SLN.requested_too_soon?(page)
+      end
     end
     
-    should "raise an InvalidPageError if it can't find the course notes" do
-      fixture_page = @browser.get(path_to_html("sln_no_course_notes"))
-
-      e = assert_raise MyUW::InvalidPageError do
-        @sln.get_course_notes(fixture_page)
+    context "with checking if an SLN exists or not" do
+      should "return false if the SLN does not exist string is found" do
+        mocked_page = RubyUW::Base.connection.get(path_to_html("sln_does_not_exist"))
+        
+        assert !RubyUW::SLN.sln_exists?(mocked_page)
       end
       
-      assert !e.page.nil?
+      should "return true if the string is not found" do
+        mocked_page = RubyUW::Base.connection.get(path_to_html("sln_status"))
+        
+        assert RubyUW::SLN.sln_exists?(mocked_page)
+      end
     end
     
-    should "raise a TimeScheduleClosedError if the time schedule system is closed" do
-      fixture_page = mock()
-      fixture_page.stubs(:uri).returns("http://www.washington.edu/students/timeschd/nots.html")
-      fixture_page.stubs(:body).returns("")
-      @browser.expects(:get).returns(fixture_page)
+    context "with checking whether time schedule is closed" do
+      should "return true if the URI matches the closed page" do
+        page = mock('page')
+        page.stubs(:uri).returns("http://www.washington.edu/students/timeschd/nots.html")
+        
+        assert RubyUW::SLN.time_schedule_closed?(page)
+      end
       
-      assert_raise MyUW::TimeScheduleClosedError do
-        @sln.course
+      should "return false if the URI is anything else" do
+        page = mock('page')
+        page.stubs(:uri).returns("foo")
+        
+        assert !RubyUW::SLN.time_schedule_closed?(page)
       end
     end
     
-    should "not raise a TimeScheduleClosedError if the URI doesn't match" do
-      fixture_page = @browser.get(path_to_html("sln_status"))
-      @browser.expects(:get).returns(fixture_page)
-      
-      assert_nothing_raised do
-        @sln.course
+    context "raising exceptions on failures" do
+      setup do
+        RubyUW::Base.stubs(:authenticated?).returns(true)
+        RubyUW::SLN.stubs(:requested_too_soon?).returns(false)
+        RubyUW::SLN.stubs(:sln_exists?).returns(true)
+        RubyUW::SLN.stubs(:time_schedule_closed?).returns(false)
+        RubyUW::SLN.stubs(:extract_data_from_page).returns({})
+        
+        page = mock('page')
+        RubyUW::Base.connection.stubs(:get).returns(page)
+        
+        @sln = "foo"
+        @term = "bar"
       end
-    end
-  end
-  
-  context "extract info from nodes" do
-    setup do
-      @myuw = MyUW.new
-      @sln = @myuw.sln("123456", "AUT+2009")
-      
-      @keys = [:foo, :bar, :baz]
-      @values = [
-        stub(:inner_text => "vfoo"),
-        stub(:inner_text => "vbar"),
-        stub(:inner_text => "vbaz")
-      ]
-      
-      @long_values = @values.dup
-      @long_values.push(stub(:inner_text => "vbad"))
       
-      @nil_keys = @keys.dup
-      @nil_keys.push(nil)
-      @nil_keys.push(:bang)
-      
-      @nil_values = @long_values.dup
-      @nil_values.push(stub(:inner_text => "vbang"))
-    end
-    
-    should "return false if there are no nodes" do
-      assert !@sln.extract_info(@keys, [])
-    end
-    
-    should "return true if everything is good" do
-      assert @sln.extract_info(@keys, @values)
-    end
-    
-    should "only extract as long as there are keys left" do
-      assert @sln.extract_info(@keys, @long_values)
-      assert_equal @keys.length, @sln.data.length
+      should "raise SLNRequestedTooSoonError is requested too soon" do
+        RubyUW::SLN.expects(:requested_too_soon?).returns(true)
+        assert_raises(RubyUW::Errors::SLNRequestedTooSoonError) { RubyUW::SLN.find(@sln, @term) }
+      end
       
-      # It shouldn't get the 4th long value since there are only 3 keys
-      @sln.data.each { |k,v| assert_not_equal @long_values[@keys.length].inner_text, v }
-    end
-    
-    should "extract values and associate them with proper keys" do
-      assert @sln.extract_info(@keys, @values)
-      assert_equal @keys.length, @sln.data.length
+      should "raise SLNDoesNotExistError if sln does not exist" do
+        RubyUW::SLN.expects(:sln_exists?).returns(false)
+        assert_raises(RubyUW::Errors::SLNDoesNotExistError) { RubyUW::SLN.find(@sln, @term) }
+      end
       
-      @sln.data.each do |k,v|
-        assert @keys.include?(k)
-        assert_equal @values[@keys.index(k)].inner_text, v
+      should "raise SLNServiceClosedError if the service is closed" do
+        RubyUW::SLN.expects(:time_schedule_closed?).returns(true)
+        assert_raises(RubyUW::Errors::SLNServiceClosedError) { RubyUW::SLN.find(@sln, @term) }
       end
-    end
-    
-    should "not store values associated with nil keys" do
-      assert @sln.extract_info(@nil_keys, @nil_values)
-      assert_equal (@nil_keys.length - 1), @sln.data.length
       
-      @nil_keys.each_index do |i|
-        key = @nil_keys[i]
-        
-        # If the key is nil, it should NOT store the value
-        # at that index, otherwise it should
-        if key.nil?
-          assert !@sln.data.has_value?(@nil_values[i].inner_text)
-        else
-          assert_equal @nil_values[i].inner_text, @sln.data[key]
-        end
+      should "not raise any exception if all fail checks are valid" do
+        assert_nothing_raised { RubyUW::SLN.find(@sln, @term) } 
       end
     end
   end