tumblr-rb 1.3.0 → 2.0.0.alpha

data/test/fixtures/vcr_cassettes/read/unlike.yml

@@ -1,31 +0,0 @@
---- 
-- !ruby/struct:VCR::RecordedResponse 
-  method: :post
-  uri: http://www.tumblr.com:80/api/unlike
-  response: !ruby/object:Net::HTTPOK 
-    body: Unliked post 445597771.
-    body_exist: true
-    code: "200"
-    header: 
-      p3p: 
-      - CP="ALL ADM DEV PSAi COM OUR OTRo STP IND ONL"
-      content-type: 
-      - text/plain; charset=utf-8
-      connection: 
-      - close
-      x-tumblr-usec: 
-      - D=119300
-      server: 
-      - Apache/2.2.3 (Red Hat)
-      date: 
-      - Sat, 13 Mar 2010 16:33:13 GMT
-      content-length: 
-      - "23"
-      x-tumblr-perf: 
-      - "\"ch:0/ cm:0/ ce:0/ c:0/0 d:0/0 e:0/0\""
-      vary: 
-      - Accept-Encoding
-    http_version: "1.1"
-    message: OK
-    read: true
-    socket: 

data/test/fixtures/vcr_cassettes/write/delete.yml

@@ -1,31 +0,0 @@
---- 
-- !ruby/struct:VCR::RecordedResponse 
-  method: :post
-  uri: http://www.tumblr.com:80/api/delete
-  response: !ruby/object:Net::HTTPOK 
-    body: Deleted
-    body_exist: true
-    code: "200"
-    header: 
-      p3p: 
-      - CP="ALL ADM DEV PSAi COM OUR OTRo STP IND ONL"
-      content-type: 
-      - text/plain; charset=utf-8
-      connection: 
-      - close
-      x-tumblr-usec: 
-      - D=109741
-      server: 
-      - Apache/2.2.3 (Red Hat)
-      date: 
-      - Sun, 07 Mar 2010 07:09:10 GMT
-      content-length: 
-      - "7"
-      x-tumblr-perf: 
-      - "\"ch:7/country_code_for_ip,rate-limiter,posts,tumblelogs,version,users,users cm:2/rate-limiter,rate-limiter ce:0/ c:0/0 d:0/0 e:0/0\""
-      vary: 
-      - Accept-Encoding
-    http_version: "1.1"
-    message: OK
-    read: true
-    socket: 

data/test/fixtures/vcr_cassettes/write/edit.yml

@@ -1,31 +0,0 @@
---- 
-- !ruby/struct:VCR::RecordedResponse 
-  method: :post
-  uri: http://www.tumblr.com:80/api/write
-  response: !ruby/object:Net::HTTPCreated 
-    body: "431830023"
-    body_exist: true
-    code: "201"
-    header: 
-      p3p: 
-      - CP="ALL ADM DEV PSAi COM OUR OTRo STP IND ONL"
-      content-type: 
-      - text/plain; charset=utf-8
-      connection: 
-      - close
-      x-tumblr-usec: 
-      - D=128043
-      server: 
-      - Apache/2.2.3 (CentOS)
-      date: 
-      - Sun, 07 Mar 2010 07:01:22 GMT
-      content-length: 
-      - "9"
-      x-tumblr-perf: 
-      - "\"ch:7/country_code_for_ip,rate-limiter,posts,tumblelogs,version,users,users cm:2/rate-limiter,rate-limiter ce:0/ c:0/0 d:0/0 e:0/0\""
-      vary: 
-      - Accept-Encoding
-    http_version: "1.1"
-    message: Created
-    read: true
-    socket: 

data/test/fixtures/vcr_cassettes/write/reblog.yml

@@ -1,31 +0,0 @@
---- 
-- !ruby/struct:VCR::RecordedResponse 
-  method: :post
-  uri: http://www.tumblr.com:80/api/reblog
-  response: !ruby/object:Net::HTTPCreated 
-    body: "508128650"
-    body_exist: true
-    code: "201"
-    header: 
-      p3p: 
-      - CP="ALL ADM DEV PSAi COM OUR OTRo STP IND ONL"
-      content-type: 
-      - text/plain; charset=utf-8
-      connection: 
-      - close
-      x-tumblr-usec: 
-      - D=380408
-      server: 
-      - Apache/2.2.3 (Red Hat)
-      date: 
-      - Fri, 09 Apr 2010 12:36:41 GMT
-      content-length: 
-      - "9"
-      x-tumblr-perf: 
-      - "\"ch:12/country_code_for_ip,posts,tumblelogs,tumblelogs,version,users,users,tumblelogs,tumblelogs,version,users,users cm:4/rate-limiter,rate-limiter,users,version ce:0/ c:0/0 d:0/0 e:0/0\""
-      vary: 
-      - Accept-Encoding
-    http_version: "1.1"
-    message: Created
-    read: true
-    socket: 

