worlddb-models 2.2.2 → 2.3.0

data/test/test_model_states_at.rb

@@ -0,0 +1,111 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_model_states_at.rb
+
+
+require 'helper'
+
+class TestModelStatesAt < MiniTest::Test
+
+  def setup
+    #  delete all countries, states, cities in in-memory only db
+    WorldDb.delete!
+  end
+
+
+  def test_n   # country > state > county > muni
+
+    at = Country.create!( key: 'at',
+                          name: 'Austria',
+                          code: 'AUT',
+                          pop: 1,
+                          area: 1 )
+
+    n = State.create!( key:  'n',
+                         name: 'Niederösterreich',
+                         country_id: at.id,
+                         pop: 1,
+                         area: 1 )
+
+    n2 = State.find_by_key!( 'n' )
+    assert_equal n.id, n2.id
+
+    assert_equal 'Niederösterreich', n.name 
+    assert_equal 1,          n.area 
+    assert_equal at.id,      n.country_id
+    assert_equal 1,          n.level
+    assert_equal 'ADM1',     n.place_kind
+
+    ### test place
+    assert_equal  'Niederösterreich', n.place.name
+
+    ## test assocs
+    assert_equal  'Austria',     n.country.name
+    assert_equal  0,             n.parts.count
+    assert_equal  0,             n.counties.count
+    assert_equal  0,             n.munis.count
+    assert_equal  0,             n.cities.count
+
+    #############################
+    # County (Landkreis, Bezirk, etc.)
+
+    tu = County.create!( key: 'tu',
+                         name: 'Tulln',
+                         state_id: n.id,
+                         pop: 1,
+                         area: 1 )
+
+    tu2 = County.find_by_key!( 'tu' )
+    assert_equal tu.id, tu2.id
+
+    assert_equal 'Tulln',  tu.name 
+    assert_equal 1,        tu.area 
+    assert_equal n.id,     tu.state_id
+    assert_equal 2,        tu.level
+    assert_equal 'ADM2',   tu.place_kind
+
+    ### test place
+    assert_equal  'Tulln', tu.place.name
+
+    ## test assocs
+    assert_equal  'Niederösterreich', tu.state.name
+    assert_equal  0,             tu.munis.count
+    assert_equal  0,             tu.cities.count
+    assert_equal  1,             n.counties.count
+    assert_equal  'Tulln',    n.counties.first.name
+
+    #############################
+    # Muni (Gemeinde - Markt, Stadt, etc.)
+
+    gr = Muni.create!( key: 'grafenwoerth',
+                       name: 'Grafenwörth',
+                       state_id: n.id,
+                       county_id: tu.id,
+                       pop: 1,
+                       area: 1 )
+
+    gr2 = Muni.find_by_key!( 'grafenwoerth' )
+    assert_equal gr.id, gr2.id
+
+    assert_equal 'Grafenwörth', gr.name 
+    assert_equal 1,             gr.area 
+    assert_equal n.id,          gr.state_id
+    assert_equal tu.id,         gr.county_id
+    assert_equal 3,             gr.level
+    assert_equal 'ADM3',        gr.place_kind
+
+    ### test place
+    assert_equal  'Grafenwörth', gr.place.name
+
+    ## test assocs
+    assert_equal  'Niederösterreich',  gr.county.state.name
+    assert_equal  0,                   gr.cities.count
+    assert_equal  1,                   n.munis.count
+    assert_equal  1,                   tu.munis.count
+    assert_equal  'Grafenwörth', n.munis.first.name
+    assert_equal  'Grafenwörth', tu.munis.first.name
+  end
+
+end # class TestModelStatesAt

data/test/test_model_states_de.rb

