smugmug 0.0.1

data/test/login.rb

@@ -0,0 +1,24 @@
+# -*- ruby -*-
+# $Hg$
+
+require 'test/unit'
+require 'smugmug'
+
+class TC_Login < Test::Unit::TestCase
+    def teardown
+        File.unlink(ENV['SMUGMUG_RC'])
+    end
+
+    def test_login
+        sm = nil
+
+        assert_nil(sm)
+        assert_raise(SmugMug::SmugMugError) { SmugMug::SmugMug.new('foo', 'blank') }
+        assert_nothing_raised { SmugMug::SmugMug.new('smugmug@example.net', 'secret') }
+
+        assert_nothing_raised { sm = SmugMug::SmugMug.new }
+        assert_equal('http://localhost:45556/', sm.base)
+
+        assert_not_nil(sm)
+    end
+end

data/test/runner.rb

@@ -0,0 +1,83 @@
+# -*- ruby -*-
+# $Hg$
+
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+require 'test/unit/ui/console/testrunner'
+require 'test/unit'
+require 'logger'
+require 'servlet'
+require 'smugmug'
+
+if not (File.exists?('table.rb'))
+    raise 'The test suite should only be run from the test directory.'
+end
+
+%w{access.log servlet.log test.log}.each do |filename|
+    File.unlink(filename) if File.exists?(filename)
+end
+
+ENV['SMUGMUG_URL'] = 'http://localhost:45556/'
+ENV['SMUGMUG_RC']  = '.smugmugrc'
+
+## Imitation smugmug.com
+server = WEBrick::HTTPServer.new(
+    :BindAddress => '127.0.0.1', 
+    :Port => 45556,
+    :AccessLog => [
+        [ File.open('access.log', 'w'), WEBrick::AccessLog::COMBINED_LOG_FORMAT ]
+    ],
+    :Logger => WEBrick::Log.new('servlet.log')
+)
+
+threads = []
+threads << Thread.new do
+    server.mount('/', SmugMugServlet)
+    server.start
+end
+
+%w{INT TERM EXIT}.each do |sig| 
+    trap(sig) do
+        server.shutdown
+        threads.each {|t| t.join}
+        File.unlink('.smugmugrc') if File.exists?('.smugmugrc')
+    end
+end
+
+$log = Logger.new('test.log')
+$smugmug = SmugMug::SmugMug.new('smugmug@example.net', 'secret')
+File.unlink(ENV['SMUGMUG_RC'])
+
+if ARGV.any?
+    ARGV.each {|fn| require(fn) }
+else
+    ## Stand alone
+    require('config.rb')
+    require('httpz.rb')
+    require('table.rb')
+
+    ## SmugMug.com WEBrick
+
+    require('login.rb')
+    require('album.rb')
+    require('image.rb')
+end
+
+class SmugMugTestSuite < Test::Unit::TestSuite
+    def initialize
+        super('SmugMug')
+    end
+    def self.suite
+        suite = Test::Unit::TestSuite.new
+        ObjectSpace.each_object(Class) do |klass|
+            suite << klass.suite if (Test::Unit::TestCase > klass)
+        end
+        return suite
+    end
+end
+
+passed = Test::Unit::UI::Console::TestRunner.run(SmugMugTestSuite.suite).passed?
+Kernel.exit(passed ? 0 : 1)
+
+# Local Variables:
+# ruby-indent-level: 4
+# End:

data/test/servlet.rb