data/test/fixtures/vcr_cassettes/write/write.yml

@@ -1,31 +0,0 @@
---- 
-- !ruby/struct:VCR::RecordedResponse 
-  method: :post
-  uri: http://www.tumblr.com:80/api/write
-  response: !ruby/object:Net::HTTPCreated 
-    body: "431830023"
-    body_exist: true
-    code: "201"
-    header: 
-      p3p: 
-      - CP="ALL ADM DEV PSAi COM OUR OTRo STP IND ONL"
-      content-type: 
-      - text/plain; charset=utf-8
-      connection: 
-      - close
-      x-tumblr-usec: 
-      - D=137805
-      server: 
-      - Apache/2.2.3 (Red Hat)
-      date: 
-      - Sun, 07 Mar 2010 06:20:29 GMT
-      content-length: 
-      - "9"
-      x-tumblr-perf: 
-      - "\"ch:8/country_code_for_ip,rate-limiter,tumblelog_id_for_host,tumblelogs,users,version,users,users cm:2/rate-limiter,rate-limiter ce:0/ c:0/0 d:0/0 e:0/0\""
-      vary: 
-      - Accept-Encoding
-    http_version: "1.1"
-    message: Created
-    read: true
-    socket: 

data/test/helper.rb

@@ -1,44 +0,0 @@
-begin
-  # Try to require the preresolved locked set of gems.
-  require File.expand_path('../.bundle/environment', __FILE__)
-rescue LoadError
-  # Fall back on doing an unlocked resolve at runtime.
-  require "rubygems"
-  require "bundler"
-  Bundler.setup
-end
-
-require 'pp'
-require 'test/unit'
-require 'contest'
-require 'vcr'
-# Ruby 1.9 does not like redgreen
-begin
-  require 'redgreen'
-rescue LoadError
-end
-
-begin
-  require 'tumblr'
-rescue LoadError
-  lib_path = File.join(File.dirname(__FILE__), '..', 'lib')
-  $LOAD_PATH.unshift lib_path unless $LOAD_PATH.include?(lib_path)
-  require 'tumblr'
-end
-
-FakeWeb.allow_net_connect = false
-
-VCR.config do |c|
-  # the cache_dir is where the cassette yml files will be saved.
-  c.cassette_library_dir = File.join(File.dirname(__FILE__),'fixtures', 'vcr_cassettes')
-
-  # this record mode will be used for any cassette you create without specifying a record mode.
-  c.default_cassette_options = {:record => :none}
-end
-
-def hijack!(request, fixture)
-  record_mode = File.exist?(VCR::Cassette.new(fixture).file) ? :none : :unregistered
-  VCR.use_cassette(fixture, :record => record_mode) do
-    request.perform
-  end
-end

data/test/test_tumblr.rb

