ffi-gphoto2 0.4.1 → 0.5.0

data/spec/gphoto2/camera_abilities_list_spec.rb

@@ -5,8 +5,8 @@ module GPhoto2
     let(:context) { double('context') }
 
     before do
-      CameraAbilitiesList.any_instance.stub(:new)
-      CameraAbilitiesList.any_instance.stub(:load)
+      allow_any_instance_of(CameraAbilitiesList).to receive(:new)
+      allow_any_instance_of(CameraAbilitiesList).to receive(:load)
     end
 
     describe '#detect' do
@@ -14,7 +14,7 @@ module GPhoto2
         camera_list = double('camera_list')
 
         abilities_list = CameraAbilitiesList.new(context)
-        abilities_list.stub(:_detect).and_return(camera_list)
+        allow(abilities_list).to receive(:_detect).and_return(camera_list)
 
         expect(abilities_list.detect).to eq(camera_list)
       end
@@ -25,7 +25,7 @@ module GPhoto2
         index = 0
 
         list = CameraAbilitiesList.new(context)
-        list.stub(:_lookup_model).and_return(index)
+        allow(list).to receive(:_lookup_model).and_return(index)
 
         expect(list.lookup_model('model')).to eq(index)
       end
@@ -35,7 +35,7 @@ module GPhoto2
       it 'returns a new CameraAbilities instance at the specified index' do
         abilities = double('camera_abilities')
 
-        CameraAbilities.stub(:new).and_return(abilities)
+        allow(CameraAbilities).to receive(:new).and_return(abilities)
         list = CameraAbilitiesList.new(context)
 
         expect(list.at(0)).to eq(abilities)

data/spec/gphoto2/camera_abilities_spec.rb

@@ -6,7 +6,7 @@ module GPhoto2
     let(:index) { 0 }
 
     before do
-      CameraAbilities.any_instance.stub(:get_abilities)
+      allow_any_instance_of(CameraAbilities).to receive(:get_abilities)
     end
 
     describe '.find' do
@@ -14,13 +14,13 @@ module GPhoto2
         abilities = double('camera_abilities')
 
         context = double('context')
-        context.stub(:finalize)
-        Context.stub(:new).and_return(context)
+        allow(context).to receive(:finalize)
+        allow(Context).to receive(:new).and_return(context)
 
         camera_abilities_list = double('camera_abilities_list')
-        CameraAbilitiesList.stub(:new).and_return(camera_abilities_list)
-        camera_abilities_list.stub(:lookup_model).and_return(0)
-        camera_abilities_list.stub(:[]).and_return(abilities)
+        allow(CameraAbilitiesList).to receive(:new).and_return(camera_abilities_list)
+        allow(camera_abilities_list).to receive(:lookup_model).and_return(0)
+        allow(camera_abilities_list).to receive(:[]).and_return(abilities)
 
         expect(CameraAbilities.find('model')).to eq(abilities)
       end
@@ -30,7 +30,7 @@ module GPhoto2
       it 'returns the value at the given field' do
         key, value = :model, 'name'
         abilities = CameraAbilities.new(camera_abilities_list, index)
-        abilities.stub(:ptr).and_return({ key => value })
+        allow(abilities).to receive(:ptr).and_return({ key => value })
         expect(abilities[key]).to eq(value)
       end
     end

data/spec/gphoto2/camera_file_path_spec.rb

@@ -6,8 +6,8 @@ module GPhoto2
     let(:folder) { '/' }
 
     before do
-      CameraFilePath.any_instance.stub(:name).and_return(name)
-      CameraFilePath.any_instance.stub(:folder).and_return(folder)
+      allow_any_instance_of(CameraFilePath).to receive(:name).and_return(name)
+      allow_any_instance_of(CameraFilePath).to receive(:folder).and_return(folder)
     end
 
     describe '#name' do

data/spec/gphoto2/camera_file_spec.rb

@@ -8,22 +8,22 @@ module GPhoto2
     let(:data_and_size) { ['data', 384] }
 
     before do
-      CameraFile.any_instance.stub(:new)
-      CameraFile.any_instance.stub(:data_and_size).and_return(data_and_size)
+      allow_any_instance_of(CameraFile).to receive(:new)
+      allow_any_instance_of(CameraFile).to receive(:data_and_size).and_return(data_and_size)
     end
 
     describe '#preview' do
       context 'when a folder and file are set' do
         it 'returns false' do
           file = CameraFile.new(camera, folder, name)
-          expect(file.preview?).to be_false
+          expect(file.preview?).to be(false)
         end
       end
 
       context 'when no folder or file is set' do
         it 'returns true' do
           file = CameraFile.new(camera)
