cloudapp 2.0.0.beta.3 → 2.0.0.beta.4

data/spec/cloudapp/service_spec.rb

@@ -4,108 +4,118 @@ require 'support/vcr'
 require 'cloudapp/service'
 
 describe CloudApp::Service do
-  let(:service) { CloudApp::Service.using_token token }
-  let(:token)   { 'abc123' }
-  let(:favicon) {
+  let(:service)  { CloudApp::Service.using_token token }
+  let(:token)    { 'abc123' }
+  let(:email)    { 'arthur@dent.com' }
+  let(:password) { 'towel' }
+  let(:favicon)  {
     Pathname('../../support/files/favicon.ico').expand_path(__FILE__)
   }
 
   after(:all) do
     VCR.use_cassette('purge_drops') do
-      service.drops(filter: 'all').items.each do |drop|
+      service.drops(filter: 'all').each do |drop|
         service.delete_drop(drop.href)
       end
     end
   end
 
-  describe '#drops' do
-    subject { VCR.use_cassette('list_drops') { service.drops }}
-    before do
-      VCR.use_cassette('setup_drops') do
-        service.upload favicon
-        service.bookmark 'http://cl.ly', private: false
-        drop = service.bookmark 'http://getcloudapp.com', name: 'CloudApp'
-        service.trash_drop drop.href
-      end
-    end
-
-    it { should be_a(CloudApp::CollectionJson::Representation) }
+  describe '.token_for_account' do
+    subject {
+      VCR.use_cassette('token_for_account') {
+        CloudApp::Service.token_for_account email, password
+      }
+    }
 
-    it 'has 2 drops' do
-      subject.should have(2).items
+    it 'returns the token' do
+      subject.should be_a(String)
+      subject.should eq(token)
     end
 
-    context 'with filter' do
+    context 'with bad credentials' do
+      let(:password) { 'wrong' }
       subject {
-        VCR.use_cassette('list_drops_with_filter') {
-          service.drops filter: 'trash'
+        VCR.use_cassette('token_for_account_with_bad_credentials') {
+          CloudApp::Service.token_for_account email, password
         }
       }
 
-      it 'returns the filtered drops' do
-        subject.should have(1).items
+      it 'returns nothing' do
+        subject.should be_nil
       end
     end
+  end
 
-    context 'with limit' do
-      subject {
-        VCR.use_cassette('list_drops_with_limit') {
-          service.drops limit: 1
-        }
+  describe '#account_token' do
+    subject {
+      VCR.use_cassette('account_token') {
+        CloudApp::Service.new.account_token email, password
       }
+    }
 
-      it 'limits drops' do
-        subject.should have(1).items
-      end
+    it { should be_a(CloudApp::CollectionJson::Representation) }
+
+    it 'returns a single item' do
+      subject.should have(1).item
     end
 
-    context 'with href' do
+    it 'returns the token' do
+      subject.items.first.data.should eq('token' => token)
+    end
+
+    context 'with bad credentials' do
+      let(:password) { 'wrong' }
       subject {
-        VCR.use_cassette('list_drops_with_href') {
-          @href = service.drops(limit: 1).link('next').href
-          service.drops href: @href
+        VCR.use_cassette('token_for_account_with_bad_credentials') {
+          CloudApp::Service.new.account_token email, password
         }
       }
 
-      it 'returns the resource at the given href' do
-        subject.link('self').href.should eq(@href)
+      it { should be_unauthorized }
+    end
+  end
+
+  describe '#drops' do
+    subject { VCR.use_cassette('list_drops') { service.drops }}
+    before do
+      VCR.use_cassette('setup_drops') do
+        service.upload favicon
+        service.bookmark 'http://cl.ly', private: false
+        drop = service.bookmark('http://getcloudapp.com', name: 'CloudApp').first
+        service.trash_drop drop.href
       end
     end
 
-    context 'with an empty href' do
-      subject {
-        VCR.use_cassette('list_drops_with_nil_href') {
-          service.drops(href: nil)
-        }
-      }
+    it { should be_a(CloudApp::DropCollection) }
 
-      it 'has 2 drops' do
-        subject.should have(2).items
-      end
+    it 'has 2 drops' do
+      subject.should have(2).items
     end
 
-    context 'with href and filter' do
+    context 'with filter' do
       subject {
-        VCR.use_cassette('list_drops_with_href_and_filter') {
-          @href = service.drops(limit: 1).link('next').href
-          service.drops href: @href, filter: 'trash'
+        VCR.use_cassette('list_drops_with_filter') {
+          service.drops filter: 'trash'
         }
       }
 
-      it 'ignores filter' do
+      it { should be_a(CloudApp::DropCollection) }
+
+      it 'returns the filtered drops' do
         subject.should have(1).items
       end
     end
 
-    context 'with href and limit' do
+    context 'with limit' do
       subject {
-        VCR.use_cassette('list_drops_with_href_and_limit') {
-          @href = service.drops(limit: 1).link('next').href
-          service.drops href: @href, limit: 42
+        VCR.use_cassette('list_drops_with_limit') {
+          service.drops limit: 1
         }
       }
 
-      it 'ignores limit' do
+      it { should be_a(CloudApp::DropCollection) }
+
+      it 'limits drops' do
         subject.should have(1).items
       end
     end
@@ -118,96 +128,38 @@ describe CloudApp::Service do
         }
       }
 
+      it { should be_a(CloudApp::DropCollection) }
       it { should be_unauthorized }
     end
   end
 
-  describe '#drop_at' do
+  describe '#drop' do
     subject {
       VCR.use_cassette('list_drops') {
-        @href = service.drops.items.first.href
+        @href = service.drops.first.href
       }
-      VCR.use_cassette('view_drop') { service.drop_at(@href) }
+      VCR.use_cassette('view_drop') { service.drop(@href) }
     }
 
-    it { should be_a(CloudApp::CollectionJson::Representation) }
+    it { should be_a(CloudApp::DropCollection) }
 
     it 'returns a drop' do
       subject.should have(1).item
     end
   end
 
-  describe '#update' do
-    let(:url)     { 'http://getcloudapp.com' }
-    let(:name)    { 'New Drop Name' }
-    let(:private) { false }
-    subject {
-      VCR.use_cassette('rename_drop') {
-        drop = service.bookmark(url).items.first
-        service.update drop.href, name: name, private: private
-      }
-    }
-
-    it { should be_a(CloudApp::CollectionJson::Representation) }
-
-    it 'returns the updated drop' do
-      subject.should have(1).item
-    end
-
-    it 'updates the name' do
-      subject.items.first.data['name'].should eq(name)
-    end
-
-    it 'updates the privacy' do
-      subject.items.first.data['private'].should eq(private)
-    end
-
-    context 'updating bookmark link' do
-      subject {
-        VCR.use_cassette('update_drop_bookmark_url') {
-          drop = service.bookmark(url).items.first
-          service.update drop.href, url: 'http://example.org'
-        }
-      }
-
-      it { should be_a(CloudApp::CollectionJson::Representation) }
-
-      it 'returns the new drop' do
-        subject.should have(1).item
-      end
-    end
-
-    context 'updating file' do
-      let(:options) {{ path: favicon }}
-      subject {
-        VCR.use_cassette('update_file') {
-          drop = service.bookmark(url).items.first
-          service.update drop.href, options
-        }
-      }
-
-      it { should be_a(CloudApp::CollectionJson::Representation) }
-
-      it 'returns the new drop' do
-        subject.should have(1).item
-      end
-    end
-  end
-
   describe '#bookmark' do
     let(:url) { 'http://getcloudapp.com' }
     subject {
       VCR.use_cassette('create_bookmark') { service.bookmark(url) }
     }
 
-    it { should be_a(CloudApp::CollectionJson::Representation) }
+    it { should be_a(CloudApp::DropCollection) }
 
     it 'returns the new drop' do
       subject.should have(1).item
     end
 
-    it 'bookmarks the url'
-
     context 'with a name' do
       let(:name) { 'New Bookmark' }
       subject {
@@ -217,7 +169,7 @@ describe CloudApp::Service do
       }
 
       it 'has the given name' do
-        subject.items.first.data['name'].should eq(name)
+        subject.first.data['name'].should eq(name)
       end
     end
 
@@ -229,7 +181,7 @@ describe CloudApp::Service do
       }
 
       it 'is public' do
-        subject.items.first.data['private'].should eq(false)
+        subject.first.data['private'].should eq(false)
       end
     end
   end
@@ -239,7 +191,7 @@ describe CloudApp::Service do
       VCR.use_cassette('upload_file') { service.upload(favicon) }
     }
 
-    it { should be_a(CloudApp::CollectionJson::Representation) }
+    it { should be_a(CloudApp::DropCollection) }
 
     it 'returns the new drop' do
       subject.should have(1).item
@@ -254,7 +206,7 @@ describe CloudApp::Service do
       }
 
       it 'has the given name' do
-        subject.items.first.data['name'].should eq(name)
+        subject.first.data['name'].should eq(name)
       end
     end
 
@@ -266,92 +218,118 @@ describe CloudApp::Service do
       }
 
       it 'is public' do
