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

data/spec/cloudapp/collection_json/item_spec.rb

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

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

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

@@ -1,127 +0,0 @@
-require 'helper'
-require 'ostruct'
-
-require 'cloudapp/drop_collection'
-
-describe CloudApp::DropCollection do
-  let(:representation) { stub :representation, unauthorized?: false,
-                                               items:         items }
-  let(:service)        { stub :service }
-  let(:items)          {[ stub(:item1), stub(:item2) ]}
-  let(:drop_class)     { stub(:drop_class, new: :drop) }
-  subject { CloudApp::DropCollection.new representation, service, drop_class }
-
-  describe 'collection' do
-    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).once.
-          with(drop, kind_of(CloudApp::DropCollection))
-      end
-      subject
-    end
-  end
-
-  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 }
-    before do representation.stub(unauthorized?: unauthorized) end
-
-    it 'delegates to representation' do
-      subject.unauthorized?.should eq(unauthorized)
-    end
-  end
-
-  describe '#follow' do
-    let(:link_representation) {
-      stub :link_representation, unauthorized?: false,
-                                 items:         []
-    }
-    subject {
-      CloudApp::DropCollection.
-        new(representation, service, drop_class).
-        follow('yes')
-    }
-
-    before do
-      link = stub :link
-      link.should_receive(:follow).once.and_return(link_representation)
-      representation.should_receive(:link).once.and_return(link)
-    end
-
-    it { subject.should be_a(CloudApp::DropCollection) }
-    its(:representation) { should eq(link_representation) }
-    its(:drop_class)     { should eq(drop_class) }
-  end
-
-  describe '#has_link?' do
-    context 'with link' do
-      before do
-        representation.should_receive(:link).
-          once.
-          with('yes').
-          and_return(stub(:link))
-      end
-
-      it 'returns false' do
-        subject.has_link?('yes').should eq(true)
-      end
-    end
-
-    context 'without link' do
-      before do
-        representation.should_receive(:link).
-          once.
-          with('no').
-          and_yield
-      end
-
-      it 'returns true' do
-        subject.has_link?('no').should eq(false)
-      end
-    end
-  end
-
-  describe '#trash' do
-    it 'trashes the given drop' do
-      href = stub :href
-      service.should_receive(:trash_drop).once.with(href)
-      subject.trash stub(:drop, href: href)
-    end
-  end
-
-  describe '#recover' do
-    it 'recovers the given drop' do
-      href = stub :href
-      service.should_receive(:recover_drop).once.with(href)
-      subject.recover stub(:drop, href: href)
-    end
-  end
-
-  describe '#delete' do
-    it 'deletes the given drop' do
-      href = stub :href
-      service.should_receive(:delete_drop).once.with(href)
-      subject.delete stub(:drop, href: href)
-    end
-  end
-
-  describe '#delete'
-
-  context 'unauthorized' do
-    before do representation.stub(unauthorized?: true) end
-
-    it { should be_empty }
-  end
-end

data/spec/cloudapp/drop_spec.rb

@@ -1,142 +0,0 @@
-require 'helper'
-
-require 'cloudapp/drop'
-stub_class :DropContent
-
-describe CloudApp::Drop do
-  let(:href)  { stub :href }
-  let(:links) { [] }
-  let(:data)  { {} }
-  let(:collection) { stub :collection }
-  subject {
-    CloudApp::Drop.new stub(:drop, href: href, links: links, data: data),
-                       collection
-  }
-
-  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 '#name' do
-    let(:data) {{ name: 'Drop' }}
-    its(:name) { should eq(data[:name]) }
-
-    context 'when nil' do
-      let(:data)  {{ name: nil }}
-      let(:links) {[ stub(:link, rel: 'canonical', href: '/canonical') ]}
-
-      it 'returns the share url' do
-        subject.name.should eq('/canonical')
-      end
-    end
-  end
-
-  describe '#private?' do
-    describe 'a private drop' do
-      let(:data) {{ private: true }}
-      it { should be_private }
-    end
-
-    describe 'a public drop' do
-      let(:data) {{ private: false }}
-      it { should_not be_private }
-    end
-  end
-
-  describe '#public?' do
-    describe 'a private drop' do
-      let(:data) {{ private: true }}
-      it { should_not be_public }
-    end
-
-    describe 'a public drop' do
-      let(:data) {{ private: false }}
-      it { should be_public }
-    end
-  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 '#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')
-    ]}
-
-    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 '#embed_url' do
-    let(:links) {[
-      stub(:canonical, rel: 'canonical', href: '/canonical'),
-      stub(:embed,     rel: 'embed',     href: '/embed')
-    ]}
-    its(:embed_url) { should eq('/embed') }
-
-    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
-
-  describe '#trash' do
-    it 'trashes itself' do
-      collection.should_receive(:trash).once.with(subject)
-      subject.trash
-    end
-  end
-
-  describe '#recover' do
-    it 'recovers itself' do
-      collection.should_receive(:recover).once.with(subject)
-      subject.recover
-    end
-  end
-
-  describe '#delete' do
-    it 'deletes itself' do
-      collection.should_receive(:delete).once.with(subject)
-      subject.delete
-    end
-  end
-end