metar-parser 0.9.11 → 0.9.12

data/spec/unit/pressure_spec.rb

@@ -0,0 +1,32 @@
+load File.expand_path( '../spec_helper.rb', File.dirname(__FILE__) )
+
+describe Metar::Pressure do
+
+  context '.parse' do
+
+    it 'interprets the Q prefix as hectopascals' do
+      Metar::Pressure.parse( 'Q1300' ).value.
+                                  should     be_within( 0.01 ).of( 1.3 )
+    end
+
+    it 'interprets the A prefix as inches of mercury' do
+      Metar::Pressure.parse( 'A1234' ).value.
+                                  should     be_within( 0.01 ).of( 0.42 )
+    end
+
+    it 'require 4 digits' do
+      Metar::Pressure.parse( 'Q12345' ).
+                                  should     be_nil
+      Metar::Pressure.parse( 'A123' ).
+                                  should     be_nil
+    end
+
+    it 'returns nil for nil' do
+      Metar::Pressure.parse( nil ).
+                                  should     be_nil
+    end
+
+  end
+
+end
+

data/spec/unit/raw_spec.rb

@@ -0,0 +1,196 @@
+load File.expand_path( '../spec_helper.rb', File.dirname(__FILE__) )
+# encoding: utf-8
+
+require 'net/ftp'
+
+describe Metar::Raw do
+
+  after :each do
+    Metar::Raw.send( :class_variable_set, '@@connection', nil )
+  end
+
+  context '.connection' do
+
+    context 'uncached' do
+
+      it 'sets up the connection' do
+        ftp = stub( 'ftp', :login => nil, :chdir => nil, :passive= => nil )
+
+        Net::FTP.                   should_receive( :new ).
+                                    and_return( ftp )
+
+        Metar::Raw.connect
+      end
+
+    end
+
+    context 'cached' do
+
+      before :each do
+        @ftp = stub( 'ftp' )
+        Metar::Raw.send( :class_variable_set, '@@connection', @ftp )
+      end
+
+      it 'does not connect to FTP' do
+        Net::FTP.                   should_not_receive( :new )
+
+        Metar::Raw.connection
+      end
+
+      it 'returns the cached connection' do
+        connection = Metar::Raw.connection
+
+        connection.               should     == @ftp
+      end
+
+    end
+    
+  end
+
+  context '.connect' do
+
+    it 'sets up the connection' do
+      ftp = stub( 'ftp' )
+
+      Net::FTP.                   should_receive( :new ).
+                                  and_return( ftp )
+      ftp.                        should_receive( :login )
+      ftp.                        should_receive( :chdir )
+      ftp.                        should_receive( :passive= ).
+                                  with( true )
+
+      Metar::Raw.connect
+    end
+
+  end
+
+  context '.fetch' do
+
+    it 'uses the connection' do
+      ftp = stub( 'ftp', :login => nil, :chdir => nil, :passive= => nil, :retrbinary => nil )
+
+      Net::FTP.                   should_receive( :new ).
+                                  and_return( ftp )
+
+      Metar::Raw.fetch( 'the_cccc' )
+    end
+
+    it 'downloads the raw report' do
+      ftp = stub( 'ftp', :login => nil, :chdir => nil, :passive= => nil )
+      Net::FTP.stub!( :new ).and_return( ftp )
+
+      ftp.                        should_receive( :retrbinary ) do | *args, &block |
+        args[ 0 ].                should     == 'RETR the_cccc.TXT'
+        args[ 1 ].                should     be_a Fixnum
+      end
+
+      Metar::Raw.fetch( 'the_cccc' )
+    end
+
+    it 'returns the data' do
+      ftp = stub( 'ftp', :login => nil, :chdir => nil, :passive= => nil )
+      def ftp.retrbinary( *args, &block )
+        block.call "chunk 1\n"
+        block.call "chunk 2\n"
+      end
+      Net::FTP.stub!( :new ).and_return( ftp )
+ 
+      raw = Metar::Raw.fetch( 'the_cccc' )
+
+      raw.                        should     == "chunk 1\nchunk 2\n"
+    end
+
+    it 'retries retrieval once' do
+      ftp = stub( 'ftp', :login => nil, :chdir => nil, :passive= => nil )
+      def ftp.attempt
+        @attempt
+      end
+      def ftp.attempt=(a)
+        @attempt = a
+      end
+      ftp.attempt = 0
+      def ftp.retrbinary( *args, &block )
+        self.attempt = self.attempt + 1
+        raise Net::FTPTempError if self.attempt == 1
+        block.call "chunk 1\n"
+        block.call "chunk 2\n"
+      end
+      Net::FTP.stub!( :new ).and_return( ftp )
+ 
+      raw = Metar::Raw.fetch( 'the_cccc' )
+
+      raw.                        should     == "chunk 1\nchunk 2\n"
+    end
+
+    it 'fails with an error, if retrieval fails twice' do
+      ftp = stub( 'ftp', :login => nil, :chdir => nil, :passive= => nil )
+      def ftp.attempt
+        @attempt
+      end
+      def ftp.attempt=(a)
+        @attempt = a
+      end
+      ftp.attempt = 0
+      def ftp.retrbinary( *args, &block )
+        self.attempt = self.attempt + 1
+        raise Net::FTPTempError
+      end
+      Net::FTP.stub!( :new ).and_return( ftp )
+
+      expect do
+        Metar::Raw.fetch( 'the_cccc' )
+      end.                        to         raise_error( RuntimeError, /failed 2 times/)
+    end
+
+  end
+
+  context 'initialization' do
+  
+    it 'should accept CCCC codes' do
+      raw = Metar::Raw.new( 'XXXX' )
+
+      raw.cccc.                   should     == 'XXXX'
+    end
+      
+    it 'should accept Stations' do
+      station = stub( 'Metar::Station', :cccc => 'YYYY' )
+      raw = Metar::Raw.new( station )
+
+      raw.cccc.                   should     == 'YYYY'
+    end
+
+    it 'should parse data, if supplied' do
+      raw = Metar::Raw.new( 'XXXX', raw_metar )
+     
+      raw.data.                   should     == raw_metar 
+      raw.raw_time.               should     == @raw_time
+      raw.metar.                  should     == @metar 
+      raw.time.                   should     == Time.parse( @raw_time ) 
+    end
+    
+  end
+
+  context 'lazy loading' do
+    
+    it 'should fetch data on demand' do
+      raw = Metar::Raw.new( 'ESSB' )
+
+      Metar::Raw.                 should_receive( :fetch ).
+                                  with( 'ESSB' ).
+                                  and_return( raw_metar )
+
+      raw.metar
+
+      raw.data.                   should     == raw_metar 
+    end
+
+  end
+
+  def raw_metar
+    @raw_time  = "2010/02/15 10:20"
+    @metar     = "ESSB 151020Z 26003KT 2000 R12/1000N R30/1500N VV002 M07/M07 Q1013 1271//55"
+    "#{ @raw_time }\n#{ @metar }"
+  end
+
+end
+

