mitchellh-rubyuw 0.7.2 → 0.99.0

data/lib/rubyuw/sln.rb

@@ -0,0 +1,108 @@
+module RubyUW
+  # RubyUW::SLN is used to find and extract information about 
+  # specific SLNs. It grabs SLN information via the MyUW time
+  # schedule.
+  #
+  # <b>Requires authentication with RubyUW::Base prior to use!</b>
+  #
+  # Additionally, this class should typically never be instantiated
+  # by any developer. Instead, the class methods should be used
+  # which will return an instance of the SLN object.
+  #
+  # == Usage Examples
+  #
+  #   require 'rubyuw'
+  #   RubyUW::Base.authenticate("netid", "password")
+  #   sln_info = RubyUW::SLN.find("12345", "AUT+2009")
+  class SLN
+    attr_reader :sln
+    attr_reader :data
+    
+    # Initialize a new SLN object. This should never be called on its
+    # own, but instead you should use the find method to setup a
+    # sln.
+    #
+    # @param [String] SLN number in string format.
+    # @param [String] Term that the SLN corresponds to.
+    # @param [Hash] Data of key to value.
+    def initialize(sln, term, data)
+      @sln = sln
+      @term = term
+      @data = data
+    end
+    
+    # Grab the data of the SLN based on a key. Returns the value of
+    # a field for the SLN, or nil otherwise. Supported fields coming
+    # soon.
+    def data(key)
+      @data[key.to_sym]
+    end
+    
+    class <<self
+      # Finds information about a specific SLN. The SLN information
+      # is grabbed from the MyUW time schedule page. Authentication is
+      # required prior to use.
+      #
+      # @param [#to_s] The SLN, which must respond to #to_s
+      # @param [String] The term, as represented in the time schedule URL.
+      # @return [RubyUW::SLN]
+      def find(sln_number, term)
+        raise Errors::NotLoggedInError.new unless Base.authenticated?
+
+        # Grab the SLN page and check for various failure scenarios
+        page = Base.connection.get("https://sdb.admin.washington.edu/timeschd/uwnetid/sln.asp?QTRYR=#{term}&SLN=#{sln_number}")
+        raise Errors::SLNRequestedTooSoonError.new if requested_too_soon?(page)
+        raise Errors::SLNDoesNotExistError.new if !sln_exists?(page)
+        raise Errors::SLNServiceClosedError.new if time_schedule_closed?(page)
+
+        # Now that the page is probably valid, we extract the field data
+        # based on various xpaths.
+        new(sln_number, term, extract_data_from_page(page))
+      end
+
+      protected
+
+      def requested_too_soon?(page)
+        page.uri.to_s == "http://www.washington.edu/students/timeschd/badrequest.html"
+      end
+
+      def sln_exists?(page)
+        page.body.to_s.match(/SLN: (.{5,6}) does not exist./).nil?
+      end
+
+      def time_schedule_closed?(page)
+        page.uri.to_s == "http://www.washington.edu/students/timeschd/nots.html"
+      end
+
+      def extract_data_from_page(page)
+        extract_data = [
+          [[nil, :course, :section, :type, :credits, :title], "//table[@border=1 and @cellpadding=3]//tr[@rowspan=1]//td"],
+          [[:current_enrollment, :limit_enrollment, :room_capacity, :space_available, :status], "//table[@border=1 and @cellpadding=3]//tr[count(td)=5]//td"],
+          [[:notes], "//table[@border=1 and @cellpadding=3]//tr[count(td)=1]//preceding-sibling::tr[count(th)=1]//following-sibling::tr//td"]
+        ]
+
+        data = {}
+        extract_data.each do |keys, xpath|
+          data.merge!(Base.extract(page, xpath, keys))
+        end
+
+        data
+      end
+    end
+  end
+  
+  module Errors
+    # An error indicating that an SLN was requested back-to-back too
+    # quickly. MyUW enforces a timeout between requests for SLN information,
+    # and when this is not obeyed, this error will be thrown by RubyUW.
+    class SLNRequestedTooSoonError < Exception; end
+    
+    # An error indicating that an SLN requested is invalid (does not
+    # exist).
+    class SLNDoesNotExistError < Exception; end
+    
+     # An error indicating that the time scheduling service of MyUW
+     # is currently closed.
+     class SLNServiceClosedError < Exception; end
+  end
+end