-          expect(file.preview?).to be_true
+          expect(file.preview?).to be(true)
         end
       end
     end
@@ -33,7 +33,7 @@ module GPhoto2
       let(:data) { data_and_size.first }
 
       before do
-        File.stub(:binwrite)
+        allow(File).to receive(:binwrite)
       end
 
       context 'when a pathname is passed' do
@@ -63,7 +63,7 @@ module GPhoto2
     describe '#data' do
       it 'returns the data of the camera file' do
         file = CameraFile.new(camera, folder, name)
-        file.stub(:data_and_size).and_return(data_and_size)
+        allow(file).to receive(:data_and_size).and_return(data_and_size)
         expect(file.data).to eq(data_and_size.first)
       end
     end
@@ -71,7 +71,7 @@ module GPhoto2
     describe '#size' do
       it 'returns the size of the camera file' do
         file = CameraFile.new(camera, folder, name)
-        file.stub(:data_and_size).and_return(data_and_size)
+        allow(file).to receive(:data_and_size).and_return(data_and_size)
         expect(file.size).to eq(data_and_size.last)
       end
     end

data/spec/gphoto2/camera_folder_spec.rb

@@ -32,7 +32,7 @@ module GPhoto2
         folder = CameraFolder.new(camera)
 
         folders = 2.times.map { folder }
-        folder.stub(:folder_list_folders).and_return(folders)
+        allow(folder).to receive(:folder_list_folders).and_return(folders)
 
         expect(folder.folders).to eq(folders)
       end
@@ -44,7 +44,7 @@ module GPhoto2
 
         file = double('camera_file')
         files = 2.times.map { file }
-        folder.stub(:folder_list_files).and_return(files)
+        allow(folder).to receive(:folder_list_files).and_return(files)
 
         expect(folder.files).to eq(files)
       end
@@ -77,7 +77,7 @@ module GPhoto2
     describe '#open' do
       it 'returns a new CameraFile of a file in the folder' do
         file = double('camera_file')
-        CameraFile.stub(:new).and_return(file)
+        allow(CameraFile).to receive(:new).and_return(file)
 
         folder = CameraFolder.new(camera)
         expect(folder.open('capt0001.jpg')).to eq(file)

data/spec/gphoto2/camera_list_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 module GPhoto2
   describe CameraList do
     before do
-      CameraList.any_instance.stub(:new)
+      allow_any_instance_of(CameraList).to receive(:new)
     end
 
     describe '#size' do
@@ -11,7 +11,7 @@ module GPhoto2
         size = 2
 
         list = CameraList.new
-        list.stub(:count).and_return(size)
+        allow(list).to receive(:count).and_return(size)
 
         expect(list.size).to eq(size)
       end
@@ -22,7 +22,7 @@ module GPhoto2
         size = 2
 
         list = CameraList.new
-        list.stub(:size).and_return(size)
+        allow(list).to receive(:size).and_return(size)
 
         ary = list.to_a
 

data/spec/gphoto2/camera_spec.rb

@@ -5,16 +5,20 @@ module GPhoto2
     let(:model) { 'Nikon DSC D5100 (PTP mode)' }
     let(:port) { 'usb:250,006' }
 
+    it_behaves_like Camera::Capture
+    it_behaves_like Camera::Configuration
+    it_behaves_like Camera::Event
+    it_behaves_like Camera::Filesystem
+
     describe '.all' do
       let(:abilities_list) { double('camera_abilities_list') }
       let(:camera_list) { double('camera_list') }
       let(:camera) { Camera.new(model, port) }
 
       before do
-        Context.stub(:stub)
-        CameraAbilitiesList.stub(:new).and_return(abilities_list)
-        abilities_list.stub(:detect).and_return(camera_list)
-        camera_list.stub_chain(:to_a, :map).and_return([camera])
+        allow(CameraAbilitiesList).to receive(:new).and_return(abilities_list)
+        allow(abilities_list).to receive(:detect).and_return(camera_list)
+        allow(camera_list).to receive_message_chain(:to_a, :map).and_return([camera])
       end
 
       it 'returns a list of device entries' do
@@ -26,16 +30,34 @@ module GPhoto2
 
     describe '.first' do
       context 'when devices are automatically detected' do