@@ -0,0 +1,147 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_model_states_de.rb
+
+
+require 'helper'
+
+class TestModelStatesDe < MiniTest::Test
+
+  def setup
+    #  delete all countries, states, cities in in-memory only db
+    WorldDb.delete!
+  end
+
+
+  def test_bayern   # country > state > part > county > muni
+
+    de = Country.create!( key: 'de',
+                          name: 'Deutschland',
+                          code: 'DEU',
+                          pop: 1,
+                          area: 1 )
+
+    by = State.create!(  key:  'by',
+                         name: 'Bayern',
+                         country_id: de.id,
+                         pop: 1,
+                         area: 1 )
+
+    by2 = State.find_by_key!( 'by' )
+    assert_equal by.id, by2.id
+
+    assert_equal 'Bayern',   by.name 
+    assert_equal 1,          by.area 
+    assert_equal de.id,      by.country_id
+    assert_equal 1,          by.level
+    assert_equal 'ADM1',     by.place_kind
+
+    ### test place
+    assert_equal  'Bayern', by.place.name
+
+    ## test assocs
+    assert_equal  'Deutschland', by.country.name
+    assert_equal  0,             by.parts.count
+    assert_equal  0,             by.counties.count
+    assert_equal  0,             by.munis.count
+    assert_equal  0,             by.cities.count
+
+    ############
+    # Part
+
+    ob = Part.create!( key: 'ob',
+                       name: 'Oberbayern',
+                       state_id: by.id,
+                       pop: 1,
+                       area: 1 )
+
+    ob2 = Part.find_by_key!( 'ob' )
+    assert_equal ob.id, ob2.id
+
+    assert_equal 'Oberbayern',   ob.name 
+    assert_equal 1,              ob.area 
+    assert_equal by.id,          ob.state_id
+    assert_equal 2,              ob.level
+    assert_equal 'ADM2',         ob.place_kind
+
+    ### test place
+    assert_equal  'Oberbayern', ob.place.name
+
+    ## test assocs
+    assert_equal  'Bayern',      ob.state.name
+    assert_equal  0,             ob.counties.count
+    assert_equal  0,             ob.cities.count
+    assert_equal  1,             by.parts.count
+    assert_equal  'Oberbayern',  by.parts.first.name
+
+    #############################
+    # County (Landkreis, Bezirk, etc.)
+
+    fs = County.create!( key: 'fs',
+                         name: 'Freising',
+                         state_id: by.id,
+                         part_id: ob.id,
+                         pop: 1,
+                         area: 1,
+                         level: 3 )
+
+    fs2 = County.find_by_key!( 'fs' )
+    assert_equal fs.id, fs2.id
+
+    assert_equal 'Freising',  fs.name 
+    assert_equal 1,           fs.area 
+    assert_equal by.id,       fs.state_id
+    assert_equal ob.id,       fs.part_id
+    assert_equal 3,           fs.level
+    assert_equal 'ADM3',      fs.place_kind
+
+    ### test place
+    assert_equal  'Freising', fs.place.name
+
+    ## test assocs
+    assert_equal  'Bayern',      fs.state.name
+    assert_equal  'Oberbayern',  fs.part.name
+    assert_equal  0,             fs.munis.count
+    assert_equal  0,             fs.cities.count
+    assert_equal  1,             by.counties.count
+    assert_equal  1,             ob.counties.count
+    assert_equal  'Freising',    by.counties.first.name
+    assert_equal  'Freising',    ob.counties.first.name
+
+    #############################
+    # Muni (Gemeinde - Markt, Stadt, etc.)
+
+    au = Muni.create!( key: 'auidhallertau',
+                       name: 'Au i.d. Hallertau',
+                       state_id: by.id,
+                       county_id: fs.id,
+                       pop: 1,
+                       area: 1,
+                       level: 4 )
+
+    au2 = Muni.find_by_key!( 'auidhallertau' )
+    assert_equal au.id, au2.id
+
+    assert_equal 'Au i.d. Hallertau', au.name 
+    assert_equal 1,                   au.area 
+    assert_equal by.id,               au.state_id
+    assert_equal fs.id,               au.county_id
+    assert_equal 4,                   au.level
+    assert_equal 'ADM4',              au.place_kind
+
+    ### test place
+    assert_equal  'Au i.d. Hallertau', au.place.name
+
+    ## test assocs
+    assert_equal  'Bayern',            au.county.state.name
+    assert_equal  'Oberbayern',        au.county.part.name
+    assert_equal  0,                   au.cities.count
+    assert_equal  1,                   by.munis.count
+    assert_equal  1,                   fs.munis.count
+    assert_equal  'Au i.d. Hallertau', by.munis.first.name
+    assert_equal  'Au i.d. Hallertau', fs.munis.first.name
+  end
+
+end # class TestModelStatesDe

