cloudapp 1.1.0 → 2.0.0.beta.1

data/spec/cloudapp/account_spec.rb

@@ -0,0 +1,166 @@
+require 'helper'
+
+require 'cloudapp/account'
+
+describe CloudApp::Account do
+  let(:args)    { stub :args }
+  let(:token)   { 'token' }
+  let(:service) { stub :service, :token= => nil }
+  let(:service_source)  { -> { service }}
+  let(:drop_collection) { stub :drop_collection }
+  before do
+    stub_class 'CloudApp::DropCollection'
+    CloudApp::Account.service_source = service_source
+    CloudApp::DropCollection.stub new: drop_collection
+  end
+
+  after do
+    CloudApp::Account.service_source = nil
+    if CloudApp::DropCollection.ancestors.include? Stubbed
+      CloudApp.send :remove_const, :DropCollection
+    end
+  end
+
+  describe '.using_token' do
+    it 'constructs and returns a new Account' do
+      CloudApp::Account.should_receive(:new).with(token)
+      CloudApp::Account.using_token(token)
+    end
+  end
+
+  describe '#drops' do
+    let(:drops)           {[ stub(:drop) ]}
+    subject { CloudApp::Account.new(token).drops(args) }
+    before do service.stub(drops: drops) end
+
+    it { should eq(drop_collection) }
+
+    it 'delegates to the drop service' do
+      service.should_receive(:drops).with(args)
+      subject
+    end
+
+    it 'creates a drop collection' do
+      CloudApp::DropCollection.should_receive(:new).with(drops)
+      subject
+    end
+  end
+
+  describe '#drop_at' do
+    let(:drop) { stub :drop }
+    subject { CloudApp::Account.new(token).drop_at(args) }
+    before do service.stub(drop_at: drop) end
+
+    it { should eq(drop_collection) }
+
+    it 'delegates to the drop service' do
+      service.should_receive(:drop_at).with(args)
+      subject
+    end
+
+    it 'creates a drop collection' do
+      CloudApp::DropCollection.should_receive(:new).with(drop)
+      subject
+    end
+  end
+
+  describe '#bookmark' do
+    let(:drop) { stub :drop }
+    subject { CloudApp::Account.new(token).bookmark(args) }
+    before do service.stub(bookmark: drop) end
+
+    it { should eq(drop_collection) }
+
+    it 'delegates to the service' do
+      service.should_receive(:bookmark).with(args)
+      subject
+    end
+
+    it 'creates a drop collection' do
+      CloudApp::DropCollection.should_receive(:new).with(drop)
+      subject
+    end
+  end
+
+  describe '#upload' do
+    let(:drop) { stub :drop }
+    subject { CloudApp::Account.new(token).upload(args) }
+    before do service.stub(upload: drop) end
+
+    it { should eq(drop_collection) }
+
+    it 'delegates to the service' do
+      service.should_receive(:upload).with(args)
+      subject
+    end
+
+    it 'creates a drop collection' do
+      CloudApp::DropCollection.should_receive(:new).with(drop)
+      subject
+    end
+  end
+
+  describe '#update' do
+    let(:drop) { stub :drop }
+    subject { CloudApp::Account.new(token).update(args) }
+    before do service.stub(update: drop) end
+
+    it { should eq(drop_collection) }
+
+    it 'delegates to the drop service' do
+      service.should_receive(:update).with(args)
+      subject
+    end
+
+    it 'creates a drop collection' do
+      CloudApp::DropCollection.should_receive(:new).with(drop)
+      subject
+    end
+  end
+
+  describe '#trash_drop' do
+    let(:drop) { stub :drop }
+    subject { CloudApp::Account.new(token).trash_drop(args) }
+    before do service.stub(trash_drop: drop) end
+
+    it { should eq(drop_collection) }
+
+    it 'delegates to the service' do
+      service.should_receive(:trash_drop).with(args)
+      subject
+    end
+
+    it 'creates a drop collection' do
+      CloudApp::DropCollection.should_receive(:new).with(drop)
+      subject
+    end
+  end
+
+  describe '#recover_drop' do
+    let(:drop) { stub :drop }
+    subject { CloudApp::Account.new(token).recover_drop(args) }
+    before do service.stub(recover_drop: drop) end
+
+    it { should eq(drop_collection) }
+
+    it 'delegates to the service' do
+      service.should_receive(:recover_drop).with(args)
+      subject
+    end
+
+    it 'creates a drop collection' do
+      CloudApp::DropCollection.should_receive(:new).with(drop)
+      subject
+    end
+  end
+
+  describe '#delete_drop' do
+    it 'delegates to the service' do
+      service.should_receive(:delete_drop).with(args)
+      CloudApp::Account.new.delete_drop(args)
+    end
+  end
+
+  describe '#download' do
+  end
+end

