uploadcare-ruby 1.2.2 → 2.0.0

data/lib/uploadcare/api/validators/group_list_options_validator.rb

@@ -0,0 +1,49 @@
+module Uploadcare
+  module Validators
+
+    class GroupListOptionsValidator
+      SUPPORTED_KEYS = [:from, :ordering, :limit]
+
+      def initialize(options)
+        @options = options
+      end
+
+      def validate
+        check_for_unsupported_keys(@options)
+
+        validate_limit(@options[:limit])
+        validate_ordering(@options[:ordering])
+        validate_from(@options[:from])
+      end
+
+      private
+
+      def check_for_unsupported_keys(options)
+        unsupported_keys = options.keys.reject{|k,_| SUPPORTED_KEYS.include?(k)}
+        error("Unknown options: #{unsupported_keys}") if unsupported_keys.any?
+      end
+
+      def validate_ordering(ordering)
+        return if !ordering || ordering =~ /^-?datetime_created$/
+        error("Unknown value for :ordering option: #{ordering.inspect}")
+      end
+
+      def validate_from(from)
+        return if from.nil? || from.to_s =~ /^\d{4}-\d{2}-\d{2}T\d{2}.*/
+        error(":from value should be a DateTime or an iso8601 string, "\
+          "#{from.inspect} given")
+      end
+
+      def validate_limit(limit)
+        return if limit.nil? || (limit.is_a?(Integer) && (1..1000).include?(limit))
+        error(":limit should be a positive integer from 1 to 1000, "\
+          "#{limit.inspect} given")
+      end
+
+      def error(message)
+        raise ArgumentError, message
+      end
+    end
+
+  end
+end

data/lib/uploadcare/resources/file_list.rb

@@ -1,41 +1,14 @@
 require 'ostruct'
+require_relative 'resource_list'
 
 module Uploadcare
   class Api
-    class FileList < OpenStruct
-      def initialize api, data
-        @api = api
+    class FileList < ResourceList
+      private
 
-        unless data["results"].nil?
-          data["results"].map! do |file| 
-            Uploadcare::Api::File.new @api, file["uuid"], file
-          end
-        end
-
-        super data
-      end
-
-      # Array-like behavior
-      def [] index
-        results[index] if defined?(:results)
-      end
-
-      def to_a
-        results if defined?(:results)
-      end
-
-      # List navigation
-      def next_page
-        @api.file_list(page+1) unless send(:next).nil?
-      end
-
-      def go_to index
-        @api.file_list(index) unless index > pages
-      end
-
-      def previous_page
-        @api.file_list(page-1) unless previous.nil?
+      def to_resource(api, file_data)
+        Uploadcare::Api::File.new(api, file_data['uuid'], file_data)
       end
     end
   end
-end
+end

data/lib/uploadcare/resources/group_list.rb

@@ -1,31 +1,14 @@
 require 'ostruct'
+require_relative 'resource_list'
 
 module Uploadcare
   class Api
-    class GroupList < OpenStruct
-      def initialize api, data
-        @api = api
+    class GroupList < ResourceList
+      private
 
-        unless data["results"].nil?
-          data["results"].map! do |group|
-            Uploadcare::Api::Group.new @api, group["id"], group
-          end
-        end
-
-        super data
-      end
-
-      def [] index
-        results[index] if defined?(:results)
-      end
-
-      def to_a
-        results if defined?(:results)
-      end
-
-      def groups
-        results if defined?(:results)
+      def to_resource(api, group_data)
+        Uploadcare::Api::Group.new api, group_data["id"], group_data
       end
     end
   end
-end
+end

data/lib/uploadcare/resources/resource_list.rb

@@ -0,0 +1,83 @@
+require 'ostruct'
+
+module Uploadcare
+  class Api
+    class ResourceList
+      include Enumerable
+
+      extend Forwardable
+      def_delegator :@data, :meta
+      def_delegator :@data, :objects
+
+      attr_reader :options
+
+      def initialize(api, data, options)
+        @api = api
+        @data = build_data(data)
+        @options = options.dup.freeze
+      end
+
+      def [](index)
+        first(index + 1).last
+      end
+
+      def each
+        return enum_for(:each) unless block_given?
+
+        resource_enumerator.each { |object| yield object }
+
+        self
+      end
+
+      def total
+        meta['total']
+      end
+
+      def loaded
+        objects.size
+      end
+
+      def fully_loaded?
+        meta['next'].nil?
+      end
+
+      private
+
+      attr_reader :api
+
+      def build_data(data_hash)
+        OpenStruct.new(
+          meta: data_hash.reject{|k, _| k == 'results'}.freeze,
+          objects: data_hash['results'].map{|object| to_resource(api, object)}
+        )
+      end
+
+      def get_next_page
+        return nil if fully_loaded?
+
+        next_page = build_data(api.get(@data.meta['next']))
+
+        @data = OpenStruct.new(
+          meta: next_page.meta,
+          objects: objects + next_page.objects
+        )
+
+        next_page
+      end
+
+      def to_resource(*args)
+        raise NotImplementedError, 'You must define this method in a child class'
+      end
+
+      def resource_enumerator
+        Enumerator.new do |yielder|
+          objects.each { |obj| yielder << obj }
+
+          while next_page = get_next_page do
+            next_page.objects.each { |obj| yielder << obj }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/uploadcare/rest/connections/api_connection.rb

@@ -10,14 +10,14 @@ module Uploadcare
           auth_strategy = Auth.strategy(options)
 
           frd.headers['Accept'] = "application/vnd.uploadcare-v#{options[:api_version]}+json"
