uploadcare-ruby 2.1.1 → 3.1.0.pre.rc1

data/spec/api/file_storage_api_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-
-describe Uploadcare::FileStorageApi do
-  let(:api){ API }
-  let(:file){ api.file_list(limit: 1).first || api.upload(IMAGE_URL) }
-
-  shared_examples 'batch action on files' do
-    let(:uuids) { ["dc2c175d-a3b5-4435-b4f4-fae77bbe5597", "cea319aa-6e17-4172-8722-8dd7c459a523"] }
-    let(:files) { uuids.map { |uuid| Uploadcare::Api::File.new(api, uuid) } }
-    let(:api_endpoint) { "/files/storage/" }
-
-    it 'accepts array of uuids' do
-      expect(api).to receive(http_method)
-      expect { subject.call(uuids) }.not_to raise_error
-    end
-
-    it 'accepts enumerable containing Uploadcare::Api::File objects' do
-      expect(api).to receive(http_method)
-      expect { subject.call(files) }.not_to raise_error
-    end
-
-    it 'converts Uploadcare::Api::File-s to uuids' do
-      expect(api).to receive(http_method).with(api_endpoint, uuids)
-      subject.call(files)
-    end
-
-    context 'when input contains something other than UUIDs or Uploadcare::Api::File-s' do
-      it 'raises ArgumentError' do
-        ['not-an-uuid', nil, 1].each do |wrong_input_value|
-          expect { subject.call([wrong_input_value]) }.to raise_error(ArgumentError)
-        end
-      end
-    end
-
-    it 'raises ArgumentError if input size is grater then max batch size' do
-      stub_const("Uploadcare::FileStorageApi::MAX_BATCH_SIZE", 1)
-      expect { subject.call(uuids) }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe '#store_files' do
-    let(:http_method) { :put }
-    subject { ->(objects) { api.store_files(objects) } }
-
-    it_behaves_like 'batch action on files'
-
-    describe 'integration test' do
-      before { file.tap { |f| wait_until_ready(f) }.delete if file.stored? }
-      subject(:store_files) { -> { api.store_files([file]) } }
-
-      it 'stores files with given uuids' do
-        is_expected.to change { file.load!.stored? }.from(false).to(true)
-      end
-
-      it 'returns the API response' do
-        expect(store_files.call).to include(
-          "status" => "ok",
-          "problems" => {},
-          "result" => [be_a(Hash)]
-        )
-      end
-    end
-  end
-
-  describe '#delete_files' do
-    let(:http_method) { :delete }
-    subject { ->(objects) { api.delete_files(objects) } }
-
-    it_behaves_like 'batch action on files'
-
-    describe 'integration test' do
-      before { file.store if file.deleted? }
-      subject(:delete_files) { -> { api.delete_files([file]) } }
-
-      it 'deletes files with given uuids' do
-        is_expected.to change { file.load!.deleted? }.from(false).to(true)
-      end
-
-      it 'returns the API response' do
-        expect(delete_files.call).to include(
-          "status" => "ok",
-          "problems" => {},
-          "result" => [be_a(Hash)]
-        )
-      end
-    end
-  end
-end

data/spec/api/group_list_api_spec.rb

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

@@ -1,25 +0,0 @@
-require 'spec_helper'
-require 'uri'
-require 'socket'
-
-describe Uploadcare::Api do
-  subject(:api) { Uploadcare::Api.new(CONFIG) }
-
-  it "should initialize api" do
-    is_expected.to be_an_instance_of(Uploadcare::Api)
-  end
-
-  it 'should respond to request methods' do
-    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
-
-  context 'when performing requests' do
-    subject(:request) { api.request }
-
-    it { is_expected.to be_a Hash }
-  end
-end

data/spec/api/uploading_api/upload_params_spec.rb

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

@@ -1,59 +0,0 @@
-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,25 +0,0 @@
-require 'spec_helper'
-
-describe Uploadcare::Api::FileList do
-  before :all do
-    @api = API
-
-    # 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
-
-    @list = @api.file_list(limit: 1)
-  end
-
-  let(:resource_class){ Uploadcare::Api::File }
-  subject{ @list }
-
-  it_behaves_like 'resource list'
-
-  describe '#objects' do
-    subject{ @list.objects }
-
-    it{ is_expected.to all(be_a(resource_class)) }
-    it{ is_expected.to all(be_loaded) }
-  end
-end

data/spec/resources/file_spec.rb