data/spec/cloudapp/authorized_representation_spec.rb

@@ -0,0 +1,32 @@
+require 'helper'
+
+require 'cloudapp/authorized_representation'
+
+describe CloudApp::AuthorizedRepresentation do
+  let(:representation) { stub :representation, __response__: response }
+  let(:response)       { stub :response, status: status }
+  let(:status)         { 200 }
+  let(:href) { stub }
+  subject    { representation }
+  before do
+    representation.extend CloudApp::AuthorizedRepresentation
+  end
+
+  describe '#authorized?' do
+    it { should be_authorized }
+
+    context 'unauthorized status' do
+      let(:status) { 401 }
+      it { should_not be_authorized }
+    end
+  end
+
+  describe '#unauthorized?' do
+    it { should_not be_unauthorized }
+
+    context 'unauthorized status' do
+      let(:status) { 401 }
+      it { should be_unauthorized }
+    end
+  end
+end

data/spec/cloudapp/collection_json/item_spec.rb

@@ -0,0 +1,45 @@
+require 'helper'
+
+require 'cloudapp/collection_json/item'
+
+describe CloudApp::CollectionJson::Item do
+  let(:item_data) {{ 'data' => [] }}
+  subject    { CloudApp::CollectionJson::Item.new item_data }
+
+  its(:href)  { should be_nil }
+  its(:links) { should be_empty }
+  its(:data)  { should be_empty }
+
+  context 'with an href' do
+    let(:href) { stub :href }
+    before do item_data['href'] = href end
+    its(:href) { should eq(href) }
+  end
+
+  context 'with links' do
+    let(:links) {[
+      { 'rel'  => 'canonical', 'href'  => 'link1' },
+      { 'rel'  => 'alternate', 'href'  => 'link2' }
+    ]}
+    before do item_data['links'] = links end
+
+    its(:links) { should have(2).items }
+
+    it 'presents links' do
+      subject.links.find {|link| link.rel == 'canonical' }.
+        href.should eq('link1')
+      subject.links.find {|link| link.rel == 'alternate' }.
+        href.should eq('link2')
+    end
+  end
+
+  context 'with data' do
+    let(:data) {[
+      { 'name' => 'attr1', 'value' => 'value1' },
+      { 'name' => 'attr2', 'value' => 'value2' }
+    ]}
+    before do item_data['data'] = data end
+
+    its(:data) { should eq('attr1' => 'value1', 'attr2' => 'value2') }
+  end
+end

data/spec/cloudapp/collection_json/representation_spec.rb

