ruby-avm-library 0.0.1

data/spec/avm/creator_spec.rb

@@ -0,0 +1,268 @@
+require 'spec_helper'
+require 'avm/image'
+require 'avm/creator'
+
+describe AVM::Creator do
+  let(:image) { AVM::Image.new }
+  let(:creator) { image.creator }
+
+  let(:name) { 'Space Telescope Science Institute' }
+  let(:url) { 'http://www.stsci.edu/' }
+  let(:rights) { 'Public Domain' }
+
+  subject { creator }
+
+  def self.can_read_properties
+    its(:name) { should == name }
+    its(:url) { should == url }
+    its(:rights) { should == rights }
+  end
+
+  describe '#merge!' do
+    before { creator.merge!(:name => name, :url => url, :rights => rights) }
+
+    can_read_properties
+  end
+
+  describe 'setters' do
+    before {
+      creator.name = name
+      creator.url = url
+      creator.rights = rights
+    }
+
+    can_read_properties
+  end
+
+  describe 'primary contact passthrough' do
+    context 'no contacts' do
+      its(:address) { should be_nil }
+    end
+
+    context 'one contact, must be primary' do
+      let(:first_contact) { AVM::Contact.new(
+        :name => 'zz bill', 
+        :address => first_contact_address,
+        :city => first_contact_address,
+        :state => first_contact_address,
+        :postal_code => first_contact_address,
+        :country => first_contact_address
+      ) }
+      let(:first_contact_address) { 'first contact' }
+
+      before { creator.contacts << first_contact }
+
+      fields = [ :address, :city, :state, :province, :postal_code, :zip, :country ]
+      fields.each { |field| its(field) { should == first_contact_address } }
+      
+      specify { creator.to_a.should == [
+        first_contact.to_h
+      ] }
+
+      context 'two contacts' do
+        let(:second_contact) { AVM::Contact.new(
+          :name => 'aa bill',
+          :address => second_contact_address,
+          :city => second_contact_address,
+          :state => second_contact_address,
+          :postal_code => second_contact_address,
+          :country => second_contact_address
+        ) }
+        let(:second_contact_address) { 'second contact' }
+
+        before { creator.contacts << second_contact }
+
+        context 'no primary, first alphabetical is primary' do
+          subject { second_contact }
+
+          fields.each { |field| its(field) { should == second_contact_address } }
+
+          specify { creator.to_a.should == [
+            second_contact.to_h, first_contact.to_h
+          ] }
+        end
+
+        context 'one is primary, use it' do
+          before { first_contact.primary = true }
+
+          fields.each { |field| its(field) { should == first_contact_address } }
+
+          specify { creator.to_a.should == [
+            first_contact.to_h, second_contact.to_h
+          ] }
+        end
+      end
+    end
+  end
+
+  describe '#create_contact' do
+    let(:first_name) { 'John' }
+    let(:first_contact) { creator.create_contact(:name => first_name) }
+
+    subject { creator.primary_contact }
+    before { first_contact }
+
+    its(:name) { should == first_name }
+  end
+
+  describe '#from_xml' do
+    let(:document) { image.to_xml }
+    let(:image) { AVM::Image.from_xml(File.read(file_path)) }
+
+    subject { image }
+
+    context 'no creator' do
+      let(:file_path) { 'spec/sample_files/creator/no_creator.xmp' }
+
+      its('creator.length') { should == 0 }
+    end
+
+    context 'one creator' do
+      let(:file_path) { 'spec/sample_files/creator/one_creator.xmp' }
+
+      its('creator.length') { should == 1 }
+
+      def self.field_checks
+        its(:name) { should == name }
+        its(:address) { should == address }
+        its(:city) { should == city }
+        its(:state) { should == state }
+        its(:zip) { should == zip }
+        its(:country) { should == country }
+        its(:email) { should == email }
+        its(:telephone) { should == telephone }
+      end
+
+      let(:name) { 'John Bintz' }
+      let(:email) { 'bintz@stsci.edu' }
+      let(:telephone) { '800-555-1234' }
+      let(:address) { '3700 San Martin Drive' }
+      let(:city) { 'Baltimore' }
+      let(:state) { 'Maryland' }
+      let(:zip) { '21218' }
+      let(:country) { 'USA' }
+
+      context 'creator one' do
+        subject { image.creator[0] }
+
+        field_checks
+
+        it { should be_primary }
+      end
+
+      context 'two creators' do
+        let(:file_path) { 'spec/sample_files/creator/two_creators.xmp' }
+
+        its('creator.length') { should == 2 }
+
+        context 'first creator' do
+          subject { image.creator[0] }
+
+          field_checks
+
+          it { should be_primary }
+        end
+
+        context 'second creator' do
+          subject { image.creator[1] }
+
+          field_checks
+
+          it { should_not be_primary }
+
+          let(:name) { 'Aohn Bintz' }
+          let(:email) { 'aohn@stsci.edu' }
+          let(:telephone) { '800-555-2345' }
+          let(:address) { '3700 San Martin Drive' }
+          let(:city) { 'Baltimore' }
+          let(:state) { 'Maryland' }
+          let(:zip) { '21218' }
+          let(:country) { 'USA' }
+        end
+      end
+    end
+  end
+
+  describe 'contact name node' do
+    let(:first_name) { 'John' }
+    let(:second_name) { 'Zohn' }
+
+    let(:first_contact) { creator.create_contact(first_contact_options) }
+    let(:second_contact) { creator.create_contact(second_contact_options) }
+
+    let(:first_contact_options) { { :name => first_name } }
+    let(:second_contact_options) { { :name => second_name } }
+
+    subject { image.to_xml.search('//dc:creator/rdf:Seq/rdf:li').collect { |node| node.text } }
+
+    context 'no contacts' do
+      it { should == [] }
+    end
+
+    context 'one contact' do
+      before { first_contact }
+
+      it { should == [ first_name ] }
+    end
+
+    context 'second contact' do
+      before { second_contact ; first_contact }
+
+      it { should == [ first_name, second_name ] }
+    end
+
+    describe 'everything else uses primary' do
+      let(:fields) { [ :address, :city, :state, :zip, :country ] }
+
+      def other_fields(what)
+        Hash[fields.zip(Array.new(fields.length, what))]
+      end
+
+      let(:first_contact_options) { { :name => first_name }.merge(other_fields('one')) }
+      let(:second_contact_options) { { :name => second_name }.merge(other_fields('two')) }
+
+      before { second_contact ; first_contact }
+
+      specify {
+        %w{CiAdrExtadr CiAdrCity CiAdrRegion CiAdrPcode CiAdrCtry}.each do |element_name|
+          image.to_xml.at_xpath("//Iptc4xmpCore:#{element_name}").text.should == 'one'
+        end
+      }
+    end
+
+    describe 'contact emails, telephones' do
+      let(:first_email) { 'bintz@stsci.edu' }
+      let(:second_email) { 'bintz-2@stsci.edu' }
+
+      let(:first_phone) { '123-456-7890' }
+      let(:second_phone) { '234-567-8901' }
+
+      let(:first_contact_options) { { :name => first_name, :email => first_email, :telephone => first_phone } }
+      let(:second_contact_options) { { :name => second_name, :email => second_email, :telephone => second_phone } }
+
+      let(:contact_info) { image.to_xml.search('//Iptc4xmpCore:CreatorContactInfo') }
+
+      let(:telephone_text) { contact_info.at_xpath('./Iptc4xmpCore:CiTelWork').text }
+      let(:email_text) { contact_info.at_xpath('./Iptc4xmpCore:CiEmailWork').text }
+
+      context 'no contacts' do
+        specify { expect { telephone_text }.to raise_error }
+        specify { expect { email_text }.to raise_error }
+      end
+
+      context 'one contact' do
+        before { first_contact }
+
+        specify { telephone_text.should == first_phone }
+        specify { email_text.should == first_email }
+      end
+
+      context 'two contacts' do
+        before { first_contact ; second_contact }
+
+        specify { telephone_text.should == [ first_phone, second_phone ] * ',' }
+        specify { email_text.should == [ first_email, second_email ] * ',' }
+      end
+    end
+  end
+end

