browse-everything 0.15.1 → 0.16.0

data/spec/lib/browse_everything/driver/google_drive_spec.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+include BrowserConfigHelper
+
+describe BrowseEverything::Driver::GoogleDrive, vcr: { cassette_name: 'google_drive', record: :none } do
+  let(:browser) { BrowseEverything::Browser.new(url_options) }
+  let(:provider) { browser.providers['google_drive'] }
+  let(:provider_yml) do
+    {
+      client_id: 'CLIENTID', client_secret: 'CLIENTSECRET',
+      url_options: { port: '3000', protocol: 'http://', host: 'example.com' }
+    }
+  end
+
+  before do
+    stub_configuration
+  end
+
+  after do
+    unstub_configuration
+  end
+
+  describe 'simple properties' do
+    subject { provider }
+
+    its(:name)      { is_expected.to eq('Google Drive') }
+    its(:key)       { is_expected.to eq('google_drive') }
+    its(:icon)      { is_expected.to eq('google-plus-sign') }
+  end
+
+  describe '#validate_config' do
+    it 'raises and error with an incomplete configuration' do
+      expect { BrowseEverything::Driver::GoogleDrive.new({}) }.to raise_error(BrowseEverything::InitializationError)
+    end
+
+    it 'raises and error with a configuration without a client secret' do
+      expect { BrowseEverything::Driver::GoogleDrive.new(client_id: 'test-client-id') }.to raise_error(BrowseEverything::InitializationError)
+    end
+  end
+
+  context 'without valid credentials' do
+    let(:driver) { described_class.new(provider_yml) }
+
+    describe '#token=' do
+      let(:value) { 'test' }
+
+      it 'restores the credentials' do
+        allow(driver).to receive(:restore_credentials)
+        driver.token = value
+        expect(driver).to have_received(:restore_credentials).with('test')
+      end
+
+      context 'when set to a Hash' do
+        let(:value) { { 'access_token' => 'test' } }
+
+        before do
+          driver.token = value
+        end
+
+        it 'sets the access token value' do
+          expect(driver.token).to be_a String
+          expect(driver.token).to eq 'test'
+        end
+      end
+    end
+  end
+
+  context 'with a valid connection' do
+    let(:driver) { described_class.new(provider_yml) }
+
+    before do
+      driver.connect({ code: 'code' }, {})
+    end
+
+    describe '#authorized?' do
+      it 'is authorized' do
+        expect(driver.authorized?).to be true
+      end
+    end
+
+    describe '#contents' do
+      subject(:contents) { driver.contents.to_a }
+
+      let(:drive_service_class) { class_double(Google::Apis::DriveV3::DriveService).as_stubbed_const(transfer_nested_constants: true) }
+      let(:drive_service) { instance_double(Google::Apis::DriveV3::DriveService) }
+      let(:file_list) { instance_double(Google::Apis::DriveV3::FileList) }
+      let(:file1) { instance_double(Google::Apis::DriveV3::File) }
+      let(:file2) { instance_double(Google::Apis::DriveV3::File) }
+      let(:files) { [file1, file2] }
+
+      before do
+        allow(file1).to receive(:id).and_return('asset-id2')
+        allow(file2).to receive(:id).and_return('directory-id1')
+        allow(file1).to receive(:name).and_return('asset-name2.pdf')
+        allow(file2).to receive(:name).and_return('directory-name1')
+        allow(file1).to receive(:size).and_return('891764')
+        allow(file2).to receive(:size).and_return('0')
+        allow(file1).to receive(:modified_time).and_return(Time.current)
+        allow(file2).to receive(:modified_time).and_return(Time.current)
+        allow(file1).to receive(:mime_type).and_return('application/pdf')
+        allow(file2).to receive(:mime_type).and_return('application/vnd.google-apps.folder')
+        allow(file_list).to receive(:files).and_return(files)
+        allow(file_list).to receive(:next_page_token).and_return(nil)
+        allow(drive_service).to receive(:list_files).and_yield(file_list, nil)
+        allow(drive_service).to receive(:batch).and_yield(drive_service)
+        allow(drive_service).to receive(:authorization=)
+        allow(drive_service).to receive(:tap).and_yield(drive_service).and_return(drive_service)
+        allow(drive_service_class).to receive(:new).and_return(drive_service)
+      end
+
+      it 'retrieves files' do
+        expect(contents).not_to be_empty
+
+        expect(contents.first).to be_a BrowseEverything::FileEntry
+        expect(contents.first.location).to eq 'google_drive:directory-id1'
+        expect(contents.first.mtime).to be_a Time
+        expect(contents.first.name).to eq 'directory-name1'
+        expect(contents.first.size).to eq 0
+        expect(contents.first.type).to eq 'directory'
+
+        expect(contents.last).to be_a BrowseEverything::FileEntry
+        expect(contents.last.location).to eq 'google_drive:asset-id2'
+        expect(contents.last.mtime).to be_a Time
+        expect(contents.last.name).to eq 'asset-name2.pdf'
+        expect(contents.last.size).to eq 891764
+        expect(contents.last.type).to eq 'application/pdf'
+      end
+
+      context 'when an error is encountered while authenticating' do
+        before do
+          allow(drive_service).to receive(:list_files).and_yield(file_list, Google::Apis::Error.new('test error'))
+        end
+
+        it 'raises an exception' do
+          expect { driver.contents.to_a }.to raise_error(Google::Apis::Error, 'test error')
+        end
+      end
+    end
+
+    describe '#link_for' do
+      subject(:link) { driver.link_for('asset-id2') }
+
+      it 'generates the link for a Google Drive asset' do
+        expect(link).to be_an Array
+        expect(link.first).to eq 'https://www.googleapis.com/drive/v3/files/asset-id2?alt=media'
+        expect(link.last).to be_a Hash
+        expect(link.last).to include auth_header: { 'Authorization' => 'Bearer access-token' }
+        expect(link.last).to include :expires
+        expect(link.last).to include file_name: 'asset-name2.pdf'
+        expect(link.last).to include file_size: 0
+      end
+    end
+
+    describe '#auth_link' do
+      subject(:uri) { driver.auth_link }
+
+      it 'exposes the authorization endpoint URI' do
+        expect(uri).to be_a Addressable::URI
+        expect(uri.to_s).to eq 'https://accounts.google.com/o/oauth2/auth?access_type=offline&approval_prompt=force&client_id=CLIENTID&include_granted_scopes=true&redirect_uri=http://example.com:3000/browse/connect&response_type=code&scope=https://www.googleapis.com/auth/drive'
+      end
+    end
+
+    describe '#drive' do
+      subject(:drive) { driver.drive_service }
+
+      it 'exposes the Google Drive API client' do
+        expect(drive).to be_a Google::Apis::DriveV3::DriveService
+      end
+    end
+  end
+end

