uploadcare-ruby 1.2.2 → 2.0.0

data/spec/api/group_list_api_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Uploadcare::GroupListApi do
+  let(:api){ API }
+  subject{ api.group_list(limit: 1) }
+
+  before(:each){ allow(api).to receive(:get){ {'results' => []} } }
+
+  it 'returns a group list' do
+    expect( subject ).to be_a(Uploadcare::Api::GroupList)
+  end
+
+  it 'stores options in a group list object' do
+    expect( subject.options ).to eq({limit: 1})
+  end
+
+  describe 'validation' do
+    it 'passes validation when no options given' do
+      expect{ api.group_list }.not_to raise_error
+    end
+
+    it "validates that options don't have unsupported keys" do
+      expect{ api.group_list(unknown: 1) }.to raise_error(ArgumentError)
+    end
+
+    it 'validates that :limit is an integer from 1 to 1000' do
+      [1, 359, 1000].each do |v|
+        expect{ api.group_list(limit: v) }.not_to raise_error
+      end
+
+      [1.0, -1, 0, 1001, false].each do |v|
+        expect{ api.group_list(limit: v) }.to raise_error(ArgumentError)
+      end
+    end
+
+    valid_ordering = %w{datetime_created -datetime_created}
+    it "validates that :ordering is in [#{valid_ordering.join(', ')}]" do
+      valid_ordering.each do |valid_value|
+        expect{ api.group_list(ordering: valid_value) }.not_to raise_error
+      end
+
+      expect{ api.group_list(ordering: 'yes') }.to raise_error(ArgumentError)
+    end
+
+    describe 'from' do
+      it 'validates that :from.to_s is a iso8601 string' do
+        valid = [DateTime.now, DateTime.now.iso8601, "2017-01-01T15"]
+        valid.each do |value|
+          expect{ api.group_list(from: value) }.not_to raise_error
+        end
+
+        invalid = [Date.today, Time.now, DateTime.now.rfc2822, "2017-01-01", 123, false]
+        invalid.each do |value|
+          expect{ api.group_list(from: value) }.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+end

data/spec/api/raw_api_spec.rb

@@ -3,23 +3,23 @@ require 'uri'
 require 'socket'
 
 describe Uploadcare::Api do
-  before :each do
-    @api = Uploadcare::Api.new(CONFIG)
-  end
+  subject(:api) { Uploadcare::Api.new(CONFIG) }
 
   it "should initialize api" do
-    @api.should be_an_instance_of(Uploadcare::Api)
+    is_expected.to be_an_instance_of(Uploadcare::Api)
   end
 
   it 'should respond to request methods' do
-    @api.should respond_to :request
-    @api.should respond_to :get
-    @api.should respond_to :post
-    @api.should respond_to :put
-    @api.should respond_to :delete
+    is_expected.to respond_to :request
+    is_expected.to respond_to :get
+    is_expected.to respond_to :post
+    is_expected.to respond_to :put
+    is_expected.to respond_to :delete
   end
 
-  it 'should perform custom requests' do
-    expect { @api.request }.to_not raise_error
+  context 'when performing requests' do
+    subject(:request) { api.request }
+
+    it { is_expected.to be_a Hash }
   end
-end
+end

