ffi-gdal 1.0.0.beta5 → 1.0.0.beta6

data/spec/integration/gdal/raster_band_info_spec.rb

@@ -1,329 +1,298 @@
 require 'spec_helper'
-require 'support/integration_help'
 require 'ffi-gdal'
+require 'gdal'
 
-TIF_FILES.each do |file|
-  dataset = GDAL::Dataset.open(file, 'r')
+RSpec.describe 'Raster Band Info', type: :integration do
+  let(:original_tiff) do
+    path = '../../../spec/support/images/osgeo/geotiff/GeogToWGS84GeoKey/GeogToWGS84GeoKey5.tif'
+    File.expand_path(path, __dir__)
+  end
 
-  dataset.each_band do |band_under_test|
-    RSpec.describe 'Raster Band Info' do
-      after :suite do
-        dataset.close
-      end
+  let(:tmp_tiff) { make_temp_test_file(original_tiff) }
+  let(:dataset) { GDAL::Dataset.open(tmp_tiff, 'w') }
+  after { dataset.close }
+  subject { dataset.raster_band(1) }
 
-      # TODO: Test against each raster band
-      subject do
-        GDAL::RasterBand.new(band_under_test.c_pointer)
-      end
+  it_behaves_like 'a major object'
 
-      it_behaves_like 'a major object'
+  describe '#x_size' do
+    it 'is a non-zero Integer' do
+      expect(subject.x_size).to be_a Fixnum
+      expect(subject.x_size).to be > 0
+    end
+  end
 
-      describe '#x_size' do
-        it 'is a non-zero Integer' do
-          expect(subject.x_size).to be_a Fixnum
-          expect(subject.x_size).to be > 0
-        end
-      end
+  describe '#y_size' do
+    it 'is a non-zero Integer' do
+      expect(subject.y_size).to be_a Fixnum
+      expect(subject.y_size).to be > 0
+    end
+  end
 
-      describe '#y_size' do
-        it 'is a non-zero Integer' do
-          expect(subject.y_size).to be_a Fixnum
-          expect(subject.y_size).to be > 0
-        end
-      end
+  describe '#access_flag' do
+    specify { expect(subject.access_flag).to eq :GA_Update }
+  end
 
-      describe '#access_flag' do
-        specify { expect(subject.access_flag).to eq :GA_ReadOnly }
-      end
+  describe '#number' do
+    it 'is a non-zero Integer' do
+      expect(subject.number).to be_a Fixnum
+      expect(subject.number).to be > 0
+    end
+  end
 
-      describe '#number' do
-        it 'is a non-zero Integer' do
-          expect(subject.number).to be_a Fixnum
-          expect(subject.number).to be > 0
-        end
-      end
+  describe '#color_interpretation' do
+    it 'is a Symbol; one of FFI::GDAL::GDAL::ColorInterp' do
+      expect(subject.color_interpretation).to be_a Symbol
+      expect(FFI::GDAL::GDAL::ColorInterp.symbols).to include subject.color_interpretation
+    end
+  end
 
-      describe '#color_interpretation' do
-        it 'is a Symbol; one of FFI::GDAL::ColorInterp' do
-          expect(subject.color_interpretation).to be_a Symbol
-          expect(FFI::GDAL::ColorInterp.symbols).to include subject.color_interpretation
-        end
+  describe '#color_table' do
+    it 'is a GDAL::ColorTable' do
+      if subject.color_table
+        expect(subject.color_table).to be_a GDAL::ColorTable
       end
+    end
+  end
 
-      describe '#color_table' do
-        it 'is a GDAL::ColorTable' do
-          if subject.color_table
-            expect(subject.color_table).to be_a GDAL::ColorTable
-          end
-        end
-      end
+  describe '#data_type' do
+    it 'is a Symbol; one of FFI::GDAL::GDAL::DataType' do
+      expect(subject.data_type).to be_a Symbol
+      expect(FFI::GDAL::GDAL::DataType.symbols).to include subject.data_type
+    end
+  end
 
-      describe '#data_type' do
-        it 'is a Symbol; one of FFI::GDAL::DataType' do
-          expect(subject.data_type).to be_a Symbol
-          expect(FFI::GDAL::DataType.symbols).to include subject.data_type
-        end
-      end
+  describe '#block_size' do
+    it 'is a Hash with x and y keys that are >= 1' do
+      expect(subject.block_size).to be_a Hash
+      expect(subject.block_size[:x]).to be >= 1
+      expect(subject.block_size[:y]).to be >= 1
+    end
+  end
+
+  describe '#category_names' do
+    it 'is an Array of Strings' do
+      expect(subject.category_names).to be_an Array
 
