uploadcare-ruby 1.2.1 → 3.0.3

data/spec/resources/file_spec.rb

@@ -1,222 +0,0 @@
-require 'spec_helper'
-require 'uri'
-require 'socket'
-require 'securerandom'
-
-describe Uploadcare::Api::File do
-  before :each do
-    @api = API
-    @file = @api.upload IMAGE_URL
-  end
-
-  it 'file should be an instance of File' do
-    @file.should be_an_instance_of Uploadcare::Api::File
-  end
-
-  it 'should not be initialized without correct UUID given' do
-    expect {Uploadcare::Api::File.new(@api, "not-uuid")}.to raise_error
-  end
-
-  it 'should have valid url' do
-    @file.uuid.should match UUID_REGEX
-  end
-
-  it 'should return public url' do
-    @file.should respond_to :cdn_url
-    @file.should respond_to :public_url
-  end
-
-  it 'public url should be valid url' do
-    url = @file.cdn_url
-    uri = URI.parse(url)
-    uri.should be_kind_of(URI::HTTP)
-  end
-
-  it 'should be able to load image data' do
-    expect {@file.load_data}.to_not raise_error
-  end
-
-  it 'should store itself' do
-    expect { @file.store }.to_not raise_error
-  end
-
-  it 'file should respond with nil for :stored? and :deleted? methods unless loaded' do
-    @file.is_loaded?.should == false
-    @file.is_stored?.should == nil
-    @file.is_deleted?.should == nil
-  end
-
-  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
-  end
-
-  it 'should delete itself' do
-    expect { @file.delete }.to_not raise_error
-  end
-
-  it 'should be able to tell thenever file was deleted' do
-    @file.load
-    @file.is_deleted?.should == false
-    @file.delete
-    @file.is_deleted?.should == true
-  end
-
-  it 'should construct file from uuid' do
-    file = @api.file @file.uuid
-    file.should be_kind_of(Uploadcare::Api::File)
-  end
-
-  it 'should construct file from cdn url' do
-    url = @file.cdn_url + "-/crop/150x150/center/-/format/png/"
-    file = @api.file url
-    file.should be_kind_of(Uploadcare::Api::File)
-  end
-
-  it 'shoul respond to datetime_ methods' do
-    @file.load
-    @file.should respond_to(:datetime_original)
-    @file.should respond_to(:datetime_uploaded)
-    @file.should respond_to(:datetime_stored)
-    @file.should respond_to(:datetime_removed)
-  end
-
-  it 'should respond to datetime_uploaded' do
-    @file.load
-    @file.datetime_uploaded.should be_kind_of(DateTime)
-  end
-
-  it 'should respond to datetime_stored' do
-    @file.load
-    @file.store
-    @file.datetime_stored.should be_kind_of(DateTime)
-  end
-
-  it 'should respond to datetime_removed' do
-    @file.load
-    @file.delete
-    @file.datetime_removed.should be_kind_of(DateTime)
-    @file.datetime_deleted.should be_kind_of(DateTime)
-    @file.datetime_removed.should == @file.datetime_deleted
-  end
-
-
-  it 'should copy 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}
-    result.should be_kind_of(Hash)
-    result["type"].should == "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

data/spec/resources/group_list_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-require 'uri'
-require 'socket'
-
-describe Uploadcare::Api::File 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
-
-  it "should contain groups and results" do
-    @list.should respond_to(:results)
-    @list.should respond_to(:groups)
-    @list.groups.should be_kind_of(Array)
-  end
-
-  it "results should contain groups" do
-    group = @list.groups.sample
-    group.should be_kind_of(Uploadcare::Api::Group)
-  end
-
-  it "group should no be loaded" do
-    group = @list.groups.sample
-    group.is_loaded?.should == false
-  end
-end

data/spec/resources/group_spec.rb

