dropio 0.9.0

data/lib/dropio/drop.rb

@@ -0,0 +1,54 @@
+class Dropio::Drop < Dropio::Resource
+  
+  attr_accessor :name, :email, :voicemail, :conference, :fax, :rss, :guest_token,
+                :admin_token, :expiration_length, :guests_can_comment, :guests_can_add, :guests_can_delete,
+                :max_bytes, :current_bytes, :hidden_upload_url, :upload_url, :password, :admin_password, :premium_code
+  
+  # Gets a list of assets associated with the Drop. Paginated at 
+  def assets(page = 1)
+    Dropio::Client.instance.find_assets(self, page)
+  end
+  
+  # Finds a drop with +name+ and optional authorization +token+
+  def self.find(name, token = nil)
+    Dropio::Client.instance.find_drop(name, token)
+  end
+  
+  # Creates a drop with an +attributes+ hash.
+  # Valid attributes: name (string), guests_can_comment (boolean), guests_can_add (boolean), guests_can_delete (boolean), expiration_length (string), password (string), admin_password (string), and premium_code (string)
+  # Descriptions can be found here: http://groups.google.com/group/dropio-api/web/full-api-documentation
+  def self.create(attributes = {})
+    Dropio::Client.instance.create_drop(attributes)
+  end
+  
+  # Saves the Drop.
+  def save
+    Dropio::Client.instance.save_drop(self)
+  end
+  
+  # Deletes the Drop from the system including all associated assets.
+  def destroy
+    Dropio::Client.instance.destroy_drop(self)
+  end
+  
+  # Adds a file to the Drop given the +file_path+.
+  def add_file(file_path)
+    Dropio::Client.instance.add_file(self, file_path)
+  end
+  
+  # Creates a note with a +title+ and +contents+
+  def create_note(title,contents)
+    Dropio::Client.instance.create_note(self, title, contents)
+  end
+  
+  # Creates a link with a +url+, +title+, and +description+.
+  def create_link(url, title = nil, description = nil)
+    Dropio::Client.instance.create_link(self, url, title, description)
+  end
+  
+  # Generates an authenticated URL that will bypass any login action.
+  def generate_url
+    Dropio::Client.instance.generate_drop_url(self)
+  end
+  
+end

data/lib/dropio/resource.rb

@@ -0,0 +1,9 @@
+class Dropio::Resource
+  
+  def initialize(params = {})
+    params.each do |key,val|
+      self.send("#{key}=", val) if self.respond_to? key
+    end
+  end
+  
+end

data/lib/dropio.rb

@@ -0,0 +1,35 @@
+module Dropio
+  VERSION = '0.9.0'
+  
+  class MissingResourceError < Exception; end
+  class AuthorizationError < Exception; end
+  class RequestError < Exception; end
+  class ServerError < Exception; end
+
+  class << self
+    attr_accessor :api_key, :base_url, :api_url, :upload_url
+  end
+end
+
+
+Dropio.base_url = "http://drop.io"
+Dropio.api_url = "http://api.drop.io"
+Dropio.upload_url = "http://assets.drop.io/upload"
+
+require 'net/http'
+require 'uri'
+require 'singleton'
+require 'rubygems'
+require 'mime/types'
+require 'base64'
+require 'cgi'
+require 'json'
+require 'digest/sha1'
+
+require 'dropio/client'
+require 'dropio/client/mapper'
+require 'dropio/client/multipart_post'
+require 'dropio/resource'
+require 'dropio/drop'
+require 'dropio/asset'
+require 'dropio/comment'

