geo_concerns 0.0.10 → 0.1.0

data/spec/processors/geo_concerns/processors/image_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe GeoConcerns::Processors::Image do
+  before do
+    class TestProcessor
+      include GeoConcerns::Processors::Image
+    end
+  end
+
+  after { Object.send(:remove_const, :TestProcessor) }
+
+  subject { TestProcessor.new }
+
+  let(:output_file_jpg) { 'output/geo.jpg' }
+  let(:output_file_png) { 'output/geo.png' }
+  let(:output_file) { output_file_png }
+  let(:file_name) { 'files/geo.tif' }
+  let(:options) { { output_size: '150 150' } }
+
+  describe '#convert' do
+    let(:image) { double }
+
+    before do
+      allow(MiniMagick::Image).to receive(:open).and_return(image)
+    end
+
+    it 'transforms the image and saves it as a PNG' do
+      expect(image).to receive(:format).with('png')
+      expect(image).to receive(:combine_options)
+      expect(image).to receive(:write).with(output_file_png)
+      subject.class.convert(file_name, output_file_png, options)
+    end
+
+    it 'transforms the image and saves it as a JPG' do
+      expect(image).to receive(:format).with('jpg')
+      expect(image).to receive(:combine_options)
+      expect(image).to receive(:write).with(output_file_jpg)
+      subject.class.convert(file_name, output_file_jpg, options)
+    end
+  end
+
+  describe '#trim' do
+    let(:shell) { double }
+    let(:args) { [["convert", "files/geo.tif", "-trim", "output/geo.png"], { whiny: true }] }
+
+    before do
+      allow(MiniMagick::Shell).to receive(:new).and_return(shell)
+    end
+    it 'transforms the image and saves it as a PNG' do
+      expect(shell).to receive(:run).with(*args).and_return('output message')
+      subject.class.trim(file_name, output_file_png, options)
+    end
+  end
+
+  describe '#center' do
+    let(:shell) { double }
+    let(:args) {
+      [['convert', '-size', '150x150', 'xc:white', 'files/geo.tif',
+        '-gravity', 'center', '-composite', 'output/geo.png'],
+       { whiny: true }]
+    }
+
+    before do
+      allow(MiniMagick::Shell).to receive(:new).and_return(shell)
+    end
+    it 'transforms the image and saves it as a PNG' do
+      expect(shell).to receive(:run).with(*args).and_return('output message')
+      subject.class.center(file_name, output_file_png, options)
+    end
+  end
+end

data/spec/processors/geo_concerns/processors/rendering_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe GeoConcerns::Processors::Rendering do
+  before do
+    class TestProcessor
+      include GeoConcerns::Processors::Rendering
+    end
+  end
+
+  after { Object.send(:remove_const, :TestProcessor) }
+
+  subject { TestProcessor.new }
+
+  let(:output_file) { 'output/geo.png' }
+  let(:file_name) { 'files' }
+  let(:options) { { output_size: '150 200' } }
+  let(:bounds) { { north: 40.0, east: -74.0, south: 40.0, west: -74.0 } }
+  let(:info) { instance_double(GeoConcerns::Processors::Vector::Info, name: 'test', bounds: bounds) }
+  let(:config) {
+    {
+      'stroke' => '#483d8b',
+      'line-cap' => 'square',
+      'line-join' => 'miter',
+      'weight' => '0.3',
+      'fill' => '#e4e3ea',
+      'radius' => '2'
+    }
+  }
+
+  before do
+    allow(GeoConcerns::Processors::Vector::Info).to receive(:new).and_return(info)
+    allow(SimplerTiles.config).to receive(:to_h).and_return(config)
+    allow(SimplerTiles.config).to receive(:bg_color).and_return('#ffffff00')
+    allow(Dir).to receive(:glob).and_return(['test.shp'])
+  end
+
+  describe '#vector_thumbnail' do
+    it 'saves a vector thumbnail using simpler tiles' do
+      expect(File).to receive(:open).with(output_file, 'wb')
+      subject.class.vector_thumbnail(file_name, output_file, options)
+    end
+  end
+
+  describe '#simple_tiles_map' do
+    subject { described_class.simple_tiles_map(file_name, options) }
+
+    it 'has a background color' do
+      expect(subject.bgcolor).to eq('#ffffff00')
+    end
+
+    it 'has a valid bounds property' do
+      expect(subject.bounds.to_wkt).to match(/-74.000000 40.000000/)
+    end
+
+    it 'has the correct width and height' do
+      expect(subject.width).to eq(150)
+      expect(subject.height).to eq(200)
+    end
+
+    it 'has a WGS 84 projection' do
+      expect(subject.srs).to eq('+proj=longlat +datum=WGS84 +no_defs ')
+    end
+  end
+end