-      describe '#block_size' do
-        it 'is a Hash with x and y keys that are >= 1' do
-          expect(subject.block_size).to be_a Hash
-          expect(subject.block_size[:x]).to be >= 1
-          expect(subject.block_size[:y]).to be >= 1
-        end
+      subject.category_names.each do |category_name|
+        expect(category_name).to be_a String
+        expect(category_name).to_not be_empty
       end
+    end
+  end
 
-      describe '#category_names' do
-        it 'is an Array of Strings' do
-          expect(subject.category_names).to be_an Array
+  describe '#category_names=' do
+    it 'sets the category names' do
+      subject.category_names = %w[one two three]
 
-          subject.category_names.each do |category_name|
-            expect(category_name).to be_a String
-            expect(category_name).to_not be_empty
-          end
-        end
-      end
+      expect(subject.category_names).to eq %w[one two three]
+    end
+  end
 
-      describe '#category_names=' do
-        around do |example|
-          category_names = subject.category_names
-          example.run
-          subject.category_names = category_names
-        end
+  describe '#no_data_value' do
+    it 'is a Hash with :value and :is_associated keys' do
+      expect(subject.no_data_value).to be_an Hash
 
-        it 'sets the category names' do
-          expect(subject.category_names).to be_empty
+      expect(subject.no_data_value[:value]).to be_a Float
+      expect(subject.no_data_value[:is_associated]).to_not be_nil
+    end
+  end
 
-          subject.category_names = %w[one two three]
+  describe '#overview_count' do
+    it 'is a Fixnum' do
+      expect(subject.overview_count).to be_a Fixnum
+    end
+  end
 
-          expect(subject.category_names).to eq %w[one two three]
-        end
-      end
+  describe '#arbitrary_overviews?' do
+    it 'is true or false' do
+      expect([true, false]).to include subject.arbitrary_overviews?
+    end
+  end
 
-      describe '#no_data_value' do
-        it 'is a Hash with :value and :is_associated keys' do
-          expect(subject.no_data_value).to be_an Hash
+  describe '#overview' do
+    it 'returns a GDAL::RasterBand if the overview exists' do
+      overview = subject.overview(0)
+      expect(overview).to be_a GDAL::RasterBand if overview
+    end
+  end
 
-          expect(subject.no_data_value[:value]).to be_a Float
-          expect(subject.no_data_value[:is_associated]).to_not be_nil
-        end
-      end
+  describe '#raster_sample_overview' do
+    it 'returns a GDAL::RasterBand if the overview exists' do
+      overview = subject.raster_sample_overview
+      expect(overview).to be_a GDAL::RasterBand
+    end
+  end
 
-      describe '#overview_count' do
-        it 'is a Fixnum' do
-          expect(subject.overview_count).to be_a Fixnum
-        end
-      end
+  describe '#mask_band' do
+    it 'returns a GDAL::RasterBand if the mask_band exists' do
+      overview = subject.mask_band
+      expect(overview).to be_a GDAL::RasterBand
+    end
+  end
 
-      describe '#arbitrary_overviews?' do
-        it 'is true or false' do
-          expect([true, false]).to include subject.arbitrary_overviews?
-        end
-      end
+  describe '#mask_flags' do
+    it 'returns an Array of Symbols' do
+      expect(subject.mask_flags).to eq([:GMF_ALL_VALID]).or eq([:GMF_PER_DATASET])
+    end
+  end
 
-      describe '#overview' do
-        it 'returns a GDAL::RasterBand if the overview exists' do
-          overview = subject.overview(0)
-          expect(overview).to be_a GDAL::RasterBand if overview
-        end
-      end
+  describe '#statistics' do
+    it 'returns a Hash with populated values' do
+      expect(subject.statistics).to be_a Hash
+      expect(%i[minimum maximum mean standard_deviation]).
+        to eq subject.statistics.keys
+    end
 
-      describe '#raster_sample_overview' do
-        it 'returns a GDAL::RasterBand if the overview exists' do
-          overview = subject.raster_sample_overview
-          expect(overview).to be_a GDAL::RasterBand
-        end
+    it 'has a :minimum that ranges between 0.0/-32768.0 and 255.0' do
+      min = subject.statistics[:minimum]
+      unless min == -32_768.0
+        expect(subject.statistics[:minimum]).to satisfy { |v| v >= 0 || v == -32_768 }
+        expect(subject.statistics[:minimum]).to be <= 255.0
       end