@@ -0,0 +1,118 @@
+require 'helper'
+
+require 'cloudapp/collection_json/representation'
+
+describe CloudApp::CollectionJson::Representation do
+  let(:response)       { stub :response, status: status }
+  let(:status)         { 200 }
+  let(:representation) {{
+    'collection' => {
+      'href'  => href,
+      'items' => []
+    }
+  }}
+  let(:href) { stub }
+  subject    { representation }
+  before do
+    representation.extend CloudApp::CollectionJson::Representation
+    representation.stub __response__: response
+  end
+
+  its(:href) { should eq(href) }
+
+  describe '#collection_links' do
+    its(:collection_links) { should be_empty }
+
+    context 'with collection links' do
+      let(:links) {[
+        { 'rel' => 'next', 'href' => '/next' },
+        { 'rel' => 'prev', 'href' => '/prev' }
+      ]}
+      before do representation['collection']['links'] = links end
+
+      its(:collection_links) { should have(2).items }
+
+      it 'presents links' do
+        subject.collection_links.find {|link| link.rel == 'next' }.
+          href.should eq('/next')
+        subject.collection_links.find {|link| link.rel == 'prev' }.
+          href.should eq('/prev')
+      end
+    end
+  end
+
+  describe '#items' do
+    it 'is empty' do
+      subject.items(stub(:item_source)).should be_empty
+    end
+
+    context 'with items' do
+      let(:items)       {[ stub(:item1),      stub(:item2) ]}
+      let(:item_data)   {[ stub(:item_data1), stub(:item_data2) ]}
+      let(:item_source) { ->(item) {
+        if item == item_data[0]
+          items[0]
+        elsif item == item_data[1]
+          items[1]
+        end
+      }}
+      before do representation['collection']['items'] = item_data end
+
+      it 'should have items' do
+        subject.items(item_source).should eq(items)
+      end
+    end
+  end
+
+  describe '#templates' do
+    it 'is nil' do
+      subject.template(stub(:template_source)).should be_nil
+    end
+
+    context 'with a template' do
+      let(:template)        { stub :template }
+      let(:template_data)   { stub :template_data }
+      let(:template_source) { ->(item) { template if item == template_data }}
+      before do representation['collection']['template'] = template_data end
+
+      it 'finds the template' do
+        subject.template(template_source).should eq(template)
+      end
+    end
+  end
+
+  describe '#queries' do
+    it 'is nil' do
+      subject.queries(stub(:query_source)).should be_nil
+    end
+
+    context 'with queries' do
+      let(:queries)      {[ stub(:query1),      stub(:query2) ]}
+      let(:query_data)   {[ stub(:query_data1), stub(:query_data2) ]}
+      let(:query_source) { ->(query) { queries.at(query_data.index(query)) }}
+      before do representation['collection']['queries'] = query_data end
+
+      it 'should have queries' do
+        subject.queries(query_source).should eq(queries)
+      end
+    end
+  end
+
+  describe '#query' do
+    it 'is nil' do
+      subject.query('rel', stub(:query_source)).should be_nil
+    end
+
+    context 'with queries' do
+      let(:queries)      {[ stub(:query1, rel: 'one'),
+                            stub(:query2, rel: 'two') ]}
+      let(:query_data)   {[ stub(:query_data1), stub(:query_data2) ]}
+      let(:query_source) { ->(query) { queries.at(query_data.index(query)) }}
+      before do representation['collection']['queries'] = query_data end
+
+      it 'finds the query by rel' do
+        subject.query('one', query_source).should eq(queries.first)
+      end
+    end
+  end
+end

data/spec/cloudapp/collection_json/template_spec.rb

@@ -0,0 +1,53 @@
+require 'helper'
+require 'cloudapp/collection_json/item'
+
+require 'cloudapp/collection_json/template'
+
+describe CloudApp::CollectionJson::Template do
+  let(:template_data) {{ 'data' => [] }}
+  subject { CloudApp::CollectionJson::Template.new template_data }
+
+  its(:rel)     { should be_nil }
+  its(:enctype) { should be_nil }
+
+
+  context 'with a rel' do
+    let(:rel) { stub :rel }
+    before do template_data['rel'] = rel end
+
+    its(:rel) { should eq(rel) }
+  end
+
+  context 'with an encoding type' do
+    let(:enctype) { stub :enctype }
+    before do template_data['enctype'] = enctype end
+
+    its(:enctype) { should eq(enctype) }
+  end
+
+  describe '#fill' do
+    let(:email) { 'arthur@dent.com' }
+    let(:template_data) {{
+      'data' => [
+        { 'name' => 'email', 'value' => '' },
+        { 'name' => 'age',   'value' => 29 }
+      ]
+    }}
+
+    it 'returns a filled template' do
+      expected = { 'email' => email, 'age' => 29 }
+      subject.fill('email' => email).should eq(expected)
+    end
+
+    it 'leaves data untouched' do
+      subject.fill('email' => email)
+      subject.data.should eq('email' => '', 'age' => 29)
+    end
+
+    it 'ignores attributes not in the template' do
+      expected = { 'email' => email, 'age' => 29 }
+      new_data = { 'email' => email, 'ignore' => 'me' }
+      subject.fill(new_data).should eq(expected)
+    end
+  end
+end

