rubyuw 0.99.1

data/lib/rubyuw/errors.rb

@@ -0,0 +1,16 @@
+module RubyUW
+  module Errors
+    # Exception signaling an invalid page was encountered.
+    class InvalidPageError < Exception
+      attr_reader :page
+
+      def initialize(page, msg=nil)
+        @page = page
+        super(msg)
+      end
+    end
+
+    # Exception when login is required and not logged in.
+    class NotLoggedInError < Exception; end
+  end
+end

data/lib/rubyuw/schedule.rb

@@ -0,0 +1,52 @@
+module RubyUW
+  # RubyUW::Schedule is used to grab the schedule of the
+  # authenticated user. 
+  #
+  # <b>Requires authentication with RubyUW::Base prior to use!</b>
+  class Schedule
+    class << self
+      # Scrapes the authenticated user's schedule from MyUW. 
+      # Authentication is required prior to use.
+      #
+      # Returns an array of {RubyUW::SLN} objects. The {RubyUW::SLN} 
+      # object responds to the following data elements:
+      #
+      # * sln
+      # * course
+      # * type
+      # * credits
+      # * title
+      # * days
+      # * time
+      # * location
+      # * instructor
+      #
+      # To get any more details you have to use the {RubyUW::SLN.find}
+      # method.
+      def get
+        raise Errors::NotLoggedInError.new unless Base.authenticated?
+        
+        page = Base.connection.get("https://sdb.admin.washington.edu/students/uwnetid/schedule.asp")
+        extract_courses(page)
+      end
+      
+      protected
+      
+      def extract_courses(page)
+        course_nodes = page.search("//table[@border=1 and @cellpadding=3]//tr[@bgcolor='#d0d0d0'][2]/following-sibling::*//td[@align='center']/parent::*")
+        courses = []
+        course_nodes.each do |node| 
+          course = extract_course(node)
+          courses << RubyUW::SLN.new(course[:sln], nil, course)
+        end
+        
+        courses
+      end
+      
+      def extract_course(node)
+        keys = [:sln, :course, :type, :credits, :title, :days, :time, :location, :instructor]
+        Base.extract(node, 'td', keys)
+      end
+    end
+  end
+end

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/rubyuw.gemspec

@@ -0,0 +1,97 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rubyuw}
+  s.version = "0.99.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Mitchell Hashimoto"]
+  s.date = %q{2009-12-06}
+  s.description = %q{Library which provides a ruby interface to the University of Washington student portal.}
+  s.email = %q{mitchell.hashimoto@gmail.com}
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    ".gitignore",
+     "README.md",
+     "Rakefile",
+     "VERSION",
+     "lib/rubyuw.rb",
+     "lib/rubyuw/base.rb",
+     "lib/rubyuw/connection.rb",
+     "lib/rubyuw/curriculum_enrollment.rb",
+     "lib/rubyuw/errors.rb",
+     "lib/rubyuw/schedule.rb",
+     "lib/rubyuw/sln.rb",
+     "rubyuw.gemspec",
+     "test/live/curriculum_enrollment_test.rb",
+     "test/live/sln_test.rb",
+     "test/live/test_helper.rb",
+     "test/mocked/base_test.rb",
+     "test/mocked/connection_test.rb",
+     "test/mocked/curriculum_enrollment_test.rb",
+     "test/mocked/fixture_pages/bad_request.html",
+     "test/mocked/fixture_pages/curric_courses.html",
+     "test/mocked/fixture_pages/curric_no_courses.html",
+     "test/mocked/fixture_pages/curric_no_curric_found.html",
+     "test/mocked/fixture_pages/logged_in_relay.html",
+     "test/mocked/fixture_pages/login.html",
+     "test/mocked/fixture_pages/no_form_login.html",
+     "test/mocked/fixture_pages/no_login_button.html",
+     "test/mocked/fixture_pages/not_logged_in_relay.html",
+     "test/mocked/fixture_pages/registration.html",
+     "test/mocked/fixture_pages/registration_error.html",
+     "test/mocked/fixture_pages/registration_error_no_rows.html",
+     "test/mocked/fixture_pages/registration_no_form.html",
+     "test/mocked/fixture_pages/registration_success.html",
+     "test/mocked/fixture_pages/registration_unknown.html",
+     "test/mocked/fixture_pages/schedule.html",
+     "test/mocked/fixture_pages/schedule_diff_credit_row.html",
+     "test/mocked/fixture_pages/schedule_empty.html",
+     "test/mocked/fixture_pages/schedule_no_credit_row.html",
+     "test/mocked/fixture_pages/sln_does_not_exist.html",
+     "test/mocked/fixture_pages/sln_no_course_info.html",
+     "test/mocked/fixture_pages/sln_no_course_notes.html",
+     "test/mocked/fixture_pages/sln_no_enrollment_info.html",
+     "test/mocked/fixture_pages/sln_status.html",
+     "test/mocked/fixture_pages/welcome.html",
+     "test/mocked/schedule_test.rb",
+     "test/mocked/sln_test.rb",
+     "test/mocked/test_helper.rb",
+     "test/password.rb.sample"
+  ]
+  s.homepage = %q{http://github.com/mitchellh/rubyuw}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Library which provides a ruby interface to the University of Washington student portal.}
+  s.test_files = [
+    "test/live/curriculum_enrollment_test.rb",
+     "test/live/sln_test.rb",
+     "test/live/test_helper.rb",
+     "test/mocked/base_test.rb",
+     "test/mocked/connection_test.rb",
+     "test/mocked/curriculum_enrollment_test.rb",
+     "test/mocked/schedule_test.rb",
+     "test/mocked/sln_test.rb",
+     "test/mocked/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<tenderlove-mechanize>, [">= 0.9.3.20090623142847"])
+    else
+      s.add_dependency(%q<tenderlove-mechanize>, [">= 0.9.3.20090623142847"])
+    end
+  else
+    s.add_dependency(%q<tenderlove-mechanize>, [">= 0.9.3.20090623142847"])
+  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

@@ -0,0 +1,54 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class LiveSLNTest < Test::Unit::TestCase
+  context "live SLN info grabbing" do
+    setup do
+      @sln_info = {
+        :sln      => "17237",
+        :quarter  => "AUT+2009",
+        :info     => {
+          :section  => "AE",
+          :type     => "QZ",
+          :credits  => "",
+          :title    => "INTRO TO LOGIC",
+          :current_enrollment => "25",
+          :limit_enrollment   => "25",
+          :room_capacity      => "40",
+          :space_available    => "",
+          :status             => "** Closed **",
+          :notes              => "Quiz Section"
+        }
+      }
+    end
+    
+    teardown do
+      sleep(5)
+    end
+    
+    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.data(k), "#{k} should've been #{v}"
+      end
+    end
+    
+    should "raise an error if requests are back to back too fast" do
+      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_info[:sln] = 91919 # Tested to not exist
+      
+      authenticate
+      assert_raise(RubyUW::Errors::SLNDoesNotExistError) { get_sln_obj }
+    end
+  end
+end

data/test/live/test_helper.rb

@@ -0,0 +1,24 @@
+begin
+  require File.join(File.dirname(__FILE__), '..', 'password')
+rescue LoadError => e
+  abort("Running live tests requires a password.rb file in the test folder with your MyUW credentials.")
+end
+
+require 'rubygems'
+$:.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+require 'rubyuw'
+require 'test/unit'
+require "contest"
+require "stories"
+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