data/spec/{unit → lib/browse_everything/driver}/s3_spec.rb

@@ -1,11 +1,20 @@
+# frozen_string_literal: true
+
 include BrowserConfigHelper
 
-describe BrowseEverything::Driver::FileSystem do
-  before(:all)   { stub_configuration   }
-  after(:all)    { unstub_configuration }
+describe BrowseEverything::Driver::S3 do
+  subject { provider }
+
   let(:browser)  { BrowseEverything::Browser.new(url_options) }
   let(:provider) { browser.providers['s3'] }
-  subject        { provider }
+
+  before do
+    stub_configuration
+  end
+
+  after do
+    unstub_configuration
+  end
 
   describe 'defaults' do
     its(:icon)   { is_expected.to eq('amazon')  }
@@ -14,34 +23,34 @@ describe BrowseEverything::Driver::FileSystem do
 
   describe 'configuration' do
     it '#validate_config' do
-      expect { BrowseEverything::Driver::S3.new({}) }.to raise_error(BrowseEverything::InitializationError)
+      expect { described_class.new({}) }.to raise_error(BrowseEverything::InitializationError)
     end
 
     it 'rejects app_key if app_secret is missing' do
-      expect { BrowseEverything::Driver::S3.new(bucket: 'bucket', app_key: 'APP_KEY') }.to raise_error(BrowseEverything::InitializationError)
+      expect { described_class.new(bucket: 'bucket', app_key: 'APP_KEY') }.to raise_error(BrowseEverything::InitializationError)
     end
 
     it 'rejects app_secret if app_key is missing' do
-      expect { BrowseEverything::Driver::S3.new(bucket: 'bucket', app_secret: 'APP_SECRET') }.to raise_error(BrowseEverything::InitializationError)
+      expect { described_class.new(bucket: 'bucket', app_secret: 'APP_SECRET') }.to raise_error(BrowseEverything::InitializationError)
     end
 
     it 'accepts app_key and app_secret together' do