data/spec/cloudapp/drop_collection_spec.rb

@@ -0,0 +1,63 @@
+require 'helper'
+require 'ostruct'
+
+require 'cloudapp/drop_collection'
+
+describe CloudApp::DropCollection do
+  let(:representation) { stub :representation, unauthorized?: unauthorized,
+                                               items: items }
+  let(:unauthorized)   { nil }
+  let(:items)          {[ stub(:item1), stub(:item2) ]}
+  let(:drop_class)     { stub(:drop_class, new: nil) }
+  subject { CloudApp::DropCollection.new representation, drop_class }
+
+  describe '#authorized?' do
+    let(:authorized) { stub :authorized }
+    before do representation.stub(authorized?: authorized) end
+
+    it 'delegates to representation' do
+      subject.authorized?.should eq(authorized)
+    end
+  end
+
+  describe '#unauthorized?' do
+    let(:unauthorized) { stub :unauthorized }
+
+    it 'delegates to representation' do
+      subject.unauthorized?.should eq(unauthorized)
+    end
+  end
+
+  describe '#link' do
+    it 'delegates to representation' do
+      args = stub :args
+      representation.should_receive(:link).with(args)
+      subject.link(args)
+    end
+  end
+
+  describe '#links' do
+    it 'delegates to representation' do
+      args = stub :args
+      representation.should_receive(:links).with(args)
+      subject.links(args)
+    end
+  end
+
+  it 'is a collection of drops' do
+    subject.size.should eq(2)
+  end
+
+  it 'decodes each drop' do
+    items.each do |drop|
+      drop_class.should_receive(:new).with(drop)
+    end
+    subject
+  end
+
+  context 'unauthorized' do
+    let(:unauthorized) { stub :unauthorized }
+
+    it { should be_empty }
+  end
+end

data/spec/cloudapp/drop_spec.rb

@@ -4,86 +4,116 @@ require 'cloudapp/drop'
 stub_class :DropContent
 
 describe CloudApp::Drop do
-  describe '#display_name' do
-    describe 'a drop with a name' do
-      let(:name) { stub :name }
-      subject    { CloudApp::Drop.new name: name }
-
-      it 'is its name' do
-        subject.display_name.should eq(name)
-      end
+  let(:href)  { stub :href }
+  let(:links) { [] }
+  let(:data)  { {} }
+  subject {
+    CloudApp::Drop.new stub(:drop, href: href, links: links, data: data)
+  }
+
+  its(:href) { should eq(href) }
+
+  describe '#data' do
+    let(:data) {{ name: 'Drop' }}
+    its(:data) { should eq(data) }
+
+    context 'with string keys' do
+      let(:data) {{ 'name' => 'Drop' }}
+      its(:data) { should eq(data) }
     end
+  end
 
-    describe 'a drop with a redirect url and no a name' do
-      let(:redirect_url) { stub :redirect_url }
-      subject { CloudApp::Drop.new redirect_url: redirect_url }
+  describe '#name' do
+    let(:data) {{ name: 'Drop' }}
+    its(:name) { should eq(data[:name]) }
 