data/spec/dropio/asset_spec.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Asset do
+  before(:each) do
+    @asset = Asset.new
+    @client = stub(Client)
+    Client.stub!(:instance).and_return(@client)
+  end
+  
+  it "should have the attributes of an Asset" do
+    @asset.should respond_to(:name, :type, :title, :description, :filesize,
+                             :created_at, :thumbnail, :status, :file,
+                             :converted, :hidden_url, :pages, :duration,
+                             :artist, :track_title, :height, :width,
+                             :contents, :url)
+  end
+  
+  it "should have comments" do
+    @comment = stub(Comment)
+    @client.stub!(:find_comments).with(@asset).and_return([@comment])
+    @asset.comments.should == [@comment]
+  end
+  
+  it "should create comments" do
+    @comment = stub(Comment)
+    @client.should_receive(:create_comment).with(@asset, "Totally rad asset, bro!").and_return(@comment)
+    @asset.create_comment("Totally rad asset, bro!").should == @comment
+  end
+  
+  it "should save itself" do
+    @client.should_receive(:save_asset).with(@asset)
+    @asset.save
+  end
+  
+  it "should destroy itself" do
+    @client.should_receive(:destroy_asset).with(@asset)
+    @asset.destroy!
+  end
+  
+  it "should be faxable if and only if it's a document" do
+    @asset.type = "Document"
+    @asset.should be_faxable
+    @asset.type = "Video"
+    @asset.should_not be_faxable
+  end
+  
+  it "should fax itself to a phone number" do
+    @asset.type = "Document"
+    @client.should_receive(:send_to_fax).with(@asset,"234-567-8901")
+    @asset.send_to_fax("234-567-8901")
+  end
+  
+  it "should not fax itself if it's not faxable" do
+    @asset.type = "Video"
+    @client.should_not_receive(:send_to_fax)
+    # TODO: Make this a specific error.
+    lambda { @asset.send_to_fax("234-567-8901") }.should raise_error
+  end
+end

data/spec/dropio/client/mapper_spec.rb

