geo_combine 0.4.0 → 0.6.0

data/spec/lib/geo_combine/geo_blacklight_harvester_spec.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'spec_helper'
+require 'rsolr'
+
+RSpec.describe GeoCombine::GeoBlacklightHarvester do
+  subject(:harvester) { described_class.new(site_key) }
+
+  let(:site_key) { :INSTITUTION }
+  let(:stub_json_response) { '{}' }
+  let(:stub_solr_connection) { double('RSolr::Connection') }
+
+  before do
+    allow(described_class).to receive(:config).and_return({
+                                                            INSTITUTION: {
+                                                              host: 'https://example.com/',
+                                                              params: {
+                                                                f: { dct_provenance_s: ['INSTITUTION'] }
+                                                              }
+                                                            }
+                                                          })
+  end
+
+  describe 'initialization' do
+    context 'when an unconfigured site is sent in' do
+      let(:site_key) { 'unknown' }
+
+      it { expect { harvester }.to raise_error(ArgumentError) }
+    end
+  end
+
+  describe '#index' do
+    before do
+      expect(Net::HTTP).to receive(:get).with(
+        URI('https://example.com?f%5Bdct_provenance_s%5D%5B%5D=INSTITUTION&format=json&per_page=100&page=1')
+      ).and_return(stub_json_response)
+      allow(RSolr).to receive(:connect).and_return(stub_solr_connection)
+    end
+
+    let(:docs) { [{ layer_slug_s: 'abc-123' }, { layer_slug_s: 'abc-321' }] }
+    let(:stub_json_response) do
+      { response: { docs: docs, pages: { current_page: 1, total_pages: 1 } } }.to_json
+    end
+
+    it 'adds documents returned to solr' do
+      expect(stub_solr_connection).to receive(:update).with(hash_including(data: docs.to_json)).and_return(nil)
+      harvester.index
+    end
+
+    describe 'document tranformations' do
+      let(:docs) do
+        [
+          { layer_slug_s: 'abc-123', _version_: '1', timestamp: '1999-12-31', score: 0.1,
+            solr_bboxtype__minX: -87.324704, solr_bboxtype__minY: 40.233691, solr_bboxtype__maxX: -87.174404, solr_bboxtype__maxY: 40.310695 },
+          { layer_slug_s: 'abc-321', dc_source_s: 'abc-123' }
+        ]
+      end
+
+      context 'when a tranformer is set' do
+        before do
+          expect(described_class).to receive(:document_transformer).at_least(:once).and_return(
+            lambda { |doc|
+              doc.delete('_version_')
+              doc
+            }
+          )
+        end
+
+        it 'removes the _version_ field as requested' do
+          expect(stub_solr_connection).to receive(:update).with(
+            hash_including(
+              data: [
+                { layer_slug_s: 'abc-123', timestamp: '1999-12-31', score: 0.1, solr_bboxtype__minX: -87.324704,
+                  solr_bboxtype__minY: 40.233691, solr_bboxtype__maxX: -87.174404, solr_bboxtype__maxY: 40.310695 },
+                { layer_slug_s: 'abc-321', dc_source_s: 'abc-123' }
+              ].to_json
+            )
+          ).and_return(nil)
+
+          harvester.index
+        end
+      end
+
+      context 'when no transformer is set' do
+        it 'removes the _version_, timestamp, score, and solr_bboxtype__* fields' do
+          expect(stub_solr_connection).to receive(:update).with(
+            hash_including(
+              data: [
+                { layer_slug_s: 'abc-123' },
+                { layer_slug_s: 'abc-321', dc_source_s: 'abc-123' }
+              ].to_json
+            )
+          ).and_return(nil)
+
+          harvester.index
+        end
+      end
+    end
+  end
+
+  describe 'BlacklightResponseVersionFactory' do
+    let(:version_class) { described_class::BlacklightResponseVersionFactory.call(json) }
+
+    context 'when a legacy blacklight version (6 and earlier)' do
+      let(:json) { { 'response' => {} } }
+
+      it { expect(version_class).to be described_class::LegacyBlacklightResponse }
+    end
+
+    context 'when a modern blacklight version (7 and later)' do
+      let(:json) { { 'links' => {}, 'data' => [] } }
+
+      it { expect(version_class).to be described_class::ModernBlacklightResponse }
+    end
+
+    context 'when a the JSON response is not recognizable' do
+      let(:json) { { error: 'Broken' } }
+
+      it { expect { version_class }.to raise_error(NotImplementedError) }
+    end
+  end
+
+  describe 'LegacyBlacklightResponse' do
+    before do
+      allow(RSolr).to receive(:connect).and_return(stub_solr_connection)
+    end
+
+    let(:first_docs) {  [{ 'layer_slug_s' => 'abc-123' }, { 'layer_slug_s' => 'abc-321' }] }
+    let(:second_docs) { [{ 'layer_slug_s' => 'xyz-123' }, { 'layer_slug_s' => 'xyz-321' }] }
+    let(:stub_first_response) do
+      { 'response' => { 'docs' => first_docs, 'pages' => { 'current_page' => 1, 'total_pages' => 2 } } }
+    end
+    let(:stub_second_response) do
+      { 'response' => { 'docs' => second_docs, 'pages' => { 'current_page' => 2, 'total_pages' => 2 } } }
+    end
+
+    describe '#documents' do
+      it 'pages through the response and returns all the documents' do
+        expect(Net::HTTP).to receive(:get).with(
+          URI('https://example.com?f%5Bdct_provenance_s%5D%5B%5D=INSTITUTION&format=json&per_page=100&page=2')
+        ).and_return(stub_second_response.to_json)
+        base_url = 'https://example.com?f%5Bdct_provenance_s%5D%5B%5D=INSTITUTION&format=json&per_page=100'
+        docs = described_class::LegacyBlacklightResponse.new(response: stub_first_response,
+                                                             base_url: base_url).documents
+
+        expect(docs.to_a).to eq([first_docs, second_docs])
+      end
+    end
+  end
+
+  describe 'ModernBlacklightResponse' do
+    before do
+      allow(RSolr).to receive(:connect).and_return(stub_solr_connection)
+      expect(Net::HTTP).to receive(:get).with(
+        URI('https://example.com/catalog.json?f%5Bdct_provenance_s%5D%5B%5D=INSTITUTION&per_page=100&page=2&format=json')
+      ).and_return(second_results_response.to_json)
+    end
+
+    let(:first_results_response) do
+      { 'data' => [
+        { 'links' => { 'self' => 'https://example.com/catalog/abc-123' } },
+        { 'links' => { 'self' => 'https://example.com/catalog/abc-321' } }
+      ],
+        'links' => { 'next' => 'https://example.com/catalog.json?f%5Bdct_provenance_s%5D%5B%5D=INSTITUTION&per_page=100&page=2' } }
+    end
+
+    let(:second_results_response) do
+      { 'data' => [
+        { 'links' => { 'self' => 'https://example.com/catalog/xyz-123' } },
+        { 'links' => { 'self' => 'https://example.com/catalog/xyz-321' } }
+      ] }
+    end
+
+    describe '#documents' do
+      it 'pages through the response and fetches documents for each "link" on the response data' do
+        %w[abc-123 abc-321 xyz-123 xyz-321].each do |id|
+          expect(Net::HTTP).to receive(:get).with(
+            URI("https://example.com/catalog/#{id}/raw")
+          ).and_return({ 'layer_slug_s' => id }.to_json)
+        end
+
+        base_url = 'https://example.com?f%5Bdct_provenance_s%5D%5B%5D=INSTITUTION&format=json&per_page=100'
+        docs = described_class::ModernBlacklightResponse.new(response: first_results_response,
+                                                             base_url: base_url).documents
+
+        expect(docs.to_a).to eq([
+                                  [{ 'layer_slug_s' => 'abc-123' }, { 'layer_slug_s' => 'abc-321' }],
+                                  [{ 'layer_slug_s' => 'xyz-123' }, { 'layer_slug_s' => 'xyz-321' }]
+                                ])
+      end
+    end
+  end
+end