data/spec/processors/geo_concerns/processors/vector/base_spec.rb

@@ -28,7 +28,7 @@ describe GeoConcerns::Processors::Vector::Base do
 
   describe '#encode_queue' do
     it 'returns an array of command name symbols' do
-      expect(subject.class.encode_queue).to include :mapnik_vector_thumbnail
+      expect(subject.class.encode_queue).to include :vector_thumbnail
     end
   end
 

data/spec/processors/geo_concerns/processors/vector/info_spec.rb

@@ -9,7 +9,7 @@ describe GeoConcerns::Processors::Vector::Info do
 
   context 'when initializing a new info class' do
     it 'shells out to ogrinfo and sets the doc variable to the output string' do
-      expect(Open3).to receive(:capture3).with("ogrinfo #{path}")
+      expect(Open3).to receive(:capture3).with("ogrinfo -ro -so -al #{path}")
         .and_return([info_doc, '', ''])
       expect(subject.doc).to eq(info_doc)
     end
@@ -37,5 +37,14 @@ describe GeoConcerns::Processors::Vector::Info do
         expect(subject.geom).to eq('Polygon')
       end
     end
+
+    describe '#bounds' do
+      it 'returns bounds hash' do
+        expect(subject.bounds).to eq(north: 42.408249,
+                                     east: -71.052853,
+                                     south: 42.347654,
+                                     west: -71.163867)
+      end
+    end
   end
 end

data/spec/services/geo_concerns/delivery/geoserver_spec.rb

@@ -34,6 +34,12 @@ describe GeoConcerns::Delivery::Geoserver do
         expect(subject).to receive(:publish_vector)
         subject.publish
       end
+
+      it 'logs a message if there is an error' do
+        expect(subject).to receive(:publish_vector).and_raise(StandardError, 'error')
+        expect(Rails.logger).to receive(:error).with("GeoServer delivery job failed with: error")
+        subject.publish
+      end
     end
 
     context 'when type is raster' do
@@ -47,22 +53,30 @@ describe GeoConcerns::Delivery::Geoserver do
     context 'when type is not a raster or vector' do
       let(:path) { 'not-a-zip-or-tif' }
       it 'raises an error' do
-        expect { subject.publish }.to raise_error(ArgumentError, /Not a ZIPed Shapefile/)
+        expect(Rails.logger).to receive(:error).with(/Not a ZIPed Shapefile/)
+        subject.publish
       end
     end
   end
 
   describe '#publish_vector' do
     context 'with a path to a zipped shapefile' do
+      let(:shapefile_path) { ['/spec/fixtures/files/shapefile/tufts-cambridgegrid100-04/tufts-cambridgegrid100-04.shp'] }
+      let(:url) { "file:////opt/geoserver/data_dir/derivatives#{shapefile_path.first}" }
       let(:ws) { double }
       let(:ds) { double }
 
+      before do
+        allow(Dir).to receive(:glob).and_return(shapefile_path)
+        allow(subject).to receive(:system).and_return(true)
+      end
+
       it 'dispatches to RGeoServer' do
         expect(RGeoServer::Workspace).to receive(:new).with(subject.catalog, hash_including(name: 'public')).and_return(ws)
         expect(ws).to receive(:'new?').and_return(true)
         expect(ws).to receive(:save)
         expect(RGeoServer::DataStore).to receive(:new).with(subject.catalog, hash_including(workspace: ws, name: id)).and_return(ds)
