metar-parser 0.1.1

data/locales/en.yml

@@ -0,0 +1,111 @@
+# encoding: utf8
+en:
+  date:
+    formats:
+      default: '%d/%m/%Y'
+  comparison:
+    more_than: more than
+    less_than: less than
+  units:
+    pressure:
+      bar:
+        full: bar
+  metar:
+    altitude:
+      at: at
+    distance:
+      unknown: unknown
+    sky_conditions:
+      clear skies: clear skies
+      broken: broken cloud
+      few: few clouds
+      scattered: scattered cloud
+      overcast: overcast
+    runway_visible_range:
+      runway: runway
+      from: from
+      to: to
+    weather:
+      mist: mist
+      dust: dust
+      blowing dust: blowing dust
+      low drifting dust: low drifting dust
+      nearby blowing dust: nearby blowing dust
+      heavy drizzle: heavy drizzle
+      light drizzle: light drizzle
+      heavy freezing drizzle: heavy freezing drizzle
+      light freezing drizzle: light freezing drizzle
+      fog: fog
+      patches of fog: patches of fog
+      freezing fog: freezing fog
+      shallow fog: shallow fog
+      partial fog: partial fog
+      nearby fog: nearby fog
+      smoke: smoke
+      hail: hail
+      heavy shower of hail: heavy shower of hail
+      light shower of hail: light shower of hail
+      heavy shower of small hail: heavy shower of small hail
+      light shower of small hail: light shower of small hail
+      haze: haze
+      ice crystals: ice crystals
+      heavy ice pellets: heavy ice pellets
+      light ice pellets: light ice pellets
+      dust whirls: dust whirls
+      nearby dust whirls: nearby dust whirls
+      spray: spray
+      rain: rain
+      heavy rain: heavy rain
+      light rain: light rain
+      heavy shower of rain: heavy shower of rain
+      light shower of rain: light shower of rain
+      heavy freezing rain: heavy freezing rain
+      light freezing rain: light freezing rain
+      sand: sand
+      blowing sand: blowing sand
+      low drifting sand: low drifting sand
+      nearby blowing sand: nearby blowing sand
+      nearby shower: nearby shower
+      snow: snow
+      heavy snow: heavy snow
+      light snow: light snow
+      heavy shower of snow: heavy shower of snow
+      light shower of snow: light shower of snow
+      blowing snow: blowing snow
+      low drifting snow: low drifting snow
+      nearby blowing snow: nearby blowing snow
+      heavy snow grains: heavy snow grains
+      light snow grains: light snow grains
+      snow and rain: snow and rain
+      squall: squall
+      unknown phenomenon: unknown phenomenon
+      heavy freezing unknown phenomenon: heavy freezing unknown phenomenon
+      light freezing unknown phenomenon: light freezing unknown phenomenon
+      heavy shower of freezing unknown phenomenon: heavy shower of freezing unknown phenomenon
+      light shower of freezing unknown phenomenon: light shower of freezing unknown phenomenon
+      volcanic ash: volcanic ash
+      nearby volcanic ash: nearby volcanic ash
+      funnel cloud: funnel cloud
+      nearby funnel cloud: nearby funnel cloud
+      sand storm: sand storm
+      heavy sand storm: heavy sand storm
+      light sand storm: light sand storm
+      nearby sand storm: nearby sand storm
+      dust storm: dust storm
+      heavy dust storm: heavy dust storm
+      light dust storm: light dust storm
+      nearby dust storm: nearby dust storm
+      thunderstorm: thunderstorm
+      nearby thunderstorm: nearby thunderstorm
+      heavy thunderstorm and hail: heavy thunderstorm and hail
+      light thunderstorm and hail: light thunderstorm and hail
+      heavy thunderstorm and small hail: heavy thunderstorm and small hail
+      light thunderstorm and small hail: light thunderstorm and small hail
+      heavy thunderstorm and rain: heavy thunderstorm and rain
+      light thunderstorm and rain: light thunderstorm and rain
+      heavy thunderstorm and snow: heavy thunderstorm and snow
+      light thunderstorm and snow: light thunderstorm and snow
+      heavy thunderstorm and unknown phenomenon: heavy thunderstorm and unknown phenomenon
+      light thunderstorm and unknown phenomenon: light thunderstorm and unknown phenomenon
+      heavy unknown phenomenon: heavy unknown phenomenon
+      light unknown phenomenon: light unknown phenomenon

data/locales/it.yml