-        subject.items.first.data['private'].should eq(false)
+        subject.first.data['private'].should eq(false)
       end
     end
 
     describe 'too large file'
   end
 
-  describe '#token_for_account' do
-    let(:service)  { CloudApp::Service.new }
-    let(:email)    { 'arthur@dent.com' }
-    let(:password) { 'towel' }
-    subject {
-      VCR.use_cassette('token_for_account') {
-        CloudApp::Service.new.token_for_account email, password
-      }
-    }
-
-    it { should be_a(CloudApp::CollectionJson::Representation) }
-
-    it 'returns a single item' do
-      subject.should have(1).item
-    end
-
-    it 'returns the token' do
-      subject.items.first.data.should eq('token' => token)
-    end
-
-    context 'with bad credentials' do
-      let(:password) { 'wrong' }
-      subject {
-        VCR.use_cassette('token_for_account_with_bad_credentials') {
-          CloudApp::Service.new.token_for_account email, password
-        }
-      }
-
-      it { should be_unauthorized }
-    end
-  end
-
-  describe '#trash_drop' do
-    subject {
-      VCR.use_cassette('trash_drop') {
-        drop = service.bookmark('http://getcloudapp.com').items.first
-        service.trash_drop drop.href
-      }
-    }
-
-    it { should be_a(CloudApp::CollectionJson::Representation) }
-
-    it 'returns the trashed drop' do
-      subject.should have(1).item
-    end
 
