geo_works 0.1.0

data/spec/processors/geo_works/processors/rendering_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe GeoWorks::Processors::Rendering do
+  before do
+    class TestProcessor
+      include GeoWorks::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(GeoWorks::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(GeoWorks::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_works/processors/vector/base_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe GeoWorks::Processors::Vector::Base do
+  let(:output_file) { 'output/geo.png' }
+  let(:file_name) { 'files/geo.zip' }
+  let(:label) {}
+  let(:options) { { output_size: '150 150', label: label } }
+
+  subject { described_class.new(file_name, {}) }
+
+  describe '#encode' do
+    context 'when output label is thumbnail' do
+      let(:label) { :thumbnail }
+      it 'calls the encode_vector method' do
+        expect(subject.class).to receive(:encode_vector)
+        subject.class.encode(file_name, options, output_file)
+      end
+    end
+
+    context 'when output label is display_vector' do
+      let(:label) { :display_vector }
+      it 'calls the reproject_vector method' do
+        expect(subject.class).to receive(:reproject_vector)
+        subject.class.encode(file_name, options, output_file)
+      end
+    end
+  end
+
+  describe '#encode_queue' do
+    it 'returns an array of command name symbols' do
+      expect(subject.class.encode_queue).to include :vector_thumbnail
+    end
+  end
+
+  describe '#reproject_queue' do
+    it 'returns an array of command name symbols' do
+      expect(subject.class.reproject_queue).to include :zip
+    end
+  end
+
+  describe '#encode_vector' do
+    it 'runs commands to encode the raster thumbnail' do
+      expect(subject.class).to receive(:run_commands)
+      subject.class.encode_vector(file_name, options, output_file)
+    end
+  end
+
+  describe '#reproject_vector' do
+    it 'runs commands to reproject the raster' do
+      expect(subject.class).to receive(:run_commands)
+      subject.class.reproject_vector(file_name, options, output_file)
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'open3'
+
+describe GeoWorks::Processors::Vector::Info do
+  let(:path) { 'test.tif' }
+  let(:info_doc) { read_test_data_fixture('ogrinfo.txt') }
+
+  subject { described_class.new(path) }
+
+  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 -ro -so -al #{path}")
+        .and_return([info_doc, '', ''])
+      expect(subject.doc).to eq(info_doc)
+    end
+  end
+
+  context 'after intialization' do
+    before do
+      allow(subject).to receive(:doc).and_return(info_doc)
+    end
+
+    describe '#name' do
+      it 'returns with min and max values' do
+        expect(subject.name).to eq('tufts-cambridgegrid100-04')
+      end
+    end
+
+    describe '#driver' do
+      it 'returns with min and max values' do
+        expect(subject.driver).to eq('ESRI Shapefile')
+      end
+    end
+
+    describe '#geom' do
+      it 'returns raster size' 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/processors/geo_works/processors/vector/processor_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe GeoWorks::Processors::Vector::Processor do
+  subject { described_class.new(file_name, directives) }
+  let(:processor) { double }
+
+  context 'when a shapefile format type is passed' do
+    let(:file_name) { 'files/shapefile.zip' }
+    let(:directives) { { input_format: 'application/zip; ogr-format="ESRI Shapefile"' } }
+
+    it 'calls the shapefile processor' do
+      expect(GeoWorks::Processors::Vector::Shapefile).to receive(:new).and_return(processor)
+      expect(processor).to receive(:process)
+      subject.process
+    end
+  end
+
+  context 'when a geojson format type is passed' do
+    let(:file_name) { 'files/geo.json' }
+    let(:directives) { { input_format: 'application/vnd.geo+json' } }
+
+    it 'calls the base vector processor' do
+      expect(GeoWorks::Processors::Vector::Base).to receive(:new).and_return(processor)
+      expect(processor).to receive(:process)
+      subject.process
+    end
+  end
+end

data/spec/processors/geo_works/processors/vector/shapefile_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe GeoWorks::Processors::Vector::Shapefile do
+  let(:output_file) { 'output/geo.png' }
+  let(:file_name) { 'files/Shapefile.zip' }
+  let(:options) { { output_size: '150 150', label: :thumbnail } }
+
+  subject { described_class.new(file_name, {}) }
+
+  describe '#encode' do
+    it 'wraps encode vector method in an unzip block' do
+      allow(subject.class).to receive(:unzip).and_yield(file_name)
+      expect(subject.class).to receive(:encode_vector)
+      subject.class.encode(file_name, options, output_file)
+    end
+  end
+end

data/spec/processors/geo_works/processors/zip_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe GeoWorks::Processors::Zip do
+  before do
+    class TestProcessor
+      include Hydra::Derivatives::Processors::ShellBasedProcessor
+      include GeoWorks::Processors::Zip
+    end
+  end
+
+  after { Object.send(:remove_const, :TestProcessor) }
+
+  subject { TestProcessor.new }
+  let(:path) { 'files/test.zip' }
+  let(:output_file) { 'output/test.tif' }
+
+  describe '#unzip' do
+    let(:command) { 'unzip -qq -j -d "output/test_out" "files/test.zip"' }
+
+    context 'given an input and output path' do
+      it 'runs an unzip command and yields to a block' do
+        arg = ''
+        expect(subject.class).to receive(:execute).with(command)
+        expect(FileUtils).to receive(:rm_rf)
+        subject.class.unzip(path, output_file) { |a| arg = a }
+        expect(arg).to eq('output/test_out')
+      end
+    end
+  end
+
+  describe '#zip' do
+    let(:command) { 'zip -j -qq -r "output/test.tif" "files/test.zip"' }
+
+    it 'runs a zip command ' do
+      expect(subject.class).to receive(:execute).with(command)
+      subject.class.zip(path, output_file)
+    end
+  end
+end

data/spec/renderers/geo_works/coverage_renderer_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe GeoWorks::CoverageRenderer do
+  let(:coverage) { 'northlimit=2.7; eastlimit=4.0; southlimit=1.3; westlimit=2.9; units=degrees; projection=EPSG:4326' }
+  let(:renderer) { described_class.new(:coverage, [coverage]) }
+  subject { renderer.render }
+
+  it 'includes the coverage string' do
+    expect(subject).to include coverage
+  end
+
+  it 'includes a map' do
+    expect(subject).to include "<div id='bbox'"
+    expect(subject).to include "boundingBoxSelector"
+  end
+
+  it 'includes a toggle button' do
+    expect(subject).to include "<a data-toggle='collapse' data-parent='accordion' href='#bbox'"
+    expect(subject).to include "Toggle Map"
+  end
+end

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

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe GeoWorks::Delivery::Geoserver do
+  let(:id) { 'abc123' }
+  let(:file_set) { instance_double("FileSet") }
+  let(:visibility) { 'open' }
+  let(:path) { 'spec/fixtures/files/tufts-cambridgegrid100-04.zip' }
+
+  subject { described_class.new file_set, path }
+
+  before do
+    allow(file_set).to receive(:visibility).and_return(visibility)
+    allow(file_set).to receive(:id).and_return(id)
+  end
+
+  context 'with an authenticated file set visibility' do
+    let(:visibility) { 'authenticated' }
+    it 'does not raise error' do
+      expect { subject }.not_to raise_error
+    end
+  end
+
+  context 'with a private file set visibility' do
+    let(:visibility) { 'private' }
+    it 'raises an error' do
+      expect { subject }.to raise_error(ArgumentError, /FileSet visibility/)
+    end
+  end
+
+  describe '#publish' do
+    context 'when type is vector' do
+      let(:path) { 'spec/fixtures/files/tufts-cambridgegrid100-04.zip' }
+      it 'routes to publish_vector' 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
+      let(:path) { 'spec/fixtures/files/S_566_1914_clip.tif' }
+      it 'routes to publish_raster' do
+        expect(subject).to receive(:publish_raster)
+        subject.publish
+      end
+    end
+
+    context 'when type is not a raster or vector' do
+      let(:path) { 'not-a-zip-or-tif' }
+      it 'raises an error' do
+        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_external).with(url, hash_including(publish: true))
+        subject.send(:publish_vector)
+      end
+    end
+  end
+
+  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).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(: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
+
+  describe '#catalog' do
+    it 'connects to a RGeoServer catalog' do
+      expect(RGeoServer).to receive(:catalog).with(hash_including(:url, :user, :password)).and_return(double).once
+      subject.catalog
+      subject.catalog # should cache result
+    end
+  end
+end

data/spec/services/geo_works/delivery_service_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe GeoWorks::DeliveryService do
+  let(:id) { 'abc123' }
+  let(:path) { 'somewhere-to-display-copy' }
+  let(:file_set) { instance_double("FileSet") }
+  let(:visibility) { 'open' }
+  let(:service) { instance_double('GeoWorks::Delivery::Geoserver') }
+
+  subject { described_class.new file_set, path }
+
+  before do
+    allow(file_set).to receive(:visibility).and_return(visibility)
+    allow(service).to receive(:visibility).and_return(visibility)
+  end
+
+  context '#publish' do
+    it 'dispatches to Geoserver delivery' do
+      expect(subject).to receive(:geoserver).and_return(service)
+      expect(service).to receive(:publish)
+      subject.publish
+    end
+  end
+end

data/spec/services/geo_works/discovery/abstract_document_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe GeoWorks::Discovery::AbstractDocument do
+  subject { described_class.new }
+
+  describe '#to_hash' do
+    it 'raises an error because the class should not be instantiated directly' do
+      expect { subject.to_hash(nil) }.to raise_error(/hash/)
+    end
+  end
+
+  describe '#to_json' do
+    it 'raises an error because the class should not be instantiated directly' do
+      expect { subject.to_json(nil) }.to raise_error(/json/)
+    end
+  end
+
+  describe '#to_xml' do
+    it 'raises an error because the class should not be instantiated directly' do
+      expect { subject.to_xml(nil) }.to raise_error(/xml/)
+    end
+  end
+end