@@ -0,0 +1,111 @@
+# encoding: utf8
+it:
+  date:
+    formats:
+      default: '%d/%m/%Y'
+  comparison:
+    more_than: piú di
+    less_than: meno di
+  units:
+    pressure:
+      bar:
+        full: bar
+  metar:
+    altitude:
+      at: a
+    distance:
+      unknown: sconosciuto
+    sky_conditions:
+      clear skies: cielo sereno
+      broken: nuvolosità parziale
+      few: poche nuvole
+      scattered: nuvole sparse
+      overcast: chiuso
+    runway_visible_range:
+      runway: pista
+      from: da
+      to: a
+    weather:
+      mist: foschia
+      dust: polvere
+      blowing dust: polviscolo
+      low drifting dust: deriva bassa di polviscolo # ?
+      nearby blowing dust: deriva vicina di polviscolo # ?
+      heavy drizzle: pioggerellina fitta
+      light drizzle: pioggerellina rada
+      heavy freezing drizzle: pioggerellina ghiacciata pesante
+      light freezing drizzle: pioggerellina ghiacciata leggera
+      fog: nebbia
+      patches of fog: nebbia a banchi
+      freezing fog: nebbia ghiacciata
+      shallow fog: nebbia bassa
+      partial fog: nebbia parziale
+      nearby fog: nebbia vicina
+      smoke: fumo
+      hail: grandine
+      heavy shower of hail: grandinata intensa
+      light shower of hail: grandinata leggera
+      heavy shower of small hail: grandinata fine intensa
+      light shower of small hail: grandinata fine leggera
+      haze: foschia
+      ice crystals: cristalli di ghiaccio
+      heavy ice pellets: caduta intensa di cristalli di ghiaccio
+      light ice pellets: caduta leggera di cristalli di ghiaccio
+      dust whirls: vortici di polvere
+      nearby dust whirls: vortici di polvere vicini
+      spray: "spruzzi d'aqua"
+      rain: pioggia
+      heavy rain: pioggia pesante
+      light rain: pioggia leggera
+      heavy shower of rain: acquazzone intenso
+      light shower of rain: acquazzone leggero
+      heavy freezing rain: pioggia ghiacciata pesante
+      light freezing rain: pioggia ghiacciata leggera
+      sand: sabbia
+      blowing sand: sabbia e vento
+      low drifting sand: deriva bassa di sabbia
+      nearby blowing sand: deriva di sabbia vicina
+      nearby shower: acquazzone vicino
+      snow: neve
+      heavy snow: neve pesante
+      light snow: neve leggera
+      heavy shower of snow: nevicata pesante
+      light shower of snow: nevicata leggera
+      blowing snow: neve portata dal vento
+      low drifting snow: deriva di neve
+      nearby blowing snow: neve portata dal vento vicino
+      heavy snow grains: caudta intensa di granelli di neve
+      light snow grains: caduta leggera di granelli di neve 
+      snow and rain: neve mista a pioggia
+      squall: bufera
+      unknown phenomenon: fenomeno sconosciuto
+      heavy freezing unknown phenomenon: fenomeno ghiacciato sconosciuto pesante
+      light freezing unknown phenomenon: fenomeno ghiacciato sconosciuto leggero
+      heavy shower of freezing unknown phenomenon: scroscio pesante ghiacciata di fenomeno sconosciuto
+      light shower of freezing unknown phenomenon: scroscio leggero ghiacciata di fenomeno sconosciuto
+      volcanic ash: cenere volcanica
+      nearby volcanic ash: cenere volcanica vicina
+      funnel cloud: nube a imbuto
+      nearby funnel cloud: nube a imbuto vicina
+      sand storm: tempesta di sabbia
+      heavy sand storm: tempesta di sabbia pesante
+      light sand storm: tempesta di sabbia leggera
+      nearby sand storm: tempesta di sabbia vicina
+      dust storm: tempesta di polvere
+      heavy dust storm: tempesta di polvere pesante
+      light dust storm: tempesta di polvere leggera
+      nearby dust storm: tempesta di polvere vicina
+      thunderstorm: temporale
+      nearby thunderstorm: temporale vicino
+      heavy thunderstorm and hail: temporale con grandine intenso
+      light thunderstorm and hail: temporale con grandine leggero
+      heavy thunderstorm and small hail: temporale con grandine fine intenso
+      light thunderstorm and small hail: temporale con grandine fine leggero
+      heavy thunderstorm and rain: temporale con pioggia intensa
+      light thunderstorm and rain: temporale con pioggia leggera
+      heavy thunderstorm and snow: temporale con neve intensa
+      light thunderstorm and snow: temporale con neve leggera
+      heavy thunderstorm and unknown phenomenon: temporale con fenomeno sconosciuto intenso
+      light thunderstorm and unknown phenomenon: temporale con fenomeno sconosciuto leggero
+      heavy unknown phenomenon: fenomeno sconosciuto intenso
+      light unknown phenomenon: fenomeno sconosciuto leggero

