dwc-archive 0.9.6 → 0.9.10

data/spec/lib/darwin_core_spec.rb

@@ -0,0 +1,279 @@
+require_relative '../spec_helper'
+
+describe DarwinCore do
+  subject { DarwinCore }
+  let(:file_dir) { File.expand_path('../../files', __FILE__) }
+
+  it 'breaks for ruby 1.8 and older' do
+    stub_const('RUBY_VERSION', '1.8.7') 
+    expect{load File.expand_path('../../../lib/dwc-archive.rb', __FILE__)}.
+      to raise_error
+  end
+
+  it 'continues for ruby 1.9.1 and higher' do
+    stub_const('RUBY_VERSION', '1.9.2') 
+    expect{load File.expand_path('../../../lib/dwc-archive.rb', __FILE__)}.
+      to_not raise_error
+  end
+
+  describe 'redis connection' do
+    it 'redis is running' do
+      expect do
+        socket = TCPSocket.open('localhost', 6379)
+        socket.close
+      end.to_not raise_error
+    end
+  end
+
+  it 'has version' do
+    expect(DarwinCore::VERSION =~ /\d+\.\d+\.\d/).to be_true
+  end
+
+  describe '.nil_field?' do
+    it 'is true for nil fields' do
+      [nil, '/N', ''].each do |i|
+        expect(DarwinCore.nil_field?(i)).to be_true
+      end
+    end
+
+    it 'is false for non-nil  fields' do
+      [0, '0', '123', 123, 'dsdfs434343/N'].each do |i|
+        expect(subject.nil_field?(i)).to be_false
+      end
+    end
+  end
+
+  describe '.clean_all' do
+    let(:tmp_dir) { DarwinCore::DEFAULT_TMP_DIR }
+
+    it 'cleans dwca directories' do
+      Dir.chdir(tmp_dir)
+      FileUtils.mkdir('dwc_123') unless File.exists?('dwc_123')
+      dwca_dirs =  Dir.entries(tmp_dir).select { |d| d.match(/^dwc_[\d]+$/) }
+      expect(dwca_dirs.size).to be > 0
+      subject.clean_all
+      dwca_dirs =  Dir.entries(tmp_dir).select { |d| d.match(/^dwc_[\d]+$/) }
+      expect(dwca_dirs.size).to be 0
+    end
+
+    context 'no dwc files exist' do
+      it 'does nothing' do
+        subject.clean_all
+        subject.clean_all
+        dwca_dirs =  Dir.entries(tmp_dir).select { |d| d.match(/^dwc_[\d]+$/) }
+        expect(dwca_dirs.size).to be 0
+      end
+    end
+  end
+
+  describe '.logger' do
+    it { expect(subject.logger).to be_kind_of Logger }
+  end
+
+  describe '.logger=' do
+    it 'sets logger' do
+      expect(subject.logger = 'fake logger').to eq 'fake logger'
+      expect(subject.logger).to eq 'fake logger'
+    end
+  end
+
+  describe '.logger_reset' do
+    it 'resets logger' do
+      subject.logger = 'fake logger'
+      expect(subject.logger).to eq 'fake logger'
+      subject.logger_reset
+      expect(subject.logger).to be_kind_of Logger
+    end
+  end
+
+  describe '.new' do
+    subject(:dwca) { DarwinCore.new(file_path) }
+   
+    context 'tar.gz and zip files supplied' do 
+      files = %w(data.zip data.tar.gz minimal.tar.gz junk_dir_inside.zip)
+      files.each do |file|
+        let(:file_path) { File.join(file_dir, file) }
+
+        it "creates archive from  %s" % file do
+          expect(dwca.archive.valid?).to be_true
+        end
+
+      end
+    end
+
+    context 'when file does not exist' do
+      let(:file_path) { File.join(file_dir, 'no_file.gz') }
+
+      it 'raises not found' do
+         expect { dwca }.to raise_error DarwinCore::FileNotFoundError
+      end
+    end
+
+    context 'archive cannot unpack' do
+
+      let(:file_path) { File.join(file_dir, 'broken.tar.gz') }
+
+      it 'raises unpacking error' do
+        expect { dwca }.to raise_error DarwinCore::UnpackingError
+      end
+    end
+
+    context 'archive is broken' do
+
+      let(:file_path) { File.join(file_dir, 'invalid.tar.gz') }
+
+      it 'raises error of invalid archive' do
+        expect { dwca }.to raise_error DarwinCore::InvalidArchiveError
+      end
+
+    end
+    
+    context 'archive is not in utf-8 encoding' do
+
+      let(:file_path) { File.join(file_dir, 'latin1.tar.gz') }
+      
+      it 'raises wrong encoding error' do
+        expect { dwca }.to raise_error DarwinCore::EncodingError
+      end
+
+    end
+    
+    context 'filename with spaces and non-alphanumeric chars' do
+
+      let(:file_path) { File.join(file_dir, 'file with characters(3).gz') }
+      
+      it 'creates archive' do
+        expect(dwca.archive.valid?).to be_true
+      end
+
+    end
+  end
+
+  describe 'file_name' do
+    subject(:dwca) { DarwinCore.new(file_path) }
+    let(:file_path) { File.join(file_dir, 'data.tar.gz') }
+
+    it 'returns file name' do
+      expect(dwca.file_name).to eq 'data.tar.gz'
+    end
+  end
+
+  describe 'path' do
+    subject(:dwca) { DarwinCore.new(file_path) }
+    let(:file_path) { File.join(file_dir, 'data.tar.gz') }
+
+    it 'returns path of the archive' do
+      expect(dwca.path).to match %r|spec.files.data\.tar\.gz|
+    end
+  end
+
+  describe '#archive' do
+    subject(:dwca) { DarwinCore.new(file_path) }
+    let(:file_path) { File.join(file_dir, 'data.tar.gz') }
+
+    it 'returns archive' do
+      expect(dwca.archive).to be_kind_of DarwinCore::Archive
+    end
+  end
+
+  describe '#core' do
+    subject(:dwca) { DarwinCore.new(file_path) }
+    let(:file_path) { File.join(file_dir, 'data.tar.gz') }
+
+    it 'returns core' do
+      expect(dwca.core).to be_kind_of DarwinCore::Core
+    end
+  end
+
+  describe '#metadata' do
+    subject(:dwca) { DarwinCore.new(file_path) }
+    let(:file_path) { File.join(file_dir, 'data.tar.gz') }
+
+    it 'returns eml' do
+      expect(dwca.eml).to be_kind_of DarwinCore::Metadata
+      expect(dwca.metadata).to be_kind_of DarwinCore::Metadata
+    end
+  end
+  
+  describe '#extensions' do
+    subject(:dwca) { DarwinCore.new(file_path) }
+    let(:file_path) { File.join(file_dir, 'data.tar.gz') }
+
+    it 'returns extensions' do
+      extensions = dwca.extensions
+      expect(extensions).to be_kind_of Array
+      expect(extensions[0]).to be_kind_of DarwinCore::Extension 
+    end
+  end
+
+  describe '#checksum' do
+    subject(:dwca) { DarwinCore.new(file_path) }
+    let(:file_path) { File.join(file_dir, 'data.tar.gz') }
+
+    it 'creates checksum hash' do
+      expect(dwca.checksum).to eq '7d94fc28ffaf434b66fbc790aa5ef00d834057bf'
+    end
+  end
+
+  describe '#has_parent_id' do
+    subject(:dwca) { DarwinCore.new(file_path) }
+
+    context 'has classification' do
+      let(:file_path) { File.join(file_dir, 'data.tar.gz') }
+      it 'returns true' do
+        expect(dwca.has_parent_id?).to be_true
+      end
+    end
+
+    context 'does not have classification' do
+      let(:file_path) { File.join(file_dir, 'gnub.tar.gz') }
+      it 'returns false' do
+        expect(dwca.has_parent_id?).to be_false
+      end
+    end
+  end
+
+  describe '#classification_normalizer' do
+    subject(:dwca) { DarwinCore.new(file_path) }
+    let(:file_path) { File.join(file_dir, 'data.tar.gz') }
+   
+    context 'not initialized' do
+      it 'is nil' do
+        expect(dwca.classification_normalizer).to be_nil
+      end
+    end
+
+    context 'initialized' do
+      it 'is DarwinCore::ClassificationNormalizer' do
+        dwca.normalize_classification
+        expect(dwca.classification_normalizer).
+          to be_kind_of DarwinCore::ClassificationNormalizer 
+      end
+    end
+  end
+
+  describe '#normalize_classification' do
+    subject(:dwca) { DarwinCore.new(file_path) }
+    let(:file_path) { File.join(file_dir, 'data.tar.gz') }
+    let(:normalized) { dwca.normalize_classification }
+
+    it 'returns hash' do
+      expect(normalized).to be_kind_of Hash
+    end
+
+    it 'uses utf-8 encoding for classification paths' do
+      encodings = []
+      normalized.each do |taxon_id, taxon|
+        taxon.classification_path.each { |p| encodings << p.encoding }
+      end
+      expect(encodings.uniq!.map { |e| e.to_s }).to eq ['UTF-8']
+    end
+
+    it 'has elements of DarwinCore::TaxonNormalized type' do
+      expect(normalized['leptogastrinae:tid:2857']).
+        to be_kind_of DarwinCore::TaxonNormalized
+    end
+  end
+
+end
+