data/test/test_models.rb

@@ -6,7 +6,7 @@ require 'helper'
 class TestModels < MiniTest::Test
 
   def setup
-    #  delete all countries, regions, cities in in-memory only db
+    #  delete all countries, states, cities in in-memory only db
     WorldDb.delete!
   end
 
@@ -15,8 +15,15 @@ class TestModels < MiniTest::Test
     assert_equal 0, Place.count
     assert_equal 0, Continent.count
     assert_equal 0, Country.count
-    assert_equal 0, Region.count
+
+    assert_equal 0, State.count
+    assert_equal 0, Part.count
+    assert_equal 0, County.count
+    assert_equal 0, Muni.count
+
+    assert_equal 0, Metro.count
     assert_equal 0, City.count
+    assert_equal 0, District.count
 
     assert_equal 0, Lang.count
     assert_equal 0, Usage.count
@@ -27,7 +34,7 @@ class TestModels < MiniTest::Test
   def test_place_assoc_counts
     # assert_equal 0, Continent.new.place.count
     # assert_equal 0, Country.new.place.count
-    # assert_equal 0, Region.new.place.count
+    # assert_equal 0, State.new.place.count
     # assert_equal 0, City.new.place.count
   end
 

data/test/test_parse_city.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_parse_city.rb
+
+require 'helper'
+
+class TestParseCity < MiniTest::Test
+
+  def setup
+    #  delete all countries, states, cities in in-memory only db
+    WorldDb.delete!
+  end
+
+
+  def test_at
+
+    at = Country.parse( 'at',
+                        'Austria',
+                        'AUT',
+                        '83_871 km²',
+                        '8_414_638' )
+
+    w = State.parse( 'w',
+                     'Wien',
+                     country_id: at.id )
+
+    c = City.parse( 'wien',
+                    'Wien',
+                    'W', 
+                    '1_731_236',
+                    'm:1_724_000',
+                    country_id: at.id )
+
+    c2 = City.find_by!( key: 'wien' )
+    assert_equal c2.id, c.id
+
+    assert_equal 'Wien',    c.name
+    assert_equal 1_731_236, c.pop
+    assert_equal w.id,      c.state_id
+    assert_equal at.id,     c.country_id
+
+    ### test place
+    assert_equal  'Wien', c.place.name
+
+    ## test assocs
+    assert_equal  'Wien',    c.state.name
+    assert_equal  'Austria', c.state.country.name
+    assert_equal  'Austria', c.country.name
+
+
+    #####
+    # check (auto-)added metro record
+
+    m = Metro.find_by!( key: 'wien' )
+    assert_equal 'Wien',     m.name
+    assert_equal 1_724_000,  m.pop
+    assert_equal at.id,      m.country_id
+    
+    ## test assocs
+    assert_equal  1,         m.cities.count
+    assert_equal  'Wien',    m.cities.first.name
+    assert_equal  'Austria', m.country.name
+
+    assert_equal  'Wien',    c.metro.name
+    assert_equal  m.id,      c.metro.id
+  end
+
+end # class TestParseCity