data/spec/api/uploading_api/upload_params_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe Uploadcare::UploadingApi::UploadParams do
+  shared_examples 'handles store flag' do |key_name|
+    let(:true_value) { 1 }
+    let(:false_value) { 0 }
+
+    context 'when neither global nor per-request store option is set' do
+      it { is_expected.not_to include(key_name) }
+    end
+
+    context 'accepts :auto value in :store option' do
+      before { request_options.merge!(store: :auto) }
+      it { is_expected.to include(key_name => 'auto') }
+    end
+
+    context 'when only global :autostore option is set' do
+      context 'to true' do
+        before { global_options.merge!(autostore: true) }
+        it { is_expected.to include(key_name => true_value) }
+      end
+
+      context 'to false' do
+        before { global_options.merge!(autostore: false) }
+        it { is_expected.to include(key_name => false_value) }
+      end
+    end
+
+    context 'per-request :store option is set' do
+      context 'to true' do
+        before { request_options.merge!(store: true) }
+        it { is_expected.to include(key_name => true_value) }
+      end
+
+      context 'to false' do
+        before { request_options.merge!(store: false) }
+        it { is_expected.to include(key_name => false_value) }
+      end
+    end
+
+    context 'when both global and per-request store options are set' do
+      before do
+        global_options.merge!(autostore: false)
+        request_options.merge!(store: true)
+      end
+
+      it 'per-request :store option has higher presidence' do
+        is_expected.to include(key_name => true_value)
+      end
+    end
+  end
+
+  let(:global_options) { {public_key: 'test_public_key'} }
+  let(:request_options) { {} }
+
+  describe '#for_url_upload' do
+    let(:url) { 'http://example.com/image.jpg' }
+    subject(:upload_params) do
+      described_class.new(global_options, request_options).for_url_upload(url)
+    end
+
+    it { is_expected.to include(source_url: URI.parse(url)) }
+    it { is_expected.to include(pub_key: 'test_public_key') }
+    it_behaves_like 'handles store flag', :store
+
+    context 'works with https URLs' do
+      let(:url) { 'https://example.com/image.jpg' }
+      it { expect { upload_params }.not_to raise_error }
+    end
+
+    context 'if url is not http/https' do
+      let(:url) { 'ftp://example.com/image.jpg' }
+      it { expect { upload_params }.to raise_error(ArgumentError) }
+    end
+  end
+
+  describe '#for_file_upload' do
+    let(:files) { FILES_ARY } # contains 2 files, first is png, second is jpg
+    subject(:upload_params) do
+      described_class.new(global_options, request_options).for_file_upload(files)
+    end
+
+    it { is_expected.to include(UPLOADCARE_PUB_KEY: 'test_public_key') }
+    it_behaves_like 'handles store flag', :UPLOADCARE_STORE
+
+    context 'file params' do
+      subject(:file_params) { upload_params.select { |k, _| k =~ /^file\[\d+\]/ }.values }
+
+      it { expect(file_params.size).to eq(files.size) }
+      it { is_expected.to all(be_a(Faraday::UploadIO)) }
+      it { is_expected.to all(satisfy { |file| file.content_type =~ /image\/(png|jpeg)/}) }
+    end
+
+    context 'when any of given objects is not a File' do
+      let(:files) { FILES_ARY + ['not a File'] }
+      it { expect {upload_params}.to raise_error(ArgumentError) }
+    end
+  end
+end

data/spec/api/uploading_api_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Uploadcare::Api do
+  shared_examples 'respects :store option' do
+    context 'respects :store option' do
+      let(:upload_options) { {store: store} }
+      subject { Array(uploaded).map(&:load_data) }
+
+      context 'when :store option is true' do
+        let(:store) { true }
+        it { is_expected.to all(be_stored) }
+      end
+
+      define_negated_matcher :be_not_stored, :be_stored
+      context 'when :store option is false' do
+        let(:store) { false }
+        it { is_expected.to all(be_not_stored) }
+      end
+    end
+  end
+
+  let(:api) { API }
+  let(:upload_options) { {} }
+
+  context 'when uploading single object' do
+    subject(:uploaded) { api.upload(object, upload_options) }
+
+    context 'when uploading a file' do
+      let(:object) { FILE1 }
+
+      it { is_expected.to be_a(Uploadcare::Api::File) }
+      it { is_expected.to have_attributes(uuid: match(UUID_REGEX)) }
+      include_examples 'respects :store option'
+    end
+
+    context 'when uploading from url' do
+      let(:object) { IMAGE_URL }
+
+      it { is_expected.to be_a(Uploadcare::Api::File) }
+      it { is_expected.to have_attributes(uuid: match(UUID_REGEX)) }
+      it { expect { api.upload('invalid.url.') }.to raise_error(ArgumentError) }
+      include_examples 'respects :store option'
+    end
+  end
+
+  context 'when loading multiple objects' do
+    before(:all) { @uploaded_files = API.upload(FILES_ARY) }
+    subject(:uploaded) { @uploaded_files.dup }
+
+    it { is_expected.to be_a(Array) }
+    it { is_expected.to all(be_a(Uploadcare::Api::File)) }
+    it { is_expected.to all(have_attributes(uuid: match(UUID_REGEX))) }
+    it { expect { uploaded.map(&:load_data) }.not_to raise_error }
+  end
+
+  context 'when given object is not a File, Array or String' do
+    it { expect { api.upload(12) }.to raise_error(ArgumentError) }
+  end
+end