data/spec/lib/generator_eml_xml_spec.rb

@@ -0,0 +1,21 @@
+require_relative '../spec_helper'
+
+describe DarwinCore::Generator::EmlXml do
+  subject(:eml) { DarwinCore::Generator::EmlXml.new(data, path) }
+  let(:data) { EML_DATA }
+  let(:path) { DarwinCore::DEFAULT_TMP_DIR }
+
+  describe '.new' do
+    it 'initializes generator' do
+      expect(eml).to be_kind_of DarwinCore::Generator::EmlXml
+    end
+  end
+
+  describe '#create' do
+    it 'should create eml xml' do
+      eml.create
+      eml_xml = File.read(File.join(path, 'eml.xml'))
+      expect(eml_xml).to match /Test Classification/
+    end
+  end
+end

data/spec/lib/generator_meta_xml_spec.rb

@@ -0,0 +1,21 @@
+require_relative '../spec_helper'
+
+describe DarwinCore::Generator::MetaXml do
+  subject(:meta) { DarwinCore::Generator::MetaXml.new(data, path) }
+  let(:data) { META_DATA }
+  let(:path) { DarwinCore::DEFAULT_TMP_DIR }
+
+  describe '.new' do
+    it 'initializes' do
+      expect(meta).to be_kind_of DarwinCore::Generator::MetaXml
+    end
+  end
+
+  describe '#create' do
+    it 'creates metadata file' do
+      meta.create
+      meta = File.read(File.join(path, 'meta.xml'))
+      expect(meta).to match %r|<location>core.csv</location>|  
+    end
+  end
+end