data/spec/unit/report_spec.rb

@@ -0,0 +1,187 @@
+load File.expand_path( '../spec_helper.rb', File.dirname(__FILE__) )
+# encoding: utf-8
+
+describe Metar::Report do
+
+  context 'initialization' do
+    
+    it 'loads the Station' do
+      station = stub( 'station' )
+      parser = stub( 'parser', :station_code => 'SSSS' )
+
+      Metar::Station.             should_receive( :find_by_cccc ).
+                                  with( 'SSSS' ).
+                                  and_return( station )
+
+      Metar::Report.new( parser )
+    end
+    
+  end
+
+  context 'attributes' do
+
+    before :each do
+      @locale       = I18n.locale
+      @station_code = 'SSSS'
+      @metar_date   = '2008/05/06'
+      @metar_time   = '10:56'
+      @metar_datetime   = "#{@metar_date} #{@metar_time}"
+      @station      = stub( 'station', :name    => 'Airport 1',
+                                       :country => 'Wwwwww' )
+      @parser       = stub( 'parser', :station_code => @station_code,
+                                      :date         => Date.parse( @metar_date ),
+                                      :time         => Time.parse( @metar_datetime ),
+                                      :observer     => :real )
+      Metar::Station.stub( :find_by_cccc ).with( @station_code ).and_return( @station )
+    end
+
+    subject { Metar::Report.new( @parser ) }
+
+    after :each do
+      I18n.locale = @locale
+    end
+
+    context '#date' do
+
+      it 'localizes' do
+        I18n.locale = :en
+
+        subject.date.             should     == '06/05/2008'
+
+        I18n.locale = :it
+
+        subject.date.             should     == '06/05/2008'
+      end
+
+    end
+
+    context '#time' do
+      specify { subject.time.     should     == @metar_time }
+    end
+
+    context '#observer' do
+      specify { subject.observer. should     == 'real' }
+    end
+
+    specify { subject.station_name.
+                                  should     == 'Airport 1' }
+
+    specify { subject.station_country.
+                                  should     == 'Wwwwww' }
+
+    specify { subject.station_code.
+                                  should     == @station_code }
+
+    context 'proxied from parser' do
+
+      context 'singly' do
+        [
+          :wind,
+          :variable_wind,
+          :visibility,
+          :vertical_visibility,
+          :temperature,
+          :dew_point,
+          :sea_level_pressure,
+        ].each do | attribute |
+          example attribute do
+            @attr = stub( attribute.to_s )
+            @parser.stub!( attribute => @attr )
+
+            @attr.                   should_receive( :to_s )
+
+            subject.send( attribute )
+          end
+        end
+
+        context '#sky_summary' do
+
+          it 'returns the summary' do
+            @skies1 = stub('sky_conditions')
+            @parser.stub!( :sky_conditions => [@skies1] )
+
+            @skies1.              should_receive( :to_summary ).
+                                  and_return( 'skies1' )
+
+            subject.sky_summary.  should     == 'skies1'
+          end
+
+          it 'clear skies when missing' do
+            @parser.stub!( :sky_conditions => [] )
+
+            subject.sky_summary.  should     == 'clear skies'
+          end
+
+          it 'uses the last, if there is more than 1' do
+            @skies1 = stub('sky_conditions1' )
+            @skies2 = stub('sky_conditions2' )
+            @parser.stub!( :sky_conditions => [ @skies1, @skies2 ] )
+
+            @skies2.              should_receive( :to_summary ).
+                                  and_return( 'skies2' )
+
+            subject.sky_summary.  should     == 'skies2'
+          end
+        end
+      end
+
+      context 'joined' do
+
+        it '#runway_visible_range' do
+          @rvr1 = stub( 'rvr1', :to_s => 'rvr1' )
+          @rvr2 = stub( 'rvr2', :to_s => 'rvr2' )
+          @parser.stub!( :runway_visible_range => [ @rvr1, @rvr2 ] )
+
+          subject.runway_visible_range.
+                                  should     == 'rvr1, rvr2'
+        end
+
+        it '#present_weather' do
+          @parser.stub!( :present_weather => [ 'pw1', 'pw2' ] )
+
+          subject.present_weather.should     == 'pw1, pw2'
+        end
+
+        it '#remarks' do
+          @parser.stub!( :remarks => [ 'rem1', 'rem2' ] )
+
+          subject.remarks.        should     == 'rem1, rem2'
+        end
+
+        it '#sky_conditions' do
+          sky1 = stub( 'sky1', :to_s => 'sky1' )
+          sky2 = stub( 'sky2', :to_s => 'sky2' )
+          @parser.stub!( :sky_conditions => [ sky1, sky2 ] )
+
+          subject.sky_conditions. should     == 'sky1, sky2'
+        end
+
+      end
+
+    end
+
+    it '#to_s' do
+          sky1 = stub( 'sky1', :to_summary => 'sky1' )
+          sky2 = stub( 'sky2', :to_summary => 'sky2' )
+      @parser.stub!( :wind            => 'wind',
+                     :visibility      => 'visibility',
+                     :present_weather => ['pw'],
+                     :sky_conditions  => [ sky1, sky2 ],
+                     :temperature     => 'temp' )
+      expected = <<EOT
+name: Airport 1
+country: Wwwwww
+time: #{@metar_time}
+wind: wind
+visibility: visibility
+weather: pw
+sky: sky2
+temperature: temp
+EOT
+      subject.to_s.               should     == expected
+    end
+
+  end
+
+end
+