-      it 'is its redirect url' do
-        subject.display_name.should eq(redirect_url)
-      end
-    end
-
-    describe 'a drop with no redirect url and name' do
-      let(:url) { stub :url }
-      subject   { CloudApp::Drop.new url: url }
+    context 'when nil' do
+      let(:data)  {{ name: nil }}
+      let(:links) {[ stub(:link, rel: 'canonical', href: '/canonical') ]}
 
-      it 'is its remote url' do
-        subject.display_name.should eq(url)
+      it 'returns the share url' do
+        subject.name.should eq('/canonical')
       end
     end
   end
 
   describe '#private?' do
     describe 'a private drop' do
-      subject { CloudApp::Drop.new private: true }
-
-      it 'is true' do
-        subject.private?.should eq(true)
-      end
+      let(:data) {{ private: true }}
+      it { should be_private }
     end
 
     describe 'a public drop' do
-      subject { CloudApp::Drop.new private: false }
-
-      it 'is false' do
-        subject.private?.should eq(false)
-      end
+      let(:data) {{ private: false }}
+      it { should_not be_private }
     end
   end
 
   describe '#public?' do
     describe 'a private drop' do
-      subject { CloudApp::Drop.new private: true }
-
-      it 'is false' do
-        subject.public?.should eq(false)
-      end
+      let(:data) {{ private: true }}
+      it { should_not be_public }
     end
 
     describe 'a public drop' do
-      subject { CloudApp::Drop.new private: false }
+      let(:data) {{ private: false }}
+      it { should be_public }
+    end
+  end
 
-      it 'is true' do
-        subject.public?.should eq(true)
-      end
+  describe '#created' do
+    let(:data) {{ created: '2012-04-01T00:00:00Z' }}
+    it 'parses date' do
+      expected = DateTime.new(2012, 4, 1)
+      subject.created.should eq(expected)
     end
   end
 
-  describe '#has_content?' do
-    describe 'an image' do
-      subject { CloudApp::Drop.new item_type: 'image' }
+  describe '#share_url' do
+    let(:links) {[
+      stub(:canonical, rel: 'canonical', href: '/canonical'),
+      stub(:alternate, rel: 'alternate', href: '/alternate')
+    ]}
+    its(:share_url) { should eq('/canonical') }
+  end
+
+  describe '#thumbnail_url' do
+    let(:links) {[
+      stub(:canonical, rel: 'canonical', href: '/canonical'),
+      stub(:icon,      rel: 'icon',      href: '/icon')
+    ]}
 
-      it 'is true' do
-        subject.has_content?.should eq(true)
-      end
+    its(:thumbnail_url) { should eq('/icon') }
+
+    context 'without an icon link' do
+      let(:links) {[ stub(:canonical, rel: 'canonical', href: '/canonical') ]}
+      its(:thumbnail_url) { should be_nil }
     end
+  end
 
-    describe 'a bookmark' do
-      subject { CloudApp::Drop.new item_type: 'bookmark' }
+  describe '#embed_url' do
+    let(:links) {[
+      stub(:canonical, rel: 'canonical', href: '/canonical'),
+      stub(:embed,     rel: 'embed',     href: '/embed')
+    ]}
+    its(:embed_url) { should eq('/embed') }
 
-      it 'is false' do
-        subject.has_content?.should eq(false)
-      end
+    context 'without an embed link' do
+      let(:links) {[ stub(:canonical, rel: 'canonical', href: '/canonical') ]}
+      its(:embed_url) { should be_nil }
+    end
+  end
+
+  describe '#download_url' do
+    let(:links) {[
+      stub(:canonical, rel: 'canonical', href: '/canonical'),
+      stub(:download,  rel: 'download',  href: '/download')
+    ]}
+    its(:download_url) { should eq('/download') }
+
+    context 'without an download link' do
+      let(:links) {[ stub(:canonical, rel: 'canonical', href: '/canonical') ]}
+      its(:download_url) { should be_nil }
     end
   end
 end