-        expect(ds).to receive(:upload_file).with(path, hash_including(publish: true))
+        expect(ds).to receive(:upload_external).with(url, hash_including(publish: true))
         subject.send(:publish_vector)
       end
     end
@@ -70,15 +84,25 @@ describe GeoConcerns::Delivery::Geoserver do
 
   describe '#publish_raster' do
     let(:path) { 'spec/fixtures/files/S_566_1914_clip.tif' }
+    let(:url) { 'file:////opt/geoserver/data_dir/derivativesspec/fixtures/files/S_566_1914_clip.tif' }
     let(:ws) { double }
     let(:cs) { double }
+    let(:cov) { double }
 
     it 'dispatches to RGeoServer' do
-      expect(RGeoServer::Workspace).to receive(:new).with(subject.catalog, hash_including(name: 'public')).and_return(ws)
-      expect(ws).to receive(:'new?').and_return(true)
-      expect(ws).to receive(:save)
+      expect(RGeoServer::Workspace).to receive(:new).with(subject.catalog, hash_including(name: 'public')).and_return(ws).twice
+      expect(ws).to receive(:'new?').and_return(true).twice
+      expect(ws).to receive(:save).twice
       expect(RGeoServer::CoverageStore).to receive(:new).with(subject.catalog, hash_including(workspace: ws, name: id)).and_return(cs)
-      expect(cs).to receive(:upload).with(path)
+      expect(cs).to receive(:name).and_return('abcdefg').at_least(:once)
+      expect(cs).to receive(:url=).with(url)
+      expect(cs).to receive(:enabled=).with('true')
+      expect(cs).to receive(:data_type=).with('GeoTIFF')
+      expect(cs).to receive(:save)
+      expect(RGeoServer::Coverage).to receive(:new).with(subject.catalog, hash_including(workspace: ws, coverage_store: cs, name: cs.name)).and_return(cov)
+      expect(cov).to receive(:title=).with(cs.name)
+      expect(cov).to receive(:metadata_links=).with([])
+      expect(cov).to receive(:save)
       subject.send(:publish_raster)
     end
   end

data/spec/services/geo_concerns/discovery/document_builder/wxs_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe GeoConcerns::Discovery::DocumentBuilder::Wxs do
+  subject { described_class.new(geo_concern_presenter) }
+
+  let(:geo_concern) { FactoryGirl.build(:public_vector_work, id: 'geo-work-1') }
+  let(:geo_concern_presenter) { GeoConcerns::VectorWorkShowPresenter.new(SolrDocument.new(geo_concern.to_solr), nil) }
+  let(:geo_file_mime_type) { 'application/zip; ogr-format="ESRI Shapefile"' }
+  let(:geo_file) { FileSet.new(id: 'geofile', geo_mime_type: geo_file_mime_type) }
+  let(:geo_file_presenter) { CurationConcerns::FileSetPresenter.new(SolrDocument.new(geo_file.to_solr), nil) }
+  let(:visibility) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+
+  before do
+    allow(geo_file_presenter.solr_document).to receive(:visibility).and_return(visibility)
+    allow(geo_concern_presenter).to receive(:member_presenters).and_return([geo_file_presenter])
+  end
+
+  describe '#identifier' do
+    context 'public document' do
+      it 'returns a public identifier' do
+        expect(subject.identifier).to eq 'public:geofile'
+      end
+    end
+
+    context 'private document' do
+      let(:visibility) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE }
+      it 'returns a the fileset id' do
+        expect(subject.identifier).to eq 'geofile'
+      end
+    end
+  end
+
+  describe '#wms_path' do
+    context 'public document' do
+      it 'returns a public wms path' do
+        expect(subject.wms_path).to eq 'http://localhost:8181/geoserver/public/wms'
+      end
+    end
+
+    context 'restricted document' do
+      let(:visibility) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED }
+      it 'returns a restricted value' do
+        expect(subject.wms_path).to eq 'http://localhost:8181/geoserver/restricted/wms'
+      end
+    end
+
+    context 'private document' do
+      let(:visibility) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE }
+      it 'returns a nil value' do
+        expect(subject.wms_path).to be_nil
+      end
+    end
+  end
+
+  describe '#wfs_path' do
+    context 'public document' do
+      it 'returns a valid wms path' do
+        expect(subject.wfs_path).to eq 'http://localhost:8181/geoserver/public/wfs'
+      end
+    end
+
+    context 'private document' do
+      let(:visibility) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE }
+      it 'returns a nil value' do
+        expect(subject.wfs_path).to be_nil
+      end
+    end
+  end
+end