-      expect { BrowseEverything::Driver::S3.new(bucket: 'bucket', app_key: 'APP_KEY', app_secret: 'APP_SECRET') }.not_to raise_error
+      expect { described_class.new(bucket: 'bucket', app_key: 'APP_KEY', app_secret: 'APP_SECRET') }.not_to raise_error
     end
 
     it 'rejects an invalid response type' do
-      expect { BrowseEverything::Driver::S3.new(bucket: 'bucket', response_type: :foo) }.to raise_error(BrowseEverything::InitializationError)
+      expect { described_class.new(bucket: 'bucket', response_type: :foo) }.to raise_error(BrowseEverything::InitializationError)
     end
 
     it 'deprecates :signed_url' do
-      driver = BrowseEverything::Driver::S3.new(bucket: 'bucket', signed_url: false)
+      driver = described_class.new(bucket: 'bucket', signed_url: false)
       expect(driver.config).not_to have_key(:signed_url)
       expect(driver.config[:response_type]).to eq(:public_url)
     end
   end
 
   describe '#contents' do
-    context 'root directory' do
+    context 'when in a root directory' do
       before do
         Aws.config[:s3] = {
           stub_responses: {
@@ -51,19 +60,22 @@ describe BrowseEverything::Driver::FileSystem do
       end
 
       let(:contents) { provider.contents('') }
-      context '[0]' do
+
+      context 'with a single asset' do
         subject { contents[0] }
+
         its(:name) { is_expected.to eq('bar') }
         specify    { is_expected.to be_container }
       end
-      context '[1]' do
+      context 'with two assets' do
         subject { contents[1] }
+
         its(:name) { is_expected.to eq('foo') }
         specify    { is_expected.to be_container }
       end
     end
 
-    context 'subdirectory' do
+    context 'when in a subdirectory' do
       before do
         Aws.config[:s3] = {
           stub_responses: {
@@ -81,21 +93,25 @@ describe BrowseEverything::Driver::FileSystem do
       end
 
       let(:contents) { provider.contents('foo/') }
-      context '[0]' do
+
+      context 'with a single directory' do
         subject { contents[0] }
+
         its(:name) { is_expected.to eq('..') }
         specify    { is_expected.to be_container }
       end
-      context '[1]' do
+      context 'with a JPEG asset' do
         subject { contents[1] }
+
         its(:name)     { is_expected.to eq('baz.jpg') }
         its(:location) { is_expected.to eq('s3:foo/baz.jpg')  }
         its(:type)     { is_expected.to eq('image/jpeg')      }
         its(:size)     { is_expected.to eq(52645)             }
         specify        { is_expected.not_to be_container }
       end
-      context '[2]' do
+      context 'with a PNG asset' do
         subject { contents[2] }
+
         its(:name)     { is_expected.to eq('quux.png') }
         its(:location) { is_expected.to eq('s3:foo/quux.png') }
         its(:type)     { is_expected.to eq('image/png')       }
@@ -103,8 +119,9 @@ describe BrowseEverything::Driver::FileSystem do
         specify        { is_expected.not_to be_container }
       end
 
-      context '#link_for' do
+      context 'when retrieving the link for an asset' do
         subject { contents[2] }
+
         before do
           object = instance_double(Aws::S3::Object)
           allow(object).to receive(:presigned_url).and_return('https://s3.amazonaws.com/presigned_url')
@@ -116,17 +133,17 @@ describe BrowseEverything::Driver::FileSystem do
 
         it ':signed_url' do
           provider.config[:response_type] = :signed_url
-          expect(provider.link_for('foo/quux.png')).to eq('https://s3.amazonaws.com/presigned_url')
+          expect(provider.link_for('foo/quux.png')).to eq ["https://s3.amazonaws.com/presigned_url", {:file_name=>"quux.png", :expires=>14400}]
         end
 
         it ':public_url' do
           provider.config[:response_type] = :public_url
-          expect(provider.link_for('foo/quux.png')).to eq('https://s3.amazonaws.com/public_url')
+          expect(provider.link_for('foo/quux.png')).to eq ["https://s3.amazonaws.com/public_url", {:file_name=>"quux.png"}]
         end
 
         it ':s3_uri' do
           provider.config[:response_type] = :s3_uri
-          expect(provider.link_for('foo/quux.png')).to eq('s3://s3.bucket/foo/quux.png')
+          expect(provider.link_for('foo/quux.png')).to eq ['s3://s3.bucket/foo/quux.png', {:file_name=>"quux.png"}]
         end
       end
     end

data/spec/lib/browse_everything/driver_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+describe BrowseEverything::Driver do
+
+  let(:my_driver) do
+    MyDriver.new
+  end
+
+  before do
+    class MyDriver
+      include BrowseEverything::Driver
+
+      def get_sorter
+        sorter
+      end
+    end
+  end
+
+  describe '#sorter' do
+    it 'defaults to nil' do
+      expect(BrowseEverything::Driver.sorter).to be nil
+    end
+  end
+
+  describe '#sorter=' do
+    let(:new_sorter) do
+      lambda { |files| }
+    end
+
+    before do
+      BrowseEverything::Driver.sorter = new_sorter
+    end
+
+    it 'mutates the sorter from the initializer' do
+      expect(my_driver.get_sorter).to eq new_sorter
+    end
+  end
+end

data/spec/{unit → lib/browse_everything}/file_entry_spec.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 describe BrowseEverything::FileEntry do
-  let(:mtime) { Time.now }
+  let(:mtime) { Time.current }
 
   describe 'regular file' do
     subject do
@@ -42,6 +44,7 @@ describe BrowseEverything::FileEntry do
         '..', '', mtime, true
       )
     end
+
     it { is_expected.to be_container }
     it { is_expected.to be_relative_parent_path }
 

data/spec/lib/browse_everything/retriever_spec.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+describe BrowseEverything::Retriever, vcr: { cassette_name: 'retriever', record: :none } do
+  let(:retriever) { described_class.new }
+  let(:datafile) { File.expand_path('../../fixtures/file_system/file_1.pdf', __dir__) }
+  let(:datafile_with_spaces) { File.expand_path('../../fixtures/file_system/file 1.pdf', __dir__) }
+  let(:data) { File.open(datafile, 'rb', &:read) }
+  let(:data_with_spaces) { File.open(datafile_with_spaces, 'rb', &:read) }
+  let(:size) { File.size(datafile) }
+
+  describe '#get_file_size' do
+    subject(:file_size) { retriever.file_size(options) }
+    let(:url) { URI.parse("file://#{datafile}") }
+    let(:headers) { [] }
+    let(:file_size) { 0 }
+    let(:options) do
+      {
+        url: url,
+        headers: headers,
+        file_size: file_size
+      }.with_indifferent_access
+    end
+
+    it 'calculates or retrieves the size of a file' do
+      retriever.retrieve(options) do |chunk, retrieved, total|
+        expect(total).to eq 2256
+      end
+    end
+
+    context "when retrieving a resource from a cloud storage provider" do
+      let(:url) { URI.parse("https://drive.google.com/uc?id=id&export=download") }
+
+      it 'calculates or retrieves the size of a file' do
+        retriever.retrieve(options) do |chunk, retrieved, total|
+          expect(total).to eq 1234
+        end
+      end
+    end
+
+    context "when retrieving a resource with an unsupported protocol" do
+      let(:url) { URI.parse("ftp://invalid") }
+
+      it "raises an error" do
+        expect { retriever.retrieve(options) {|c, r, t|} }.to raise_error(URI::BadURIError, "Unknown URI scheme: ftp")
+      end
+    end
+  end
+
+  context 'with a non-URI' do
+    let(:spec) do
+      {
+        '0' => {
+          'url' => '/some/dir/file.pdf',
+          'file_name' => 'file.pdf',
+          'file_size' => size.to_s
+        }
+      }
+    end
+
+    describe '#retrieve' do
+      it 'raises an error' do
+        expect { retriever.retrieve(spec['0']) }.to raise_error(URI::BadURIError)
+      end
+    end
+  end
+
+  context 'when retrieving using the HTTP' do
+    let(:expiry_time) { (Time.current + 3600).xmlschema }
+    let(:spec) do
+      {
+        '0' => {
+          'url' => 'https://retrieve.cloud.example.com/some/dir/file.pdf',
+          'auth_header' => { 'Authorization' => 'Bearer ya29.kQCEAHj1bwFXr2AuGQJmSGRWQXpacmmYZs4kzCiXns3d6H1ZpIDWmdM8' },
+          'expires' => expiry_time,
+          'file_name' => 'file.pdf',
+          'file_size' => size.to_s
+        }
+      }
+    end
+
+    context 'when retrieving data using chunked-encoded streams' do
+      it 'content' do
+        content = +''
+        retriever.retrieve(spec['0']) { |chunk, _retrieved, _total| content << chunk }
+        expect(content).to eq(data)
+      end
+
+      it 'callbacks' do
+        expect { |block| retriever.retrieve(spec['0'], &block) }.to yield_with_args(data, data.length, data.length)
+      end
+    end
+
+    context 'when downloading content' do
+      it 'content' do
+        file = retriever.download(spec['0'])
+        expect(File.open(file, 'rb', &:read)).to eq(data)
+      end
+
+      it 'callbacks' do
+        expect { |block| retriever.download(spec['0'], &block) }.to yield_with_args(String, data.length, data.length)
+      end
+    end
+
+    context 'when downloading content and a server error occurs' do
+      let(:spec) do
+        {
+          '0' => {
+            'url' => 'https://retrieve.cloud.example.com/some/dir/file_error.pdf',
+            'auth_header' => { 'Authorization' => 'Bearer ya29.kQCEAHj1bwFXr2AuGQJmSGRWQXpacmmYZs4kzCiXns3d6H1ZpIDWmdM8' },
+            'expires' => expiry_time,
+            'file_name' => 'file.pdf',
+            'file_size' => size.to_s
+          }
+        }
+      end
+      let(:download_options) { spec['0'] }
+
+      it 'raises an exception' do
+        expect { retriever.download(download_options) }.to raise_error(BrowseEverything::DownloadError, /BrowseEverything::Retriever: Failed to download/)
+      end
+    end
+  end
+
+  context 'when retrieving file content' do
+    let(:spec) do
+      {
+        '0' => {
+          'url' => "file://#{datafile}",
+          'file_name' => 'file.pdf',
+          'file_size' => size.to_s
+        },
+        '1' => {
+          'url' => "file://#{datafile_with_spaces}",
+          'file_name' => 'file.pdf',
+          'file_size' => size.to_s
+        }
+      }
+    end
+
+    context 'when retrieving data using chunked-encoded streams' do
+      it 'content' do
+        content = +''
+        retriever.retrieve(spec['0']) { |chunk, _retrieved, _total| content << chunk }
+        expect(content).to eq(data)
+      end
+
+      it 'content with spaces' do
+        content = +''
+        retriever.retrieve(spec['1']) { |chunk, _retrieved, _total| content << chunk }
+        expect(content).to eq(data_with_spaces)
+      end
+
+      it 'callbacks' do
+        expect { |block| retriever.retrieve(spec['0'], &block) }.to yield_with_args(data, data.length, data.length)
+      end
+    end
+
+    context 'when downloading content' do
+      it 'content' do
+        file = retriever.download(spec['0'])
+        expect(File.open(file, 'rb', &:read)).to eq(data)
+      end
+
+      it 'callbacks' do
+        expect { |block| retriever.download(spec['0'], &block) }.to yield_with_args(String, data.length, data.length)
+      end
+    end
+  end
+
+  context '.can_retrieve?' do
+    let(:expiry_time) { (Time.current + 3600).xmlschema }
+    let(:spec) do
+      {
+        '0' => {
+          'url' => url,
+          'auth_header' => { 'Authorization' => 'Bearer ya29.kQCEAHj1bwFXr2AuGQJmSGRWQXpacmmYZs4kzCiXns3d6H1ZpIDWmdM8' },
+          'expires' => expiry_time,
+          'file_name' => 'file.pdf',
+          'file_size' => '64134'
+        }
+      }
+    end
+
+    context 'can retrieve' do
+      let(:url) { 'https://retrieve.cloud.example.com/some/dir/can_retrieve.pdf' }
+
+      it 'says it can' do
+        expect(described_class.can_retrieve?(url)).to be_truthy
+      end
+    end
+
+    context 'cannot retrieve' do
+      let(:url) { 'https://retrieve.cloud.example.com/some/dir/cannot_retrieve.pdf' }
+
+      it 'says it cannot' do
+        expect(described_class.can_retrieve?(url)).to be_falsey
+      end
+    end
+  end
+end