@@ -1,223 +0,0 @@
-require 'spec_helper'
-require 'uri'
-require 'socket'
-require 'securerandom'
-
-describe Uploadcare::Api::File do
-  let(:api) { API }
-  let(:file) { api.upload IMAGE_URL }
-
-  it 'is an instance of File' do
-    expect(file).to be_an_instance_of Uploadcare::Api::File
-  end
-
-  it 'is not initialized without correct UUID given' do
-    expect {Uploadcare::Api::File.new(api, "not-uuid")}.to raise_error NoMethodError
-  end
-
-  it 'has a valid url' do
-    expect(file.uuid).to match UUID_REGEX
-  end
-
-  it 'returns a public url' do
-    expect(file).to respond_to :cdn_url
-    expect(file).to respond_to :public_url
-  end
-
-  it 'has a public url that is valid' do
-    url = file.cdn_url
-    uri = URI.parse(url)
-    expect(uri).to be_kind_of(URI::HTTP)
-  end
-
-  it 'is able to load image data' do
-    expect {file.load_data}.to_not raise_error
-  end
-
-  it 'stores itself' do
-    expect { file.store }.to_not raise_error
-  end
-
-  it 'responds with nil for :stored? and :deleted? methods unless loaded' do
-    expect(file.is_loaded?).to be false
-    expect(file.is_stored?).to be_nil
-    expect(file.is_deleted?).to be_nil
-  end
-
-  it 'is able to tell thenever file was stored' do
-    file.load
-    expect(file.stored?).to be(true)
-    wait_until_ready(file)
-    file.delete
-    expect(file.stored?).to be(false)
-  end
-
-  it 'deletes itself' do
-    expect { file.delete }.to_not raise_error
-  end
-
-  it 'is able to tell thenever file was deleted' do
-    file.load
-    file.is_deleted?.should == false
-    wait_until_ready(file)
-    file.delete
-    expect(file.is_deleted?).to be true
-  end
-
-  it 'constructs file from uuid' do
-    uuid_file = api.file file.uuid
-    expect(uuid_file).to be_kind_of(Uploadcare::Api::File)
-  end
-
-  it 'constructs file from cdn url' do
-    url = file.cdn_url + "-/crop/150x150/center/-/format/png/"
-    file = api.file url
-    expect(file).to be_kind_of(Uploadcare::Api::File)
-  end
-
-  it 'responds to datetime_ methods' do
-    file.load
-    expect(file).to respond_to(:datetime_original)
-    expect(file).to respond_to(:datetime_uploaded)
-    expect(file).to respond_to(:datetime_stored)
-    expect(file).to respond_to(:datetime_removed)
-  end
-
-  it 'responds to datetime_uploaded' do
-    file.load
-    expect(file.datetime_uploaded).to be_kind_of(DateTime)
-  end
-
-  it 'responds to datetime_stored' do
-    file.load
-    file.store
-    expect(file.datetime_stored).to be_kind_of(DateTime)
-  end
-
-  it 'responds to datetime_removed' do
-    file.load
-    wait_until_ready(file)
-    file.delete
-    expect(file.datetime_removed).to be_kind_of(DateTime)
-    expect(file.datetime_deleted).to be_kind_of(DateTime)
-    expect(file.datetime_removed).to eq file.datetime_deleted
-  end
-
-
-  it 'copies itself' do
-    # This can cause "File is not ready yet" error if ran too early
-    # In this case we retry it 3 times before giving up
-    result = retry_if(Uploadcare::Error::RequestError::BadRequest){file.copy}
-    expect(result).to be_kind_of(Hash)
-    expect(result["type"]).to eq "file"
-  end
-
-
-  describe '#internal_copy' do
-    describe 'integration' do
-      it 'creates an internal copy of the file' do
-        response = retry_if(Uploadcare::Error::RequestError::BadRequest){file.internal_copy}
-
-        expect( response['type'] ).to eq 'file'
-        expect( response['result']['uuid'] ).not_to eq file.uuid
-      end
-    end
-
-    describe 'params' do
-      let(:url_without_ops){ api.file(SecureRandom.uuid).cdn_url }
-      let(:url_with_ops){ url_without_ops + "-/crop/5x5/center/" }
-      let(:file){ api.file(url_with_ops) }
-
-      context 'if no params given' do
-        it 'requests server to create an unstored copy with operataions applied' do
-          expect(api).to receive(:post)
-            .with('/files/', source: url_with_ops)
-
-          file.internal_copy
-        end
-      end
-
-      context 'if strip_operations: true given' do
-        it 'passes url without operations as a source for a copy' do
-          expect(api).to receive(:post)
-            .with('/files/', source: url_without_ops)
-
-          file.internal_copy(strip_operations: true)
-        end
-      end
-
-      context 'if store: true given' do
-        it 'requests server to create a stored copy' do
-          expect(api).to receive(:post)
-            .with('/files/', source: url_with_ops, store: true)
-
-          file.internal_copy(store: true)
-        end
-      end
-    end
-  end
-
-
-  describe '#external_copy' do
-    let(:target){ 'with-prefix' }
-
-    describe 'integration', :payed_feature do
-      it 'creates an external copy of the file' do
-        response = retry_if(Uploadcare::Error::RequestError::BadRequest) do
-                     file.external_copy(target)
-                   end
-
-        expect( response['type'] ).to eq 'url'
-        expect( response['result'] ).to match(URI.regexp)
-      end
-    end
-
-    describe 'params' do
-      let(:url_without_ops){ api.file(SecureRandom.uuid).cdn_url }
-      let(:url_with_ops){ url_without_ops + "-/resize/50x50/" }
-      let(:file){ api.file(url_with_ops) }
-
-      context 'if only target is given' do
-        it 'requests server to create a private copy with default name and with operataions applied' do
-          expect(api).to receive(:post)
-            .with('/files/', source: url_with_ops, target: target)
-
-          file.external_copy(target)
-        end
-      end
-
-      context 'if target is not given' do
-        it 'raises ArgumentError' do
-          expect{ file.external_copy }.to raise_error(ArgumentError)
-        end
-      end
-
-      context 'if strip_operations: true given' do
-        it 'passes url without operations as a source for a copy' do
-          expect(api).to receive(:post)
-            .with('/files/', source: url_without_ops, target: target)
-
-          file.external_copy(target, strip_operations: true)
-        end
-      end
-
-      context 'if :make_public given' do
-        it 'requests server to create a copy with correspondent permissions' do
-          expect(api).to receive(:post)
-            .with('/files/', source: url_with_ops, target: target, make_public: false)
-
-          file.external_copy(target, make_public: false)
-        end
-      end
-
-      context 'if :pattern given' do
-        it 'requests server to apply given pattern to name of a copy' do
-          expect(api).to receive(:post)
-            .with('/files/', source: url_with_ops, target: target, pattern: 'test')
-
-          file.external_copy(target, pattern: 'test')
-        end
-      end
-    end
-  end
-end