+    end
+  end
 
-      describe '#mask_band' do
-        it 'returns a GDAL::RasterBand if the mask_band exists' do
-          overview = subject.mask_band
-          expect(overview).to be_a GDAL::RasterBand
-        end
-      end
+  describe '#scale' do
+    it 'returns a Hash with populated values' do
+      expect(subject.scale).to be_a Hash
+      expect(%i[value is_meaningful]).to eq subject.scale.keys
+    end
 
-      describe '#mask_flags' do
-        it 'returns an Array of Symbols' do
-          expect(subject.mask_flags).to eq([:GMF_ALL_VALID]).or eq([:GMF_PER_DATASET])
-        end
-      end
+    it 'has a :value that is a Float' do
+      expect(subject.scale[:value]).to be_a Float
+    end
 
-      describe '#statistics' do
-        it 'returns a Hash with populated values' do
-          expect(subject.statistics).to be_a Hash
-          expect(%i[minimum maximum mean standard_deviation]).
-            to eq subject.statistics.keys
-        end
-
-        it 'has a :minimum that ranges between 0.0/-32768.0 and 255.0' do
-          min = subject.statistics[:minimum]
-          unless min == -32_768.0
-            expect(subject.statistics[:minimum]).to (be >= 0.0).or eq(-32_768.0)
-            expect(subject.statistics[:minimum]).to be <= 255.0
-          end
-        end
-      end
+    it 'has a :is_meaningful that is false (since the examples are geotiffs)' do
+      expect(subject.scale[:is_meaningful]).to eq false
+    end
+  end
 
-      describe '#scale' do
-        it 'returns a Hash with populated values' do
-          expect(subject.scale).to be_a Hash
-          expect(%i[value is_meaningful]).to eq subject.scale.keys
-        end
+  describe '#scale=' do
+    it 'does nothing (because the file formats dont support it)' do
+      subject.scale = 0.1
+      expect(subject.scale[:value]).to eq 0.1
+    end
+  end
 
-        it 'has a :value that is a Float' do
-          expect(subject.scale[:value]).to be_a Float
-        end
+  describe '#offset' do
+    it 'returns a Hash with populated values' do
+      expect(subject.offset).to be_a Hash
+      expect(%i[value is_meaningful]).to eq subject.offset.keys
+    end
 
-        it 'has a :is_meaningful that is false (since the examples are geotiffs)' do
-          expect(subject.scale[:is_meaningful]).to eq false
-        end
-      end
+    it 'has a :value that is a Float' do
+      expect(subject.offset[:value]).to be_a Float
+    end
 
-      describe '#scale=' do
-        around do |example|
-          scale = subject.scale[:value]
-          example.run
-          subject.scale = scale
-        end
-
-        it 'does nothing (because the file formats dont support it)' do
-          subject.scale = 0.1
-          expect(subject.scale[:value]).to eq 0.1
-        end
-      end
+    it 'has a :is_meaningful that is false (since the examples are geotiffs)' do
+      expect(subject.offset[:is_meaningful]).to eq false
+    end
+  end
 
-      describe '#offset' do
-        it 'returns a Hash with populated values' do
-          expect(subject.offset).to be_a Hash
-          expect(%i[value is_meaningful]).to eq subject.offset.keys
-        end
+  describe '#offset=' do
+    it 'does nothing (because the file formats dont support it)' do
+      subject.offset = 0.1
+      expect(subject.offset[:value]).to eq 0.1
+    end
+  end
 
-        it 'has a :value that is a Float' do
-          expect(subject.offset[:value]).to be_a Float
-        end
+  describe '#unit_type' do
+    it 'returns a String' do
+      expect(subject.unit_type).to be_a String
+    end
+  end
 
-        it 'has a :is_meaningful that is false (since the examples are geotiffs)' do
-          expect(subject.offset[:is_meaningful]).to eq false
-        end
+  describe '#unit_type=' do
+    it 'does nothing (because the file formats dont support it)' do
+      if defined? FFI::GDAL::GDAL::GDALSetRasterUnitType
+        subject.unit_type = 'ft'
+        expect(subject.unit_type).to eq 'ft'
+      else
+        skip 'GDALSetRasterUnitType not supported'
       end
