uploadcare-ruby 2.1.1 → 3.1.0.pre.rc1

data/spec/resources/group_list_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-describe Uploadcare::Api::GroupList do
-  before :all do
-    @api = API
-
-    # 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
-
-    @list = @api.group_list(limit: 1)
-  end
-
-  let(:resource_class){ Uploadcare::Api::Group }
-  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.not_to include(be_loaded) }
-  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 ArgumentError
-  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

data/spec/rest/auth/secure_spec.rb

@@ -1,66 +0,0 @@
-require 'spec_helper'
-
-describe Uploadcare::Connections::Auth::Secure do
-  describe '#apply' do
-    let(:env){ Faraday::Env.new(:get, nil, URI::HTTP.build(host: 'example.com'), nil, {}) }
-    subject{ env.request_headers }
-
-    before(:each) do
-      described_class.new(public_key: 'pub', private_key: 'priv').apply(env)
-    end
-
-    it "adds Authorization header to env's request_headers" do
-      expect(subject).to include('Authorization')
-    end
-
-    it "adds Date header to env's request_headers" do
-      expect(subject).to include('Date')
-    end
-
-    it "uses secure authorization" do
-      expect(subject['Authorization']).to match /Uploadcare pub:.+/
-    end
-  end
-
-  describe 'signature' do
-    let(:uri){ URI::HTTP.build(host: 'example.com', path: '/path', query: 'test=1') }
-    let(:headers){ {'Content-Type' => 'application/x-www-form-urlencoded'} }
-    let(:env){ Faraday::Env.new(:post, 'url=encoded&test=body', uri, nil, headers) }
-
-    subject{ env.request_headers }
-
-    before(:each) do
-      allow(Time).to receive(:now).and_return(Time.parse('2017.02.02 12:58:50 +0000'))
-      described_class.new(public_key: 'pub', private_key: 'priv').apply(env)
-    end
-
-    it "counts signature correctly" do
-      expected = '71b61ed67d16f48d2e46a4ee72ca12025aeb8d1f'
-      expect(subject['Authorization']).to eq "Uploadcare pub:#{expected}"
-    end
-  end
-
-
-  describe 'integration' do
-    let(:api){ Uploadcare::Api.new(auth_scheme: :secure) }
-    let(:file){ api.upload IMAGE_URL }
-
-    before(:each) do
-      # ensure that secure auth is being used
-      expect_any_instance_of(described_class).to receive(:apply).at_least(4).times.and_call_original
-    end
-
-    it 'auth works with real requests' do
-      # request with url params
-      expect{ api.get('/files/', limit: 1) }.not_to raise_error
-      # request with an url-encoded body
-      expect{
-        retry_if(Uploadcare::Error::RequestError::BadRequest) do
-          api.post('/files/', source: file.uuid)
-        end
-      }.not_to raise_error
-      # request with an empty body and a redirect
-      expect{ api.delete("/files/#{file.uuid}/storage/") }.not_to raise_error
-    end
-  end
-end

data/spec/rest/auth/simple_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe Uploadcare::Connections::Auth::Simple do
-  let(:env){ Faraday::Env.new(nil, nil, nil, nil, {}) }
-  subject{ described_class.new(public_key: 'pub', private_key: 'priv') }
-
-  describe 'apply' do
-    it "adds Authorization header to env's request_headers" do
-      subject.apply(env)
-      expect(env.request_headers).to include('Authorization')
-    end
-
-    it "sets Authorization header's value correctly" do
-      subject.apply(env)
-      expect(env.request_headers['Authorization']).to eq "Uploadcare.Simple pub:priv"
-    end
-  end
-
-  describe 'integration' do
-    let(:api){ Uploadcare::Api.new(auth_scheme: :simple) }
-
-    before(:each) do
-      # ensure that simple auth is being used
-      expect_any_instance_of(described_class).to receive(:apply).and_call_original
-    end
-
-    it 'auth works with real requests' do
-      expect{ api.get('/files/') }.not_to raise_error
-    end
-  end
-end

data/spec/rest/errors_spec.rb

@@ -1,75 +0,0 @@
-require 'spec_helper'
-require 'uri'
-require 'socket'
-
-describe Uploadcare::Error do
-  before(:all) do
-    @settings = Uploadcare.default_settings
-    @codes = [400,401,403,404,406,408,422,429,500,502,503,504]
-    @connection = Uploadcare::Connections::ApiConnection.new(@settings)
-  end
-
-  it 'Error codes should be accesbile' do
-    Uploadcare::Error.errors.keys.should == @codes
-  end
-
-  it 'Errors should be kind of requested codes' do
-    not_found = Uploadcare::Error.errors[404]
-    not_found.new('File not found').should be_kind_of(Uploadcare::Error::RequestError::NotFound)
-  end
-
-  it 'errors should have meaningfull messages' do
-    not_found = Uploadcare::Error.errors[404]
-    error = not_found.new
-    error.message.should == "HTTP 404 - the requested resource could not be found."
-  end
-
-  it 'Should raise an error' do
-    error = Uploadcare::Error::RequestError::NotFound
-    expect{ @connection.send :get, '/random_url/', {} }.to raise_error(error)
-  end
-
-  it "should escape particular error" do
-    error = Uploadcare::Error::RequestError::NotFound
-    expect do
-      begin
-        @connection.send :get, '/random_url/', {}
-      rescue error => e
-        nil
-      end
-    end.to_not raise_error
-  end
-
-  it 'should escape common request error' do
-    error = Uploadcare::Error::RequestError
-    expect do
-      begin
-        @connection.send :get, '/random_url/', {}
-      rescue error => e
-        nil
-      end
-    end.to_not raise_error
-  end
-
-  it 'should escape generic uploadcare service error' do
-    error = Uploadcare::Error
-    expect do
-      begin
-        @connection.send :get, '/random_url/', {}
-      rescue error => e
-        nil
-      end
-    end.to_not raise_error
-  end
-
-  it 'should escape generic uploadcare service error' do
-    error = StandardError
-    expect do
-      begin
-        @connection.send :get, '/random_url/', {}
-      rescue error => e
-        nil
-      end
-    end.to_not raise_error
-  end
-end