@@ -0,0 +1,257 @@
+#!/usr/bin/env ruby
+# -*- Mode: ruby; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+# $Hg: servlet.rb,v 3b8b5b808b51 2007/08/11 07:33:22 boumenot $
+
+require 'webrick'
+require 'uri'
+
+module URI
+    class Generic
+        def [](key)
+            return query_hash[key]
+        end
+
+        def query_hash
+            raise RuntimeError if query.nil?
+            hash = {}
+            query.split('&').each do |s|
+                k,v = s.split('=')
+                hash[k] = v
+            end
+            return hash
+        end
+
+        def has_key?(key)
+            return query_hash.has_key?(key)
+        end
+    end
+end
+
+class EmptySet      < RuntimeError; end
+class InvalidAPIKey < RuntimeError; end
+class InvalidLogin  < RuntimeError; end
+class InvalidMethod < RuntimeError; end
+class InvalidUser   < RuntimeError; end
+class SystemError   < RuntimeError; end
+
+class Methods
+    attr_accessor :uri
+
+    attr_reader :account_type, :logger
+    attr_reader :api_key, :email_address, :password, :password_hash, :session_id, :user_id
+
+    @authenticated = false
+    class << self
+        attr_accessor :authenticated
+        def authenticated?()  @authenticated ; end
+    end
+
+    def initialize(account_type='Standard')
+        @authenticated = false
+
+        @account_type  = account_type
+        @api_key       = 'dydlCYDzmykqoLkVGgECEIP5WEuwWFzc'
+        @email_address = 'smugmug@example.net'
+        @password      = 'secret'
+        @password_hash = '$1$add02c7c2232759874e1c205587017bed'
+        @session_id    = '42e74d96e8a3454259eed4e2b6a143cf'
+        @user_id       = 1001
+    end
+
+    ## accessors
+    
+    def authenticated?() self.class.authenticated? ; end
+
+    ## methods
+
+    private
+
+    def api_key?()       uri['APIKey']       == api_key       ; end
+    def email_address?() uri['EmailAddress'] == email_address ; end
+    def password?()      uri['Password']     == password      ; end
+    def password_hash?() uri['PasswordHash'] == password_hash ; end
+    def session_id?()    uri['SessionID']    == session_id    ; end
+    def user_id?()       uri['UserID'].to_i  == user_id       ; end
+
+    def login_check
+        raise InvalidAPIKey unless uri.has_key?('APIKey')
+        raise InvalidAPIKey unless api_key?
+    end
+
+    public
+
+    ## login
+
+    def login?()
+        return %w{smugmug.login.withPassword smugmug.login.withHash}.include?(uri['method'])
+    end
+
+    def login_withPassword
+        raise InvalidLogin unless uri.has_key?('EmailAddress')
+        raise InvalidLogin unless uri.has_key?('Password')
+
+        raise InvalidLogin unless email_address?
+        raise InvalidLogin unless password?
+
+        login_check()
+        
+        self.class.authenticated = true
+        return _read('login.withPassword')
+    end
+
+    def login_withHash
+        raise InvalidLogin unless uri.has_key?('UserID')
+        raise InvalidLogin unless uri.has_key?('PasswordHash')
+
+        raise InvalidLogin unless user_id?
+        raise InvalidLogin unless password_hash?
+
+        login_check()
+
+        self.class.authenticated = true
+        return _read('login.withHash')
+    end
+
+    ## albums
+
+    def album_id?() 
+        return (uri['AlbumID'].to_i >= 1001 and uri['AlbumID'].to_i <= 1003)
+    end
+
+    def albums?()
+        raise InvalidUser unless uri.has_key?('AlbumID')
+        raise InvalidUser unless album_id?
+    end
+
+    def albums_get
+        raise InvalidAPIKey unless session_id?
+        return _read('albums.get')
+    end
+    def albums_getInfo
+        raise InvalidAPIKey unless session_id?
+        raise SystemError unless uri.has_key?('AlbumID')
+        albums?
+        return _read('albums.getInfo')
+    end
+    def albums_getStats
+        raise InvalidAPIKey unless session_id?
+        albums?
+        return _read('albums.getStats')
+    end
+
+    ## images
+
+    def image_id?()
+        return (uri['ImageID'].to_i >= 1001 and uri['ImageID'].to_i <= 1003)
+    end
+
+    def images?()
+        raise InvalidUser unless uri.has_key?('ImageID')
+        raise InvalidUser unless image_id?
+    end
+
+    def images_get
+        albums?
+        raise InvalidAPIKey unless session_id?
+        return _read('images.get')
+    end
+    def images_getInfo
+        raise InvalidAPIKey unless session_id?
+        images?
+        return _read('images.getInfo')
+    end
+    def images_getEXIF
+        raise InvalidAPIKey unless session_id?
+        images?
+        return _read('images.getEXIF')
+    end
+    def images_getStats
+        raise InvalidAPIKey unless session_id?
+        images?
+        return _read('images.getStats')
+    end
+
+    ## fail
+
+    def empty_set
+        return _read('empty_set', 'fail')
+    end
+    def invalid_login
+        return _read('invalid_login', 'fail')
+    end
+    def invalid_method
+        return _read('invalid_method', 'fail')
+    end
+
+    private
+
+    def _read(method, type=account_type.downcase)
+        method.gsub!('smugmug.', '')
+        method.gsub!('_', '.')
+
+        filename = File.join('..', 'xml', type, "#{method}.xml")
+        unless File.exists?(filename)
+            raise RuntimeError, "Cannot locate the XML file (#{filename} )for the method #{method}!"
+        end
+        return IO.read(filename)
+    end
+end
+
+class SmugMugServlet < WEBrick::HTTPServlet::AbstractServlet
+    attr_reader :method
+    def initialize(*args)
+        super(*args)
+        @method = Methods.new
+    end
+
+    def _method
+        raise InvalidMethod unless @method.uri.has_key?('method')
+        m = @method.uri['method']
+        m.gsub!('smugmug.', '')
+        m.gsub!('.', '_')
+        return m.to_sym
+    end
+
+    def do_GET(req, res)
+        @logger.info("URI: " + req.request_uri.to_s)
+        begin
+            @method.uri = req.request_uri
+            raise InvalidMethod.new unless method.respond_to?(_method)
+
+            unless method.authenticated?
+                raise InvalidAPIKey unless method.login?
+            end
+
+            res.body = method.send(_method)
+        rescue InvalidLogin
+            raise WEBrick::HTTPStatus::Unauthorized, method.invalid_login
+        rescue InvalidMethod
+            raise WEBrick::HTTPStatus::MethodNotAllowed, method.invalid_method
+        rescue 
+            @logger.info($!.class)
+            $!.backtrace.each { |line| @logger.info(line) }
+            raise WEBrick::HTTPStatus::InternalServerError
+        end
+
+        return res
+    end
+
+    def do_PUT
+    end
+    
+    def do_POST
+    end
+end
+
+if __FILE__ == $0
+	s = WEBrick::HTTPServer.new(
+        :BindAddress => '127.0.0.1', 
+        :Port => 45556, 
+        :Logger => WEBrick::Log.new('servlet.log', WEBrick::Log::DEBUG),
+        :AccessLog => [ [ File.open('access.log', 'w'), WEBrick::AccessLog::COMBINED_LOG_FORMAT ] ]
+    )
+	s.mount('/', SmugMugServlet)
+	trap("INT")  { s.shutdown }
+	trap("TERM") { s.shutdown }
+	s.start
+end