data/test/test_parse_country.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_parse_country.rb
+
+
+require 'helper'
+
+class TestParseCountry < MiniTest::Test
+
+  def setup
+    #  delete all countries, states, cities in in-memory only db
+    WorldDb.delete!
+  end
+
+  def test_to_path
+    eu = Continent.create!( key: 'eu', name: 'Europe' )
+
+    assert_equal 'europe', eu.slug
+
+    at = Country.parse( 'at',
+                        'Austria',
+                        'AUT',
+                        '83_871 km²',
+                        '8_414_638',
+                        continent: eu )
+
+    assert_equal 'austria', at.slug    
+    assert_equal 'europe/at-austria', at.to_path
+  end
+
+  def test_at
+
+    c = Country.parse( 'at',
+                       'Austria',
+                       'AUT',
+                       '83_871 km²',
+                       '8_414_638',
+                       'un|fifa|uefa|eu|euro|schengen|central_europe|western_europe' )
+
+    c2 = Country.find_by!( key: 'at' )
+    assert_equal c.id, c2.id
+
+    assert_equal 'Austria',   c.name
+    assert_equal 8_414_638,   c.pop
+    assert_equal 83_871,      c.area
+    ## todo: assert tag count; add supra:eu etc.
+
+    ### test place
+    assert_equal  'Austria', c.place.name
+  end
+
+
+end # class TestParseCountry
+

data/test/test_parse_state.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_parse_state.rb
+
+
+require 'helper'
+
+class TestParseState < MiniTest::Test
+
+  def setup
+    #  delete all countries, states, cities in in-memory only db
+    WorldDb.delete!
+  end
+
+  def test_at
+
+    at = Country.parse( 'at',
+                        'Austria',
+                        'AUT',
+                        '8_414_638 km²',
+                        '83_871' )
+
+    w = State.parse( 'w',
+                     'Wien',
+                     '415 km²',
+                     'eastern austria',
+                     country_id: at.id )
+
+    w2 = State.find_by!( key: 'w' )
+    assert_equal w.id, w2.id
+
+    assert_equal 'Wien',  w.name 
+    assert_equal 415,     w.area 
+    assert_equal at.id,   w.country_id
+
+    ### test place
+    assert_equal  'Wien', w.place.name
+
+    ## test assocs
+    assert_equal  'Austria', w.country.name
+  end
+
+end # class TestParseState
+

data/test/test_state_tree_reader_at.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_state_tree_reader_at.rb
+
+
+require 'helper'
+
+class TestStateTreeReaderAt < MiniTest::Test
+
+  def setup
+    #  delete all countries, states, cities in in-memory only db
+    WorldDb.delete!
+
+    Country.create!( key: 'at',
+                     name: 'Austria',
+                     code: 'AUT',
+                     pop: 0,
+                     area: 0 )
+
+    reader = WorldDb::Reader.new( "#{WorldDb.root}/test/data/at-austria" )
+    reader.load_setup( 'setups/adm' )
+  end
+
+  def test_orte
+    at = Country.find_by!( key: 'at' )
+    more_attribs = { country_id: at.id }
+    reader = WorldDb::StateTreeReader.from_file( "#{WorldDb.root}/test/data/at-austria/orte.txt",
+                                                 more_attribs )
+    reader.read
+
+    n = State.find_by!( key: 'n' )
+    assert_equal 'Niederösterreich [Lower Austria]',  n.name
+    assert_equal 25,                                  n.counties.count
+
+    ks = County.find_by!( key: 'ks' )
+    assert_equal 'Krems an der Donau (Stadt)', ks.name
+    assert_equal 1,                            ks.munis.count
+    
+    k = Muni.find_by!( key: 'kremsanderdonau' )  ## Statutarstadt (Gemeinde)
+    assert_equal 'Krems an der Donau',         k.name
+    assert_equal 12,                           k.cities.count
+    assert_equal 'Krems an der Donau (Stadt)', k.county.name
+
+    gneixendorf = City.find_by!( key: 'gneixendorf' )
+    assert_equal 'Gneixendorf',                      gneixendorf.name
+    assert_equal 'Krems an der Donau',               gneixendorf.muni.name
+    assert_equal 'Krems an der Donau (Stadt)',       gneixendorf.muni.county.name
+    assert_equal 'Niederösterreich [Lower Austria]', gneixendorf.muni.county.state.name
+  end
+
+end # class TestStateTreeReaderAt
+