data/spec/services/geo_concerns/discovery/document_builder_spec.rb

@@ -9,6 +9,7 @@ describe GeoConcerns::Discovery::DocumentBuilder do
   let(:geo_concern_presenter) { GeoConcerns::VectorWorkShowPresenter.new(SolrDocument.new(geo_concern.to_solr), nil) }
   let(:document_class) { GeoConcerns::Discovery::GeoblacklightDocument.new }
   let(:document) { JSON.parse(subject.to_json(nil)) }
+  let(:visibility) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
   let(:metadata__mime_type) { 'application/xml; schema=iso19139' }
   let(:metadata_file) { FileSet.new(id: 'metadatafile', geo_mime_type: metadata__mime_type) }
   let(:metadata_presenter) { CurationConcerns::FileSetPresenter.new(SolrDocument.new(metadata_file.to_solr), nil) }
@@ -28,22 +29,27 @@ describe GeoConcerns::Discovery::DocumentBuilder do
                        spatial: ['Micronesia'],
                        temporal: ['2011'],
                        subject: ['Human settlements'],
-                       language: ['Esperanto'] }
+                       language: ['Esperanto'],
+                       identifier: ['ark:/99999/fk4'] }
   }
 
-  describe 'vector work' do
-    before do
-      allow(geo_concern_presenter).to receive(:file_set_presenters).and_return([geo_file_presenter, metadata_presenter])
-    end
+  before do
+    allow(geo_concern_presenter.solr_document).to receive(:visibility).and_return(visibility)
+    allow(geo_concern_presenter.solr_document).to receive(:representative_id).and_return(geo_file_presenter.id)
+    allow(geo_concern_presenter).to receive(:file_set_presenters).and_return([geo_file_presenter, metadata_presenter])
+    allow(geo_concern_presenter).to receive(:member_presenters).and_return([geo_file_presenter, metadata_presenter])
+    allow(geo_file_presenter.request).to receive_messages(host_with_port: 'localhost:3000', protocol: 'http://')
+  end
 
+  describe 'vector work' do
     context 'required' do
       it 'has all metadata' do
-        expect(document['dc_identifier_s']).to eq('https://your-institution/geo-work-1')
+        expect(document['dc_identifier_s']).to eq('ark:/99999/fk4')
         expect(document['layer_slug_s']).to eq('your-institution-geo-work-1')
         expect(document['dc_title_s']).to eq('Geo Work')
         expect(document['solr_geom']).to eq('ENVELOPE(-71.032, -69.856, 43.039, 42.943)')
         expect(document['dct_provenance_s']).to eq('Your Institution')
-        expect(document['dc_rights_s']).to eq('Restricted')
+        expect(document['dc_rights_s']).to eq('Public')
         expect(document['geoblacklight_version']).to eq('1.0')
       end
     end
@@ -98,10 +104,6 @@ describe GeoConcerns::Discovery::DocumentBuilder do
       let(:geo_file_mime_type) { 'image/tiff; gdal-format=GTiff' }
       let(:metadata__mime_type) { 'application/xml; schema=fgdc' }
 
-      before do
-        allow(geo_concern_presenter).to receive(:file_set_presenters).and_return([geo_file_presenter, metadata_presenter])
-      end
-
       it 'has layer info fields' do
         expect(document['layer_geom_type_s']).to eq('Raster')
         expect(document['dc_format_s']).to eq('GeoTIFF')