data/test/live/curriculum_enrollment_test.rb

@@ -0,0 +1,47 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class LiveCurriculumEnrollmentTest < Test::Unit::TestCase
+  context "live curriculum info grabbing" do
+    setup do
+      @curriculum = "CHEM"
+      @term = "AUT+2009"
+      
+      @curriculum_info = {
+        "11633" => {
+          :course => "CHEM   110",
+          :section => "A",
+          :type => "LC"
+        },
+        "11635" => {
+          :course => "CHEM   110",
+          :section => "AB",
+          :type => "QZ"
+        },
+        "11826" => {
+          :course => "CHEM   475",
+          :section => "A",
+          :type => "LC"
+        }
+      }
+    end
+    
+    should "raise an error for an invalid SLN/quarter" do
+      authenticate
+      assert_raise(RubyUW::Errors::CurriculumDoesNotExistError) { RubyUW::CurriculumEnrollment.find("NOTCHEM", @term) }
+    end
+    
+    should "grab all SLNs properly" do
+      authenticate
+      results = RubyUW::CurriculumEnrollment.find(@curriculum, @term)
+      
+      @curriculum_info.each do |sln, info|
+        course = results[sln]
+        assert !course.nil?
+        
+        info.each do |k,v|
+          assert_equal v, course.data(k)
+        end
+      end
+    end
+  end
+end

data/test/live/sln_test.rb

@@ -3,13 +3,6 @@ require File.join(File.dirname(__FILE__), 'test_helper')
 class LiveSLNTest < Test::Unit::TestCase
   context "live SLN info grabbing" do
     setup do
-      @myuw = MyUW.new
-      @session = @myuw.session
-      @session.email = MYUW_ID
-      @session.password = MYUW_PASSWORD
-      @session.login
-      assert @session.logged_in? # Sanity
-      
       @sln_info = {
         :sln      => "17237",
         :quarter  => "AUT+2009",
@@ -26,39 +19,36 @@ class LiveSLNTest < Test::Unit::TestCase
           :notes              => "Quiz Section"
         }
       }
-      
-      @sln = @myuw.sln(@sln_info[:sln], @sln_info[:quarter])
-      assert @sln # Sanity
     end
     
     teardown do
-      sleep(5) # To avoid the timeout problems within tests
+      sleep(5)
     end
     
-    should "grab course info for a valid SLN and quarter" do
+    def get_sln_obj
+      RubyUW::SLN.find(@sln_info[:sln], @sln_info[:quarter])
+    end
+    
+    should "grab course info for a valid SLN" do
+      authenticate
+      @sln = get_sln_obj
+      
       @sln_info[:info].each do |k,v|
-        assert_equal v, @sln.send(k), "#{k} should've been #{v}"
+        assert_equal v, @sln.data(k), "#{k} should've been #{v}"
       end
     end
     
     should "raise an error if requests are back to back too fast" do
-      assert_nothing_raised do
-        @sln.course
-      end
-      
-      @sln.sln = @sln.sln # Force reload
-      
-      assert_raise MyUW::RequestSLNTooSoonError do
-        @sln.course
-      end
+      authenticate
+      assert_nothing_raised() { get_sln_obj }
+      assert_raise(RubyUW::Errors::SLNRequestedTooSoonError) { get_sln_obj }
     end
     
     should "raise an error for an invalid SLN/quarter" do
-      @sln.sln = 91919 # Tested to not exist
+      @sln_info[:sln] = 91919 # Tested to not exist
       