data/spec/lib/generator_spec.rb

@@ -0,0 +1,116 @@
+# encoding: utf-8
+require_relative '../spec_helper'
+
+describe DarwinCore::Generator do
+  subject(:gen) { DarwinCore::Generator.new(dwc_path, tmp_dir) }
+  let(:tmp_dir) { DarwinCore::DEFAULT_TMP_DIR }
+  let(:dwc_path) { File.join(tmp_dir, 'spec_dwca.tar.gz') } 
+
+  describe '.new' do
+    it 'initializes empty DwCA' do
+      expect(gen).to be_kind_of DarwinCore::Generator      
+    end
+  end
+
+  describe '#add_core' do
+    it 'adds core to DwCA instance' do
+      gen.add_core(CORE_DATA.dup, 'core.csv', true)
+      core = File.read(File.join(gen.path, 'core.csv'))
+      expect(core).to match /taxonID,parentNameUsageID,scientificName/
+    end
+
+    context 'urls are not given in header' do
+      it 'raises error' do
+        data = CORE_DATA.dup
+        data[0] = data[0].map { |f| f.split('/')[-1] }
+        expect { gen.add_core(data, 'core.csv', true) }.
+                              to raise_error DarwinCore::GeneratorError
+      end
+    end
+  end
+
+  describe '#add_extension' do
+    it 'adds extension to DwCA instance' do
+      gen.add_extension(EXTENSION_DATA.dup, 
+                        'vern.csv', 
+                        true, 
+                        'http://rs.gbif.org/terms/1.0/VernacularName')
+      extension = File.read(File.join(gen.path, 'vern.csv'))
+      
+      expect(extension).to match /Береза/
+    end
+  end
+
+  describe '#add_meta_xml' do
+    it 'creates metadata for DwCA' do
+      gen.add_core(CORE_DATA.dup, 'core.csv', true)
+      gen.add_extension(EXTENSION_DATA.dup, 
+                        'vern.csv', 
+                        true, 
+                        'http://rs.gbif.org/terms/1.0/VernacularName')
+
+      gen.add_meta_xml
+      meta = File.read(File.join(gen.path, 'meta.xml'))
+      expect(meta).to match %r|<location>core.csv</location>|
+    end
+  end
+
+  describe '#add_eml_data' do
+    it 'adds eml data' do
+      gen.add_eml_xml(EML_DATA)
+      eml = File.read(File.join(gen.path, 'eml.xml'))
+      expect(eml).to match /jdoe@example.com/
+    end
+  end
+
+  describe '#path' do
+    it 'returns temporary path for assembling DwCA' do
+      expect(gen.path).to match /dwc_\d+$/
+    end
+  end
+
+  describe '#files' do
+    it 'returns created files' do
+      gen.add_core(CORE_DATA.dup, 'core.csv', true)
+      gen.add_extension(EXTENSION_DATA.dup, 
+                        'vern.csv', 
+                        true, 
+                        'http://rs.gbif.org/terms/1.0/VernacularName')
+
+      gen.add_meta_xml
+      expect(gen.files).to match_array ['core.csv', 'meta.xml', 'vern.csv']  
+    end
+  end
+
+  describe '#pack' do
+    it 'creates final DwCA file' do
+      FileUtils.rm dwc_path if File.exists?(dwc_path)
+      gen.add_core(CORE_DATA.dup, 'core.csv', true)
+      gen.add_extension(EXTENSION_DATA.dup, 
+                        'vern.csv', 
+                        true, 
+                        'http://rs.gbif.org/terms/1.0/VernacularName')
+
+      gen.add_meta_xml
+      gen.add_eml_xml(EML_DATA)
+      gen.pack
+      expect(File.exists?(dwc_path)).to be_true 
+    end
+  end
+
+  describe '#clean' do
+    it 'removes temporary directory for DwCA' do
+      gen.add_eml_xml(EML_DATA)
+      expect(File.exists?(gen.path)).to be true
+      gen.clean
+      expect(File.exists?(gen.path)).to be false
+    end
+  end
+
+  describe '#eml_xml_data' do
+    it 'returns current eml data' do
+      expect(gen.eml_xml_data).to be_kind_of Hash
+    end
+  end
+  
+end