@@ -117,10 +119,6 @@ describe GeoConcerns::Discovery::DocumentBuilder do
       let(:geo_file_mime_type) { 'application/octet-stream; gdal-format=AIG' }
       let(:metadata__mime_type) { 'application/mods+xml' }
 
-      before do
-        allow(geo_concern_presenter).to receive(:file_set_presenters).and_return([geo_file_presenter, metadata_presenter])
-      end
-
       it 'has layer info fields' do
         expect(document['dc_format_s']).to eq('ArcGRID')
       end
@@ -139,8 +137,7 @@ describe GeoConcerns::Discovery::DocumentBuilder do
       let(:geo_file_mime_type) { 'image/tiff' }
 
       before do
-        attributes.delete(:description)
-        allow(geo_concern_presenter).to receive(:file_set_presenters).and_return([geo_file_presenter, metadata_presenter])
+        allow(geo_concern_presenter).to receive(:description).and_return([])
       end
 
       it 'uses a default description' do
@@ -156,20 +153,18 @@ describe GeoConcerns::Discovery::DocumentBuilder do
 
   context 'with a missing required metadata field' do
     before do
-      attributes.delete(:title)
-      allow(geo_concern_presenter).to receive(:file_set_presenters).and_return([geo_file_presenter, metadata_presenter])
+      allow(geo_concern_presenter).to receive(:coverage).and_return(nil)
     end
 
     it 'returns an error document' do
-      expect(document['error'][0]).to include('dc_title_s')
+      expect(document['error'][0]).to include('solr_geom')
       expect(document['error'].size).to eq(1)
     end
   end
 
   context 'with a missing non-required metadata field' do
     before do
-      attributes.delete(:language)
-      allow(geo_concern_presenter).to receive(:file_set_presenters).and_return([geo_file_presenter, metadata_presenter])
+      allow(geo_concern_presenter).to receive(:language).and_return([])
     end
 
     it 'returns a document without the field but valid' do
@@ -177,25 +172,46 @@ describe GeoConcerns::Discovery::DocumentBuilder do
     end
   end
 
-  context 'with a public visibility' do
+  context 'with a missing temporal field' do
     before do
-      viz = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
-      allow(geo_concern_presenter).to receive(:file_set_presenters).and_return([geo_file_presenter, metadata_presenter])
-      allow(geo_concern_presenter.solr_document).to receive(:visibility).and_return(viz)
+      allow(geo_concern_presenter).to receive(:temporal).and_return([])
     end
 
-    it 'return a public access' do
-      expect(document['dc_rights_s']).to eq('Public')
+    it 'returns a document without the field but valid' do
+      expect(document['dct_temporal_sm']).to be_nil
     end
   end
 
-  context 'with ssl enabled' do
-    subject { described_class.new(geo_concern_presenter, document_class, ssl: true) }
-
+  context 'with a missing issued field' do
     before do
-      allow(geo_concern_presenter).to receive(:file_set_presenters).and_return([geo_file_presenter, metadata_presenter])
+      allow(geo_concern_presenter).to receive(:issued).and_return(nil)
     end
 
+    it 'returns a document without the field but valid' do
+      expect(document['dct_issued_dt']).to be_nil
+    end
+  end
+
+  context 'with an authenticated visibility' do
+    let(:visibility) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED }
+
+    it 'returns a restricted rights field value' do
+      expect(document['dc_rights_s']).to eq('Restricted')
+    end
+  end
+
+  context 'with a private visibility' do
+    let(:visibility) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE }
+
+    it 'returns an empty document' do
+      expect(document).to eq({})
+    end
+  end
+
+  context 'with ssl enabled' do
+    before do
+      allow(geo_file_presenter.request).to receive_messages(host_with_port: 'localhost:3000', protocol: 'https://')
+    end
     it 'returns https reference urls' do
       refs = JSON.parse(document['dct_references_s'])
       expect(refs['http://schema.org/url']).to eq('https://localhost:3000/concern/vector_works/geo-work-1')