data/spec/resources/file_list_spec.rb

@@ -1,64 +1,25 @@
 require 'spec_helper'
-require 'uri'
-require 'socket'
 
-describe Uploadcare::Api::File do
+describe Uploadcare::Api::FileList do
   before :all do
     @api = API
-    @list = @api.file_list 1
-  end
-
-  it "should return file list" do
-    @list.should be_kind_of(Uploadcare::Api::FileList)
-  end
-
-  it "should respont to results method" do
-    @list.should respond_to :results
-  end
 
-  it "results should be an array" do
-    @list.results.should be_kind_of(Array)
-  end
+    # ensure that current project has at least three files
+    count = @api.get('/files/', limit: 3)['results'].size
+    (3 - count).times{ @api.upload(IMAGE_URL) } if count < 3
 
-  it "resulst should be UC files" do
-    @list.results.each do |file|
-      file.should be_kind_of(Uploadcare::Api::File)
-    end
+    @list = @api.file_list(limit: 1)
   end
 
-  it "results should be not only files, but loaded files" do
-    @list.results.each do |file|
-      file.is_loaded?.should be true
-    end
-  end
+  let(:resource_class){ Uploadcare::Api::File }
+  subject{ @list }
 
-  it "should load next page" do
-    next_page = @list.next_page
-    next_page.should be_kind_of(Uploadcare::Api::FileList)
-  end
+  it_behaves_like 'resource list'
 
-  it "should load prev page" do
-    list =  @api.file_list 3
-    prev_page = list.previous_page
-    prev_page.should be_kind_of(Uploadcare::Api::FileList)
-  end
-
-  it "should load custom page" do
-    page = @list.go_to(@list.pages - 1)
-    page.should be_kind_of(Uploadcare::Api::FileList)
-  end
-
-  it "should not load next page if there isn't one" do
-    page= @list.go_to @list.pages
-    page.next_page.should be_nil
-  end
-
-  it "should not load prev page if there isn't one" do
-    @list.previous_page.should be_nil
-  end
+  describe '#objects' do
+    subject{ @list.objects }
 
-  it "should not load custom page with index more than there is actually page in project" do
-    page = @list.go_to @list.pages + 3
-    page.should be_nil
+    it{ is_expected.to all(be_a(resource_class)) }
+    it{ is_expected.to all(be_loaded) }
   end
-end
+end

data/spec/resources/file_spec.rb

@@ -48,9 +48,10 @@ describe Uploadcare::Api::File do
 
   it 'should be able to tell thenever file was stored' do
     @file.load
-    @file.is_stored?.should == false
-    @file.store
-    @file.is_stored?.should == true
+    expect(@file.stored?).to be(true)
+    wait_until_ready(@file)
+    @file.delete
+    expect(@file.stored?).to be(false)
   end
 
   it 'should delete itself' do
@@ -60,6 +61,7 @@ describe Uploadcare::Api::File do
   it 'should be able to tell thenever file was deleted' do
     @file.load
     @file.is_deleted?.should == false