data/spec/unit/runway_visible_range_spec.rb

@@ -0,0 +1,88 @@
+load File.expand_path( '../spec_helper.rb', File.dirname(__FILE__) )
+# encoding: utf-8
+
+RSpec::Matchers.define :be_runway_visible_range do | designator, visibility1, visibility2, tendency |
+  match do | rvr |
+    if rvr.nil?                && designator.nil?
+      true
+    elsif rvr.nil?             != designator.nil?
+      false
+    elsif rvr.visibility1.nil? != visibility1.nil?
+      false
+    elsif rvr.visibility2.nil? != visibility2.nil?
+      false
+    elsif rvr.tendency.nil? != tendency.nil?
+      false
+    elsif ! visibility1.nil? &&
+          ( ( rvr.visibility1.distance.value - visibility1[0] ).abs > 0.01 ||
+            rvr.visibility1.comparator != visibility1[ 2 ] )
+      false
+    elsif ! visibility2.nil? &&
+          ( ( rvr.visibility2.distance.value - visibility2[0] ).abs > 0.02 ||
+            rvr.visibility2.comparator != visibility2[2] )
+      false
+    elsif tendency != rvr.tendency
+      false
+    else
+      true
+    end
+  end
+end
+
+describe Metar::RunwayVisibleRange do
+
+  context '.parse' do
+
+    [
+      [ 'understands R + nn + / + nnnn',     'R12/3400',        [ '12',  [3400.00, nil, nil],        nil,                nil ] ],
+      [ 'understands runway positions: RLC', 'R12L/3400',       [ '12L', [3400.00, nil, nil],        nil,                nil ] ],
+      [ 'understands comparators: PM',       'R12/P3400',       [ '12',  [3400.00, nil, :more_than], nil,                nil ] ],
+      [ 'understands tendencies: NUD',       'R12/3400U',       [ '12',  [3400.00, nil, nil],        nil,                :improving ] ],
+      [ 'understands feet',                  'R12/3400FT',      [ '12',  [1036.32, nil, nil],        nil,                nil ] ],
+      [ 'understands second visibilties',    'R12/3400V1800FT', [ '12',  [1036.32, nil, nil],        [548.64, nil, nil], nil ] ],
+      [ 'returns nil for nil',               nil,               [ nil,   nil,                        nil,                nil ] ],
+    ].each do | docstring, raw, expected |
+      example docstring do
+        Metar::RunwayVisibleRange.parse( raw ).should be_runway_visible_range( *expected )
+      end
+    end
+
+  end
+
+  context '#to_s' do
+
+    before :all do
+      @locale = I18n.locale
+      I18n.locale = :it
+    end
+
+    after :all do
+      I18n.locale = @locale
+    end
+
+    [
+      [ 'v1',        :en, [ [3400.00, nil, nil], nil,                 nil ], 'runway 14: 3400m' ],
+      [ 'v1 and v2',       :en,  [ [3400.00, nil, nil], [1900.00, nil, nil], nil ], 'runway 14: from 3400m to 1900m' ],
+      [ 'v1 and tendency', :en, [ [3400.00, nil, nil], nil,                 :improving ], 'runway 14: 3400m improving' ],
+    ].each do | docstring, locale, ( visibility1, visibility2, tendency ), expected |
+      d1 = Metar::Distance.new( visibility1[0] )
+      v1 = Metar::Visibility.new( d1, visibility1[1], visibility1[2] )
+      v2 =
+        if ! visibility2.nil?
+          d2 = Metar::Distance.new( visibility2[0] )
+          Metar::Visibility.new( d2, visibility2[1], visibility2[2] )
+        else
+          nil
+        end
+
+      example docstring + " (#{locale})" do
+        I18n.locale = locale
+        Metar::RunwayVisibleRange.new( '14', v1, v2, tendency ).to_s.
+                                  should     == expected
+      end
+    end
+
+  end
+
+end
+