cloudapp 1.1.0 → 2.0.0.beta.1

data/spec/cloudapp/service_spec.rb

@@ -0,0 +1,357 @@
+require 'helper'
+require 'support/vcr'
+
+require 'cloudapp/service'
+
+describe CloudApp::Service do
+  let(:service) { CloudApp::Service.using_token token }
+  let(:token)   { 'abc123' }
+  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.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) }
+
+    it 'has 2 drops' do
+      subject.should have(2).items
+    end
+
+    context 'with filter' do
+      subject {
+        VCR.use_cassette('list_drops_with_filter') {
+          service.drops filter: 'trash'
+        }
+      }
+
+      it 'returns the filtered drops' do
+        subject.should have(1).items
+      end
+    end
+
+    context 'with limit' do
+      subject {
+        VCR.use_cassette('list_drops_with_limit') {
+          service.drops limit: 1
+        }
+      }
+
+      it 'limits drops' do
+        subject.should have(1).items
+      end
+    end
+
+    context 'with href' do
+      subject {
+        VCR.use_cassette('list_drops_with_href') {
+          @href = service.drops(limit: 1).link('next').href
+          service.drops href: @href
+        }
+      }
+
+      it 'returns the resource at the given href' do
+        subject.link('self').href.should eq(@href)
+      end
+    end
+
+    context 'with an empty href' do
+      subject {
+        VCR.use_cassette('list_drops_with_nil_href') {
+          service.drops(href: nil)
+        }
+      }
+
+      it 'has 2 drops' do
+        subject.should have(2).items
+      end
+    end
+
+    context 'with href and 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'
+        }
+      }
+
+      it 'ignores filter' do
+        subject.should have(1).items
+      end
+    end
+
+    context 'with href and 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
+        }
+      }
+
+      it 'ignores limit' do
+        subject.should have(1).items
+      end
+    end
+
+    context 'with a bad token' do
+      let(:token) { 'wrong' }
+      subject {
+        VCR.use_cassette('list_drops_with_bad_token') {
+          service.drops
+        }
+      }
+
+      it { should be_unauthorized }
+    end
+  end
+
+  describe '#drop_at' do
+    subject {
+      VCR.use_cassette('list_drops') {
+        @href = service.drops.items.first.href
+      }
+      VCR.use_cassette('view_drop') { service.drop_at(@href) }
+    }
+
+    it { should be_a(CloudApp::CollectionJson::Representation) }
+
+    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 '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 {
+        VCR.use_cassette('create_bookmark_with_name') {
+          service.bookmark url, name: name
+        }
+      }
+
+      it 'has the given name' do
+        subject.items.first.data['name'].should eq(name)
+      end
+    end
+
+    context 'with a privacy' do
+      subject {
+        VCR.use_cassette('create_bookmark_with_privacy') {
+          service.bookmark url, private: false
+        }
+      }
+
+      it 'is public' do
+        subject.items.first.data['private'].should eq(false)
+      end
+    end
+  end
+
+  describe '#upload' do
+    subject {
+      VCR.use_cassette('upload_file') { service.upload(favicon) }
+    }
+
+    it { should be_a(CloudApp::CollectionJson::Representation) }
+
+    it 'returns the new drop' do
+      subject.should have(1).item
+    end
+
+    context 'with a name' do
+      let(:name) { 'New File' }
+      subject {
+        VCR.use_cassette('upload_file_with_name') {
+          service.upload favicon, name: name
+        }
+      }
+
+      it 'has the given name' do
+        subject.items.first.data['name'].should eq(name)
+      end
+    end
+
+    context 'with a privacy' do
+      subject {
+        VCR.use_cassette('upload_file_with_privacy') {
+          service.upload favicon, private: false
+        }
+      }
+
+      it 'is public' do
+        subject.items.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
+end

data/spec/cloudapp/token_spec.rb