data/spec/lib/geo_combine/geoblacklight_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe GeoCombine::Geoblacklight do
@@ -5,68 +7,84 @@ RSpec.describe GeoCombine::Geoblacklight do
   include JsonDocs
   include GeoCombine::Exceptions
   let(:full_geobl) { described_class.new(full_geoblacklight) }
+  let(:enhanced_geobl) { described_class.new(basic_geoblacklight, 'layer_geom_type_s' => 'esriGeometryPolygon') }
   let(:basic_geobl) { described_class.new(basic_geoblacklight) }
   let(:pre_v1_geobl) { described_class.new(geoblacklight_pre_v1) }
+  let(:enhanced_geobl) { described_class.new(basic_geoblacklight, 'layer_geom_type_s' => 'esriGeometryPolygon') }
+
+  before { enhanced_geobl.enhance_metadata }
+
   describe '#initialize' do
     it 'parses metadata argument JSON to Hash' do
       expect(basic_geobl.instance_variable_get(:@metadata)).to be_an Hash
     end
+
     describe 'merges fields argument into metadata' do
-      let(:basic_geobl) { described_class.new(basic_geoblacklight, 'dc_identifier_s' => 'new one', "extra_field" => true)}
+      let(:basic_geobl) do
+        described_class.new(basic_geoblacklight, 'dc_identifier_s' => 'new one', 'extra_field' => true)
+      end
+
       it 'overwrites existing metadata fields' do
         expect(basic_geobl.metadata['dc_identifier_s']).to eq 'new one'
       end