data/test/all_tests.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+Dir['unit/*test.rb'].each do |test_file|
+  puts test_file
+  require File.join(File.dirname(__FILE__), test_file)
+end

data/test/metar_test_helper.rb

@@ -0,0 +1,14 @@
+require 'rubygems' if RUBY_VERSION < '1.9'
+require File.join(File.expand_path(File.dirname(__FILE__) + '/../lib'), 'metar')
+
+Metar::Station.load_local
+
+RAW_EXAMPLE = "2010/02/06 15:20\nLIRQ 061520Z 01007KT 350V050 9999 SCT035 BKN080 08/02 Q1005"
+# Use a fixed string for testing
+Metar::Raw.instance_eval do
+  def fetch(cccc)
+    RAW_EXAMPLE
+  end
+end
+
+require 'test/unit'

data/test/unit/data_test.rb

@@ -0,0 +1,183 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../metar_test_helper'
+
+class TestMetarData < Test::Unit::TestCase
+  
+  def setup
+    I18n.locale = :en
+  end
+
+  def test_m9t_translations_available
+    assert_equal('10 kilometers', M9t::Distance.new(10000, {:units => :kilometers, :precision => 0}).to_s)
+  end
+
+  # Speed
+  def test_speed_parse_blank_gives_nil
+    speed = Metar::Speed.parse('')
+    assert_nil(speed)
+  end
+
+  def test_class_options_set
+    assert_not_nil(Metar::Speed.options)
+  end
+
+  def test_speed_parse_default_unit
+    speed = Metar::Speed.parse('12')
+    assert_equal(12, speed.to_kilometers_per_hour)
+    assert_equal(:kilometers_per_hour, speed.options[:units])
+  end
+
+  def test_speed_parse_kilometers_per_hour
+    speed = Metar::Speed.parse('12KMH')
+    assert_equal(12, speed.to_kilometers_per_hour)
+    assert_equal(:kilometers_per_hour, speed.options[:units])
+  end
+
+  def test_speed_parse_knots
+    speed = Metar::Speed.parse('12KT')
+    assert_equal(:knots, speed.options[:units])
+  end
+
+  def test_speed_parse_meters_per_second
+    speed = Metar::Speed.parse('12MPS')
+    assert_equal(:meters_per_second, speed.options[:units])
+  end
+  
+  # Temperature
+  def test_temperature_parse_blank_gives_nil
+    temperature = Metar::Temperature.parse('')
+    assert_nil(temperature)
+  end
+
+  def test_temperature_parse_incorrect_gives_nil
+    temperature = Metar::Temperature.parse('XYZ')
+    assert_nil(temperature)
+  end
+
+  def test_temperature_parse_positive
+    temperature = Metar::Temperature.parse('12')
+    assert_equal(12, temperature.value)
+  end
+
+  def test_temperature_parse_negative
+    temperature = Metar::Temperature.parse('M12')
+    assert_equal(-12, temperature.value)
+  end
+
+  # Distance
+  def test_distance_nil
+    distance = Metar::Distance.new
+    I18n.locale = :en
+    assert_equal('unknown', distance.to_s)
+    I18n.locale = :it
+    assert_equal('sconosciuto', distance.to_s)
+  end
+
+  # Wind
+  def test_wind
+    wind = Metar::Wind.parse('24006KT')
+    assert_equal(240, wind.direction.value)
+    assert_equal(6, wind.speed.to_knots)
+    assert_equal(:knots, wind.speed.options[:units])
+  end
+
+  # VariableWind
+  def test_variable_wind
+    variable_wind = Metar::VariableWind.parse('350V050')
+    assert_equal(350, variable_wind.direction1.value)
+    assert_equal(50, variable_wind.direction2.value)
+  end
+
+  # Visibility
+  def test_visibility_parse_blank
+    visibility = Metar::Visibility.parse('')
+    assert_nil(visibility)
+  end
+
+  def test_visibility_parse_comparator_defaults_to_nil
+    visibility = Metar::Visibility.parse('0200NDV')
+    assert_nil(visibility.comparator)
+  end
+
+  def test_visibility_parse_9999
+    visibility = Metar::Visibility.parse('9999')
+    assert_equal('more than 10km', visibility.to_s)
+    I18n.locale = :it
+    assert_equal('piú di 10km', visibility.to_s)
+  end
+
+  def test_visibility_parse_ndv
+    visibility = Metar::Visibility.parse('0200NDV')
+    assert_equal(200, visibility.distance.value)
+    assert_nil(visibility.direction)
+  end
+
+  def test_visibility_parse_us_fractions_1_4
+    visibility = Metar::Visibility.parse('1/4SM')
+    assert_equal(M9t::Distance.miles(0.25).value, visibility.distance.value)
+    assert_equal(:miles, visibility.distance.options[:units])
+  end
+
+  def test_visibility_parse_us_fractions_2_1_2
+    visibility = Metar::Visibility.parse('2 1/2SM')
+    assert_equal(M9t::Distance.miles(2.5).value, visibility.distance.value)
+    assert_equal(:miles, visibility.distance.options[:units])
+  end
+
+  def test_visibility_parse_kilometers
+    visibility = Metar::Visibility.parse('5KM')
+    assert_equal(5000.0, visibility.distance.value)
+    assert_equal(:kilometers, visibility.distance.options[:units])
+  end
+
+  def test_visibility_parse_compass
+    visibility = Metar::Visibility.parse('5NE')
+    assert_equal(5000.0, visibility.distance.value)
+    assert_equal(:kilometers, visibility.distance.options[:units])
+    assert_equal(45.0, visibility.direction.value)
+    visibility.distance.options[:units] = :kilometers
+    visibility.distance.options[:abbreviated] = true
+    visibility.distance.options[:precision] = 0
+    visibility.direction.options[:units] = :compass
+    assert_equal('5km NE', visibility.to_s)
+  end
+  
+  # RunwayVisibleRange
+  def test_runway_visible_range
+    runway_visible_range = Metar::RunwayVisibleRange.parse('R12/1000N')
+    assert_equal('12', runway_visible_range.designator)
+    assert_equal(1000, runway_visible_range.visibility1.distance.value)
+    assert_equal(:no_change, runway_visible_range.tendency)
+  end
+
+  def test_runway_visible_range_variable
+    runway_visible_range = Metar::RunwayVisibleRange.parse('R10R/1600VP6000FT')
+    assert_equal('10R', runway_visible_range.designator)
+    assert_equal(1600, runway_visible_range.visibility1.distance.to_feet)
+    assert_equal(6000, runway_visible_range.visibility2.distance.to_feet)
+  end
+
+  # WeatherPhenomenon
+  def test_weather_phenomenon_i18n
+    freezing_rain = Metar::WeatherPhenomenon.parse('FZFG')
+    assert_equal('freezing fog', freezing_rain.to_s)
+    I18n.locale =  :it
+    assert_equal('nebbia ghiacciata', freezing_rain.to_s)
+  end
+
+  # SkyCondition
+  def test_sky_condition
+    sky_condition = Metar::SkyCondition.parse('BKN016')
+    assert_equal('broken', sky_condition.quantity)
+    assert_equal(480, sky_condition.height.value)
+  end
+
+  # VerticalVisibility
+  def test_vertical_visibility
+    vertical_visibility = Metar::VerticalVisibility.parse('VV001')
+    assert_equal(30, vertical_visibility.value)
+  end
+
+end