data/test/test_state_tree_reader_de.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_state_tree_reader_de.rb
+
+
+require 'helper'
+
+class TestStateTreeReaderDe < MiniTest::Test
+
+  def setup
+    #  delete all countries, states, cities in in-memory only db
+    WorldDb.delete!
+
+    Country.create!( key: 'de',
+                     name: 'Germany',
+                     code: 'GER',
+                     pop: 0,
+                     area: 0 )
+
+    reader = WorldDb::Reader.new( "#{WorldDb.root}/test/data/de-deutschland" )
+    reader.load_setup( 'setups/adm' )
+  end
+
+  def test_oberfranken_ii   ## small (short) version
+    de = Country.find_by!( key: 'de' )
+    more_attribs = { country_id: de.id }
+    reader = WorldDb::StateTreeReader.from_file( "#{WorldDb.root}/test/data/de-deutschland/3--by-bayern/4--oberfranken/orte_ii.txt",
+                                                 more_attribs )
+    reader.read
+
+    ofr = Part.find_by!( key: 'ofr' )
+    assert_equal 'Oberfranken', ofr.name
+    assert_equal 13,            ofr.counties.count
+
+    ba = County.find_by!( key: 'ba' )
+    assert_equal 'Bamberg (Stadt)', ba.name
+    assert_equal 1,                 ba.munis.count
+    
+    baland = County.find_by!( key: 'baland' )
+    assert_equal 'Bamberg (Land)', baland.name
+    assert_equal 2,                baland.munis.count
+
+    hallstadt = Muni.find_by!( key: 'hallstadt' )
+    assert_equal 'Hallstadt',      hallstadt.name
+    assert_equal 2,                hallstadt.cities.count
+    assert_equal 'Bamberg (Land)', hallstadt.county.name
+
+    doerfleins = City.find_by!( key: 'doerfleins' )
+    assert_equal 'Dörfleins',      doerfleins.name
+    assert_equal 'Hallstadt',      doerfleins.muni.name
+    assert_equal 'Bamberg (Land)', doerfleins.muni.county.name
+    assert_equal 'Oberfranken',    doerfleins.muni.county.part.name
+  end
+
+
+  def test_oberfranken
+    de = Country.find_by!( key: 'de' )
+    more_attribs = { country_id: de.id }
+    reader = WorldDb::StateTreeReader.from_file( "#{WorldDb.root}/test/data/de-deutschland/3--by-bayern/4--oberfranken/orte.txt",
+                                                 more_attribs )
+    reader.read
+
+    ba = County.find_by!( key: 'ba' )
+    assert_equal 'Bamberg (Stadt)', ba.name
+    assert_equal 1,                 ba.munis.count
+  end
+
+end # class TestStateTreeReaderDe
+

data/test/test_tree_reader.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_tree_reader.rb
+
+
+require 'helper'
+
+class TestTreeReader < MiniTest::Test
+
+  def setup
+    #  delete all countries, states, cities in in-memory only db
+    WorldDb.delete!
+  end
+
+
+  def test_oberfranken
+    reader = TreeReader.from_file( "#{WorldDb.root}/test/data/de-deutschland/3--by-bayern/4--oberfranken/orte.txt" )
+ 
+    reader.each_line do |_|
+      ## do nothing for now
+    end
+    
+    assert true ## assume everything ok if we get here
+  end
+
+  def test_de
+    reader = TreeReader.from_file( "#{WorldDb.root}/test/data/de-deutschland/orte.txt" )
+ 
+    reader.each_line do |_|
+      ## do nothing for now
+    end
+
+    assert true ## assume everything ok if we get here
+  end
+
+end # class TestTreeReader
+