-    it 'trashes the drop' do
-      subject.items.first.data['trash'].should eq(true)
-    end
-  end
-
-  describe '#recover_drop' do
-    subject {
-      VCR.use_cassette('recover_drop') {
-        drop = service.bookmark('http://getcloudapp.com').items.first
-        service.trash_drop   drop.href
-        service.recover_drop drop.href
-      }
-    }
-
-    it { should be_a(CloudApp::CollectionJson::Representation) }
-
-    it 'returns the recovered drop' do
-      subject.should have(1).item
-    end
-
-    it 'recovers the drop' do
-      subject.items.first.data['trash'].should eq(false)
-    end
-  end
-
-  describe '#delete_drop' do
-    subject {
-      VCR.use_cassette('delete_drop') {
-        drop = service.bookmark('http://getcloudapp.com').items.first
-        service.delete_drop drop.href
-      }
-    }
-
-    it { should be_authorized }
-  end
+  # describe '#update' do
+  #   let(:url)     { 'http://getcloudapp.com' }
+  #   let(:name)    { 'New Drop Name' }
+  #   let(:private) { false }
+  #   subject {
+  #     VCR.use_cassette('rename_drop') {
+  #       drop = service.bookmark(url).items.first
+  #       service.update drop.href, name: name, private: private
+  #     }
+  #   }
+
+  #   it { should be_a(CloudApp::CollectionJson::Representation) }
+
+  #   it 'returns the updated drop' do
+  #     subject.should have(1).item
+  #   end
+
+  #   it 'updates the name' do
+  #     subject.items.first.data['name'].should eq(name)
+  #   end
+
+  #   it 'updates the privacy' do
+  #     subject.items.first.data['private'].should eq(private)
+  #   end
+
+  #   context 'updating bookmark link' do
+  #     subject {
+  #       VCR.use_cassette('update_drop_bookmark_url') {
+  #         drop = service.bookmark(url).items.first
+  #         service.update drop.href, url: 'http://example.org'
+  #       }
+  #     }
+
+  #     it { should be_a(CloudApp::CollectionJson::Representation) }
+
+  #     it 'returns the new drop' do
+  #       subject.should have(1).item
+  #     end
+  #   end
+
+  #   context 'updating file' do
+  #     let(:options) {{ path: favicon }}
+  #     subject {
+  #       VCR.use_cassette('update_file') {
+  #         drop = service.bookmark(url).items.first
+  #         service.update drop.href, options
+  #       }
+  #     }
+
+  #     it { should be_a(CloudApp::CollectionJson::Representation) }
+
+  #     it 'returns the new drop' do
+  #       subject.should have(1).item
+  #     end
+  #   end
+  # end
+
+  # describe '#trash_drop' do
+  #   subject {
+  #     VCR.use_cassette('trash_drop') {
+  #       drop = service.bookmark('http://getcloudapp.com').items.first
+  #       service.trash_drop drop.href
+  #     }
+  #   }
+
+  #   it { should be_a(CloudApp::CollectionJson::Representation) }
+
+  #   it 'returns the trashed drop' do
+  #     subject.should have(1).item
+  #   end
+
+  #   it 'trashes the drop' do
+  #     subject.items.first.data['trash'].should eq(true)
+  #   end
+  # end
+
+  # describe '#recover_drop' do
+  #   subject {
+  #     VCR.use_cassette('recover_drop') {
+  #       drop = service.bookmark('http://getcloudapp.com').items.first
+  #       service.trash_drop   drop.href
+  #       service.recover_drop drop.href
+  #     }
+  #   }
+
+  #   it { should be_a(CloudApp::CollectionJson::Representation) }
+
+  #   it 'returns the recovered drop' do
+  #     subject.should have(1).item
+  #   end
+
+  #   it 'recovers the drop' do
+  #     subject.items.first.data['trash'].should eq(false)
+  #   end
+  # end
+
+  # describe '#delete_drop' do
+  #   subject {
+  #     VCR.use_cassette('delete_drop') {
+  #       drop = service.bookmark('http://getcloudapp.com').items.first
+  #       service.delete_drop drop.href
+  #     }
+  #   }
+
+  #   it { should be_authorized }
+  # end
 end