+    wait_until_ready(@file)
     @file.delete
     @file.is_deleted?.should == true
   end
@@ -96,6 +98,7 @@ describe Uploadcare::Api::File do
 
   it 'should respond to datetime_removed' do
     @file.load
+    wait_until_ready(@file)
     @file.delete
     @file.datetime_removed.should be_kind_of(DateTime)
     @file.datetime_deleted.should be_kind_of(DateTime)

data/spec/resources/group_list_spec.rb

@@ -1,30 +1,25 @@
 require 'spec_helper'
-require 'uri'
-require 'socket'
 
-describe Uploadcare::Api::File do
+describe Uploadcare::Api::GroupList do
   before :all do
     @api = API
-    @list = @api.group_list
-  end
 
-  it "basic group list" do
-    @list.should be_kind_of Uploadcare::Api::GroupList
-  end
+    # ensure that current project has at least three groups
+    count = @api.get('/groups/', limit: 3)['results'].size
+    (3 - count).times{ @api.create_group([@api.upload(IMAGE_URL)]) } if count < 3
 
-  it "should contain groups and results" do
-    @list.should respond_to(:results)
-    @list.should respond_to(:groups)
-    @list.groups.should be_kind_of(Array)
+    @list = @api.group_list(limit: 1)
   end
 
-  it "results should contain groups" do
-    group = @list.groups.sample
-    group.should be_kind_of(Uploadcare::Api::Group)
-  end
+  let(:resource_class){ Uploadcare::Api::Group }
+  subject{ @list }
+
+  it_behaves_like 'resource list'
+
+  describe '#objects' do
+    subject{ @list.objects }
 
-  it "group should no be loaded" do
-    group = @list.groups.sample
-    group.is_loaded?.should == false
+    it{ is_expected.to all(be_a(resource_class)) }
+    it{ is_expected.not_to include(be_loaded) }
   end
-end
+end

data/spec/rest/api_connection_spec.rb

@@ -19,7 +19,7 @@ describe Uploadcare::Connections::ApiConnection do
     end
 
     it 'includes correct User-Agent header' do
-      expected = Uploadcare::UserAgent.new.call(settings)
+      expected = Uploadcare::user_agent(settings)
       expect(subject['User-Agent']).to eq expected
     end
   end

data/spec/shared/resource_list.rb