+    end
+  end
 
-      describe '#offset=' do
-        around do |example|
-          offset = subject.offset[:value]
-          example.run
-          subject.offset = offset
-        end
-
-        it 'does nothing (because the file formats dont support it)' do
-          subject.offset = 0.1
-          expect(subject.offset[:value]).to eq 0.1
-        end
-      end
+  describe '#default_histogram' do
+    let!(:histogram) { subject.default_histogram }
 
-      describe '#unit_type' do
-        it 'returns a String' do
-          expect(subject.unit_type).to be_a String
-        end
+    it 'returns a Hash with :minimum, :maximum, :buckets, and :totals' do
+      if histogram
+        expect(histogram).to be_a Hash
+        expect(histogram.keys).to eq %i[minimum maximum buckets totals]
       end
+    end
 
-      describe '#unit_type=' do
-        around do |example|
-          unit_type = subject.unit_type
-          example.run
-          subject.unit_type = unit_type
-        end
-
-        it 'does nothing (because the file formats dont support it)' do
-          if defined? FFI::GDAL::GDALSetRasterUnitType
-            subject.unit_type = 'ft'
-            expect(subject.unit_type).to eq 'ft'
-          else
-            skip 'GDALSetRasterUnitType not supported'
-          end
-        end
-      end
+    it 'has :minimum as a Float' do
+      expect(histogram[:minimum]).to be_a Float if histogram
+    end
 
-      describe '#default_histogram' do
-        let!(:histogram) { subject.default_histogram }
-
-        it 'returns a Hash with :minimum, :maximum, :buckets, and :totals' do
-          if histogram
-            expect(histogram).to be_a Hash
-            expect(histogram.keys).to eq %i[minimum maximum buckets totals]
-          end
-        end
-
-        it 'has :minimum as a Float' do
-          expect(histogram[:minimum]).to be_a Float if histogram
-        end
-
-        it 'has :maximum as a Float' do
-          expect(histogram[:maximum]).to be_a Float if histogram
-        end
-
-        it 'has :buckets as a Fixnum' do
-          expect(histogram[:buckets]).to be_a Fixnum if histogram
-        end
-
-        it 'has :totals as an Array of 0 or 256 Fixnums' do
-          if histogram
-            expect(histogram[:totals]).to be_an Array
-            expect(histogram[:totals].size).to eq(256).or eq(0)
-            expect(histogram[:totals].all? { |t| t.class == Fixnum }).to eq true
-          end
-        end
-      end
+    it 'has :maximum as a Float' do
+      expect(histogram[:maximum]).to be_a Float if histogram
+    end
 
-      describe '#default_raster_attribute_table' do
-        it 'returns a GDAL::RasterAttributeTable' do
-          rat = subject.default_raster_attribute_table
+    it 'has :buckets as a Fixnum' do
+      expect(histogram[:buckets]).to be_a Fixnum if histogram
+    end
 
-          expect(rat).to be_a GDAL::RasterAttributeTable if rat
-        end
+    it 'has :totals as an Array of 0 or 256 Fixnums' do
+      if histogram
+        expect(histogram[:totals]).to be_an Array
+        expect(histogram[:totals].size).to eq(256).or eq(0)
+        expect(histogram[:totals].all? { |t| t.class == Fixnum }).to eq true
       end
+    end
+  end
 
-      describe '#min_max' do
-        it 'returns a Hash with :min and :max keys' do
-          expect(subject.min_max).to be_a Hash
-          expect(subject.min_max.size).to eq 2
-          expect(subject.min_max[:min]).to be_a Float
-          expect(subject.min_max[:max]).to be_a Float
-        end
-
-        it 'has a min that is < its max' do
-          expect(subject.min_max[:min]).to be < subject.min_max[:max]
-        end
-      end
+  describe '#default_raster_attribute_table' do
+    it 'returns a GDAL::RasterAttributeTable' do
+      rat = subject.default_raster_attribute_table
 
-      describe '#minimum_value' do
-        it 'returns a Hash with populated values' do
-          expect(subject.minimum_value).to be_a Hash
-          expect(%i[value is_tight]).to eq subject.minimum_value.keys
-        end
+      expect(rat).to be_a GDAL::RasterAttributeTable if rat
+    end
+  end
 