@@ -1,710 +0,0 @@
-require 'helper'
-
-class TestTumblr < Test::Unit::TestCase
-  describe 'Tumblr' do
-    test 'maps post types to the right class' do
-      assert_respond_to Tumblr, :map
-      assert_equal Tumblr::Post::Photo, Tumblr.map(:photo)
-      assert_raise RuntimeError do
-        Tumblr.map(:foobar)
-      end
-    end
-    
-    test 'parses a post out of a document' do
-      klass = Class.new Tumblr::Post
-      klass.parameters :title, :body
-      type = :regular
-      post = klass.new
-      post.instance_variable_set(:@type,type)
-      post.body = "Hello world."
-      post.title = "Regular post"
-      document = post.to_s
-      assert Tumblr.parse(document).is_a? Tumblr.map(type)
-      assert_equal post.body, Tumblr.parse(document).body
-      assert_equal post.to_h, Tumblr.parse(document).to_h
-      assert_equal post.title, Tumblr.parse(document).title
-    end
-        
-    test 'parses a document and sets up basic post' do
-      klass = Class.new Tumblr::Post
-      klass.parameters :title, :body
-      type = :regular
-      post = klass.new('123')
-      post.instance_variable_set(:@type,type)
-      post.tags 'hello', 'stuff'
-      post.state = :queue
-      post.format = :markdown
-      post.send_to_twitter 'Hi from tumblr'
-      post.publish_on 'tuesday'
-      post.date = Time.now.iso8601
-      post.body = "Hello world."
-      post.generator = Tumblr::GENERATOR
-      post.private = true
-      post.group = 'tumblrgemtest.tumblr.com'
-      document = post.to_s
-      
-      %w(post_id format state tags send_to_twitter publish_on date generator private? group).each do |attribute|
-        assert_equal post.send(attribute), Tumblr.parse(document).send(attribute)
-      end
-    end
-    
-    test 'infers a post type from a document if none is explicitly set' do
-      link = 'http://something.com'
-      video = 'http://www.youtube.com/watch?v=CW0DUg63lqU'
-      text = "Hello world"
-      assert_equal :video, Tumblr.infer_post_type(video)
-      assert_equal :link, Tumblr.infer_post_type(link)
-      assert_equal :regular, Tumblr.infer_post_type(text)            
-    end
-    
-    test 'parses a document' do
-      link = <<-link
----
-name: The Something Website
----
-http://something.com
-link
-      
-      post = Tumblr.parse(link)
-      assert_equal :link, post.type
-      assert_equal 'The Something Website', post.name
-      assert_equal 'http://something.com', post.url
-    end
-  
-    test 'sets up credentials for authentication' do
-      params = {:email => 'test@testermcgee.com', :password => 'dontrevealmysecrets'}
-      credentials = Tumblr.new(params[:email],params[:password]).instance_variable_get(:@credentials)
-      assert credentials.has_key? :email
-      assert credentials.has_key? :password
-      assert_equal params, credentials
-    end
-    
-    test 'can read posts' do
-      assert Tumblr.new.read('mwunsch').is_a? Weary::Request
-    end
-    
-    test 'can publish posts to tumblr' do
-      tumbl = Tumblr.new('test@testermcgee.com','dontrevealmysecrets')
-      write = tumbl.post('Hello world')
-      assert write.is_a? Weary::Request
-    end
-  
-    test 'can read the dashboard' do
-      dashboard = Tumblr.new('test@testermcgee.com','dontrevealmysecrets').dashboard
-      reader = Tumblr::Reader.new('test@testermcgee.com','dontrevealmysecrets').dashboard
-      assert dashboard.is_a? Weary::Request
-      assert_equal reader.uri, dashboard.uri
-    end
-    
-    test 'provides a convenience method for reader and writer' do
-      tumbl = Tumblr.new('test@testermcgee.com','dontrevealmysecrets')
-      assert tumbl.reader.is_a? Tumblr::Reader
-      assert tumbl.writer.is_a? Tumblr::Writer
-    end
-    
-    test 'authenticates to get user information' do
-      tumbl = Tumblr.new('test@testermcgee.com','dontrevealmysecrets')
-      auth = Tumblr::Authenticator.new('test@testermcgee.com','dontrevealmysecrets').authenticate
-      assert_respond_to tumbl, :authenticate
-      assert tumbl.authenticate.is_a? Weary::Request
-      assert_equal auth.uri, tumbl.authenticate.uri
-    end
-    
-    test 'can pass include theme params to authenticate method' do
-      tumbl = Tumblr.new('test@testermcgee.com','dontrevealmysecrets')
-      include_theme = tumbl.authenticate(true)
-      assert include_theme.with.split('&').include?("include-theme=1")
-    end
-    
-    test 'executes' do
-      cred = {:email => 'test@testermcgee.com', :password => 'dontrevealmysecrets'}
-      response = VCR.use_cassette('write/write') do
-        Tumblr.execute(cred, 'Hello World.')
-      end
-      assert response.is_a? Weary::Response
-      assert response.success?
-    end
-  end
-    
-  describe 'Reader' do
-    test 'sets up credentials for authentication' do
-      reader = Tumblr::Reader
-      assert !reader.new.defaults
-      params = {:email => 'test@testermcgee.com', :password => 'dontrevealmysecrets'}
-      credentials = reader.new(params[:email],params[:password]).defaults
-      assert credentials.has_key? :email
-      assert credentials.has_key? :password
-      assert_equal params, credentials
-    end
-    
-    test 'handles parameters for reads' do
-      reader = Tumblr::Reader
-      options = {:start => 5, :num => 10, :foo => 'Bar', :type => 'video'}
-      cred = {:email => 'test@testermcgee.com', :password => 'dontrevealmysecrets'}
-      assert !reader.new.parameters(options).has_key?(:foo)
-      assert_equal cred[:email], reader.new(cred[:email],cred[:password]).parameters(options)[:email]
-      assert reader.new(*cred.values).parameters(options).has_key?(:password)
-    end
-    
-    test 'convenience method for reads' do
-      t = Tumblr::Reader
-      assert_respond_to t, :read
-      assert_equal :get, t.read('mwunsch').via
-      assert_equal 'http://mwunsch.tumblr.com/api/read/', t.read('mwunsch').uri.normalize.to_s
-      assert_equal :post, t.read('mwunsch',:post).via
-      params = {:email => 'test@testermcgee.com', :password => 'dontrevealmysecrets'}
-      assert_equal params.to_params, t.read('mwunsch',:post,params).with
-    end
-  
-    test 'reads posts' do
-      reader = Tumblr::Reader
-      mwunsch = reader.new.read('mwunsch')
-      assert_respond_to mwunsch, :perform
-      assert_equal 'http://mwunsch.tumblr.com/api/read/', mwunsch.uri.normalize.to_s
-      response = hijack! mwunsch, 'read/mwunsch'
-      assert response.success?
-      assert_equal :xml, response.format
-    end
-    
-    test 'reads posts with some optional parameters' do
-      reader = Tumblr::Reader
-      options = {:num => 5, :type => :video}
-      posts = reader.new.read 'mwunsch', options
-      response = hijack! posts, 'read/optional'
-      parsed = response.parse["tumblr"]["posts"]
-      assert_equal "video", parsed["type"]
-      assert_equal 5, parsed['post'].count
-    end
-    
-    test 'attempts to perform an authenticated read' do
-      reader = Tumblr::Reader
-      auth = reader.new('test@testermcgee.com','dontrevealmysecrets').authenticated_read('mwunsch',{:state => :draft})
-      response = hijack! auth, 'read/authenticated'
-      assert_equal '420292045', response['tumblr']['posts']['post']['id']
-    end
-    
-    test 'sometimes authentication fails' do
-      reader = Tumblr::Reader
-      auth = reader.new('test@testermcgee.com','dontrevealmysecrets').authenticated_read('mwunsch')
-      response = hijack! auth, 'read/authentication failure'
-      assert !response.success?
-      assert_equal 403, response.code
-    end
-    
-    test 'can not do an authenticated read without credentials' do
-      reader = Tumblr::Reader
-      assert_raise RuntimeError do 
-        reader.new.authenticated_read('mwunsch')
-      end
-    end
-    
-    # need to test these more thoroughly
-    test 'has several other authenticated read methods' do
-      reader = Tumblr::Reader.new
-      assert_respond_to reader, :dashboard
-      assert_respond_to reader, :likes
-      assert_respond_to reader, :like
-      assert_respond_to reader, :unlike
-    end
-    
-    test 'likes a post' do
-      reader = Tumblr::Reader.new('test@testermcgee.com','dontrevealmysecrets')
-      like = hijack! reader.like(:'post-id' => '445597771', :'reblog-key' => 'DLVWOpfh'), 'read/like'
-      assert like.success?
-    end
-    
-    test 'unlikes a post' do
-      reader = Tumblr::Reader.new('test@testermcgee.com','dontrevealmysecrets')
-      unlike = hijack! reader.unlike(:'post-id' => '445597771', :'reblog-key' => 'DLVWOpfh'), 'read/unlike'
-      assert unlike.success?
-    end
-  
-    test 'parses posts out of a read' do
-      reader = Tumblr::Reader
-      assert_respond_to reader, :get_posts
-      mwunsch = reader.new.read('mwunsch')
-      response = hijack! mwunsch, 'read/mwunsch'
-      assert_equal response['tumblr']['posts']['post'].count, reader.get_posts(response).count
-      assert reader.get_posts(response).first.is_a? Tumblr::Post::Quote
-    end
-    
-    test 'selects posts by type' do
-      reader = Tumblr::Reader
-      assert_respond_to reader, :get_posts
-      mwunsch = reader.new.read('mwunsch')
-      response = hijack! mwunsch, 'read/mwunsch'
-      assert reader.get_posts(response, :link).first.is_a? Tumblr::Post::Link
-    end
-    
-    test 'generates a Post object from a parsed post' do
-      reader = Tumblr::Reader
-      assert_respond_to reader, :build_post
-      mwunsch = reader.new.read('mwunsch')
-      response = hijack! mwunsch, 'read/mwunsch'
-      posts = response['tumblr']['posts']['post']
-      link = posts.select {|post| post['type'].eql?('link') }
-      link_post = reader.build_post(link.first)
-      assert link_post.is_a? Tumblr::Post::Link
-      assert_equal :link, link_post.type
-      assert_equal :markdown, link_post.format
-      assert_equal link.first['link_url'], link_post.url
-      assert_equal link.first['reblog_key'], link_post.reblog_key
-    end
-    
-    test 'gets all the posts for a username' do
-      reader = Tumblr::Reader.new('test@testermcgee.com','dontrevealmysecrets')
-      posts = VCR.use_cassette('read/authenticated') do
-        reader.get_all_posts('mwunsch')
-      end
-      assert_equal 66, posts.count
-    end
-    
-    test 'read pages' do
-      reader = Tumblr::Reader.new
-      assert_respond_to reader, :pages
-      response = hijack! reader.pages('tumblrgemtest'), 'read/pages'
-      assert response['tumblr'].has_key?("pages")
-    end
-    
-    test 'reads all pages by authenticating' do
-      reader = Tumblr::Reader.new('test@testermcgee.com','dontrevealmysecrets')
-      assert_respond_to reader, :all_pages
-      response = hijack! reader.all_pages('tumblrgemtest'), 'read/all_pages'
-      assert_equal 200, response.code
-      assert_equal 2, response['tumblr']['pages']['page'].count
-    end
-  end
-  
-  describe 'Writer' do
-    test 'sets up credentials for authentication' do
-      writer = Tumblr::Writer
-      params = {:email => 'test@testermcgee.com', :password => 'dontrevealmysecrets'}
-      credentials = writer.new(params[:email],params[:password]).defaults
-      assert credentials.has_key? :email
-      assert credentials.has_key? :password
-    end
-  
-    test 'writes a post' do
-      writer = Tumblr::Writer
-      assert_respond_to writer.new, :write
-      post = {:type => :regular, :body => 'Hello world.', :group => 'tumblrgemtest.tumblr.com'}
-      publisher = Tumblr::Writer.new('test@testermcgee.com','dontrevealmysecrets')
-      response = hijack! publisher.write(post), 'write/write'
-      assert_equal 201, response.code
-    end
-    
-    test 'edits an existing post' do
-      assert_respond_to Tumblr::Writer.new, :edit
-      publisher = Tumblr::Writer.new('test@testermcgee.com','dontrevealmysecrets')
-      post = {:'post-id' => "431830023", :body => 'Hello world?'}
-      response = hijack! publisher.edit(post), 'write/edit'
-      assert_equal 201, response.code
-    end
-    
-    test 'deletes a post' do
-      assert_respond_to Tumblr::Writer.new, :edit
-      publisher = Tumblr::Writer.new('test@testermcgee.com','dontrevealmysecrets')
-      post = {:'post-id' => "431830023"}
-      response = hijack! publisher.delete(post), 'write/delete'
-      assert response.success?
-      assert_equal 'Deleted', response.body
-    end
-    
-    test 'reblogs a post' do
-      assert_respond_to Tumblr::Writer.new, :reblog
-      publisher = Tumblr::Writer.new('test@testermcgee.com','dontrevealmysecrets')
-      post = {:'post-id' => "507998507", :'reblog-key' => 'DifhdmQI'}
-      response = hijack! publisher.reblog(post), 'write/reblog'
-      assert_equal 201, response.code
-    end
-  end
-  
-  describe 'Authenticator' do
-    test 'sets up credentials for authentication' do
-      user = Tumblr::Authenticator
-      params = {:email => 'test@testermcgee.com', :password => 'dontrevealmysecrets'}
-      credentials = user.new(params[:email],params[:password]).defaults
-      assert credentials.has_key? :email
-      assert credentials.has_key? :password
-    end
-    
-    test 'authenticates a user to get information' do
-      user = Tumblr::Authenticator.new('test@testermcgee.com','dontrevealmysecrets')
-      assert_respond_to user, :authenticate
-      response = hijack! user.authenticate, 'authenticate/authenticate'
-      assert response.success?
-      assert_equal 'mwunsch', response["tumblr"]["tumblelog"].first["name"]
-    end
-    
-    test 'can include an optional theme' do
-      user = Tumblr::Authenticator.new('test@testermcgee.com','dontrevealmysecrets')
-      assert user.authenticate(:'include-theme' => 1).with.split('&').include?("include-theme=1")
-    end
-  end
-  
-  describe 'Post' do
-    describe 'Basic' do
-      test 'has a set of post-specific parameters' do
-        klass = Class.new(Tumblr::Post)
-        assert_respond_to klass, :parameters
-        klass.parameters :title, :body
-        assert klass.parameters.include? :title
-        post = klass.new
-        assert_respond_to post, :title
-        post.title = 'Hello world'
-        assert_equal 'Hello world', post.title
-      end
-      
-      test 'can have a post_id already set' do
-        post = Tumblr::Post.new
-        assert !post.post_id
-        post = Tumblr::Post.new 123
-        assert_equal 123, post.post_id
-      end
-      
-      test 'sets a date for publishing in the past' do
-        post = Tumblr::Post.new
-        assert_respond_to post, :date
-        right_now = Time.now.iso8601
-        post.date = right_now
-        assert_equal right_now, post.date
-      end
-      
-      test 'can be a private post' do
-        post = Tumblr::Post.new
-        assert_respond_to post, :private?
-        assert !post.private?
-        post.private = true
-        assert post.private?
-      end
-      
-      test 'can have a reblog key' do
-        post = Tumblr::Post.new
-        assert_respond_to post, :reblog_key
-        post.reblog_key = 'reblog_me'
-        assert_equal 'reblog_me', post.reblog_key
-      end
-      
-      test 'has a comma separated list of tags' do
-        post = Tumblr::Post.new
-        assert_respond_to post, :tags
-        post.tags :tumblr, :whatever, :ruby
-        assert_equal 'tumblr,whatever,ruby', post.tags
-      end
-      
-      test 'can set its format to be html or markdown' do
-        post = Tumblr::Post.new
-        assert_respond_to post, :format
-        post.format = :foobar
-        assert !post.format
-        post.format = :markdown
-        assert_equal :markdown, post.format
-      end
-      
-      test 'can set this post to be published to a secondary blog' do
-        post = Tumblr::Post.new
-        assert_respond_to post, :group
-        post.group = 'mygroup.tumblr.com'
-        assert_equal 'mygroup.tumblr.com', post.group
-      end
-      
-      test 'sets a slug for its url' do
-        post = Tumblr::Post.new
-        assert_respond_to post, :slug
-        post.slug = "this-string-right-here"
-        assert_equal "this-string-right-here", post.slug
-      end
-      
-      test 'can change published state' do
-        post = Tumblr::Post.new
-        assert_respond_to post, :state
-        post.state = 'queue'
-        assert_equal :queue, post.state
-        assert_raise RuntimeError do
-          post.state = 'foobar'
-        end
-      end
-      
-      test 'sends to twitter' do
-        post = Tumblr::Post.new
-        assert_respond_to post, :send_to_twitter
-        assert !post.send_to_twitter
-        post.send_to_twitter :no
-        assert !post.send_to_twitter
-        post.send_to_twitter 'Updating twitter through tumblr'
-        assert_equal 'Updating twitter through tumblr', post.send_to_twitter
-      end
-      
-      test 'if the published state is in the queue, specify a publish date' do
-        post = Tumblr::Post.new
-        assert_respond_to post, :publish_on
-        right_now = Time.now.iso8601
-        post.publish_on right_now
-        assert !post.publish_on
-        post.state = :queue
-        post.publish_on right_now
-        assert_equal right_now, post.publish_on
-      end 
-    
-      test 'converts to a hash' do
-        post = Tumblr::Post.new(123)
-        post.private = 1
-        assert_respond_to post, :to_h
-        assert_equal 1, post.to_h[:private]
-        assert_equal 123, post.to_h[:'post-id']
-        klass = Class.new(post.class)
-        klass.parameters :title, :body
-        new_post = klass.new(456)
-        new_post.title = "Hello world"
-        assert_equal 'Hello world', new_post.to_h[:title]
-        assert !new_post.to_h.has_key?(:body)
-      end
-    
-      test 'writes itself to tumblr' do
-        klass = Class.new Tumblr::Post
-        post = klass.new
-        post.instance_variable_set(:@type,:regular)
-        assert post.write('test@testermcgee.com','dontrevealmysecrets').is_a? Weary::Request
-      end
-      
-      test 'edits itself on tumblr' do
-        post = Tumblr::Post.new(123)
-        assert post.edit('test@testermcgee.com','dontrevealmysecrets').is_a? Weary::Request
-      end
-      
-      test 'deletes itself' do
-        post = Tumblr::Post.new(123)
-        assert post.delete('test@testermcgee.com','dontrevealmysecrets').is_a? Weary::Request
-      end
-      
-      test 'reblogs itself' do
-        post = Tumblr::Post.new(123)
-        post.reblog_key = '0U812'
-        assert post.reblog('test@testermcgee.com','dontrevealmysecrets').is_a? Weary::Request
-      end
-      
-      test 'likes itself' do
-        post = Tumblr::Post.new(445597771)
-        post.reblog_key = "DLVWOpfh"
-        like = post.like('test@testermcgee.com','dontrevealmysecrets')
-        assert like.is_a? Weary::Request
-        assert_equal 'http://www.tumblr.com/api/like', like.uri.to_s
-      end
-      
-      test 'unlikes itself' do
-        post = Tumblr::Post.new(445597771)
-        post.reblog_key = "DLVWOpfh"
-        unlike = post.unlike('test@testermcgee.com','dontrevealmysecrets')
-        assert unlike.is_a? Weary::Request
-        assert_equal 'http://www.tumblr.com/api/unlike', unlike.uri.to_s
-      end
-    
-      test 'publishes to tumblr' do
-        klass = Class.new Tumblr::Post
-        post = klass.new
-        post.instance_variable_set(:@type,:regular)
-        post.state = :queue
-        assert post.publish_now('test@testermcgee.com','dontrevealmysecrets').is_a? Weary::Request
-        assert_equal :published, post.state
-      end
-      
-      test 'saves as a draft to tumblr' do
-        klass = Class.new Tumblr::Post
-        post = klass.new
-        post.instance_variable_set(:@type,:regular)
-        post.state = :published
-        assert post.save_as_draft('test@testermcgee.com','dontrevealmysecrets').is_a? Weary::Request
-        assert_equal :draft, post.state
-      end
-      
-      test 'adds to tumblr queue' do
-        klass = Class.new Tumblr::Post
-        post = klass.new
-        post.instance_variable_set(:@type,:regular)
-        post.state = :draft
-        assert post.add_to_queue('test@testermcgee.com','dontrevealmysecrets').is_a? Weary::Request
-        assert_equal :queue, post.state
-      end
-      
-      test 'publish on a specific date' do
-        klass = Class.new Tumblr::Post
-        post = klass.new
-        post.instance_variable_set(:@type,:regular)
-        post.state = :draft
-        assert post.add_to_queue('test@testermcgee.com','dontrevealmysecrets','tuesday').is_a? Weary::Request
-        assert_equal :queue, post.state
-        assert_equal 'tuesday',post.publish_on
-      end
-    
-      test 'converts itself to YAML' do
-        klass = Class.new Tumblr::Post
-        klass.parameters :title, :body
-        post = klass.new
-        post.instance_variable_set(:@type,:regular)
-        post.tags 'hello', 'stuff'
-        post.state = :queue
-        post.body = "Hello world."
-        assert_respond_to post, :to_yaml
-        post_yaml = post.to_yaml
-        assert_equal 'Hello world.', YAML.load(post_yaml)['body']
-        assert_equal 'regular', YAML.load(post_yaml)['data']['type']
-      end
-      
-      test 'converts itself to a string for writing to a file' do
-        klass = Class.new Tumblr::Post
-        klass.parameters :title, :body
-        post = klass.new
-        post.instance_variable_set(:@type,:regular)
-        post.tags 'hello', 'stuff'
-        post.state = :queue
-        post.body = "Hello world."
-        assert_equal 'regular', YAML.load(post.to_s)['type']
-      end
-    end
-  
-    describe 'Regular' do
-      test 'is of regular type' do
-        reg = Tumblr::Post::Regular.new
-        assert_equal :regular, reg.type
-      end
-      
-      test 'has a body' do
-        reg = Tumblr::Post::Regular.new
-        assert_respond_to reg, :body
-        reg.body = "Hi"
-        assert_equal "Hi", reg.body
-      end
-      
-      test 'has a title' do
-        reg = Tumblr::Post::Regular.new
-        assert_respond_to reg, :title
-        reg.title = "Hi"
-        assert_equal "Hi", reg.title
-      end
-    end
-  
-    describe 'Photo' do
-      test 'is a photo' do
-        photo = Tumblr::Post::Photo.new
-        assert_equal :photo, photo.type
-      end
-      
-      test 'has a source' do
-        photo = Tumblr::Post::Photo.new
-        photo.source = "http://foo.bar/picture.png"
-        assert_equal "http://foo.bar/picture.png", photo.source
-      end
-      
-      test 'has a caption' do
-        photo = Tumblr::Post::Photo.new
-        photo.caption = "Me in my youth"
-        assert_equal "Me in my youth", photo.caption
-      end
-      
-      test 'has a click-through-url' do
-        photo = Tumblr::Post::Photo.new
-        photo.click_through_url = "http://tumblr.com"
-        assert_equal "http://tumblr.com", photo.click_through_url
-      end
-    end
-    
-    describe 'Quote' do
-      test 'is a quote' do
-        quote = Tumblr::Post::Quote.new("To be or not to be")
-        assert_equal :quote, quote.type
-      end
-      
-      test 'the quote is text' do
-        quote = Tumblr::Post::Quote.new("To be or not to be")
-        assert_equal "To be or not to be", quote.quote
-        quote.quote = "that is the question."
-        assert_equal "that is the question.", quote.quote
-      end
-      
-      test 'the quote has a source' do
-        quote = Tumblr::Post::Quote.new("To be or not to be")
-        quote.source = "Hamlet"
-        assert_equal 'Hamlet', quote.source
-      end
-    end
-    
-    describe 'Link' do
-      test 'is a link' do
-        link = Tumblr::Post::Link.new('http://tumblr.com')
-        assert_equal :link, link.type
-      end
-      
-      test 'is a link to something' do
-        link = Tumblr::Post::Link.new('http://tumblr.com')
-        assert_equal 'http://tumblr.com', link.url
-      end
-      
-      test 'has an optional name' do
-        link = Tumblr::Post::Link.new('http://tumblr.com')
-        link.name = 'Tumblr'
-        assert_equal 'Tumblr', link.name
-      end
-      
-      test 'has an optional description' do
-        link = Tumblr::Post::Link.new('http://tumblr.com')
-        link.description = "Simple blogging"
-        assert_equal 'Simple blogging', link.description
-      end
-    end
-    
-    describe 'Conversation' do
-      test 'is a conversation' do
-        conversation = Tumblr::Post::Conversation.new('Me: hey whatsup')
-        assert_equal :conversation, conversation.type
-      end
-      
-      test 'requires a chat' do
-        conversation = Tumblr::Post::Conversation.new('Me: hey whatsup')
-        assert_equal 'Me: hey whatsup', conversation.conversation
-      end
-      
-      test 'has an optional title' do
-        conversation = Tumblr::Post::Conversation.new('Me: hey whatsup')
-        conversation.title = 'Inner dialogue'
-        assert_equal 'Inner dialogue', conversation.title
-      end
-    end
-    
-    describe 'Video' do
-      test 'is a video' do
-        video = Tumblr::Post::Video.new('http://www.youtube.com/watch?v=CW0DUg63lqU')
-        assert_equal :video, video.type
-      end
-      
-      test 'has a url or embed code' do
-        video = Tumblr::Post::Video.new('http://www.youtube.com/watch?v=CW0DUg63lqU')
-        assert_equal 'http://www.youtube.com/watch?v=CW0DUg63lqU', video.embed
-      end
-      
-      test 'has a caption' do
-        video = Tumblr::Post::Video.new('http://www.youtube.com/watch?v=CW0DUg63lqU')
-        video.caption = 'Good artists copy...'
-        assert_equal 'Good artists copy...', video.caption
-      end
-    end
-    
-    describe 'Audio' do
-      test 'is audio' do
-        audio = Tumblr::Post::Audio.new
-        assert_equal :audio, audio.type
-      end
-      
-      test 'can be a hosted url to an mp3 file' do
-        audio = Tumblr::Post::Audio.new
-        audio.externally_hosted_url = 'http://foobar.com/some.mp3'
-        assert_equal 'http://foobar.com/some.mp3', audio.externally_hosted_url
-      end
-      
-      test 'has an optional caption' do
-        audio = Tumblr::Post::Audio.new
-        audio.caption = 'not pirated'
-        assert_equal 'not pirated', audio.caption
-      end
-    end
-  end
-end