dropio 0.9.1 → 1.0

data/lib/dropio.rb

@@ -1,35 +1,34 @@
 module Dropio
-  VERSION = '0.9.1'
+  VERSION = '1.0.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
+  
+  class Config
+    class << self
+      attr_accessor :api_key, :base_url, :api_url, :upload_url, :version
+    end
   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 'rbconfig'
 require 'mime/types'
-require 'base64'
-require 'cgi'
-require 'json'
-require 'digest/sha1'
+require 'httparty'
+require 'net/http/post/multipart'
+
+Dropio::Config.base_url = "http://drop.io"
+Dropio::Config.api_url = "http://api.drop.io"
+Dropio::Config.upload_url = "http://assets.drop.io/upload"
+Dropio::Config.version = "2.0"
 
+require 'dropio/api'
 require 'dropio/client'
-require 'dropio/client/mapper'
-require 'dropio/client/multipart_post'
 require 'dropio/resource'
 require 'dropio/drop'
 require 'dropio/asset'
 require 'dropio/comment'
+require 'dropio/subscription'

data/spec/dropio/asset_spec.rb

@@ -1,39 +1,55 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
-describe Asset do
+describe Dropio::Asset do
   before(:each) do
-    @asset = Asset.new
-    @client = stub(Client)
-    Client.stub!(:instance).and_return(@client)
+    @drop = Dropio::Drop.new
+    @drop.name = "test_drop"
+    @asset = Dropio::Asset.new
+    @asset.name = "test_asset"
+    @asset.drop = @drop
+    
+    @client = Dropio::Client.new
+    @api = stub(Dropio::Api)
+    @client.service = @api
+    
+    Dropio::Resource.stub!(:client).and_return(@client)
+    Dropio::Resource.client.should == @client
+    Dropio::Resource.client.service.should == @api
   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)
+    @asset.should respond_to(:drop, :name, :type, :title, :description, :filesize, :created_at,
+                  :thumbnail, :status, :converted, :hidden_url, :pages, :fax_status,
+                  :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])
+    @comment.should_receive(:asset=).once
+    @client.should_receive(:handle).with(:comments,{}).and_return([@comment])
+    @api.stub!(:comments).with(@drop.name, @asset.name, @drop.default_token).and_return({})
     @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)
+    @comment.should_receive(:asset=).once
+    @client.should_receive(:handle).with(:comment,{}).and_return(@comment)
+    @api.stub!(:create_comment).with(@drop.name, @asset.name, "Totally rad asset, bro!",@drop.default_token).and_return({})
     @asset.create_comment("Totally rad asset, bro!").should == @comment
   end
   
   it "should save itself" do
-    @client.should_receive(:save_asset).with(@asset)
+    @client.should_receive(:handle).with(:asset,{}).and_return(@asset)
+    expected_hash = {:url=> "http://drop.io", :contents=>nil, :description=>nil, :title=>nil}
+    @asset.url = expected_hash[:url]
+    @api.stub!(:update_asset).with(@drop.name, @asset.name, expected_hash,@drop.default_token).and_return({})
     @asset.save
   end
   
   it "should destroy itself" do
-    @client.should_receive(:destroy_asset).with(@asset)
+    @client.should_receive(:handle).with(:response,{}).and_return({"result" => "Success"})
+    @api.stub!(:delete_asset).with(@drop.name, @asset.name,@drop.default_token).and_return({})
     @asset.destroy!
   end
   
@@ -46,14 +62,72 @@ describe Asset do
   
   it "should fax itself to a phone number" do
     @asset.type = "Document"
-    @client.should_receive(:send_to_fax).with(@asset,"234-567-8901")
+    
+    @client.should_receive(:handle).with(:response,{}).and_return({"result" => "Success"})
+    @api.stub!(:send_asset_to_fax).with(@drop.name, @asset.name,"234-567-8901",@drop.default_token).and_return({})
     @asset.send_to_fax("234-567-8901")
   end
   