data/spec/integration_spec.rb

@@ -6,95 +6,63 @@ require 'cloudapp'
 describe CloudApp, :integration do
   let(:path) { Pathname('../support/files/favicon.ico').expand_path(__FILE__) }
 
-  def all_drops(options = {})
-    options = { filter: 'all' }.merge(options)
-    @account.drops(options)
-  end
-
-  def active_drops
-    @account.drops(filter: 'active')
-  end
-
-  def trashed_drops
-    @account.drops(filter: 'trash')
-  end
-
-  def create_bookmark(url, options = {})
-    @account.bookmark(url, options).first
-  end
-
-  def create_upload(path, options = {})
-    @account.upload(path, options).first
-  end
-
-  def drop_details(drop)
-    @account.drop_at(drop.href).first
-  end
-
-  def recover_drop(drop)
-    @account.recover_drop(drop.href).first
-  end
-
-  def trash_drop(drop)
-    @account.trash_drop(drop.href).first
-  end
-
-  def delete_drop(drop)
-    @account.delete_drop(drop.href)
-  end
-
-
   it 'integrates with the API' do
-    token = CloudApp::Token.for_account 'arthur@dent.com', 'towel'
-    token.should_not be_nil
-
-    @account = CloudApp::Account.using_token token
-    drops    = all_drops
-    unless all_drops.empty?
-      drops.each do |drop| delete_drop(drop) end
-    end
+    token = CloudApp::Service.token_for_account 'arthur@dent.com', 'towel'
+    token.should =~ /\w+/
 