data/spec/lib/gnub_taxon_spec.rb

@@ -0,0 +1,34 @@
+require_relative '../spec_helper'
+
+describe DarwinCore::GnubTaxon do
+  subject(:dwca) { DarwinCore.new(file_path) }
+  subject(:normalizer) { DarwinCore::ClassificationNormalizer.new(dwca) }
+  let(:file_dir) { File.expand_path('../../files', __FILE__) }
+  let(:file_path) { File.join(file_dir, file_name) }
+  let(:file_name) { 'gnub.tar.gz' }
+
+  it 'should get uuids from GNUB' do
+    normalizer.normalize
+    tn = normalizer.normalized_data['9c399f90-cfb8-5a7f-9a21-18285a473488']
+    expect(tn).to be_kind_of DarwinCore::GnubTaxon
+    expect(tn).to be_kind_of DarwinCore::TaxonNormalized
+    expect(tn.uuid).to eq '8faa91f6-663f-4cfe-b785-0ab4e9415a51'
+    expect(tn.uuid_path).to eq [
+      '9a9f9eeb-d5f9-4ff6-b6cb-a5ad345e33c3',
+      'bf4c91c0-3d1f-44c7-9d3b-249382182a26',
+      '8faa91f6-663f-4cfe-b785-0ab4e9415a51']
+
+  end
+
+
+  context 'not a gnub data' do
+    let(:file_name) { 'data.tar.gz' }
+    it 'should not be of GnubTaxon type' do
+      normalizer.normalize
+      tn = normalizer.normalized_data['leptogastrinae:tid:42']
+      expect(tn).to be_kind_of DarwinCore::TaxonNormalized
+      expect(tn).not_to be_kind_of DarwinCore::GnubTaxon
+    end
+  end
+    
+end