+  it "should email itself to a comma separated list of emails with an optional message" do
+    @asset.type = "Document"
+    @client.should_receive(:handle).with(:response,{}).and_return({"result" => "Success"})
+    @api.stub!(:send_asset_to_emails).with(@drop.name, @asset.name,"jake@dropio.com, jacob@dropio.com", "Awesome stuff!", @drop.default_token).and_return({})
+    @asset.send_to_emails("jake@dropio.com, jacob@dropio.com","Awesome stuff!")
+    
+    @client.should_receive(:handle).with(:response,{}).and_return({"result" => "Success"})
+    @api.stub!(:send_asset_to_emails).with(@drop.name, @asset.name,"jake@dropio.com, jacob@dropio.com", nil, @drop.default_token).and_return({})
+    @asset.send_to_emails("jake@dropio.com, jacob@dropio.com")
+  end
+  
+  it "should send itself to another drop." do
+    @target_drop = Drop.new
+    @target_drop.name = "target_drop"
+    @target_drop.guest_token = "guest_token"
+    @client.should_receive(:handle).with(:response,{}).and_return({"result" => "Success"})
+    @api.stub!(:send_asset_to_drop).with(@drop.name, @asset.name, @target_drop.name, @target_drop.guest_token, @drop.default_token).and_return({})
+    @asset.send_to_drop(@target_drop)
+  end
+  
+  it "should copy itself to another drop." do
+    @target_drop = Drop.new
+    @target_drop.name = "target_drop"
+    @target_drop.guest_token = "guest_token"
+    @client.should_receive(:handle).with(:response,{}).and_return({"result" => "Success"})
+    @api.stub!(:copy_asset).with(@drop.name, @asset.name, @target_drop.name, @target_drop.guest_token, @drop.default_token).and_return({})
+    @asset.copy_to(@target_drop)
+  end
+  
+  it "should move itself to another drop." do
+    @target_drop = Drop.new
+    @target_drop.name = "target_drop"
+    @target_drop.guest_token = "guest_token"
+    @client.should_receive(:handle).with(:response,{}).and_return({"result" => "Success"})
+    @api.stub!(:move_asset).with(@drop.name, @asset.name, @target_drop.name, @target_drop.guest_token, @drop.default_token).and_return({})
+    @asset.move_to(@target_drop)
+  end
+  
   it "should not fax itself if it's not faxable" do
     @asset.type = "Video"
-    @client.should_not_receive(:send_to_fax)
+    @api.should_not_receive(:send_asset_to_fax)
     # TODO: Make this a specific error.
     lambda { @asset.send_to_fax("234-567-8901") }.should raise_error
   end
-end
+  
+  it "should find itself" do
+    @client.should_receive(:handle).with(:asset,{}).and_return(@asset)
+    @api.should_receive(:asset).with(@drop.name, @asset.name, @drop.default_token).and_return({})
+    Asset.find(@drop,@asset.name).should == @asset
+  end
+  
+  it "should generate a signed url" do
+    @api.should_receive(:generate_drop_url).with(@drop.name,@asset.name,@drop.default_token)  
+    @asset.generate_url
+  end
+  
+  it "should get it's embed_code" do
+    @client.should_receive(:handle).with(:response,{}).and_return({"response" => {"embed_code" => "my_embed_code"}})
+    @api.should_receive(:asset_embed_code).with(@drop.name,@asset.name,@drop.default_token).and_return({})
+    @asset.embed_code
+  end
+  
+end

data/spec/dropio/client_spec.rb

@@ -1,322 +0,0 @@
-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

data/spec/dropio/comment_spec.rb

@@ -1,10 +1,22 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
-describe Comment do
+describe Dropio::Comment do
   before(:each) do
-    @comment = Comment.new
-    @client = stub(Client)
-    Client.stub!(:instance).and_return(@client)
+    @drop = Dropio::Drop.new
+    @drop.name = "test_drop"
+    @asset = Dropio::Asset.new
+    @asset.drop = @drop
+    @asset.name = "test_asset"
+    @comment = Dropio::Comment.new
+    @comment.asset = @asset
+    
+    @client = Dropio::Client.new
+    @api = stub(Dropio::Api)
+    @client.service = @api
+    
+    Dropio::Resource.stub!(:client).and_return(@client)
+    Dropio::Resource.client.should == @client
+    Dropio::Resource.client.service.should == @api
   end
   
   it "should have the attributes of an Comment" do
@@ -12,12 +24,15 @@ describe Comment do
   end
   
   it "should save itself" do
-    @client.should_receive(:save_comment).with(@comment)
+    @client.should_receive(:handle).with(:comment,{}).and_return(@comment)
+    @api.should_receive(:update_comment).with(@drop.name, @asset.name, @comment.id, "My new content", @drop.default_token).and_return({})
+    @comment.contents = "My new content"
     @comment.save
   end
   
   it "should destroy itself" do
-    @client.should_receive(:destroy_comment).with(@comment)
-    @comment.destroy
+    @client.should_receive(:handle).with(:response,{}).and_return({"result" => "Success"})
+    @api.should_receive(:delete_comment).with(@drop.name, @asset.name, @comment.id, @drop.admin_token).and_return({})
+    @comment.destroy!
   end
 end