@@ -1,101 +0,0 @@
-require 'spec_helper'
-require 'uri'
-require 'socket'
-
-describe Uploadcare::Api::Group do
-  before :all do
-    @api = API
-    @files = @api.upload FILES_ARY
-  end
-
-  it "should return group object" do
-    group = @api.create_group @files
-    group.should be_kind_of(Uploadcare::Api::Group)
-  end
-
-  it "should have valid UUID and count of files" do
-    group = @api.create_group @files
-    group.should respond_to(:uuid)
-    group.should respond_to(:files_count)
-  end
-
-  it "should may have files" do
-    group = @api.create_group @files
-    group.should respond_to(:files)
-    group.files.should be_kind_of(Array)
-    group.files.each do |file|
-      file.should be_kind_of(Uploadcare::Api::File)
-    end
-  end
-
-  it "should create group by id" do
-    group = @api.create_group @files
-
-    expect {group_uloaded = @api.group group.uuid}.to_not raise_error
-  end
-
-  it "should create loaded and unloaded groups" do
-    group = @api.create_group @files
-    group_uloaded = @api.group group.uuid
-    group.is_loaded?.should be true
-    group_uloaded.is_loaded?.should be false
-  end
-
-  it "group should load data" do
-    group = @api.create_group @files
-    group_uloaded = @api.group group.uuid
-    group_uloaded.should respond_to(:load_data)
-    expect {group_uloaded.load_data}.to_not raise_error
-    group_uloaded.is_loaded?.should be true
-  end
-
-  it "group should store itself" do
-    group = @api.create_group @files
-    expect {group.store}.to_not raise_error
-  end
-
-  it "should be able to tell when group is stored" do
-    group = @api.create_group @files
-    group_unloaded = @api.group group.uuid
-
-    group_unloaded.is_loaded?.should == false
-    group_unloaded.is_stored?.should == nil
-
-    group_unloaded.load
-    group_unloaded.is_stored?.should == false
-
-    group_unloaded.store
-    group_unloaded.is_stored?.should == true
-  end
-
-  it "group should have datetime attributes" do
-    group = @api.create_group @files
-    group.should respond_to(:datetime_created)
-    group.should respond_to(:datetime_stored)
-  end
-
-  it "group should have datetime_created as DateTime object" do
-    group = @api.create_group @files
-    group.datetime_created.should be_kind_of(DateTime)
-  end
-
-  it "group should have datetime_created as DateTime object" do
-    group = @api.create_group @files
-    group.store
-    group.datetime_stored.should be_kind_of(DateTime)
-  end
-
-  it "should return cdn string for file in group by it index" do
-    group = @api.create_group @files
-
-    file_cdn_url = group.file_cdn_url(0)
-
-    file_cdn_url.should be_kind_of(String)
-    file_cdn_url.should == group.cdn_url + "nth/0/"
-  end 
-
-  it 'should raise an error if index is greater than files count in group' do
-    group = @api.create_group @files
-    expect {group.file_cdn_url(5)}.to raise_error
-  end
-end