-          frd.headers['User-Agent'] = UserAgent.new.call(options)
+          frd.headers['User-Agent'] = Uploadcare::user_agent(options)
 
           # order of middleware matters!
 
-          # url_encoded changes request body and thus should be before
+          # :json middleware changes request body and thus should be before
           # uploadcare_auth which uses it to sign requests when secure auth
           # strategy is being used
-          frd.request :url_encoded
+          frd.request :json
           frd.request :uploadcare_auth, auth_strategy
 
           frd.response :uploadcare_raise_error
@@ -27,6 +27,28 @@ module Uploadcare
           frd.adapter :net_http # actually, default adapter, just to be clear
         end
       end
+
+      # NOTE: Faraday doesn't support body in DELETE requests, but
+      # Uploadcare API v0.5 requires clients to send array of UUIDs with
+      # `DELETE /files/storage/` requests.
+      #
+      # This is on override of the original Faraday::Connection#delete method.
+      #
+      # As for now, there are no DELETE requests in Uploadcare REST API
+      # which require params to be sent as URI params, so for simplicity
+      # this method send all params in a body.
+      def delete(url = nil, params = nil, headers = nil)
+        run_request(:delete, url, nil, headers) { |request|
+          # Original line from Faraday::Connection#delete method
+          # request.params.update(params) if params
+
+          # Monkey patch
+          request.body = params if params
+
+          yield(request) if block_given?
+        }
+      end
+
     end
   end
 end

data/lib/uploadcare/rest/connections/upload_connection.rb

@@ -9,11 +9,12 @@ module Uploadcare
         super ssl: { ca_path: ca_path }, url: options[:upload_url_base] do |frd|
           frd.request :multipart
           frd.request :url_encoded
-          frd.adapter :net_http
-          frd.headers['User-Agent'] = UserAgent.new.call(options)
+          frd.headers['User-Agent'] = Uploadcare::user_agent(options)
 
           frd.response :uploadcare_raise_error
           frd.response :uploadcare_parse_json
+
+          frd.adapter :net_http
         end
       end
     end

data/lib/uploadcare/version.rb

@@ -1,3 +1,3 @@
 module Uploadcare
-  VERSION = "1.2.2"
+  VERSION = '2.0.0'.freeze
 end

data/spec/api/file_list_api_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Uploadcare::FileListApi do
+  let(:api){ API }
+  subject{ api.file_list(limit: 1) }
+
+  before(:each){ allow(api).to receive(:get){ {'results' => []} } }
+
+  it 'returns a file list' do
+    expect( subject ).to be_a(Uploadcare::Api::FileList)
+  end
+
+  it 'stores options in a file list object' do
+    expect( subject.options ).to eq({limit: 1})
+  end
+
+  describe 'validation' do
+    it 'passes validation when no options given' do
+      expect{ api.file_list }.not_to raise_error
+    end
+
+    it "validates that options don't have unsupported keys" do
+      expect{ api.file_list(unknown: 1) }.to raise_error(ArgumentError)
+    end
+
+    it 'validates that :limit is an integer from 1 to 1000' do
+      expect{ api.file_list(limit: 1) }.not_to raise_error
+      expect{ api.file_list(limit: 395) }.not_to raise_error
+      expect{ api.file_list(limit: 1000) }.not_to raise_error
+
+      expect{ api.file_list(limit: 1.0) }.to raise_error(ArgumentError)
+      expect{ api.file_list(limit: -1) }.to raise_error(ArgumentError)
+      expect{ api.file_list(limit: 0) }.to raise_error(ArgumentError)
+      expect{ api.file_list(limit: 1001) }.to raise_error(ArgumentError)
+      expect{ api.file_list(limit: false) }.to raise_error(ArgumentError)
+    end
+
+    it 'validates that :stored is a boolean' do
+      expect{ api.file_list(stored: true) }.not_to raise_error
+      expect{ api.file_list(stored: false) }.not_to raise_error
+
+      expect{ api.file_list(stored: 'yes') }.to raise_error(ArgumentError)
+    end
+
+    it 'validates that :removed is a boolean' do
+      expect{ api.file_list(removed: true) }.not_to raise_error
+      expect{ api.file_list(removed: false) }.not_to raise_error
+
+      expect{ api.file_list(removed: 'yes') }.to raise_error(ArgumentError)
+    end
+
+    valid_ordering = %w{size -size datetime_uploaded -datetime_uploaded}
+    it "validates that :ordering is in [#{valid_ordering.join(', ')}]" do
+      valid_ordering.each do |valid_value|
+        expect{ api.file_list(ordering: valid_value) }.not_to raise_error
+      end
+
+      expect{ api.file_list(ordering: 'yes') }.to raise_error(ArgumentError)
+    end
+
+    describe 'from' do
+      context 'when ordering is "size" or "-size"' do
+        let(:opts){ {ordering: ['size', '-size'].sample} }
+
+        it 'validates that :from is a non-negative integer' do
+          valid = [0, 100500]
+          valid.each do |value|
+            expect{ api.file_list(opts.merge(from: value)) }.not_to raise_error
+          end
+
+          invalid = [-1, 200.0, "string", false]
+          invalid.each do |value|
+            expect{ api.file_list(opts.merge(from: value)) }.to raise_error(ArgumentError)
+          end
+        end
+      end
+
+      context 'when ordering is "datetime_uploaded", "-datetime_uploaded" or nil' do
+        let(:opts){ {ordering: ['datetime_uploaded', '-datetime_uploaded', nil].sample} }
+
+        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.file_list(opts.merge(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.file_list(opts.merge(from: value)) }.to raise_error(ArgumentError)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/api/file_storage_api_spec.rb

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