-      assert_raise MyUW::InvalidSLNError do
-        @sln.course
-      end
+      authenticate
+      assert_raise(RubyUW::Errors::SLNDoesNotExistError) { get_sln_obj }
     end
   end
 end

data/test/live/test_helper.rb

@@ -4,8 +4,21 @@ rescue LoadError => e
   abort("Running live tests requires a password.rb file in the test folder with your MyUW credentials.")
 end
 
-require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'myuw')
+require 'rubygems'
+$:.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+require 'rubyuw'
 require 'test/unit'
 require "contest"
 require "stories"
-require "mocha"
+require "mocha"
+
+class Test::Unit::TestCase
+  def setup
+    RubyUW::Base.reset_connection!
+  end
+  
+  def authenticate
+    assert RubyUW::Base.authenticate(MYUW_ID, MYUW_PASSWORD)
+    assert RubyUW::Base.authenticated? # sanity
+  end
+end

data/test/mocked/base_test.rb

@@ -0,0 +1,171 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class BaseTest < Test::Unit::TestCase
+  context "with connection" do
+    setup do
+      RubyUW::Base.reset_connection!
+    end
+    
+    should "initialize a WWW::Mechanize object on the first call" do
+      RubyUW::Connection.expects(:new).once
+      RubyUW::Base.connection
+    end
+    
+    should "not initialize WWW::Mechanize objects on subsequent calls" do
+      RubyUW::Connection.expects(:new).once.returns(true)
+      50.times { RubyUW::Base.connection }
+    end
+    
+    should "clear out the connection to force recreation of object on reset_connection!" do
+      assert !RubyUW::Base.connection.nil?
+      RubyUW::Base.reset_connection!
+      RubyUW::Connection.expects(:new).once.returns(true)
+      50.times { RubyUW::Base.connection }
+    end
+  end
+  
+  context "with authentication" do
+    setup do
+      # initialize the base connection
+      @conn = RubyUW::Base.reset_connection!.connection
+      @conn.follow_meta_refresh = false
+      
+      @good_id = "foo"
+      @good_password = "bar"
+      @bad_password = @good_password + "wrong"
+    end
+    
+    should "clear the cookie jar of the connection" do
+      RubyUW::Base.expects(:logout).once
+      
+      result_page = mock('page')
+      result_page.stubs(:form_with).returns(true)
+      @conn.stubs(:execute!).returns(result_page)
+      
+      RubyUW::Base.authenticate(@good_id, @good_password)
+    end
+    
+    should "succeed login with good ID and password and valid pages" do
+      mock_flow([
+        [:goto, ["http://myuw.washington.edu"], "welcome"],
+        [:submit_form, ["f", anything], "not_logged_in_relay"],
+        [:submit_form, ["relay", anything], "login"],
+        [:submit_form, ["query", anything], "not_logged_in_relay"]
+      ])
+      
+      assert RubyUW::Base.authenticate(@good_id, @good_password)
+    end
+    
+    should "fail login with bad ID and password" do
+      mock_flow([
+        [:goto, ["http://myuw.washington.edu"], "welcome"],
+        [:submit_form, ["f", anything], "not_logged_in_relay"],
+        [:submit_form, ["relay", anything], "login"],
+        [:submit_form, ["query", anything], "login"]
+      ])
+      
+      assert !RubyUW::Base.authenticate(@good_id, @bad_password)
+    end
+  end
+  
+  context "with authentication check" do
+    should "return true if it can find the correct xpath" do
+      mock_flow([
+        [:goto, ["http://myuw.washington.edu"], "welcome"],
+        [:submit_form, ["f", anything], "logged_in_relay"]
+      ])
+      
+      assert RubyUW::Base.authenticated?
+    end
+    
+    should "not return true if it can't find the greeting" do
+      mock_flow([
+        [:goto, ["http://myuw.washington.edu"], "welcome"],
+        [:submit_form, ["f", anything], "login"]
+      ])
+      
+      assert !RubyUW::Base.authenticated?
+    end
+  end
+  
+  context "with logging out" do
+    should "clear the cookie jar on logout" do
+      cookie_jar = mock('cookie_jar')
+      cookie_jar.expects(:clear!).once
+      
+      conn = RubyUW::Base.connection
+      conn.expects(:cookie_jar).returns(cookie_jar)
+      
+      RubyUW::Base.logout
+    end
+  end
+  
+  context "with extracting data from page" do
+    setup do
+      @page = mock('page')
+      @xpath = "foo"
+    end
+    
+    def setup_nodes(inner_texts)
+      nodes = []
+      inner_texts.each do |text|
+        node = mock('node')
+        node.stubs(:inner_text).returns(text)
+        
+        nodes << node
+      end
+      
+      nodes
+    end
+    
+    should "run the xpath on the specified page" do
+      @page.expects(:search).with(@xpath).returns([])
+      RubyUW::Base.extract(@page, @xpath, [])
+    end
+    
+    should "return nil if the xpath returns an empty array" do
+      @page.expects(:search).with(@xpath).returns([])
+      assert_nil RubyUW::Base.extract(@page, @xpath, [])
+    end
+    
+    should "map keys to node results if xpath returns valid nodes" do
+      expected = { :one => "1", :two => "2", :three => "3" }
+      nodes = setup_nodes(expected.values)
+      keys = expected.keys
+      
+      @page.expects(:search).with(@xpath).returns(nodes)
+      result = RubyUW::Base.extract(@page, @xpath, keys)
+      assert expected == result
+    end
+    
+    should "skip the nil keys (while continuing to go through the node list)" do
+      nodes = setup_nodes(["1","2","3"])
+      keys = [:one, nil, :three]
+      
+      @page.expects(:search).with(@xpath).returns(nodes)
+      result = RubyUW::Base.extract(@page, @xpath, keys)
+      assert_equal 2, result.length
+      assert !result.value?("2")
+    end
+    
+    should "return what it has so far if it runs out of keys" do
+      nodes = setup_nodes((1..50).to_a.map(&:to_s))
+      keys = [:one]
+      
+      @page.expects(:search).with(@xpath).returns(nodes)
+      result = RubyUW::Base.extract(@page, @xpath, keys)
+      assert_equal keys.length, result.length
+      assert_equal "1", result[keys[0]]
+    end
+    
+    should "get rid of odd characters that MyUW has in text" do
+      nodes = setup_nodes(["foo\302\240"])
+      keys = [:one]
+      
+      @page.expects(:search).with(@xpath).returns(nodes)
+      result = RubyUW::Base.extract(@page, @xpath, keys)
+      assert_equal keys.length, result.length
+      assert_equal "foo", result[keys[0]]
+    end
+  end
+end