+
       it 'adds in new fields' do
         expect(basic_geobl.metadata['extra_field']).to be true
       end
     end
   end
+
   describe '#metadata' do
     it 'reads the metadata instance variable' do
       expect(basic_geobl.metadata).to be_an Hash
       expect(basic_geobl.metadata).to have_key 'dc_identifier_s'
     end
   end
+
   describe '#to_json' do
     it 'returns valid json' do
       expect(valid_json?(full_geobl.to_json)).to be_truthy
       expect(valid_json?(basic_geobl.to_json)).to be_truthy
     end
   end
-  let(:enhanced_geobl) { described_class.new(basic_geoblacklight, 'layer_geom_type_s' => 'esriGeometryPolygon') }
-  before { enhanced_geobl.enhance_metadata }
+
   describe '#enhance_metadata' do
     it 'enhances the dc_subject_sm field' do
       expect(enhanced_geobl.metadata['dc_subject_sm']).to include 'Boundaries', 'Inland Waters'
     end
+
     it 'formats the date properly as ISO8601' do
       expect(enhanced_geobl.metadata['layer_modified_dt']).to match(/Z$/)
     end
+
     it 'formats the geometry type field' do
       expect(enhanced_geobl.metadata['layer_geom_type_s']).to eq 'Polygon'
     end
   end
+
   describe '#valid?' do
     it 'a valid geoblacklight-schema document should be valid' do
       expect(full_geobl.valid?).to be true
     end
+
     context 'must have required fields' do