@@ -0,0 +1,169 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Client::Mapper do
+  it "should parse Drops" do
+    test_drop = Client::Mapper.map_drops <<-RESPONSE
+      {"rss":"http:\/\/drop.io\/k4gpvnty6tw9ho8u3j4w\/b9b2c8f2b8e655679d2fb62b83f8efec4fb4c8af\/test_drop.rss",
+       "voicemail":"646-495-9201 x 02302",
+       "email":"test_drop@drop.io",
+       "admin_token":"A97KQ4Vk7qQU90",
+       "fax":"856-632-1999",
+       "conference":" 218-486-3891 x 915088666",
+       "name":"test_drop",
+       "upload_url":"http:\/\/assets.drop.io\/upload",
+       "guests_can_add":"true",
+       "guests_can_comment":"true",
+       "guests_can_delete":"false",
+       "current_bytes":51488,
+       "max_bytes":104857600.0,
+       "expiration_length":"1_YEAR_FROM_LAST_VIEW",
+       "delete_permission_type":"ALLOWED"}
+    RESPONSE
+    
+    test_drop.should be_an_instance_of(Drop)
+    test_drop.rss.should                    == "http:\/\/drop.io\/k4gpvnty6tw9ho8u3j4w\/b9b2c8f2b8e655679d2fb62b83f8efec4fb4c8af\/test_drop.rss"
+    test_drop.voicemail.should              == "646-495-9201 x 02302"
+    test_drop.email.should                  == "test_drop@drop.io"
+    test_drop.admin_token.should            == "A97KQ4Vk7qQU90"
+    test_drop.fax.should                    == "856-632-1999"
+    test_drop.conference.should             == " 218-486-3891 x 915088666"
+    test_drop.name.should                   == "test_drop"
+    test_drop.upload_url.should             == "http:\/\/assets.drop.io\/upload"
+    test_drop.guests_can_add.should         == "true"
+    test_drop.guests_can_comment.should         == "true"
+    test_drop.guests_can_delete.should         == "false"
+    test_drop.current_bytes.should          == 51488
+    test_drop.max_bytes.should              == 104857600.0
+    test_drop.expiration_length.should      == "1_YEAR_FROM_LAST_VIEW"
+  end
+  
+  it "should parse lists of Drops" do
+    drops = Client::Mapper.map_drops <<-RESPONSE
+      [{"rss":"http:\/\/drop.io\/k4gpvnty6tw9ho8u3j4w\/b9b2c8f2b8e655679d2fb62b83f8efec4fb4c8af\/test_drop.rss",
+        "voicemail":"646-495-9201 x 02302",
+        "email":"test_drop@drop.io",
+        "admin_token":"A97KQ4Vk7qQU90",
+        "fax":"856-632-1999",
+        "conference":" 218-486-3891 x 915088666",
+        "name":"test_drop",
+        "upload_url":"http:\/\/assets.drop.io\/upload",
+        "guests_can_add":"true",
+        "guests_can_comment":"true",
+        "guests_can_delete":"false",
+        "current_bytes":51488,
+        "max_bytes":104857600.0,
+        "expiration_length":"1_YEAR_FROM_LAST_VIEW"},
+       {"current_bytes":178857,
+        "max_bytes":104857600.0,
+        "voicemail":"646-495-9201 x 72025",
+        "admin_token":"8a8vfzfvs2",
+        "email":"0sdcmz7@drop.io",
+        "upload_url":"http:\/\/assets.drop.io\/upload",
+        "guests_can_add":"true",
+        "guests_can_comment":"true",
+        "guests_can_delete":"false",
+        "conference":" 218-486-3891 x 680277944",
+        "name":"0sdcmz7",
+        "expiration_length":"1_YEAR_FROM_LAST_VIEW",
+        "fax":"856-632-1999",
+        "rss":"http:\/\/drop.io\/no9mbevuq3ttmfi6kqen\/3ec4f87d720032bae579cca40740e5e4b267e090\/0sdcmz7.rss"}]
+    RESPONSE
+    
+    drops.should be_an_instance_of(Array)
+    drops.each_should be_an_instance_of(Drop)
+    drops[0].name.should == "test_drop"
+    drops[1].name.should == "0sdcmz7"
+  end
+  
+  it "should parse Assets" do
+    parent_drop = stub(Drop)
+    audio = Client::Mapper.map_assets parent_drop, <<-RESPONSE
+      {"type":"audio",
+       "thumbnail":"http:\/\/drop.io\/download\/public\/vhahbqybv2dx2vdh0z7c\/8c525895399b8eafcd1621b4bd001ee1797e6679\/1c073ae0-7d29-012b-f659-002241261481\/316995b0-7d2e-012b-b8db-002241261481\/",
+       "status":"converted",
+       "filesize":178857,
+       "name":"audio",
+       "file":"http:\/\/drop.io\/download\/48f660ba\/b3c057eb4ce606f2f9f478379ea94ab703416ab3\/1c073ae0-7d29-012b-f659-002241261481\/316995b0-7d2e-012b-b8db-002241261481\/audio.mp3\/audio.mp3",
+       "duration":11,
+       "track_title":"Unknown",
+       "artist":"Unknown",
+       "created_at":"2008/10/15 21:28:55 +0000",
+       "converted":"http:\/\/drop.io\/download\/48f660ba\/26f6688a110f481b169daaa0a023656d4688dac0\/1c073ae0-7d29-012b-f659-002241261481\/316995b0-7d2e-012b-b8db-002241261481\/converted-audio_converted.mp3"}
+    RESPONSE
+    
+    audio.should be_an_instance_of(Asset)
+    audio.drop.should        == parent_drop
+    audio.type.should        == "audio"
+    audio.thumbnail.should   == "http:\/\/drop.io\/download\/public\/vhahbqybv2dx2vdh0z7c\/8c525895399b8eafcd1621b4bd001ee1797e6679\/1c073ae0-7d29-012b-f659-002241261481\/316995b0-7d2e-012b-b8db-002241261481\/"
+    audio.status.should      == "converted"
+    audio.filesize.should    == 178857
+    audio.name.should        == "audio"
+    audio.file.should        == "http:\/\/drop.io\/download\/48f660ba\/b3c057eb4ce606f2f9f478379ea94ab703416ab3\/1c073ae0-7d29-012b-f659-002241261481\/316995b0-7d2e-012b-b8db-002241261481\/audio.mp3\/audio.mp3"
+    audio.duration.should    == 11
+    audio.track_title.should == "Unknown"
+    audio.artist.should      == "Unknown"
+    audio.created_at.should  == "2008/10/15 21:28:55 +0000"
+    audio.converted.should   == "http:\/\/drop.io\/download\/48f660ba\/26f6688a110f481b169daaa0a023656d4688dac0\/1c073ae0-7d29-012b-f659-002241261481\/316995b0-7d2e-012b-b8db-002241261481\/converted-audio_converted.mp3"
+  end
+
+  it "should parse lists of Assets" do
+    parent_drop = stub(Drop)
+    assets = Client::Mapper.map_assets parent_drop, <<-RESPONSE
+      [{"type":"note",
+        "status":"converted",
+        "filesize":109,
+        "name":"about-these-files",
+        "contents":"These files are vital to our mission.&nbsp; <strong>Please<\/strong> do not delete them.<br \/><br \/>Thank you.",
+        "title":"About these files",
+        "created_at":"2008/10/15 21:21:49 +0000"},
+       {"type":"audio",
+        "thumbnail":"http:\/\/drop.io\/download\/public\/vhahbqybv2dx2vdh0z7c\/8c525895399b8eafcd1621b4bd001ee1797e6679\/1c073ae0-7d29-012b-f659-002241261481\/316995b0-7d2e-012b-b8db-002241261481\/",
+        "status":"converted",
+        "filesize":178857,
+        "name":"audio",
+        "file":"http:\/\/drop.io\/download\/48f660ba\/b3c057eb4ce606f2f9f478379ea94ab703416ab3\/1c073ae0-7d29-012b-f659-002241261481\/316995b0-7d2e-012b-b8db-002241261481\/audio.mp3\/audio.mp3",
+        "duration":11,
+        "track_title":"Unknown",
+        "artist":"Unknown",
+        "created_at":"2008/10/15 21:28:55 +0000",
+        "converted":"http:\/\/drop.io\/download\/48f660ba\/26f6688a110f481b169daaa0a023656d4688dac0\/1c073ae0-7d29-012b-f659-002241261481\/316995b0-7d2e-012b-b8db-002241261481\/converted-audio_converted.mp3"}]
+    RESPONSE
+    
+    assets.should be_an_instance_of(Array)
+    assets.each_should be_an_instance_of(Asset)
+    assets[0].name.should == "about-these-files"
+    assets[1].name.should == "audio"
+  end
+
+  it "should parse Comments" do
+    parent_asset = stub(Asset)
+    comment = Client::Mapper.map_comments parent_asset, <<-RESPONSE
+      {"created_at":"2008/09/17 20:47:47 +0000",
+       "id":1,
+       "contents":"This is my comment content."}
+    RESPONSE
+    
+    comment.should be_an_instance_of(Comment)
+    comment.asset.should == parent_asset
+    comment.created_at.should == "2008/09/17 20:47:47 +0000"
+    comment.id.should         == 1
+    comment.contents.should   == "This is my comment content."
+  end
+
+  it "should parse lists of Comments" do
+    parent_asset = stub(Asset)
+    comments = Client::Mapper.map_comments parent_asset, <<-RESPONSE
+      [{"contents":"Really?  Looks like a waste of space to me.  I'm going to delete some of these...",
+        "created_at":"2008/10/15 21:44:24 +0000",
+        "id":1},
+       {"contents":"DON'T DO IT!!",
+        "created_at":"2008/10/15 21:44:36 +0000",
+        "id":2}]
+    RESPONSE
+    
+    comments.should be_an_instance_of(Array)
+    comments.each_should be_an_instance_of(Comment)
+    comments[0].contents.should =~ /waste of space/
+    comments[1].contents.should =~ /DON'T/
+  end
+end