-        it 'has a :value that is a Float' do
-          expect(subject.minimum_value[:value]).to be_a Float
-        end
+  describe '#min_max' do
+    it 'returns a Hash with :min and :max keys' do
+      expect(subject.min_max).to be_a Hash
+      expect(subject.min_max.size).to eq 2
+      expect(subject.min_max[:min]).to be_a Float
+      expect(subject.min_max[:max]).to be_a Float
+    end
 
-        it 'has a :is_tight that is nil (since the examples are geotiffs)' do
-          # expect(subject.minimum_value[:is_tight]).to eq nil
-        end
-      end
+    it 'has a min that is < its max' do
+      expect(subject.min_max[:min]).to be < subject.min_max[:max]
+    end
+  end
 
-      describe '#maximum_value' do
-        it 'returns a Hash with populated values' do
-          expect(subject.maximum_value).to be_a Hash
-          expect(%i[value is_tight]).to eq subject.maximum_value.keys
-        end
+  describe '#minimum_value' do
+    it 'returns a Hash with populated values' do
+      expect(subject.minimum_value).to be_a Hash
+      expect(%i[value is_tight]).to eq subject.minimum_value.keys
+    end
 
-        it 'has a :value that is a Float' do
-          expect(subject.maximum_value[:value]).to be_a Float
-        end
+    it 'has a :value that is a Float' do
+      expect(subject.minimum_value[:value]).to be_a Float
+    end
 
-        it 'has a :is_tight that is nil (since the examples are geotiffs)' do
-          # expect(subject.maximum_value[:is_tight]).to eq nil
-        end
-      end
+    it 'has a :is_tight that is nil (since the examples are geotiffs)' do
+      # expect(subject.minimum_value[:is_tight]).to eq nil
+    end
+  end
+
+  describe '#maximum_value' do
+    it 'returns a Hash with populated values' do
+      expect(subject.maximum_value).to be_a Hash
+      expect(%i[value is_tight]).to eq subject.maximum_value.keys
+    end
+
+    it 'has a :value that is a Float' do
+      expect(subject.maximum_value[:value]).to be_a Float
+    end
+
+    it 'has a :is_tight that is nil (since the examples are geotiffs)' do
+      # expect(subject.maximum_value[:is_tight]).to eq nil
     end
   end
 end

data/spec/integration/ogr/layer_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
+require 'ogr'
 
-RSpec.describe OGR::Layer do
+RSpec.describe 'OGR::Layer' do
   let(:data_source) do
     OGR::DataSource.open('spec/support/shapefiles/states_21basic/states.shp', 'r')
   end
@@ -35,6 +36,7 @@ RSpec.describe OGR::Layer do
 
   describe '#next_feature' do
     subject { layer0.next_feature }
+    after { subject.destroy! }
     it { is_expected.to be_a OGR::Feature }
   end
 

data/spec/spec_helper.rb

@@ -9,9 +9,9 @@ end
 
 $LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
 require 'ffi-gdal'
+require 'byebug'
 
-require './spec/support/shared_contexts'
-Dir['./spec/support/shared_examples/**/*.rb'].sort.each { |f| require f }
+Dir['./spec/support/**/*.rb'].sort.each { |f| require f }
 
 # This file was generated by the `rspec --init` command. Conventionally, all
 # specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
@@ -81,13 +81,13 @@ RSpec.configure do |config|
     # Use the documentation formatter for detailed output,
     # unless a formatter has already been configured
     # (e.g. via a command-line flag).
-    # config.default_formatter = 'doc'
+    config.default_formatter = 'doc'
   end
 
   # Print the 10 slowest examples and example groups at the
   # end of the spec run, to help surface which specs are running
   # particularly slow.
-  config.profile_examples = 3
+  config.profile_examples = 10
 
   # Run specs in random order to surface order dependencies. If you find an
   # order dependency and want to debug it, you can fix the order by providing
@@ -100,6 +100,15 @@ RSpec.configure do |config|
   # test failures related to randomization by passing the same `--seed` value
   # as the one that triggered the failure.
   Kernel.srand config.seed
-end
 
-GDAL::Logger.logging_enabled = true
+  config.include IntegrationHelp, type: :integration
+
+  config.before do
+    ::FFI::GDAL::GDAL.GDALAllRegister
+    Dir[File.join('tmp', '*')].each { |f| File.unlink(f) if File.exist?(f) }
+  end
+
+  config.after(:example, type: :integration) do
+    cleanup_test_files
+  end
+end