smugmug 0.0.1

data/test/config.rb

@@ -0,0 +1,39 @@
+# -*- ruby -*-
+# $Hg$
+
+require 'test/unit'
+require 'smugmug/config'
+
+class TC_Config < Test::Unit::TestCase
+
+    def setup
+        @config = SmugMug::Config.new
+    end
+
+    def teardown
+        File.unlink(ENV['SMUGMUG_RC'])
+    end
+
+    def test_default
+        # setters
+        @config.AccountType  = 'Standard'
+        @config.EmailAddress = 'foo@example.net'
+        @config.PasswordHash = 'feedface'
+        @config.UserID       = '1234'
+
+        assert(!File.exists?(ENV['SMUGMUG_RC']))
+        # save
+        @config.save
+        assert(File.exists?(ENV['SMUGMUG_RC']))
+
+        # getters
+        assert_equal('Standard', @config.AccountType)
+        assert_equal('foo@example.net', @config.EmailAddress)
+        assert_equal('feedface', @config.PasswordHash)
+        assert_equal('1234', @config.UserID)
+
+        # restore
+        restore = SmugMug::Config.new
+        assert_equal('Standard', restore.AccountType)
+    end
+end

data/test/httpz.rb

@@ -0,0 +1,120 @@
+# -*- Mode: ruby; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+# $Hg$
+#
+# The idea/code for this test came from a soap4r unit test.
+
+require 'test/unit'
+require 'webrick'
+require 'net/httpz'
+require 'stringio'
+require 'zlib'
+
+class TC_HTTPZ < Test::Unit::TestCase
+    HOST = '127.0.0.1'
+    PORT    = 45554
+    PORT_GZ = 45555
+    DATA    = 'the quick brown fox jumps over the lazy dog'
+
+    def setup
+        setup_server
+        setup_server_gz
+        setup_client
+        setup_client_gz
+    end
+
+    def teardown
+        teardown_server
+        teardown_server_gz
+    end
+
+    def _setup_server(port, proc)
+        server = WEBrick::HTTPServer.new(
+            :BindAddress => HOST,
+            :Port => port,
+            :Logger => WEBrick::Log.new(StringIO.new, 0),
+            :AccessLog => [],
+            :DocumentRoot => File.dirname(File.expand_path(__FILE__))
+        )
+        server.mount(
+            '/',
+            WEBrick::HTTPServlet::ProcHandler.new(proc)
+        )
+        server_thread = Thread.new{
+            Thread.current.abort_on_exception = true
+            server.start
+        }
+        return server, server_thread
+    end
+
+    ## setup/teardown #####################
+
+    def setup_server
+        @server, @server_thread = _setup_server(PORT, method(:do_server_proc).to_proc)
+    end
+
+    def teardown_server
+        @server.shutdown
+        @server_thread.kill
+        @server_thread.join
+    end
+
+    def setup_client
+        @client = Net::HTTP.new(HOST, PORT)
+    end
+
+    def do_server_proc(req, res)
+        assert_not_nil(req['Accept-Encoding'])
+        assert_equal('identity', req['Accept-Encoding'])
+        res['Content-Encoding'] = 'identity'
+        res.body = DATA
+    end
+
+    ## setup/teardown (gz) #####################
+
+    def setup_server_gz
+        @server_gz, @server_thread_gz = _setup_server(PORT_GZ, method(:do_server_proc_gz).to_proc)
+    end
+
+    def teardown_server_gz
+        @server_gz.shutdown
+        @server_thread_gz.kill
+        @server_thread_gz.join
+    end
+
+    def setup_client_gz
+        @client_gz = Net::HTTP.new(HOST, PORT_GZ)
+    end
+
+    def do_server_proc_gz(req, res)
+        assert_not_nil(req['Accept-Encoding'])
+        assert_equal('gzip', req['Accept-Encoding'])
+        res['Content-Encoding'] = 'gzip'
+        
+        s = ''
+        gz = Zlib::GzipWriter.new(StringIO.new(s))
+        gz.write(DATA)
+        gz.close()
+
+        res.body = s
+    end
+
+    ## tests ################################
+
+    def _http_get(client, type)
+        client.start {
+            response = client.get('/', {'Accept-Encoding' => type})
+            assert_equal(200, response.code.to_i)
+            assert_not_nil(response['Content-Encoding'])
+            assert_equal(type, response['Content-Encoding'])
+            assert_equal(DATA, response.body)
+        }
+    end
+
+    def test_http_get
+        _http_get(@client, 'identity')
+    end
+
+    def test_http_get_gz
+        _http_get(@client_gz, 'gzip')
+    end
+end