@@ -0,0 +1,188 @@
+require 'spec_helper'
+
+shared_examples 'resource list' do
+  describe '#options' do
+    subject{ @list.options }
+
+    it{ is_expected.to be_a(Hash) }
+    it{ is_expected.to be_frozen }
+
+    it 'stores options' do
+      expect( subject ).to eq(limit: 1)
+    end
+  end
+
+  describe '#meta' do
+    subject{ @list.meta }
+
+    it{ is_expected.to be_a(Hash) }
+    it{ is_expected.to be_frozen }
+  end
+
+  describe '#total' do
+    subject{ @list.total }
+
+    it{ is_expected.to be_an(Integer) }
+
+    it 'returns a "total" value from metadata' do
+      expect( subject ).to eq @list.meta["total"]
+    end
+  end
+
+  describe '#loaded' do
+    subject{ @list.loaded }
+
+    it{ is_expected.to be_an(Integer) }
+
+    it 'contains currently loaded objects count' do
+      size = rand(2..10)
+      allow(@list).to receive(:objects){ Array.new(size) }
+
+      expect( subject ).to eq(size)
+    end
+  end
+
+  describe '#fully_loaded?' do
+    subject{ @list.fully_loaded? }
+
+    context 'if there is no more next pages left' do
+      before { allow(@list).to receive(:meta){ {"next" => nil} } }
+      it { is_expected.to be_truthy }
+    end
+
+    context 'if there is a next page' do
+      before { allow(@list).to receive(:meta){ {"next" => 'example.com'} } }
+      it { is_expected.to be_falsey }
+    end
+  end
+
+  describe '#each' do
+    it 'when called without a block, returns an Enumerator' do
+      expect( subject.each ).to be_an(Enumerator)
+    end
+
+    it 'when called with a block, returns self' do
+      allow(subject).to receive(:meta){ {"next" => nil} }
+      expect( subject.each{|o| nil } ).to eq(subject)
+    end
+
+    it 'when called with a break inside a block, returns nil' do
+      expect( subject.each{|o| break } ).to be_nil
+    end
+  end
+
+  describe '#[]' do
+    subject{ @list.dup }
+
+    it "returns instances of a resource class" do
+      expect( subject[0] ).to be_a(resource_class)
+    end
+
+    it 'loads additional objects when needed' do
+      expect(@api).to receive(:get)
+        .with(subject.meta["next"]).and_call_original
+
+      expect { subject[1] }.to change { subject.objects.size }.by(1)
+    end
+  end
+
+  describe 'enumerable interface' do
+    subject{ @list.dup }
+
+    it 'is an Enumerable' do
+      expect( subject ).to be_an(Enumerable)
+    end
+
+    it 'iterates through objects' do
+      i, uuids = 0, []
+      subject.each{|object| uuids << object.uuid; i+=1; break if i >= 2 }
+
+      expect(uuids).to eq([subject[0].uuid, subject[1].uuid])
+    end
+
+    it 'loads additional objects when needed' do
+      expect(@api).to receive(:get)
+        .with(subject.meta["next"]).and_call_original
+
+      objects = subject.first(2)
+
+      expect(objects.size).to eq(2)
+    end
+
+    it 'doesn\'t load more objects than needed' do
+      expect(@api).to receive(:get).once.and_call_original
+
+      objects = subject.first(2)
+
+      expect(objects.size).to eq(2)
+    end
+
+    it "loads different objects" do
+      expect(@api).to receive(:get)
+        .with(subject.meta["next"]).and_call_original
+
+      objects = subject.first(2)
+
+      expect(objects[0].uuid).not_to eq(objects[1].uuid)
+    end
+
+    it 'stops loading objects when no objects left' do
+      allow(@api).to receive(:get).and_wrap_original do |m, *args|
+        m.call(*args).tap{|data| data["next"] = nil}
+      end
+
+      uuids = subject.map{|object| object.uuid}
+
+      expect( uuids.size ).to eq(2)
+    end
+
+    it 'preserves loaded objects' do
+      expect( subject.loaded ).to eq(1)
+
+      subject.first(2)
+
+      expect( subject.loaded ).to eq(2)
+    end
+
+    it 'updates #meta with data from last api response' do
+      new_meta = {}
+      allow(@api).to receive(:get).and_wrap_original do |m, *args|
+        m.call(*args).tap{|data| new_meta = data.reject{|k,_| k == "results"}}
+      end
+
+      subject.first(2)
+
+      expect( subject.meta ).to eq(new_meta)
+    end
+
+    if Gem.ruby_version >= Gem::Version.new('2.0.0')
+      context 'when lazy enumerator is used' do
+        it 'preserves loaded objects' do
+          expect(subject.loaded).to eq 1
+
+          subject.lazy.first(2)
+
+          expect(subject.loaded).to eq 2
+        end
+      end
+    end
+
+    context 'when a block passed to an enumerator method contains a break' do
+      it 'preserves loaded objects' do
+        i = 0
+        subject.each{|o| i+= 1; break if i >= 2}
+
+        expect( subject.loaded ).to eq(2)
+      end
+    end
+
+    context 'when a block passed to an enumerator method raises an exception' do
+      it 'preserves loaded objects' do
+        i = 0
+        subject.each{|o| i += 1; raise if i>= 2} rescue nil
+
+        expect( subject.loaded ).to eq(2)
+      end
+    end
+  end
+end