data/spec/avm/image_spec.rb

@@ -0,0 +1,350 @@
+require 'spec_helper'
+require 'avm/image'
+
+describe AVM::Image do
+  let(:image) { self.class.describes.new(options) }
+  let(:options) { {} }
+
+  subject { image }
+
+  let(:title) { 'My title' }
+  let(:headline) { 'Headline' }
+  let(:description) { 'Description' }
+  let(:distance_notes) { 'Distance Notes' }
+  let(:spectral_notes) { 'Spectral Notes' }
+  let(:reference_url) { 'Reference URL' }
+  let(:credit) { 'Credit' }
+  let(:date) { '2010-01-01' }
+  let(:id) { 'ID' }
+  let(:type) { 'Observation' }
+  let(:image_quality) { 'Good' }
+  let(:redshift) { 'Redshift' }
+  let(:light_years) { 'Light years' }
+
+  let(:subject_names) { [ 'Name one', 'Name two' ] }
+  let(:categories) { [ 'Category one', 'Category two' ] }
+
+  let(:coordinate_frame) { 'ICRS' }
+  let(:equinox) { '100' }
+  let(:reference_value) { [ 100, 50 ] }
+  let(:reference_dimension) { [ 200, 150 ] }
+  let(:reference_pixel) { [ 25, 15 ] }
+  let(:spatial_scale) { [ 40, 35 ] }
+  let(:spatial_rotation) { 10.0 }
+  let(:coordinate_system_projection) { 'TAN' }
+  let(:spatial_quality) { 'Full' }
+  let(:spatial_notes) { 'Spatial Notes' }
+  let(:fits_header) { 'FITS header' }
+  let(:spatial_cd_matrix) { [ 1, 2, 3, 4 ] }
+
+  let(:publisher) { 'Publisher' }
+  let(:publisher_id) { 'Publisher ID' }
+  let(:resource_id) { 'Resource ID' }
+  let(:resource_url) { 'Resource URL' }
+  let(:related_resources) { [ 'Resource 1', 'Resource 2' ] }
+  let(:metadata_date) { '2010-01-05' }
+  let(:metadata_version) { '1.2' }
+
+  def self.with_all_options
+    let(:options) { { 
+      :title => title, 
+      :headline => headline, 
+      :description => description, 
+      :distance_notes => distance_notes, 
+      :spectral_notes => spectral_notes, 
+      :reference_url => reference_url, 
+      :credit => credit, 
+      :date => date, 
+      :id => id, 
+      :type => type, 
+      :quality => image_quality,
+      :redshift => redshift,
+      :light_years => light_years,
+      :coordinate_frame => coordinate_frame,
+      :equinox => equinox,
+      :reference_value => reference_value,
+      :reference_dimension => reference_dimension,
+      :reference_pixel => reference_pixel,
+      :spatial_scale => spatial_scale,
+      :spatial_rotation => spatial_rotation,
+      :coordinate_system_projection => coordinate_system_projection,
+      :spatial_quality => spatial_quality,
+      :spatial_notes => spatial_notes,
+      :fits_header => fits_header,
+      :spatial_cd_matrix => spatial_cd_matrix,
+      :publisher => publisher,
+      :publisher_id => publisher_id,
+      :resource_id => resource_id,
+      :resource_url => resource_url,
+      :related_resources => related_resources,
+      :metadata_date => metadata_date,
+      :metadata_version => metadata_version,
+      :subject_names => subject_names,
+      :categories => categories
+    } }
+  end
+
+  let(:avm_image_type) { eval("AVM::ImageType::#{type}") }
+  let(:avm_image_quality) { eval("AVM::ImageQuality::#{image_quality}") }
+  let(:avm_coordinate_frame) { eval("AVM::CoordinateFrame::#{coordinate_frame}") }
+  let(:avm_coordinate_system_projection) { eval("AVM::CoordinateSystemProjection::#{coordinate_system_projection}") }
+  let(:avm_spatial_quality) { eval("AVM::SpatialQuality::#{spatial_quality}") }
+
+  def self.has_most_options
+    its(:creator) { should be_a_kind_of(AVM::Creator) }
+    its(:title) { should == title }
+    its(:headline) { should == headline }
+    its(:description) { should == description }
+    its(:distance_notes) { should == distance_notes }
+    its(:spectral_notes) { should == spectral_notes }
+    its(:reference_url) { should == reference_url }
+    its(:credit) { should == credit }
+    its(:date) { should == Time.parse(date) }
+    its(:id) { should == id }
+    its(:image_type) { should be_a_kind_of avm_image_type }
+    its(:image_quality) { should be_a_kind_of avm_image_quality }
+
+    its(:coordinate_frame) { should be_a_kind_of avm_coordinate_frame }
+    its(:equinox) { should == equinox }
+    its(:reference_value) { should == reference_value }
+    its(:reference_dimension) { should == reference_dimension }
+    its(:reference_pixel) { should == reference_pixel }
+    its(:spatial_scale) { should == spatial_scale }
+    its(:spatial_rotation) { should == spatial_rotation }
+    its(:coordinate_system_projection) { should be_a_kind_of avm_coordinate_system_projection }
+    its(:spatial_quality) { should be_a_kind_of avm_spatial_quality }
+    its(:spatial_notes) { should == spatial_notes }
+    its(:fits_header) { should == fits_header }
+    its(:spatial_cd_matrix) { should == spatial_cd_matrix }
+
+    its(:publisher) { should == publisher }
+    its(:publisher_id) { should == publisher_id }
+    its(:resource_id) { should == resource_id }
+    its(:resource_url) { should == resource_url }
+    its(:related_resources) { should == related_resources }
+    its(:metadata_date) { should == Time.parse(metadata_date) }
+    its(:metadata_version) { should == metadata_version }
+
+    its(:subject_names) { should == subject_names }
+    its(:categories) { should == categories }
+
+    it { should be_valid }
+  end
+
+  describe '#initialize' do
+    with_all_options
+
+    it { should be_a_kind_of(AVM::Image) }
+
+    has_most_options
+
+    its(:to_h) { should == {
+      :title => title,
+      :headline => headline,
+      :description => description,
+      :distance_notes => distance_notes,
+      :spectral_notes => spectral_notes,
+      :reference_url => reference_url,
+      :credit => credit,
+      :date => Time.parse(date),
+      :id => id,
+      :image_type => avm_image_type.new,
+      :image_quality => avm_image_quality.new,
+      :coordinate_frame => avm_coordinate_frame.new,
+      :equinox => equinox,
+      :reference_value => reference_value,
+      :reference_dimension => reference_dimension,
+      :reference_pixel => reference_pixel,
+      :spatial_scale => spatial_scale,
+      :spatial_rotation => spatial_rotation,
+      :coordinate_system_projection => avm_coordinate_system_projection.new,
+      :spatial_quality => avm_spatial_quality.new,
+      :spatial_notes => spatial_notes,
+      :fits_header => fits_header,
+      :spatial_cd_matrix => spatial_cd_matrix,
+      :distance => [ light_years, redshift ],
+      :creator => [],
+      :publisher => publisher,
+      :publisher_id => publisher_id,
+      :resource_id => resource_id,
+      :resource_url => resource_url,
+      :related_resources => related_resources,
+      :metadata_date => Time.parse(metadata_date),
+      :metadata_version => metadata_version,
+      :subject_names => subject_names,
+      :categories => categories,
+      :observations => []
+    } }
+
+    its(:distance) { should == [ light_years, redshift ] }
+  end
+
+  describe 'not valid' do
+    let(:image) { AVM::Image.new }
+
+    it { should_not be_valid }
+  end
+
+  describe '.from_xml' do
+    let!(:image) { AVM::Image.from_xml(File.read(file_path)) }
+
+    subject { image }
+
+    context "nothing in it" do
+      let(:file_path) { 'spec/sample_files/image/nothing.xmp' }
+
+      [ :title, :headline, :description, :distance_notes,
+        :spectral_notes, :reference_url, :credit, :date,
+        :id, :image_type, :image_quality, :redshift,
+        :light_years, :coordinate_frame, :equinox, :reference_value,
+        :reference_dimension, :reference_pixel, :spatial_scale,
+        :spatial_rotation, :coordinate_system_projection, :spatial_quality, :spatial_notes,
+        :fits_header, :spatial_cd_matrix, :subject_names, :categories
+      ].each do |field|
+        its(field) { should be_nil }
+      end
+
+      it { should_not be_valid }
+    end
+
+    context "image in it" do
+      context 'distance as a single value, assume light years' do
+        let(:file_path) { 'spec/sample_files/image/single_value_light_years.xmp' }
+
+        has_most_options
+
+        its(:redshift) { should be_nil }
+        its(:light_years) { should == light_years }
+      end
+
+      context "distance in light years" do
+        let(:file_path) { 'spec/sample_files/image/light_years.xmp' }
+
+        has_most_options
+
+        its(:redshift) { should be_nil }
+        its(:light_years) { should == light_years }
+      end
+
+      context "distaince in redshift" do
+        let(:file_path) { 'spec/sample_files/image/redshift.xmp' }
+
+        has_most_options
+
+        its(:light_years) { should be_nil }
+        its(:redshift) { should == redshift }
+      end
+
+      context "distance in both" do
+        let(:file_path) { 'spec/sample_files/image/both.xmp' }
+
+        has_most_options
+
+        its(:light_years) { should == light_years }
+        its(:redshift) { should == redshift }
+      end
+    end
+  end
+
+  describe '#to_xml' do
+    let(:xml) { image.to_xml }
+
+    let(:dublin_core) { xml.at_xpath('//rdf:Description[@rdf:about="Dublin Core"]') }
+    let(:photoshop) { xml.at_xpath('//rdf:Description[@rdf:about="Photoshop"]') }
+    let(:avm) { xml.at_xpath('//rdf:Description[@rdf:about="AVM"]') }
+      
+    context 'nothing in it' do
+      it "should have basic tags" do
+        xml.at_xpath('//rdf:RDF').should_not be_nil 
+        xml.search('//rdf:RDF/rdf:Description').should_not be_empty 
+        photoshop.at_xpath('./photoshop:DateCreated').should_not be_nil
+      end
+    end
+
+    context 'with basics' do
+      with_all_options
+      
+      def xpath_text(which, xpath)
+        which.at_xpath(xpath).text
+      end
+
+      def xpath_list(which, xpath, search = './/rdf:li')
+        which.at_xpath(xpath).search(search).collect(&:text)
+      end
+
+      it "should have the image info tags" do
+        xpath_text(dublin_core, './dc:title/rdf:Alt/rdf:li').should == title
+        xpath_text(photoshop, './photoshop:Headline').should == headline
+        xpath_text(dublin_core, './dc:description/rdf:Alt/rdf:li').should == description
+                
+        xpath_text(avm, './avm:Distance.Notes').should == distance_notes
+        xpath_text(avm, './avm:Spectral.Notes').should == spectral_notes
+        xpath_text(avm, './avm:ReferenceURL').should == reference_url
+        xpath_text(photoshop, './photoshop:Credit').should == credit
+        xpath_text(photoshop, './photoshop:DateCreated').should == date
+        xpath_text(avm, './avm:ID').should == id
+        xpath_text(avm, './avm:Type').should == type
+        xpath_text(avm, './avm:Image.ProductQuality').should == image_quality
+      end
+
+      it "should have the spatial tags" do
+        xpath_text(avm, './avm:Spatial.CoordinateFrame').should == coordinate_frame
+        xpath_text(avm, './avm:Spatial.Equinox').should == equinox
+        xpath_list(avm, './avm:Spatial.ReferenceValue').should == reference_value.collect { |v| v.to_f.to_s }
+        xpath_list(avm, './avm:Spatial.ReferenceDimension').should == reference_dimension.collect { |v| v.to_f.to_s }
+        xpath_list(avm, './avm:Spatial.ReferencePixel').should == reference_pixel.collect { |v| v.to_f.to_s }
+        xpath_list(avm, './avm:Spatial.Scale').should == spatial_scale.collect { |v| v.to_f.to_s }
+        xpath_text(avm, './avm:Spatial.CoordsystemProjection').should == coordinate_system_projection
+        xpath_text(avm, './avm:Spatial.Quality').should == spatial_quality
+        xpath_text(avm, './avm:Spatial.Notes').should == spatial_notes
+        xpath_text(avm, './avm:Spatial.FITSheader').should == fits_header
+        xpath_list(avm, './avm:Spatial.CDMatrix').should == spatial_cd_matrix.collect { |v| v.to_f.to_s }
+      end
+
+      it "should have the publisher tags" do
+        xpath_text(avm, './avm:Publisher').should == publisher
+        xpath_text(avm, './avm:PublisherID').should == publisher_id
+        xpath_text(avm, './avm:ResourceID').should == resource_id
+        xpath_text(avm, './avm:ResourceURL').should == resource_url
+        xpath_list(avm, './avm:RelatedResources', './rdf:Bag/rdf:li').should == related_resources
+        xpath_text(avm, './avm:MetadataDate').should == metadata_date
+        xpath_text(avm, './avm:MetadataVersion').should == metadata_version
+      end
+
+      context "distance" do
+        context "no distances" do
+          let(:redshift) { nil }
+          let(:light_years) { nil }
+
+          it("should have no distances") { avm.at_xpath('./avm:Distance').should be_nil }
+        end
+
+        context "redshift only" do
+          let(:light_years) { nil }
+
+          it "should have redshift only" do
+            avm.at_xpath('./avm:Distance/rdf:Seq/rdf:li[1]').text.should == '-'
+            avm.at_xpath('./avm:Distance/rdf:Seq/rdf:li[2]').text.should == redshift
+          end
+        end
+        
+        context "light years only" do
+          let(:redshift) { nil }
+
+          it "should should have light years but not redshift" do
+            avm.at_xpath('./avm:Distance/rdf:Seq/rdf:li[1]').text.should == light_years
+            avm.at_xpath('./avm:Distance/rdf:Seq/rdf:li[2]').should be_nil
+          end
+        end
+        
+        context "redshift and light years" do
+          it "should have both light years and redshift" do
+            avm.at_xpath('./avm:Distance/rdf:Seq/rdf:li[1]').text.should == light_years
+            avm.at_xpath('./avm:Distance/rdf:Seq/rdf:li[2]').text.should == redshift
+          end
+        end
+      end
+    end
+  end
+end
+