-        it 'returns a new Camera using the first entry' do
-          camera = Camera.new(model, port)
-          Camera.stub(:all).and_return([camera])
-          expect(Camera.first).to be_kind_of(Camera)
+        let(:camera) { Camera.new(model, port) }
+
+        before do
+          allow(Camera).to receive(:all).and_return([camera])
+        end
+
+        context 'when a block is given' do
+          it 'yeilds the first detected camera' do
+            expect(Camera).to receive(:first).and_yield(camera)
+            Camera.first { |c| }
+          end
+
+          it 'finalizes the camera when the block terminates' do
+            expect(camera).to receive(:finalize)
+            Camera.first { |c| }
+          end
+        end
+
+        context 'when no block is given' do
+          it 'returns a new Camera using the first entry' do
+            expect(Camera.first).to be_kind_of(Camera)
+          end
         end
       end
 
       context 'when no devices are detected' do
         it 'raises a RuntimeError' do
-          Camera.stub(:all).and_return([])
+          allow(Camera).to receive(:all).and_return([])
           expect { Camera.first }.to raise_error(RuntimeError)
         end
       end
@@ -43,7 +65,7 @@ module GPhoto2
 
     describe '.open' do
       let(:camera) { double('camera') }
-      before { Camera.stub(:new).and_return(camera) }
+      before { allow(Camera).to receive(:new).and_return(camera) }
 
       context 'when a block is given' do
         it 'yeilds a new camera instance' do
@@ -74,7 +96,7 @@ module GPhoto2
       end
 
       before do
-        Camera.stub(:all).and_return(cameras)
+        allow(Camera).to receive(:all).and_return(cameras)
       end
 
       it 'filters all detected cameras by model' do
@@ -93,286 +115,29 @@ module GPhoto2
     describe '#exit' do
       it 'closes the camera connection' do
         camera = Camera.new(model, port)
-        camera.stub(:_exit)
+        allow(camera).to receive(:_exit)
         expect(camera).to receive(:_exit)
         camera.exit
       end
     end
 