data/spec/resources/operations_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-require 'uri'
-require 'socket'
-
-describe Uploadcare::Api::File do
-  before :all do
-    @api = API
-    @file = @api.upload IMAGE_URL
-  end
-
-  it "freshly uploaded file should have empty operations list" do
-    @file.should respond_to :operations
-    @file.operations.should be_kind_of(Array)
-    @file.operations.should be_empty
-  end
-
-  it "file created from uuid should be not loaded and without operations" do
-    file = @api.file @file.uuid
-    file.is_loaded?.should be false
-    file.operations.should be_empty
-  end
-
-  it "file created from url without operations should be not be loaded and have no operations" do
-    file = @api.file @file.cdn_url
-    file.is_loaded?.should be false
-    file.operations.should be_empty
-  end
-
-  it "file created from url with operations should be not be loaded and have operations" do
-    file = @api.file @file.cdn_url + "-/crop/150x150/center/-/format/png/"
-    file.is_loaded?.should be false
-    file.operations.should_not be_empty
-  end
-
-  it "file should have methods for construct cdn urls with or without cdn operations" do
-    @file.should respond_to(:cdn_url_with_operations)
-    @file.should respond_to(:cdn_url_without_operations)
-  end
-
-  it "file should construct cdn_url with and without opreations" do
-    url_without_operations  = @file.cdn_url
-    url_with_operations     = @file.cdn_url + "-/crop/150x150/center/-/format/png/"
-
-    file = @api.file url_with_operations
-
-    file.cdn_url.should         == (url_without_operations)
-    file.cdn_url(true).should   == (url_with_operations)
-  end
-
-  it 'should works also with exact methods' do
-    url_without_operations  = @file.cdn_url.to_s
-    url_with_operations     = @file.cdn_url + "-/crop/150x150/center/-/format/png/"
-
-    file = @api.file url_with_operations
-
-    file.cdn_url_with_operations.should     == (url_with_operations)
-    file.cdn_url_without_operations.should  == (url_without_operations)
-  end
-end

data/spec/resources/project_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-require 'uri'
-require 'socket'
-
-describe Uploadcare::Api::Project do
-  before :all do
-    @api = API
-    @project = @api.project
-  end
-
-  it "should instantiated project" do
-    @project.should be_kind_of Uploadcare::Api::Project
-  end
-
-  it "should respond to project api methods" do
-    @project.should respond_to :collaborators
-    @project.should respond_to :name
-    @project.should respond_to :pub_key
-    @project.should respond_to :autostore_enabled
-  end
-end

data/spec/rest/api_connection_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-require 'uri'
-require 'socket'
-
-describe Uploadcare::Connections::ApiConnection do
-  let(:settings){ Uploadcare.default_settings }
-
-  it 'is initializable with default settings' do
-    expect {described_class.new(settings)}.to_not raise_error
-  end
-
-
-  describe 'default request headers' do
-    subject{ described_class.new(settings).headers }
-
-    it 'includes correct Accept header' do
-      expected = "application/vnd.uploadcare-v#{settings[:api_version]}+json"
-      expect(subject['Accept']).to eq expected
-    end
-
-    it 'includes correct User-Agent header' do
-      expected = Uploadcare::UserAgent.new.call(settings)
-      expect(subject['User-Agent']).to eq expected
-    end
-  end
-
-
-  describe 'middleware' do
-    subject{ described_class.new(settings).builder.handlers }
-
-    it 'uses Request::Auth middleware' do
-      expect(subject).to include(Uploadcare::Connections::Request::Auth)
-    end
-
-    it 'uses Response::ParseJson middleware' do
-      expect(subject).to include(Uploadcare::Connections::Response::ParseJson)
-    end
-
-    it 'uses Response::RaiseError middleware' do
-      expect(subject).to include(Uploadcare::Connections::Response::RaiseError)
-    end
-  end
-
-
-  describe 'auth scheme' do
-    it 'uses simple auth when auth_scheme: :simple setting is provided' do
-      expect(Uploadcare::Connections::Auth::Simple).to receive(:new)
-      described_class.new(settings.merge(auth_scheme: :simple))
-    end
-
-    it 'uses secure auth when auth_scheme: :secure setting is provided' do
-      expect(Uploadcare::Connections::Auth::Secure).to receive(:new)
-      described_class.new(settings.merge(auth_scheme: :secure))
-    end
-
-    it 'raises KeyError when :auth_scheme options is not provided' do
-      expect{
-        described_class.new(settings.reject{|k,_| k == :auth_scheme})
-      }.to raise_error(KeyError)
-    end
-
-    it 'raises ArgumentError when provided :auth_scheme is unknown' do
-      expect{
-        described_class.new(settings.merge(auth_scheme: :unknown))
-      }.to raise_error(ArgumentError)
-    end
-  end
-end