cloudapp 2.0.0.beta.4 → 2.0.0.beta.5

data/spec/cloudapp/service_spec.rb

@@ -1,335 +0,0 @@
-require 'helper'
-require 'support/vcr'
-
-require 'cloudapp/service'
-
-describe CloudApp::Service do
-  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').each do |drop|
-        service.delete_drop(drop.href)
-      end
-    end
-  end
-
-  describe '.token_for_account' do
-    subject {
-      VCR.use_cassette('token_for_account') {
-        CloudApp::Service.token_for_account email, password
-      }
-    }
-
-    it 'returns the token' do
-      subject.should be_a(String)
-      subject.should eq(token)
-    end
-
-    context 'with bad credentials' do
-      let(:password) { 'wrong' }
-      subject {
-        VCR.use_cassette('token_for_account_with_bad_credentials') {
-          CloudApp::Service.token_for_account email, password
-        }
-      }
-
-      it 'returns nothing' do
-        subject.should be_nil
-      end
-    end
-  end
-
-  describe '#account_token' do
-    subject {
-      VCR.use_cassette('account_token') {
-        CloudApp::Service.new.account_token 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.account_token email, password
-        }
-      }
-
-      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
-
-    it { should be_a(CloudApp::DropCollection) }
-
-    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 { should be_a(CloudApp::DropCollection) }
-
-      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 { should be_a(CloudApp::DropCollection) }
-
-      it 'limits drops' 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_a(CloudApp::DropCollection) }
-      it { should be_unauthorized }
-    end
-  end
-
-  describe '#drop' do
-    subject {
-      VCR.use_cassette('list_drops') {
-        @href = service.drops.first.href
-      }
-      VCR.use_cassette('view_drop') { service.drop(@href) }
-    }
-
-    it { should be_a(CloudApp::DropCollection) }
-
-    it 'returns a drop' do
-      subject.should have(1).item
-    end
-  end
-
-  describe '#bookmark' do
-    let(:url) { 'http://getcloudapp.com' }
-    subject {
-      VCR.use_cassette('create_bookmark') { service.bookmark(url) }
-    }
-
-    it { should be_a(CloudApp::DropCollection) }
-
-    it 'returns the new drop' do
-      subject.should have(1).item
-    end
-
-    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.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.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::DropCollection) }
-
-    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.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.first.data['private'].should eq(false)
-      end
-    end
-
-    describe 'too large file'
-  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/helper.rb

@@ -1,8 +0,0 @@
-require 'support/stub_class_or_module'
-require 'English'
-
-root = File.expand_path('../..', __FILE__)
-$LOAD_PATH.unshift(File.expand_path('app/models', root))
-$LOAD_PATH.unshift(File.expand_path('app/controllers', root))
-$LOAD_PATH.unshift(File.expand_path('app/helpers', root))
-$LOAD_PATH.unshift(File.expand_path('lib', root))

data/spec/integration_spec.rb

@@ -1,68 +0,0 @@
-require 'helper'
-require 'support/vcr'
-
-require 'cloudapp'
-
-describe CloudApp, :integration do
-  let(:path) { Pathname('../support/files/favicon.ico').expand_path(__FILE__) }
-
-  it 'integrates with the API' do
-    token = CloudApp::Service.token_for_account 'arthur@dent.com', 'towel'
-    token.should =~ /\w+/
-
-    service = CloudApp::Service.using_token token
-    service.drops(filter: 'all').each(&:delete)
-    service.drops(filter: 'all').should be_empty
-
-    bookmark    = service.bookmark('http://getcloudapp.com', name: 'CloudApp').first
-    file        = service.upload(path).first
-    public_drop = service.bookmark('http://getcloudapp.com', private: false).first
-
-    service.drops(filter: 'all').should have(3).items
-
-    bookmark_details = service.drop(bookmark.href).first
-    bookmark_details.name   .should eq('CloudApp')
-    bookmark_details.private.should eq(true)
-
-    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
-
-    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
-
-    page1 = service.drops(filter: 'all', limit: 1)
-    page1.should have(1).item
-
-    page2 = page1.follow 'next'
-    page2.should have(1).item
-
-    page3 = page2.follow 'next'
-    page3.should have(1).item
-    page3.has_link?('next').should eq(false)
-
-    page2 = page3.follow 'previous'
-    page2.should have(1).item
-
-    page1 = page2.follow 'previous'
-    page1.should have(1).item
-    page1.has_link?('previous').should eq(false)
-
-    bookmark   .delete
-    file       .delete
-    public_drop.delete
-    service.drops(filter: 'all').should be_empty
-  end
-end

data/spec/support/stub_class_or_module.rb

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

data/spec/support/vcr.rb

@@ -1,24 +0,0 @@
-require 'vcr'
-
-VCR.configure do |vcr|
-  vcr.cassette_library_dir     = 'spec/cassettes'
-  vcr.default_cassette_options = { record: :once,
-                                   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