@@ -0,0 +1,33 @@
+require 'helper'
+
+require 'cloudapp/token'
+
+describe CloudApp::Token do
+  let(:service_source) { -> { service }}
+  before do CloudApp::Token.service_source = service_source end
+  after  do CloudApp::Token.service_source = nil end
+
+  describe '.for_account' do
+    let(:email)          { 'arthur@dent.com' }
+    let(:password)       { 'towel' }
+    let(:service)        { stub :service, token_for_account: representation }
+    let(:representation) { stub :representation, unauthorized?: unauthorized,
+                                                 items: [ item ]}
+    let(:unauthorized)   { false }
+    let(:item)           { stub :item, data: { 'token' => token }}
+    let(:token)          { 'token' }
+    subject { CloudApp::Token.for_account(email, password) }
+
+    it { should eq(token) }
+
+    it 'queries the drop service' do
+      service.should_receive(:token_for_account).with(email, password)
+      subject
+    end
+
+    context 'with bad credentials' do
+      let(:unauthorized) { true }
+      it { should be_nil }
+    end
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,100 @@
+require 'helper'
+require 'support/vcr'
+
+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
+
+    all_drops.should be_empty
+
+    bookmark    = create_bookmark 'http://getcloudapp.com', name: 'CloudApp'
+    file        = create_upload   path
+    public_drop = create_bookmark 'http://getcloudapp.com', private: false
+
+    all_drops.should have(3).items
+
+    bookmark_details = drop_details bookmark
+    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)
+
+    trash_drop bookmark
+    trash_drop file
+    all_drops    .should have(3).items
+    active_drops .should have(1).items
+    trashed_drops.should have(2).items
+
+    recover_drop bookmark
+    all_drops    .should have(3).items
+    active_drops .should have(2).items
+    trashed_drops.should have(1).items
+
+    limited = all_drops(limit: 1)
+    limited.should have(1).item
+
+    next_page = all_drops(href: limited.link('next').href)
+    next_page.should have(1).item
+
+    # 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
+
+    delete_drop bookmark
+    delete_drop file
+    delete_drop public_drop
+
+    all_drops.should have(0).items
+  end
+end

data/spec/support/stub_class_or_module.rb

@@ -1,3 +1,5 @@
+module Stubbed end
+
 def stub_module(full_name, &block)
   stub_class_or_module full_name, Module, &block
 end
@@ -7,13 +9,14 @@ def stub_class(full_name, &block)
 end
 
 def stub_class_or_module(full_name, kind, &block)
-  full_name.to_s.split(/::/).inject(Object) do |context, name|
+  stub = full_name.to_s.split(/::/).inject(Object) do |context, name|
     begin
       context.const_get(name)
     rescue NameError
-      context.const_set(name, kind.new)
+      stubbed = kind.new do include(Stubbed) end
+      context.const_set(name, stubbed)
     end
   end
 
-  Object.const_get(full_name).class_eval &block if block
+  stub.class_eval &block if block
 end

data/spec/support/vcr.rb

@@ -1,8 +1,24 @@
 require 'vcr'
 
-VCR.configure do |c|
-  c.cassette_library_dir     = 'spec/cassettes'
-  c.default_cassette_options = { record: :none,
-                                 match_requests_on: [ :method, :uri, :body ]}
-  c.hook_into :webmock
+VCR.configure do |vcr|
+  vcr.cassette_library_dir     = 'spec/cassettes'
+  vcr.default_cassette_options = { record: :none,
+                                   match_requests_on: [ :method, :uri, :body ]}
+  vcr.hook_into :webmock
+  vcr.configure_rspec_metadata!
+end
+
+RSpec.configure do |rspec|
+  rspec.treat_symbols_as_metadata_keys_with_true_values = true
+  rspec.before :each, integration: true do
+    VCR.configure do |vcr|
+      vcr.allow_http_connections_when_no_cassette = true
+    end
+  end
+
+  rspec.after :each, integration: true do
+    VCR.configure do |vcr|
+      vcr.allow_http_connections_when_no_cassette = false
+    end
+  end
 end