data/test/unit/parser_test.rb

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../metar_test_helper'
+
+class TestMetarParser < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def test_new
+    raw = Metar::Raw.new('PAIL', "2010/02/06 16:10\nPAIL 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000")
+    assert_nothing_thrown do
+      report = Metar::Parser.new(raw)
+    end
+  end
+
+  def test_date
+    parser = setup_parser('PAIL', "2010/02/06 16:10\nPAIL 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000")
+    assert_equal(Date.new(2010, 2, 6), parser.date)
+  end
+
+  def test_wind
+    parser = setup_parser('PAIL', "2010/02/06 16:10\nPAIL 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000")
+    assert_in_delta(240, parser.wind.direction.value, 0.0001)
+    assert_in_delta(6, parser.wind.speed.to_knots, 0.0001)
+  end
+
+  def test_variable_wind
+    parser = setup_parser('LIRQ', "2010/02/06 15:20\nLIRQ 061520Z 01007KT 350V050 9999 SCT035 BKN080 08/02 Q1005")
+    assert_in_delta(350, parser.variable_wind.direction1.value, 0.0001)
+    assert_in_delta(50, parser.variable_wind.direction2.value, 0.0001)
+  end
+
+  def test_visibility_miles_and_fractions
+    parser = setup_parser('PAIL', "2010/02/06 16:10\nPAIL 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000")
+    assert_in_delta(1.75, parser.visibility.distance.to_miles, 0.01)
+    assert_equal(:miles, parser.visibility.distance.options[:units])
+  end
+
+  def test_runway_visible_range
+    parser = setup_parser('ESSB', "2010/02/15 10:20\nESSB 151020Z 26003KT 2000 R12/1000N R30/1500N VV002 M07/M07 Q1013 1271//55")
+    assert_equal(2, parser.runway_visible_range.length)
+    assert_equal('12', parser.runway_visible_range[0].designator)
+    assert_equal(1000, parser.runway_visible_range[0].visibility1.distance.value)
+    assert_equal(:no_change, parser.runway_visible_range[0].tendency)
+  end
+
+  def test_runway_visible_range_variable
+    parser = setup_parser('KPDX', "2010/02/15 11:08\nKPDX 151108Z 11006KT 1/4SM R10R/1600VP6000FT FG OVC002 05/05 A3022 RMK AO2")
+    assert_equal(1600.0, parser.runway_visible_range[0].visibility1.distance.to_feet)
+    assert_equal(:feet, parser.runway_visible_range[0].visibility1.distance.options[:units])
+    assert_equal(6000.0, parser.runway_visible_range[0].visibility2.distance.to_feet)
+    assert_equal(:feet, parser.runway_visible_range[0].visibility2.distance.options[:units])
+  end
+
+  def test_present_weather
+    parser = setup_parser('PAIL', "2010/02/06 16:10\nPAIL 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000")
+    assert_equal(1, parser.present_weather.length)
+    assert_equal('light', parser.present_weather[0].modifier)
+    assert_equal('snow', parser.present_weather[0].phenomenon)
+  end
+
+  def test_sky_conditions
+    parser = setup_parser('PAIL', "2010/02/06 16:10\nPAIL 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000")
+    assert_equal(2, parser.sky_conditions.length)
+    assert_equal('broken', parser.sky_conditions[0].quantity)
+    assert_equal(480, parser.sky_conditions[0].height.value)
+    assert_equal('overcast', parser.sky_conditions[1].quantity)
+    assert_equal(900, parser.sky_conditions[1].height.value)
+  end
+
+  def test_vertical_visibility
+    parser = setup_parser('CYXS', "2010/02/15 10:34\nCYXS 151034Z AUTO 09003KT 1/8SM FZFG VV001 M03/M03 A3019 RMK SLP263 ICG")
+    assert_equal(30, parser.vertical_visibility.value)
+  end
+
+  def test_temperature
+    parser = setup_parser('PAIL', "2010/02/06 16:10\nPAIL 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000")
+    assert_equal(-17, parser.temperature.value)
+  end
+
+  def test_dew_point
+    parser = setup_parser('PAIL', "2010/02/06 16:10\nPAIL 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000")
+    assert_equal(-20, parser.dew_point.value)
+  end
+
+  def test_sea_level_pressure
+    parser = setup_parser('PAIL', "2010/02/06 16:10\nPAIL 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000")
+    assert_equal(29.10, parser.sea_level_pressure.to_inches_of_mercury)
+    assert_equal(:bar, parser.sea_level_pressure.options[:units])
+  end
+
+  private
+
+  def setup_parser(cccc, metar)
+    raw = Metar::Raw.new(cccc, metar)
+    Metar::Parser.new(raw)
+  end
+
+end