data/test/image.rb

@@ -0,0 +1,540 @@
+# -*- Mode: ruby; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+# $Hg: image.rb,v 7ee85ec830b2 2007/08/11 07:39:15 boumenot $
+
+require 'test/unit'
+require 'smugmug'
+require 'smugmug/albums'
+require 'smugmug/album/info'
+require 'smugmug/images'
+require 'smugmug/image/exif'
+require 'smugmug/image/info'
+require 'smugmug/image/stats'
+
+class TC_ImageInfo < Test::Unit::TestCase
+    def setup
+        $smugmug.each do |album|
+            @album = album
+            album.each do |image|
+                @image = image
+            end
+        end
+    end
+
+    def teardown
+    end
+
+    ## tests 
+
+    def test_method
+        assert('smugmug.images.getInfo', @image.method)
+    end
+
+    def test_image_append
+        start = 1001
+        $smugmug.each do |album|
+            album.each do |image|
+                assert_equal(start, image.image_id)
+                start += 1
+            end
+            break
+        end
+    end
+
+    ## ----------
+    ## dynamic accessors (method_missing)
+
+    ## Fixnum ################################################
+
+
+    def test_AlbumID
+        val = @image.AlbumID
+        assert_kind_of(Fixnum, val)
+        assert_kind_of(Fixnum, @image.album_id)
+        assert_equal(1001, val)
+        assert_equal(val, @image.album_id)
+    end
+
+    def test_Height
+        val = @image.Height
+        assert_kind_of(Fixnum, val)
+        assert_kind_of(Fixnum, @image.height)
+        assert_equal(2304, val)
+        assert_equal(val, @image.height)
+    end
+
+    def test_ImageID
+        val = @image.ImageID
+        assert_kind_of(Fixnum, val)
+        assert_kind_of(Fixnum, @image.image_id)
+        assert_equal(1001, val)
+        assert_equal(val, @image.image_id)
+    end
+
+    def test_Position
+        val = @image.Position
+        assert_kind_of(Fixnum, val)
+        assert_kind_of(Fixnum, @image.position)
+        assert_equal(1, val)
+        assert_equal(val, @image.position)
+    end
+
+    def test_Serial
+        val = @image.Serial
+        assert_kind_of(Fixnum, val)
+        assert_kind_of(Fixnum, @image.serial)
+        assert_equal(0, val)
+        assert_equal(val, @image.serial)
+    end
+
+    def test_Size
+        val = @image.Size
+        assert_kind_of(Fixnum, val)
+        assert_kind_of(Fixnum, @image.size)
+        assert_equal(2250102, val)
+        assert_equal(val, @image.size)
+    end
+
+    def test_Watermark
+        val = @image.Watermark
+        assert_kind_of(Fixnum, val)
+        assert_kind_of(Fixnum, @image.watermark)
+        assert_equal(0, val)
+        assert_equal(val, @image.watermark)
+    end
+
+    def test_Width
+        val = @image.Width
+        assert_kind_of(Fixnum, val)
+        assert_kind_of(Fixnum, @image.width)
+        assert_equal(3072, val)
+        assert_equal(val, @image.width)
+    end
+
+   ## String ################################################
+
+    def test_AlbumURL
+        val = @image.AlbumURL
+        assert_kind_of(String, val)
+        assert_kind_of(String, @image.album_url)
+        assert_equal('http://example.smugmug.com/gallery/1001/1/1001', val)
+        assert_equal(val, @image.album_url)
+    end
+
+    def test_Caption
+        val = @image.Caption
+        assert_kind_of(String, val)
+        assert_kind_of(String, @image.caption)
+        assert_equal('caption', val)
+        assert_equal(val, @image.caption)
+    end
+
+    def test_Date
+        val = @image.Date
+        assert_kind_of(String, val)
+        assert_kind_of(String, @image.date)
+        assert_equal('1970-01-01 00:00:00', val)
+        assert_equal(val, @image.date)
+    end
+
+    def test_FileName
+        val = @image.FileName
+        assert_kind_of(String, val)
+        assert_kind_of(String, @image.file_name)
+        assert_equal('example.JPG', val)
+        assert_equal(val, @image.file_name)
+    end
+
+    def test_Format
+        val = @image.Format
+        assert_kind_of(String, val)
+        assert_kind_of(String, @image.format)
+        assert_equal('JPG', val)
+        assert_equal(val, @image.format)
+    end
+
+    def test_Keywords
+        val = @image.Keywords
+        assert_kind_of(String, val)
+        assert_kind_of(String, @image.keywords)
+        assert_equal('keywords', val)
+        assert_equal(val, @image.keywords)
+    end
+
+    def test_LargeURL
+        val = @image.LargeURL
+        assert_kind_of(String, val)
+        assert_kind_of(String, @image.large_url)
+        assert_equal('http://example.smugmug.com/photos/1001-L.jpg', val)
+        assert_equal(val, @image.large_url)
+    end
+
+    def test_LastUpdated
+        val = @image.LastUpdated
+        assert_kind_of(String, val)
+        assert_kind_of(String, @image.last_updated)
+        assert_equal('1970-01-01 00:00:00', val)
+        assert_equal(val, @image.last_updated)
+    end
+
+    def test_MD5Sum
+        val = @image.MD5Sum
+        assert_kind_of(String, val)
+        assert_kind_of(String, @image.md5_sum)
+        assert_equal('06a22c22b8984c07b91992bc891fe2d6', val)
+        assert_equal(val, @image.md5_sum)
+    end
+
+    def test_MediumURL
+        val = @image.MediumURL
+        assert_kind_of(String, val)
+        assert_kind_of(String, @image.medium_url)
+        assert_equal('http://example.smugmug.com/photos/1001-M.jpg', val)
+        assert_equal(val, @image.medium_url)
+    end
+
+    def test_OriginalURL
+        val = @image.OriginalURL
+        assert_kind_of(String, val)
+        assert_kind_of(String, @image.original_url)
+        assert_equal('http://example.smugmug.com/photos/1001-O.jpg', val)
+        assert_equal(val, @image.original_url)
+    end
+
+    def test_SmallURL
+        val = @image.SmallURL
+        assert_kind_of(String, val)
+        assert_kind_of(String, @image.small_url)
+        assert_equal('http://example.smugmug.com/photos/1001-S.jpg', val)
+        assert_equal(val, @image.small_url)
+    end
+
+    def test_ThumbURL
+        val = @image.ThumbURL
+        assert_kind_of(String, val)
+        assert_kind_of(String, @image.thumb_url)
+        assert_equal('http://example.smugmug.com/photos/1001-Th.jpg', val)
+        assert_equal(val, @image.thumb_url)
+    end
+
+    def test_TinyURL
+        val = @image.TinyURL
+        assert_kind_of(String, val)
+        assert_kind_of(String, @image.tiny_url)
+        assert_equal('http://example.smugmug.com/photos/1001-Ti.jpg', val)
+        assert_equal(val, @image.tiny_url)
+    end
+end
+
+class TC_ImageEXIF < Test::Unit::TestCase
+    def setup
+        $smugmug.each do |album|
+            album.each do |image|
+                @exif = image.exif
+            end
+        end
+    end
+
+    def teardown
+    end
+
+    ## tests 
+    
+    def test_method
+        assert_equal('smugmug.images.getEXIF', @exif.method)
+    end
+
+    ## ----------
+    ## dynamic accessors (method_missing)
+
+    ## Fixnum ################################################
+
+    def test_ISO
+        val = @exif.ISO
+        assert_kind_of(Fixnum, val)
+        assert_kind_of(Fixnum, @exif.iso)
+        assert_equal(400, val)
+        assert_equal(val, @exif.iso)
+    end
+
+    def test_Flash
+        val = @exif.Flash
+        assert_kind_of(Fixnum, val)
+        assert_kind_of(Fixnum, @exif.flash)
+        assert_equal(89, val)
+        assert_equal(val, @exif.flash)
+    end
+
+    def test_Metering
+        val = @exif.Metering
+        assert_kind_of(Fixnum, val)
+        assert_kind_of(Fixnum, @exif.metering)
+        assert_equal(761, val)
+        assert_equal(val, @exif.metering)
+    end
+
+    def test_ExposureProgram
+        val = @exif.ExposureProgram
+        assert_kind_of(Fixnum, val)
+        assert_kind_of(Fixnum, @exif.exposure_program)
+        assert_equal(100, val)
+        assert_equal(val, @exif.exposure_program)
+    end
+
+    def test_ExposureMode
+        val = @exif.ExposureMode
+        assert_kind_of(Fixnum, val)
+        assert_kind_of(Fixnum, @exif.exposure_mode)
+        assert_equal(0, val)
+        assert_equal(val, @exif.exposure_mode)
+    end
+
+    def test_LightSource
+        val = @exif.LightSource
+        assert_kind_of(Fixnum, val)
+        assert_kind_of(Fixnum, @exif.light_source)
+        assert_equal(505, val)
+        assert_equal(val, @exif.light_source)
+    end
+
+    def test_WhiteBalance
+        val = @exif.WhiteBalance
+        assert_kind_of(Fixnum, val)
+        assert_kind_of(Fixnum, @exif.white_balance)
+        assert_equal(0, val)
+        assert_equal(val, @exif.white_balance)
+    end
+
+    def test_Contrast
+        assert_nil(@exif.Contrast)
+        assert_kind_of(NilClass, @exif.Contrast)
+        assert_kind_of(NilClass, @exif.contrast)
+    end
+
+    def test_Saturation
+        val = @exif.Saturation
+        assert_kind_of(Fixnum, val)
+        assert_kind_of(Fixnum, @exif.saturation)
+        assert_equal(1001, val)
+        assert_equal(val, @exif.saturation)
+    end
+
+    def test_Sharpness
+        val = @exif.Sharpness
+        assert_kind_of(Fixnum, val)
+        assert_kind_of(Fixnum, @exif.sharpness)
+        assert_equal(1001, val)
+        assert_equal(val, @exif.sharpness)
+    end
+
+    def test_SensingMethod
+        val = @exif.SensingMethod
+        assert_kind_of(Fixnum, val)
+        assert_kind_of(Fixnum, @exif.sensing_method)
+        assert_equal(2, val)
+        assert_equal(val, @exif.sensing_method)
+    end
+
+    ## String ################################################
+
+    def test_DateTime
+        val = @exif.DateTime
+        assert_kind_of(String, val)
+        assert_kind_of(String, @exif.date_time)
+        assert_equal('1970-01-01 00:00:00', val)
+        assert_equal(val, @exif.date_time)
+    end
+
+    def test_DateTimeOriginal
+        val = @exif.DateTimeOriginal
+        assert_kind_of(String, val)
+        assert_kind_of(String, @exif.date_time_original)
+        assert_equal('1970-01-01 00:00:00', val)
+        assert_equal(val, @exif.date_time_original)
+    end
+
+    def test_DateTimeDigitized
+        val = @exif.DateTimeDigitized
+        assert_kind_of(String, val)
+        assert_kind_of(String, @exif.date_time_digitized)
+        assert_equal('1970-01-01 00:00:00', val)
+        assert_equal(val, @exif.date_time_digitized)
+    end
+
+    def test_Make
+        val = @exif.Make
+        assert_kind_of(String, val)
+        assert_kind_of(String, @exif.make)
+        assert_equal('Canon', val)
+        assert_equal(val, @exif.make)
+    end
+
+    def test_Model
+        val = @exif.Model
+        assert_kind_of(String, val)
+        assert_kind_of(String, @exif.model)
+        assert_equal('Canon PowerShot SD500', val)
+        assert_equal(val, @exif.model)
+    end
+
+    def test_ExposureTime
+        val = @exif.ExposureTime
+        assert_kind_of(String, val)
+        assert_kind_of(String, @exif.exposure_time)
+        assert_equal('1/60', val)
+        assert_equal(val, @exif.exposure_time)
+    end
+
+    def test_Aperture
+        val = @exif.Aperture
+        assert_kind_of(String, val)
+        assert_kind_of(String, @exif.aperture)
+        assert_equal('f/2.8', val)
+        assert_equal(val, @exif.aperture)
+    end
+
+    def test_FocalLength
+        val = @exif.FocalLength
+        assert_kind_of(String, val)
+        assert_kind_of(String, @exif.focal_length)
+        assert_equal('7700/1000', val)
+        assert_equal(val, @exif.focal_length)
+    end
+
+    def test_FocalLength35mmFilm
+        val = @exif.FocalLength35mmFilm
+        assert_kind_of(String, val)
+        assert_kind_of(String, @exif.focal_length35mm_film)
+        assert_equal('focallength35mmfilm', val)
+        assert_equal(val, @exif.focal_length35mm_film)
+    end
+
+    def test_CCDWidth
+        val = @exif.CCDWidth
+        assert_kind_of(String, val)
+        assert_kind_of(String, @exif.ccdwidth)
+        assert_equal('7mm', val)
+        assert_equal(val, @exif.ccdwidth)
+    end
+
+    def test_CompressedBitsPerPixel
+        val = @exif.CompressedBitsPerPixel
+        assert_kind_of(String, val)
+        assert_kind_of(String, @exif.compressed_bits_per_pixel)
+        assert_equal('5/1', val)
+        assert_equal(val, @exif.compressed_bits_per_pixel)
+    end
+
+    def test_ExposureBiasValue
+        val = @exif.ExposureBiasValue
+        assert_kind_of(String, val)
+        assert_kind_of(String, @exif.exposure_bias_value)
+        assert_equal('0/3', val)
+        assert_equal(val, @exif.exposure_bias_value)
+    end
+
+    def test_DigitalZoomRatio
+        val = @exif.DigitalZoomRatio
+        assert_kind_of(String, val)
+        assert_kind_of(String, @exif.digital_zoom_ratio)
+        assert_equal('3072/3072', val)
+        assert_equal(val, @exif.digital_zoom_ratio)
+    end
+
+    def test_SubjectDistance
+        val = @exif.SubjectDistance
+        assert_kind_of(String, val)
+        assert_kind_of(String, @exif.subject_distance)
+        assert_equal('subjectdistance', val)
+        assert_equal(val, @exif.subject_distance)
+    end
+
+    def test_SubjectDistanceRange
+        assert_nil(@exif.SubjectDistanceRange)
+        assert_kind_of(NilClass, @exif.SubjectDistanceRange)
+        assert_kind_of(NilClass, @exif.subject_distance_range)
+    end
+
+    def test_ColorSpace
+        val = @exif.ColorSpace
+        assert_kind_of(String, val)
+        assert_kind_of(String, @exif.color_space)
+        assert_equal('1', val)
+        assert_equal(val, @exif.color_space)
+    end
+    def test_Brightness
+        val = @exif.Brightness
+        assert_kind_of(String, val)
+        assert_kind_of(String, @exif.brightness)
+        assert_equal('brightness', val)
+        assert_equal(val, @exif.brightness)
+    end
+end
+
+class TC_ImageStats < Test::Unit::TestCase
+    def setup
+        $smugmug.each do |album|
+            album.each do |image|
+                @stats = image.stats
+            end
+        end
+    end
+
+    def teardown
+    end
+
+    ## tests 
+
+    def test_method
+        assert_equal('smugmug.images.getStats', @stats.method)
+    end
+
+    def test_bytes
+        assert_kind_of(Fixnum, @stats.bytes)
+        assert_equal(83593, @stats.bytes)
+        assert_kind_of(Fixnum, @stats.Bytes)
+        assert_equal(83593, @stats.Bytes)
+    end
+
+    def test_medium
+        assert_kind_of(Fixnum, @stats.medium)
+        assert_equal(1, @stats.medium)
+        assert_kind_of(Fixnum, @stats.Medium)
+        assert_equal(1, @stats.Medium)
+    end
+
+    def test_original
+        assert_kind_of(Float, @stats.original)
+        assert_equal(0, @stats.original)
+        assert_kind_of(Float, @stats.original)
+        assert_equal(0, @stats.original)
+    end
+
+    def test_small
+        assert_kind_of(Fixnum, @stats.small)
+        assert_equal(0, @stats.small)
+        assert_kind_of(Fixnum, @stats.Small)
+        assert_equal(0, @stats.Small)
+    end
+
+    ## XXX: should I support this?
+#     def test_status
+#         assert_kind_of(String, @stats.status)
+#         assert_equal('Open', @stats.status)
+#         assert_kind_of(String, @stats.Status)
+#         assert_equal('Open', @stats.Status)
+#     end
+
+    def test_thumb
+        assert_kind_of(Fixnum, @stats.thumb)
+        assert_equal(0, @stats.thumb)
+        assert_kind_of(Fixnum, @stats.Thumb)
+        assert_equal(0, @stats.Thumb)
+    end
+
+    def test_tiny
+        assert_kind_of(Fixnum, @stats.tiny)
+        assert_equal(1, @stats.tiny)
+        assert_kind_of(Fixnum, @stats.Tiny)
+        assert_equal(1, @stats.Tiny)
+    end
+end