-      %w(
+      %w[
         dc_title_s
         dc_identifier_s
         dc_rights_s
         dct_provenance_s
         layer_slug_s
         solr_geom
-      ).each do |field|
+      ].each do |field|
         it field do
           full_geobl.metadata.delete field
           expect { full_geobl.valid? }.to raise_error(JSON::Schema::ValidationError, /#{field}/)
         end
       end
     end
+
     context 'need not have optional fields' do
-      %w(
+      %w[
         dc_description_s
         dc_format_s
         dc_language_s
@@ -83,46 +101,52 @@ RSpec.describe GeoCombine::Geoblacklight do
         layer_id_s
         layer_modified_dt
         solr_year_i
-      ).each do |field|
+      ].each do |field|
         it field do
           full_geobl.metadata.delete field
           expect { full_geobl.valid? }.not_to raise_error
         end
       end
     end
+
     context 'need not have deprecated fields' do
-      %w(
+      %w[
         dc_relation_sm
         dc_type_s
         georss_box_s
         georss_point_s
         uuid
-      ).each do |field|
+      ].each do |field|
         it field do
           full_geobl.metadata.delete field
           expect { full_geobl.valid? }.not_to raise_error
         end
       end
     end
+
     it 'an invalid document' do
       expect { basic_geobl.valid? }.to raise_error JSON::Schema::ValidationError
     end
+
     it 'calls the dct_references_s validator' do
       expect(enhanced_geobl).to receive(:dct_references_validate!)
       enhanced_geobl.valid?
     end
+
     it 'validates spatial bounding box' do
       expect(JSON::Validator).to receive(:validate!).and_return true
       expect { basic_geobl.valid? }
         .to raise_error GeoCombine::Exceptions::InvalidGeometry
     end
   end
+
   describe '#dct_references_validate!' do
     context 'with valid document' do
       it 'is valid' do
         expect(full_geobl.dct_references_validate!).to be true
       end
     end
+
     context 'with invalid document' do
       let(:unparseable_json) do
         <<-JSON
@@ -133,35 +157,41 @@ RSpec.describe GeoCombine::Geoblacklight do
         JSON
       end
       let(:bad_ref) do
-        GeoCombine::Geoblacklight.new(
+        described_class.new(
           basic_geoblacklight, 'dct_references_s' => unparseable_json, 'layer_geom_type_s' => 'esriGeometryPolygon'
         )
       end
       let(:not_hash) do
-        GeoCombine::Geoblacklight.new(
+        described_class.new(
           basic_geoblacklight, 'dct_references_s' => '[{}]', 'layer_geom_type_s' => 'esriGeometryPolygon'
         )
       end
+
       before do
         bad_ref.enhance_metadata
         not_hash.enhance_metadata
       end
+
       it 'unparseable json' do
         expect { bad_ref.dct_references_validate! }.to raise_error JSON::ParserError
       end
+
       it 'not a hash' do
         expect { not_hash.dct_references_validate! }.to raise_error GeoCombine::Exceptions::InvalidDCTReferences
       end
     end
   end
+
   describe 'spatial_validate!' do
     context 'when valid' do
       it { full_geobl.spatial_validate! }
     end
+
     context 'when invalid' do
       it { expect { basic_geobl.spatial_validate! }.to raise_error GeoCombine::Exceptions::InvalidGeometry }
     end
   end
+
   describe 'upgrade_to_v1' do
     before do
       expect(pre_v1_geobl).to receive(:upgrade_to_v1).and_call_original

data/spec/lib/geo_combine/iso19139_spec.rb

@@ -1,46 +1,58 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe GeoCombine::Iso19139 do
   include XmlDocs
-  let(:iso_object){ GeoCombine::Iso19139.new(stanford_iso) }
+  let(:iso_object) { described_class.new(stanford_iso) }
+
   describe '#initialize' do
     it 'returns an instantiated Iso19139 object' do
-      expect(iso_object).to be_an GeoCombine::Iso19139
+      expect(iso_object).to be_an described_class
     end
   end
+
   describe '#xsl_geoblacklight' do
-    it 'should be defined' do
+    it 'is defined' do
       expect(iso_object.xsl_geoblacklight).to be_an Nokogiri::XSLT::Stylesheet
     end
   end
+
   describe '#xsl_html' do
-    it 'should be defined' do
+    it 'is defined' do
       expect(iso_object.xsl_geoblacklight).to be_an Nokogiri::XSLT::Stylesheet
     end
   end
+
   describe '#to_geoblacklight' do
     let(:valid_geoblacklight) { iso_object.to_geoblacklight('layer_geom_type_s' => 'Polygon') }
-    it 'should create a GeoCombine::Geoblacklight object' do
+
+    it 'creates a GeoCombine::Geoblacklight object' do
       expect(valid_geoblacklight).to be_an GeoCombine::Geoblacklight
     end
+
     it 'is valid GeoBlacklight-Schema' do
       valid_geoblacklight.enhance_metadata
-      expect(valid_geoblacklight.valid?).to be_truthy
+      expect(valid_geoblacklight).to be_valid
     end
-    it 'should have geoblacklight_version' do
+
+    it 'has geoblacklight_version' do
       expect(valid_geoblacklight.metadata['geoblacklight_version']).to eq '1.0'
     end
-    it 'should have dc_creator_sm' do
-      expect(valid_geoblacklight.metadata["dc_creator_sm"]).to be_an Array
-      expect(valid_geoblacklight.metadata["dc_creator_sm"]).to eq ["Circuit Rider Productions"]
+
+    it 'has dc_creator_sm' do
+      expect(valid_geoblacklight.metadata['dc_creator_sm']).to be_an Array
+      expect(valid_geoblacklight.metadata['dc_creator_sm']).to eq ['Circuit Rider Productions']
     end
-    it 'should have dc_publisher_sm' do
-      expect(valid_geoblacklight.metadata["dc_publisher_sm"]).to be_an Array
-      expect(valid_geoblacklight.metadata["dc_publisher_sm"]).to eq ["Circuit Rider Productions"]
+
+    it 'has dc_publisher_sm' do
+      expect(valid_geoblacklight.metadata['dc_publisher_sm']).to be_an Array
+      expect(valid_geoblacklight.metadata['dc_publisher_sm']).to eq ['Circuit Rider Productions']
     end
   end
+
   describe '#to_html' do
-    it 'should create a transformation of the metadata as a String' do
+    it 'creates a transformation of the metadata as a String' do
       expect(iso_object.to_html).to be_an String
     end
   end

data/spec/lib/geo_combine/ogp_spec.rb

@@ -1,11 +1,14 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe GeoCombine::OGP do
   include JsonDocs
 
-  subject(:ogp) { GeoCombine::OGP.new(ogp_harvard_raster) }
-  let(:ogp_tufts) { GeoCombine::OGP.new(ogp_tufts_vector) }
-  let(:ogp_line) { GeoCombine::OGP.new(ogp_harvard_line) }
+  subject(:ogp) { described_class.new(ogp_harvard_raster) }
+
+  let(:ogp_tufts) { described_class.new(ogp_tufts_vector) }
+  let(:ogp_line) { described_class.new(ogp_harvard_line) }
   let(:metadata) { ogp.instance_variable_get(:@metadata) }
 
   describe '#initialize' do
@@ -26,36 +29,46 @@ RSpec.describe GeoCombine::OGP do
       it 'with dc_identifier_s' do
         expect(ogp.geoblacklight_terms).to include(dc_identifier_s: 'HARVARD.SDE2.G1059_W57_1654_PF_SH1')
       end
+
       it 'with dc_title_s' do
         expect(ogp.geoblacklight_terms).to include(dc_title_s: 'World Map, 1654 (Raster Image)')
       end
+
       it 'with dc_description_s sanitized' do
         expect(ogp.geoblacklight_terms).to include(dc_description_s: metadata['Abstract'])
       end
+
       it 'with dc_rights_s' do
         expect(ogp.geoblacklight_terms).to include(dc_rights_s: 'Public')
         expect(ogp_line.geoblacklight_terms).to include(dc_rights_s: 'Restricted')
       end
+
       it 'with dct_provenance_s' do
         expect(ogp.geoblacklight_terms).to include(dct_provenance_s: 'Harvard')
       end
+
       it 'with dct_references_s' do
         expect(ogp.geoblacklight_terms).to include(:dct_references_s)
       end
+
       it 'with layer_id_s that is blank' do
         expect(ogp.geoblacklight_terms)
           .to include(layer_id_s: "#{metadata['WorkspaceName']}:#{metadata['Name']}")
       end
+
       it 'with layer_geom_type_s' do
         expect(ogp.geoblacklight_terms).to include(:layer_geom_type_s)
       end
+
       it 'with layer_slug_s' do
         expect(ogp.geoblacklight_terms)
           .to include(layer_slug_s: 'harvard-g1059-w57-1654-pf-sh1')
       end
+
       it 'with solr_geom' do
         expect(ogp.geoblacklight_terms).to include(:solr_geom)
       end
+
       it 'with dc_subject_sm' do
         expect(ogp.geoblacklight_terms).to include(
           dc_subject_sm: [
@@ -65,6 +78,7 @@ RSpec.describe GeoCombine::OGP do
           ]
         )
       end
+
       it 'with dct_spatial_sm' do
         expect(ogp.geoblacklight_terms).to include(
           dct_spatial_sm: [
@@ -82,6 +96,7 @@ RSpec.describe GeoCombine::OGP do
     it 'when Paper Map use Raster' do
       expect(ogp.ogp_geom).to eq 'Raster'
     end
+
     it 'anything else, return it' do
       expect(ogp_tufts.ogp_geom).to eq 'Polygon'
     end
@@ -90,13 +105,13 @@ RSpec.describe GeoCombine::OGP do
   describe '#ogp_formats' do
     context 'when Paper Map or Raster' do
       it 'returns GeoTIFF' do
-        %w[Raster Paper\ Map].each do |datatype|
+        ['Raster', 'Paper Map'].each do |datatype|
           expect(ogp).to receive(:metadata).and_return('DataType' => datatype)
           expect(ogp.ogp_formats).to eq 'GeoTIFF'
         end
-
       end
     end
+
     context 'when Polygon, Line, or Point' do
       it 'returns Shapefile' do
         %w[Polygon Line Point].each do |datatype|
@@ -105,6 +120,7 @@ RSpec.describe GeoCombine::OGP do
         end
       end
     end
+
     context 'unknown data types' do
       it 'throws exception' do
         expect(ogp).to receive(:metadata).twice.and_return('DataType' => 'Unknown')
@@ -117,6 +133,7 @@ RSpec.describe GeoCombine::OGP do
     it 'properly formatted envelope' do
       expect(ogp.envelope).to eq 'ENVELOPE(-180.0, 180.0, 90.0, -90.0)'
     end
+
     it 'fails on out-of-bounds envelopes' do
       expect(ogp).to receive(:west).and_return(-181)
       expect { ogp.envelope }.to raise_error(ArgumentError)
@@ -132,6 +149,7 @@ RSpec.describe GeoCombine::OGP do
         )
       end
     end
+
     context 'tufts vector' do
       it 'has wms wfs services' do
         expect(JSON.parse(ogp_tufts.references)).to include(
@@ -140,6 +158,7 @@ RSpec.describe GeoCombine::OGP do
         )
       end
     end
+
     context 'harvard line' do
       it 'has restricted services' do
         expect(JSON.parse(ogp_line.references)).to include(
@@ -153,11 +172,12 @@ RSpec.describe GeoCombine::OGP do
 
   describe 'valid geoblacklight schema' do
     context 'harvard' do
-      it { expect { ogp.to_geoblacklight.valid? }.to_not raise_error }
-      it { expect { ogp_line.to_geoblacklight.valid? }.to_not raise_error }
+      it { expect { ogp.to_geoblacklight.valid? }.not_to raise_error }
+      it { expect { ogp_line.to_geoblacklight.valid? }.not_to raise_error }
     end
+
     context 'tufts' do
-      it { expect { ogp_tufts.to_geoblacklight.valid? }.to_not raise_error }
+      it { expect { ogp_tufts.to_geoblacklight.valid? }.not_to raise_error }
     end
   end
 end

data/spec/lib/geo_combine_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe GeoCombine::Metadata do
@@ -6,14 +8,15 @@ RSpec.describe GeoCombine::Metadata do
     it 'reads metadata from file if File is readable' do
       expect(File).to receive(:readable?).and_return(true)
       expect(File).to receive(:read).and_return(simple_xml)
-      metadata_object = GeoCombine::Metadata.new('./tmp/fake/file/location')
-      expect(metadata_object).to be_an GeoCombine::Metadata
+      metadata_object = described_class.new('./tmp/fake/file/location')
+      expect(metadata_object).to be_an described_class
       expect(metadata_object.metadata).to be_an Nokogiri::XML::Document
       expect(metadata_object.metadata.css('Author').count).to eq 2
     end
+
     it 'reads metadata from parameter if File is not readable' do
-      metadata_object = GeoCombine::Metadata.new(simple_xml)
-      expect(metadata_object).to be_an GeoCombine::Metadata
+      metadata_object = described_class.new(simple_xml)
+      expect(metadata_object).to be_an described_class
       expect(metadata_object.metadata).to be_an Nokogiri::XML::Document
       expect(metadata_object.metadata.css('Author').count).to eq 2
     end

data/spec/lib/tasks/geo_combine_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'rake'
+
+describe 'geo_combine.rake' do
+  before(:all) do
+    load File.expand_path('../../../lib/tasks/geo_combine.rake', __dir__)
+    Rake::Task.define_task(:environment)
+  end
+
+  before do
+    allow(ENV).to receive(:[]).and_call_original
+    allow(ENV).to receive(:[]).with('OGM_PATH').and_return(File.join(fixture_dir, 'indexing'))
+  end
+
+  describe 'geocombine:clone' do
+    before do
+      WebMock.disable_net_connect!
+    end
+
+    after do
+      WebMock.allow_net_connect!
+    end
+
+    it 'does not clone repos on deny list' do
+      stub_request(:get, 'https://api.github.com/orgs/opengeometadata/repos').to_return(status: 200, body: read_fixture('docs/repos.json'))
+      allow(Kernel).to receive(:system)
+      Rake::Task['geocombine:clone'].invoke
+      expect(Kernel).to have_received(:system).exactly(21).times
+    end
+  end
+
+  describe 'geocombine:index' do
+    it 'only indexes .json files but not layers.json' do
+      rsolr_mock = instance_double('RSolr::Client')
+      allow(rsolr_mock).to receive(:update)
+      allow(rsolr_mock).to receive(:commit)
+      allow(RSolr).to receive(:connect).and_return(rsolr_mock)
+      Rake::Task['geocombine:index'].invoke
+      # We expect 2 files to index
+      expect(rsolr_mock).to have_received(:update).exactly(2).times
+    end
+  end
+end