-    describe '#capture' do
-      let(:camera) { Camera.new(model, port) }
-      let(:path) { double('camera_file_path', folder: 'folder', name: 'name') }
-
-      before do
-        camera.stub(:_capture).and_return(path)
-      end
-
-      it 'saves the camera configuration' do
-        expect(camera).to receive(:save)
-        camera.capture
-      end
-
-      it 'returns a new CameraFile' do
-        expect(camera).to receive(:_capture)
-        expect(camera.capture).to be_kind_of(CameraFile)
-      end
-    end
-
-    describe '#preview' do
-      let(:camera) { Camera.new(model, port) }
-      let(:file) { double('camera_file') }
-
-      before do
-        camera.stub(:save)
-        camera.stub(:capture_preview).and_return(file)
-      end
-
-      it 'saves the camera configuration' do
-        expect(camera).to receive(:save)
-        camera.preview
-      end
-
-      it 'returns a new CameraFile' do
-        expect(camera.preview).to eq(file)
-      end
-    end
-
-    describe '#wait' do
-      let(:camera) { Camera.new(model, port) }
-      let(:event) { double('camera_event') }
-
-      before do
-        camera.stub(:wait_for_event).and_return(event)
-      end
-
-      it 'waits for a camera event' do
-        expect(camera).to receive(:wait_for_event)
-        camera.wait
-      end
-
-      it 'returns an event symbol' do
-        expect(camera.wait).to eq(event)
-      end
-    end
-
-    describe '#wait_for' do
-      let(:camera) { Camera.new(model, port) }
-      let(:event) { double('camera_event', type: :capture_complete) }
-
-      before do
-        camera.stub(:wait).and_return(event)
-      end
-
-      it 'blocks until a given event is returned from #wait' do
-        expect(camera).to receive(:wait)
-        camera.wait_for(:capture_complete)
-      end
-
-      it 'returns the first event of the given type' do
-        expect(camera.wait_for(:capture_complete)).to eq(event)
-      end
-    end
-
-    describe '#window' do
-      let(:camera) { Camera.new(model, port) }
-      let(:window) { double('camera_widget') }
-
-      it 'always returns the same CameraWidget instance' do
-        camera.stub(:get_config).and_return(window)
-        expect(camera.window).to eq(window)
-        expect(camera.window).to eq(window)
-      end
-    end
-
-    describe '#config' do
-      it 'returns a map of configuration widgets' do
-        camera = Camera.new(model, port)
-        window = double('camera_widget')
-        camera.stub(:window).and_return(window)
-        window.stub(:flatten).and_return({ 'iso' => window })
-
-        expect(camera.config).to eq({ 'iso' => window })
-      end
-    end
-
-    describe '#filesystem' do
-      let(:camera) { Camera.new(model, port) }
-
-      context 'when a path is passed' do
-        let(:path) { '/store_00010001' }
-
-        it 'assumes the path is absolute' do
-          fs = camera.filesystem(path[1..-1])
-          expect(fs.path).to eq(path)
-        end
-
-        it 'returns a folder at the path that was passed' do
-          fs = camera.filesystem(path)
-          expect(fs.path).to eq(path)
-        end
-      end
-
-      context 'when no path is passed' do
-        it 'returns a folder at the root of the filesystem' do
-          fs = camera.filesystem
-          expect(fs.path).to eq('/')
-        end
-      end
-    end
-
-    describe '#file' do
-      it 'retrieves a file from the camera' do
-        camera = Camera.new(model, port)
-        camera.stub(:file_get)
-        expect(camera).to receive(:file_get)
-        camera.file(double('camera_file'))
-      end
-    end
-
-    describe '#delete' do
-      it 'deletes a file from the camera' do
-        camera = Camera.new(model, port)
-        camera.stub(:file_delete)
-        expect(camera).to receive(:file_delete)
-        camera.delete(double('camera_file'))
-      end
-    end
-
-    describe '#[]' do
-      let(:window) { double('camera_widget') }
-
-      let(:camera) do
-        camera = Camera.new(model, port)
-        camera.stub(:config).and_return({ 'iso' => window })
-        camera
-      end
-
-      context 'when the specified key exists' do
-        it 'returns a CameraWidget' do
-          expect(camera['iso']).to eq(window)
-        end
-      end
-
-      context 'when the specified key does not exist' do
-        it 'returns nil' do
-          expect(camera['shutterspeed2']).to be_nil
-        end
-      end
-    end
-
-    describe '#[]=' do
-      let(:window) do
-        window = double('camera_widget')
-        expect(window).to receive(:value=).with(400)
-        window
-      end
-
-      let(:camera) do
-        camera = Camera.new(model, port)
-        camera.stub(:[]).and_return(window)
-        camera
-      end
-
-      it "sets a widget's value" do
-        camera['iso'] = 400
-      end
-
-      it 'marks the camera as dirty' do
-        camera['iso'] = 400
-        expect(camera).to be_dirty
-      end
-
-      it 'returns the passed value' do
-        expect(camera['iso'] = 400).to eq(400)
-      end
-    end
-
-    describe '#update' do
-      let(:camera) do
-        camera = Camera.new(model, port)
-        camera.stub(:[]=)
-        camera.stub(:save)
-        camera
-      end
-
-      it 'sets one or more camera setting' do
-        expect(camera).to receive(:[]=).exactly(2).times
-        camera.update('iso' => 400, 'shutterspeed2' => '1/30')
-      end
-
-       it 'immediately saves the settings to the camera' do
-        expect(camera).to receive(:save)
-        camera.update
-       end
-    end
-
-    describe '#dirty?' do
-      context 'when the configuration changed' do
-        it 'returns true' do
-          camera = Camera.new(model, port)
-          camera.stub_chain(:[], :value=)
-
-          camera['iso'] = 400
-
-          expect(camera).to be_dirty
-        end
-      end
-
-      context 'when the configuration has not changed' do
-        it 'returns false' do
-          camera = Camera.new(model, port)
-          expect(camera).not_to be_dirty 
-        end
-      end
-    end
-
     describe '#can?' do
       let(:camera) { Camera.new(model, port) }
       let(:operations) { FFI::GPhoto2::CameraOperation[:capture_image] }
 
       before do
-        camera.stub_chain(:abilities, :[])
-          .with(:operations)
-          .and_return(operations)
+        allow(camera).to receive_message_chain(:abilities, :[]).and_return(operations)
       end
 
       context 'when the camera does not have the ability perform an operation' do
         it 'return false' do
-          expect(camera.can?(:capture_audio)).to be_false
+          expect(camera.can?(:capture_audio)).to be(false)
         end
       end
 
       context 'when the camera does have the ability to perform an operation' do
         it 'returns true' do
-          expect(camera.can?(:capture_image)).to be_true
-        end
-      end
-    end
-
-    describe '#save' do
-      let(:camera) do
-        camera = Camera.new(model, port)
-        camera.stub_chain(:[], :value=)
-        camera.stub(:set_config)
-        camera
-      end
-
-      context 'when the camera is marked as dirty' do
-        it 'returns true' do
-          camera['iso'] = 400
-          expect(camera.save).to be_true
-        end
-
-        it 'marks the camera as not dirty' do
-          camera['iso'] = 400
-          camera.save
-          expect(camera).not_to be_dirty
-        end
-      end
-
-      context 'when the camera is not marked as dirty' do
-        it 'returns false' do
-          expect(camera.save).to be_false
+          expect(camera.can?(:capture_image)).to be(true)
         end
       end
     end