data/test/unit/raw_test.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../metar_test_helper'
+
+class TestMetarRaw < Test::Unit::TestCase
+  
+  def setup
+  end
+
+  def test_fetch
+    raw = Metar::Raw.fetch('LIRQ')
+    assert_instance_of(String, raw)
+  end
+
+  def test_new
+    assert_nothing_thrown do
+      raw = Metar::Raw.new('LIRQ')
+    end
+  end
+
+  def test_attributes
+    raw = Metar::Raw.new('LIRQ')
+    assert_equal('LIRQ', raw.cccc)
+    assert_instance_of(Time, raw.time)
+    assert_instance_of(String, raw.metar)
+  end
+
+end

data/test/unit/report_test.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../metar_test_helper'
+
+class TestMetarReport < Test::Unit::TestCase
+  def setup
+    I18n.locale = :en
+  end
+
+  def test_date
+    report = setup_report('LIRQ', "2010/02/06 15:20\nLIRQ 061520Z 01007KT 350V050 9999 SCT035 BKN080 08/02 Q1005")
+    assert_equal('06/02/2010', report.date)
+  end
+
+  def test_time
+    report = setup_report('LIRQ', "2010/02/06 15:20\nLIRQ 061520Z 01007KT 350V050 9999 SCT035 BKN080 08/02 Q1005")
+    assert_equal('15:20', report.time)
+  end
+
+  def test_wind_knots
+    report = setup_report('LIRQ', "2010/02/06 15:20\nLIRQ 061520Z 01007KT 350V050 9999 SCT035 BKN080 08/02 Q1005")
+    assert_equal('10° 7 knots', report.wind)
+    I18n.locale = :it
+    assert_equal('10° 7 nodi', report.wind)
+  end
+
+  def test_variable_wind
+    report = setup_report('LIRQ', "2010/02/06 15:20\nLIRQ 061520Z 01007KT 350V050 9999 SCT035 BKN080 08/02 Q1005")
+    assert_equal('350 degrees - 50 degrees', report.variable_wind)
+  end
+
+  def test_visibility
+    report = setup_report('LIRQ', "2010/02/06 15:20\nLIRQ 061520Z 01007KT 350V050 9999 SCT035 BKN080 08/02 Q1005")
+    assert_equal('more than 10km', report.visibility)
+  end
+
+  def test_runway_visible_range
+    report = setup_report('ESSB', "2010/02/15 10:20\nESSB 151020Z 26003KT 2000 R12/1000N R30/1500N VV002 M07/M07 Q1013 1271//55")
+    assert_equal('runway 12: 1000m, runway 30: 1500m', report.runway_visible_range)
+  end
+
+  def test_runway_visible_range_variable
+    report = setup_report('KPDX', "2010/02/15 11:08\nKPDX 151108Z 11006KT 1/4SM R10R/1600VP6000FT FG OVC002 05/05 A3022 RMK AO2")
+    assert_equal('runway 10R: from 1600ft to more than 6000ft', report.runway_visible_range)
+  end
+
+  def test_present_weather
+    report = setup_report('DAAS', "2010/02/15 10:00\nDAAS 151000Z 16012KT 9999 -RA FEW010 BKN026 06/05 Q1006")
+    assert_equal('light rain', report.present_weather)
+    I18n.locale = :it
+    assert_equal('pioggia leggera', report.present_weather)
+  end
+
+  def test_sky_conditions
+    report = setup_report('LIRQ', "2010/02/06 15:20\nLIRQ 061520Z 01007KT 350V050 9999 SCT035 BKN080 08/02 Q1005")
+    I18n.locale = :en
+    assert_equal('scattered cloud at 1050m, broken cloud at 2400m', report.sky_conditions)
+    I18n.locale = :it
+    assert_equal('nuvole sparse a 1050m, nuvolosità parziale a 2400m', report.sky_conditions)
+  end
+
+  def test_vertical_visibility
+    report = setup_report('CYXS', "2010/02/15 10:34\nCYXS 151034Z AUTO 09003KT 1/8SM FZFG VV001 M03/M03 A3019 RMK SLP263 ICG")
+    assert_equal('30m', report.vertical_visibility)
+  end
+
+  def test_temperature
+    report = setup_report('LIRQ', "2010/02/06 15:20\nLIRQ 061520Z 01007KT 350V050 9999 SCT035 BKN080 08/02 Q1005")
+    assert_equal('8°C', report.temperature)
+  end
+
+  def test_dew_point
+    report = setup_report('LIRQ', "2010/02/06 15:20\nLIRQ 061520Z 01007KT 350V050 9999 SCT035 BKN080 08/02 Q1005")
+    assert_equal('2°C', report.dew_point)
+  end
+
+  def test_sea_level_pressure
+    report = setup_report('LIRQ', "2010/02/06 15:20\nLIRQ 061520Z 01007KT 350V050 9999 SCT035 BKN080 08/02 Q1005")
+    assert_equal('1.00500 bar', report.sea_level_pressure)
+  end
+
+  private
+
+  def setup_report(cccc, metar)
+    raw = Metar::Raw.new(cccc, metar)
+    parser = Metar::Parser.new(raw)
+    Metar::Report.new(parser)
+  end
+
+end