data/test/table.rb

@@ -0,0 +1,113 @@
+# -*- ruby -*-
+# $Hg: table.rb,v 1a7959f46f5c 2007/08/11 05:56:18 boumenot $
+
+require 'test/unit'
+require 'smugmug/table'
+
+
+class TC_MethodTable < Test::Unit::TestCase
+    attr_reader :std, :pow, :poW, :pro, :sup
+
+    def setup
+        table_xml = %q{
+<smugmug>
+    <TestId   type="int"     xpath="//TestId/attribute::id"/>
+    <String/>
+    <Int      type="int"/>
+    <False    type="boolean"/>
+    <True     type="boolean"/>
+    <Power    account="power"/>
+    <Pro      account="pro"/>
+</smugmug>
+}
+
+        resp_xml = %q{
+<test>
+    <TestId id="1234"/>
+    <String>foo</String>
+    <Int>4567</Int>
+    <False>0</False>
+    <True>1</True>
+    <Power>power</Power>
+    <Pro>pro</Pro>
+</test>
+}
+
+        @doc = REXML::Document.new(resp_xml)
+        
+        @std = SmugMug::MethodTable.new(table_xml, 'standard', 'foo')
+        @pow = SmugMug::MethodTable.new(table_xml, 'power', 'foo')
+        @poW = SmugMug::MethodTable.new(table_xml, 'PoWeR', 'foo')
+        @pro = SmugMug::MethodTable.new(table_xml, 'pro', 'foo')
+        @sup = SmugMug::MethodTable.new(table_xml, 'super', 'foo')
+    end
+
+    def test_klass
+        %w{std pow poW pro sup}.each do |inst|
+            assert_equal('foo', self.send(inst.to_sym).klass)
+        end
+    end
+
+    def test_bad_permission
+        assert_nothing_raised { std.get(@doc, :String) }
+        assert_nothing_raised { pow.get(@doc, :String) }
+        assert_nothing_raised { pro.get(@doc, :String) }
+
+        assert_raise(RuntimeError) { std.get(@doc, :Power) }
+        assert_raise(RuntimeError) { std.get(@doc, :Pro)   }
+        assert_raise(RuntimeError) { pow.get(@doc, :Pro)   }
+    end
+
+    def test_convert_to_type
+        assert_instance_of String, std.get(@doc, :String)
+        assert_instance_of Fixnum, std.get(@doc, :Int)
+        assert_instance_of Fixnum, std.get(@doc, :TestId)
+        assert_instance_of FalseClass, std.get(@doc, :False)
+        assert_instance_of TrueClass, std.get(@doc, :True)
+    end
+
+    def test_mixed_case_account_type
+        assert_nothing_raised { poW.get(@doc, :String) }
+    end
+
+    def test_return_values
+        %w{std pow poW pro}.each do |inst|
+            assert_equal 1234,    self.send(inst.to_sym).get(@doc, :TestId)
+            assert_equal 'foo',   self.send(inst.to_sym).get(@doc, :String)
+            assert_equal 4567,    self.send(inst.to_sym).get(@doc, :Int)
+            assert_equal false,   self.send(inst.to_sym).get(@doc, :False)
+            assert_equal true,    self.send(inst.to_sym).get(@doc, :True)
+        end
+
+        assert_equal 'power', pow.get(@doc, :Power)
+        assert_equal 'power', poW.get(@doc, :Power)
+        assert_equal 'power', pro.get(@doc, :Power)
+        assert_equal 'pro',   pro.get(@doc, :Pro)
+    end
+
+    def test_undefined_methods
+        assert_raise(NoMethodError) { std.get(@doc, :fart) }
+        assert_raise(NoMethodError) { pow.get(@doc, :fart) }
+        assert_raise(NoMethodError) { pro.get(@doc, :fart) }
+    end
+
+    def test_unknown_account_type
+        assert_raise(RuntimeError) { sup.get(@doc, :Power) }
+        assert_raise(RuntimeError) { sup.get(@doc, :Pro)   }
+    end
+
+    def test_aliases
+        %w{std pow poW pro}.each do |inst|
+            assert_equal 1234,    self.send(inst.to_sym).get(@doc, :test_id)
+            assert_equal 'foo',   self.send(inst.to_sym).get(@doc, :string)
+            assert_equal 4567,    self.send(inst.to_sym).get(@doc, :int)
+            assert_equal false,   self.send(inst.to_sym).get(@doc, :false?)
+            assert_equal true,    self.send(inst.to_sym).get(@doc, :true?)
+        end
+    end
+end
+
+# Local Variables:
+# ruby-indent-level: 4
+# End:
+