data/spec/dropio/client_spec.rb

@@ -0,0 +1,322 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Client do
+  def mock_http(method, path, response, form_data = nil)
+    request_klass = { :get    => Net::HTTP::Get,
+                      :post   => Net::HTTP::Post,
+                      :put    => Net::HTTP::Put,
+                      :delete => Net::HTTP::Delete }[method]
+    raise "Don't know how to mock a #{method.inspect} HTTP call." if request_klass.nil?
+    request = mock(request_klass)
+    request.should_receive(:set_form_data).with(form_data) if form_data
+    request_klass.stub!(:new).with(path, Client::DEFAULT_HEADER).and_return(request)
+    
+    http = mock(Net::HTTP)
+    Net::HTTP.stub!(:new).with("api.drop.io").and_return(http)
+    http.stub!(:start).and_yield(http)
+    http.stub!(:request).with(request).and_return(response)
+  end
+  
+  def stub_asset(more_stubs={})
+    stub Asset, [:drop, :name, :type, :title, :description, :filesize, :created_at,
+                 :thumbnail, :status, :file, :converted, :hidden_url, :pages,
+                 :duration, :artist, :track_title, :height, :width, :contents, :url].
+                   inject({}) { |stubs, key| stubs[key] = nil; stubs }.merge(more_stubs)
+  end
+  
+  before(:each) do
+    # Don't allow HTTPRequests to be created without being
+    # specifically stubbed, typically with mock_http above.
+    [Net::HTTP::Get, Net::HTTP::Post, Net::HTTP::Put, Net::HTTP::Delete].each do |request_klass|
+      request_klass.stub!(:new).with do |*args|
+        raise "Created an unexpected #{request_klass}!\n#{request_klass}.new(#{args.map { |e| e.inspect }.join(", ")})"
+      end
+    end
+    
+    Dropio.api_url = "http://api.drop.io"
+    Dropio.api_key = "43myapikey13"
+    
+    @api_response_body = stub("API Response Body")
+    @api_response      = stub(Net::HTTPSuccess, :body => @api_response_body)
+    
+    @mydrop     = stub(Drop, :name => 'mydrop', :admin_token => '93mydroptoken97')
+    @note       = stub_asset(:drop => @mydrop, :name => 'a-note', :contents => "My thoughts on life.")
+    @link       = stub_asset(:drop => @mydrop, :name => 'a-link', :url => "http://google.com/")
+    @file_asset = stub_asset(:drop => @mydrop, :name => 'some-video')
+    @comment    = stub(Comment, :asset => @file_asset, :id => 1, :contents => "I remember that day.")
+  end
+  
+  it "should create drops" do
+    settings = {:name               => "mynewdrop",
+                :admin_password     => "niftieradminpassword",
+                :password           => "niftyguestpassword",
+                :guests_can_comment => true,
+                :guests_can_add     => true,
+                :guests_can_delete  => false,
+                :expiration_length  => "1_WEEK_FROM_NOW",
+                :premium_code       => "yeswecan"}
+    
+    mock_http(:post, "/drops/", @api_response, settings.merge(:api_key => "43myapikey13", :format => "json", :version => "1.0"))
+    Client::Mapper.stub!(:map_drops).with(@api_response_body).and_return(@mydrop)
+    Client.instance.create_drop(settings).should == @mydrop
+  end
+  
+  it "should create notes" do
+    mock_http(:post, "/drops/mydrop/assets/", @api_response, :title    => "Just a Note",
+                                                             :contents => "This is just to say",
+                                                             :token    => "93mydroptoken97",
+                                                             :api_key  => "43myapikey13",
+                                                             :format   => "json",
+                                                             :version  => "1.0")
+    Client::Mapper.stub!(:map_assets).with(@mydrop, @api_response_body).and_return(@note)
+    Client.instance.create_note(@mydrop, "Just a Note", "This is just to say").should == @note
+  end
+  
+  it "should create links" do
+    mock_http(:post, "/drops/mydrop/assets/", @api_response, :url         => "http://drop.io/",
+                                                             :title       => "Drop.io",
+                                                             :description => "An awesome sharing site.",
+                                                             :token       => "93mydroptoken97",
+                                                             :api_key     => "43myapikey13",
+                                                             :format      => "json",
+                                                             :version     => "1.0")
+    Client::Mapper.stub!(:map_assets).with(@mydrop, @api_response_body).and_return(@link)
+    Client.instance.create_link(@mydrop, "http://drop.io/", "Drop.io", "An awesome sharing site.").should == @link
+  end
+  
+  it "should add files" do
+    file = stub(File)
+    File.stub!(:open).with("/path/to/video.avi", "r").and_yield(file)
+    
+    path = "/upload"
+    form_data = {:drop_name => "mydrop",
+                 :file      => file,
+                 :token     => "93mydroptoken97",
+                 :api_key   => "43myapikey13",
+                 :format    => "json",
+                 :version   => "1.0"}
+    
+    # We can't use mock_http here because the host is different and we're using multipart.
+    request = mock(Net::HTTP::Post)
+    request.should_receive(:multipart_params=).with(form_data) if form_data
+    Net::HTTP::Post.stub!(:new).with(path, Client::DEFAULT_HEADER).and_return(request)
+    
+    http = mock(Net::HTTP)
+    Net::HTTP.stub!(:new).with("assets.drop.io").and_return(http)
+    http.stub!(:start).and_yield(http)
+    http.stub!(:request).with(request).and_return(@api_response)
+    
+    Client::Mapper.stub!(:map_assets).with(@mydrop, @api_response_body).and_return(@file_asset)
+    Client.instance.add_file(@mydrop, "/path/to/video.avi").should == @file_asset
+  end
+  
+  it "should create comments" do
+    comment = stub(Comment)
+    mock_http(:post, "/drops/mydrop/assets/some-video/comments/", @api_response,
+                                                                  :contents => "What a cool video!",
+                                                                  :token    => "93mydroptoken97",
+                                                                  :api_key  => "43myapikey13",
+                                                                  :format   => "json",
+                                                                  :version  => "1.0")
+    Client::Mapper.stub!(:map_comments).with(@file_asset, @api_response_body).and_return(comment)
+    Client.instance.create_comment(@file_asset, "What a cool video!").should == comment
+  end
+  
+  it "should find drops" do
+    mock_http(:get, "/drops/mydrop?api_key=43myapikey13&token=93mydroptoken97&version=1.0&format=json", @api_response)
+    Client::Mapper.stub!(:map_drops).with(@api_response_body).and_return(@mydrop)
+    Client.instance.find_drop("mydrop", "93mydroptoken97").should == @mydrop
+  end
+  
+  it "should find assets" do
+    mock_http(:get, %r|^/drops/mydrop/assets/\?api_key=43myapikey13&token=93mydroptoken97&version=1.0&format=json|, @api_response)
+    Client::Mapper.stub!(:map_assets).with(@mydrop, @api_response_body).and_return([@file_asset])
+    Client.instance.find_assets(@mydrop).should == [@file_asset]
+  end
+  
+  it "should find comments" do
+    mock_http(:get, %r|^/drops/mydrop/assets/some-video/comments/\?api_key=43myapikey13&token=93mydroptoken97&version=1.0&format=json|, @api_response)
+    Client::Mapper.stub!(:map_comments).with(@file_asset, @api_response_body).and_return([@comment])
+    Client.instance.find_comments(@file_asset).should == [@comment]
+  end
+  
+  it "should save drops" do
+    @mydrop.stub!(:guests_can_comment => true,
+                  :guests_can_add     => false,
+                  :guests_can_delete  => false,
+                  :expiration_length  => "1_WEEK_FROM_LAST_VIEW",
+                  :password           => "mazda",
+                  :admin_password     => "foo64bar",
+                  :premium_code       => "yeswecan")
+    
+    mock_http(:put, "/drops/mydrop", @api_response,
+                                     :guests_can_comment => true,
+                                     :guests_can_add     => false,
+                                     :guests_can_delete  => false,
+                                     :expiration_length  => "1_WEEK_FROM_LAST_VIEW",
+                                     :password           => "mazda",
+                                     :admin_password     => "foo64bar",
+                                     :premium_code       => "yeswecan",
+                                     :token              => "93mydroptoken97",
+                                     :api_key            => "43myapikey13",
+                                     :format             => "json",
+                                     :version            => "1.0")
+    
+    new_drop = stub(Drop)
+    Client::Mapper.stub!(:map_drops).with(@api_response_body).and_return(new_drop)
+    Client.instance.save_drop(@mydrop).should == new_drop
+  end
+  
+  it "should save note assets" do
+    @note.stub!(:title    => "Just a Note",
+                :contents => "This is just to say")
+    
+    mock_http(:put, "/drops/mydrop/assets/a-note", @api_response,
+                                                   :title       => "Just a Note",
+                                                   :description => nil,
+                                                   :url         => nil,
+                                                   :contents    => "This is just to say",
+                                                   :token       => "93mydroptoken97",
+                                                   :api_key     => "43myapikey13",
+                                                   :format      => "json",
+                                                   :version     => "1.0")
+    
+    new_note = stub_asset
+    Client::Mapper.stub!(:map_assets).with(@mydrop, @api_response_body).and_return(new_note)
+    Client.instance.save_asset(@note).should == new_note
+  end
+
+  it "should save link assets" do
+    @link.stub!(:url         => "http://drop.io/",
+                :title       => "Drop.io",
+                :description => "An awesome sharing site.")
+    
+    mock_http(:put, "/drops/mydrop/assets/a-link", @api_response,
+                                                   :title       => "Drop.io",
+                                                   :description => "An awesome sharing site.",
+                                                   :url         => "http://drop.io/",
+                                                   :contents    => nil,
+                                                   :token       => "93mydroptoken97",
+                                                   :api_key     => "43myapikey13",
+                                                   :format      => "json",
+                                                   :version     => "1.0")
+    
+    new_link = stub_asset
+    Client::Mapper.stub!(:map_assets).with(@mydrop, @api_response_body).and_return(new_link)
+    Client.instance.save_asset(@link).should == new_link
+  end
+
+  it "should save file assets" do
+    @file_asset.stub!(:title       => "Snowboarding in March",
+                      :description => "This was really fun.")
+    
+    mock_http(:put, "/drops/mydrop/assets/some-video", @api_response,
+                                                       :title       => "Snowboarding in March",
+                                                       :description => "This was really fun.",
+                                                       :url         => nil,
+                                                       :contents    => nil,
+                                                       :token       => "93mydroptoken97",
+                                                       :api_key     => "43myapikey13",
+                                                       :format      => "json",
+                                                       :version     => "1.0")
+    
+    new_file_asset = stub_asset
+    Client::Mapper.stub!(:map_assets).with(@mydrop, @api_response_body).and_return(new_file_asset)
+    Client.instance.save_asset(@file_asset).should == new_file_asset
+  end
+  
+  it "should save comments" do
+    @comment.stub!(:contents => "I remember that day.")
+    
+    mock_http(:put, "/drops/mydrop/assets/some-video/comments/1", @api_response,
+                                                                  :contents => "I remember that day.",
+                                                                  :token    => "93mydroptoken97",
+                                                                  :api_key  => "43myapikey13",
+                                                                  :format   => "json",
+                                                                  :version  => "1.0")
+     
+    new_comment = stub(Comment)
+    
+    Client::Mapper.stub!(:map_comments).with(@file_asset, @api_response_body).and_return(new_comment)
+    Client.instance.save_comment(@comment).should == new_comment
+  end
+  
+  it "should destroy drops" do
+    mock_http(:delete, "/drops/mydrop", @api_response, :token    => "93mydroptoken97",
+                                                       :api_key  => "43myapikey13",
+                                                       :format   => "json",
+                                                       :version  => "1.0")
+    
+    Client.instance.destroy_drop(@mydrop).should be_true
+  end
+  
+  it "should destroy assets" do
+    mock_http(:delete, "/drops/mydrop/assets/some-video", @api_response,
+                                                          :token    => "93mydroptoken97",
+                                                          :api_key  => "43myapikey13",
+                                                          :format   => "json",
+                                                          :version  => "1.0")
+    
+    Client.instance.destroy_asset(@file_asset).should be_true
+  end
+  
+  it "should destroy comments" do
+    mock_http(:delete, "/drops/mydrop/assets/some-video/comments/1", @api_response,
+                                                                     :token    => "93mydroptoken97",
+                                                                     :api_key  => "43myapikey13",
+                                                                     :format   => "json",
+                                                                     :version  => "1.0")
+    
+    Client.instance.destroy_comment(@comment).should be_true
+  end
+  
+  it "should send assets by fax" do
+    mock_http(:post, "/drops/mydrop/assets/some-video/send_to",
+                     @api_response,
+                     :medium     => "fax",
+                     :fax_number => "12345678901",
+                     :token      => "93mydroptoken97",
+                     :api_key    => "43myapikey13",
+                     :format     => "json",
+                     :version    => "1.0")
+    
+    Client.instance.send_to_fax(@file_asset, "12345678901").should be_true
+  end
+  
+  it "should send assets by email" do
+    mock_http(:post, "/drops/mydrop/assets/some-video/send_to",
+                     @api_response,
+                     :medium  => "email",
+                     :emails  => "joe@broomtown.com,bill@vaccsrus.com",
+                     :message => "Check this out!",
+                     :token   => "93mydroptoken97",
+                     :api_key => "43myapikey13",
+                     :format  => "json",
+                     :version => "1.0")
+    
+    Client.instance.send_to_emails(@file_asset,
+                                   ["joe@broomtown.com", "bill@vaccsrus.com"],
+                                   "Check this out!").should be_true
+  end
+  
+  it "should send assets to drops" do
+    mock_http(:post, "/drops/mydrop/assets/some-video/send_to",
+                     @api_response,
+                     :medium    => "drop",
+                     :drop_name => "myotherdrop",
+                     :token     => "93mydroptoken97",
+                     :api_key   => "43myapikey13",
+                     :format    => "json",
+                     :version   => "1.0")
+    
+    Client.instance.send_to_drop(@file_asset, "myotherdrop").should be_true
+  end
+  
+  it "should generate drop urls" do
+    Client.instance.generate_drop_url(@mydrop).should =~ %r|http://drop.io/mydrop/from_api\?expires=\d+&signature=[0-9a-f]+|
+  end
+  
+  it "should generate asset urls" do
+    Client.instance.generate_asset_url(@file_asset).should =~ %r|http://drop.io/mydrop/asset/some-video/from_api\?expires=\d+&signature=[0-9a-f]+|
+  end
+end