-    all_drops.should be_empty
+    service = CloudApp::Service.using_token token
+    service.drops(filter: 'all').each(&:delete)
+    service.drops(filter: 'all').should be_empty
 
-    bookmark    = create_bookmark 'http://getcloudapp.com', name: 'CloudApp'
-    file        = create_upload   path
-    public_drop = create_bookmark 'http://getcloudapp.com', private: false
+    bookmark    = service.bookmark('http://getcloudapp.com', name: 'CloudApp').first
+    file        = service.upload(path).first
+    public_drop = service.bookmark('http://getcloudapp.com', private: false).first
 
-    all_drops.should have(3).items
+    service.drops(filter: 'all').should have(3).items
 
-    bookmark_details = drop_details bookmark
+    bookmark_details = service.drop(bookmark.href).first
     bookmark_details.name   .should eq('CloudApp')
     bookmark_details.private.should eq(true)
 
-    drop_details(file).name.should eq('favicon.ico')
-    drop_details(public_drop).private.should eq(false)
+    file_details = service.drop(file.href).first
+    file_details.name   .should eq('favicon.ico')
+    file_details.private.should eq(true)
+
+    public_drop_details = service.drop(public_drop.href).first
+    public_drop_details.name   .should eq('http://getcloudapp.com')
+    public_drop_details.private.should eq(false)
+
+    bookmark.trash
+    file    .trash
+    service.drops(filter: 'all')   .should have(3).items
+    service.drops(filter: 'active').should have(1).item
+    service.drops(filter: 'trash') .should have(2).items
 
-    trash_drop bookmark
-    trash_drop file
-    all_drops    .should have(3).items
-    active_drops .should have(1).items
-    trashed_drops.should have(2).items
+    bookmark.recover
+    service.drops(filter: 'all')   .should have(3).items
+    service.drops(filter: 'active').should have(2).item
+    service.drops(filter: 'trash') .should have(1).items
 
-    recover_drop bookmark
-    all_drops    .should have(3).items
-    active_drops .should have(2).items
-    trashed_drops.should have(1).items
+    page1 = service.drops(filter: 'all', limit: 1)
+    page1.should have(1).item
 
-    limited = all_drops(limit: 1)
-    limited.should have(1).item
+    page2 = page1.follow 'next'
+    page2.should have(1).item
 
-    next_page = all_drops(href: limited.link('next').href)
-    next_page.should have(1).item
+    page3 = page2.follow 'next'
+    page3.should have(1).item
+    page3.has_link?('next').should eq(false)
 
-    # TODO: Uncomment when pagination with filter is fixed.
-    next_page = all_drops(href: next_page.link('next').href)
-    next_page.should have(1).item
-    next_page.link('next') { nil }.should be_nil
+    page2 = page3.follow 'previous'
+    page2.should have(1).item
 
-    delete_drop bookmark
-    delete_drop file
-    delete_drop public_drop
+    page1 = page2.follow 'previous'
+    page1.should have(1).item
+    page1.has_link?('previous').should eq(false)
 
-    all_drops.should have(0).items
+    bookmark   .delete
+    file       .delete
+    public_drop.delete
+    service.drops(filter: 'all').should be_empty
   end
 end

data/spec/support/vcr.rb

@@ -2,7 +2,7 @@ require 'vcr'
 
 VCR.configure do |vcr|
   vcr.cassette_library_dir     = 'spec/cassettes'
-  vcr.default_cassette_options = { record: :none,
+  vcr.default_cassette_options = { record: :once,
                                    match_requests_on: [ :method, :uri, :body ]}
   vcr.hook_into :webmock
   vcr.configure_rspec_metadata!