data/test/mocked/connection_test.rb

@@ -0,0 +1,178 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class ConnectionTest < Test::Unit::TestCase
+  should "be a kind of WWW::Mechanize" do
+    assert RubyUW::Connection.new.kind_of?(WWW::Mechanize)
+  end
+  
+  context "web flows" do
+    setup do
+      @conn = RubyUW::Connection.new
+    end
+    
+    should "be empty to begin with" do
+      assert @conn.current_flow.empty?
+    end
+    
+    context "with goto" do
+      should "add new item to flow and return self when calling goto" do
+        url = "http://foo.com"
+        assert_equal @conn, @conn.goto(url)
+        assert_equal 1, @conn.current_flow.length
+        assert_equal :goto, @conn.current_flow[0][0]
+      end
+      
+      should "get the page when executing" do
+        @url = "http://foo.com"
+        @conn.goto(@url)
+        @conn.expects(:get).with(@url).once
+        @conn.execute!
+      end
+    end
+    
+    context "with verify" do
+      setup do
+        @xpath = "//foo"
+        @url = "fake"
+      end
+      
+      def mock_context(return_value=nil)
+        context = mock('context')
+        context.expects(:search).with(@xpath).once.returns(return_value)
+        @conn.expects(:execute_goto!).returns(context)
+        @conn.goto(@url)
+        
+        context
+      end
+      
+      should "add new item to flow and return self when calling verify" do
+        xpath = "//foo"
+        assert_equal @conn, @conn.verify(xpath)
+        assert_equal 1, @conn.current_flow.length
+        assert_equal :verify, @conn.current_flow[0][0]
+      end
+      
+      should "verify the previous page result when executing" do
+        mock_context([1])
+        @conn.verify(@xpath)
+        
+        assert_nothing_raised { @conn.execute! }
+      end
+      
+      should "return back the context given" do
+        context = mock_context([1])
+        @conn.verify(@xpath)
+        
+        assert_equal context, @conn.execute!
+      end
+      
+      should "raise an InvalidPageError if no elements found" do
+        mock_context([])
+        @conn.verify(@xpath)
+        
+        assert_raises(RubyUW::Errors::InvalidPageError) { @conn.execute! }
+      end
+    end
+    
+    context "with submitting form" do
+      setup do
+        @url = "fake"
+        @form = "form"
+        @params = { :key => :value, :key2 => :value2 }
+      end
+      
+      def mock_context
+        context = mock('context')
+        @conn.expects(:execute_goto!).returns(context)
+        @conn.goto(@url)
+        
+        context
+      end
+      
+      def mock_form_object(context)
+        form_obj = mock('form_obj')
+        form_obj.stubs(:[]=)
+        form_obj.expects(:submit).returns(:submit)
+        context.expects(:form_with).with(:name => @form).once.returns(form_obj)
+        form_obj
+      end
+      
+      should "add new item to flow and return self when calling submit_form" do
+        assert_equal @conn, @conn.submit_form(@form, @params)
+        assert_equal 1, @conn.current_flow.length
+        assert_equal :submit_form, @conn.current_flow[0][0]
+      end
+      
+      should "raise InvalidPageError if the form is not found on the page" do
+        context = mock_context
+        context.expects(:form_with).with(:name => @form).once.returns(nil)
+        @conn.submit_form(@form, @params)
+        
+        assert_raises(RubyUW::Errors::InvalidPageError) { @conn.execute! }
+      end
+      
+      should "assign the parameters to the form object" do
+        context = mock_context
+        form_obj = mock_form_object(context)
+        form_obj.expects(:[]=).times(@params.length)
+
+        @conn.submit_form(@form, @params)
+        @conn.execute!
+      end
+      
+      should "send the parameters after #to_s'ing them" do
+        key = mock('para_key')
+        key.expects(:to_s).once
+        
+        param = mock('param')
+        param.expects(:to_s).once
+        
+        params = { key => param }
+        
+        context = mock_context
+        form_obj = mock_form_object(context)
+        form_obj.expects(:[]=).times(params.length)
+
+        @conn.submit_form(@form, params)
+        @conn.execute!
+      end
+      
+      should "submit and return the form result" do
+        context = mock_context
+        mock_form_object(context)
+        @conn.submit_form(@form, @params)
+        
+        assert_equal :submit, @conn.execute!
+      end
+    end
+    
+    context "with executing" do
+      setup do
+        @url = "foo"
+        @form_name = "form"
+        @form_params = {}
+        
+        @conn.goto(@url).submit_form(@form_name, @form_params)
+        @conn.stubs(:execute_goto!).returns(:goto)
+        @conn.stubs(:execute_submit_form!).returns(:submit_form)
+      end
+      
+      should "execute in the order given" do
+        execution_sequence = sequence('execution')
+        @conn.expects(:execute_goto!).in_sequence(execution_sequence)
+        @conn.expects(:execute_submit_form!).in_sequence(execution_sequence)
+        @conn.execute!
+      end
+      
+      should "reset the current flow to empty" do
+        assert !@conn.current_flow.empty?
+        @conn.execute!
+        assert @conn.current_flow.empty?
+      end
+      
+      should "return the last task's return value" do
+        assert_equal :submit_form, @conn.execute!
+      end
+    end
+  end
+end