us_geo 1.0.3 → 2.0.1

data/spec/us_geo/state_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-
-describe USGeo::State do
-
-  describe "associations" do
-    it "should belong to a region" do
-      state = USGeo::State.new
-      state.code = "XX"
-      expect{ state.region }.to_not raise_error
-      expect(state.build_region).to be_a(USGeo::Region)
-    end
-
-    it "should belong to a division" do
-      state = USGeo::State.new
-      state.code = "XX"
-      expect{ state.division }.to_not raise_error
-      expect(state.build_division).to be_a(USGeo::Division)
-    end
-
-    it "should have counties" do
-      state = USGeo::State.new
-      state.code = "XX"
-      expect{ state.counties }.to_not raise_error
-      expect(state.counties.build).to be_a(USGeo::County)
-    end
-
-    it "should have places" do
-      state = USGeo::State.new
-      state.code = "XX"
-      expect{ state.places }.to_not raise_error
-      expect(state.places.build).to be_a(USGeo::Place)
-    end
-  end
-
-  describe "load" do
-    after { USGeo::State.delete_all }
-
-    it "should load the fixture data" do
-      data = File.read(File.expand_path("../../data/dist/states.csv", __dir__))
-      stub_request(:get, "#{USGeo.base_data_uri}/states.csv").to_return(body: data, headers: {"Content-Type": "text/csv; charset=UTF-8"})
-      USGeo::State.load!
-      expect(USGeo::State.imported.count).to eq 59
-      expect(USGeo::State.removed.count).to eq 0
-
-      illinois = USGeo::State.find("IL")
-      expect(illinois.name).to eq "Illinois"
-      expect(illinois.type).to eq "state"
-      expect(illinois.fips).to eq "17"
-      expect(illinois.region_id).to eq 2
-      expect(illinois.division_id).to eq 3
-    end
-  end
-
-  describe "type" do
-    it "should detect the state type" do
-      expect(USGeo::State.new(type: "state").state?).to eq true
-      expect(USGeo::State.new(type: "territory").state?).to eq false
-      expect(USGeo::State.new(type: "district").state?).to eq false
-
-      expect(USGeo::State.new(type: "state").district?).to eq false
-      expect(USGeo::State.new(type: "territory").district?).to eq false
-      expect(USGeo::State.new(type: "district").district?).to eq true
-
-      expect(USGeo::State.new(type: "state").territory?).to eq false
-      expect(USGeo::State.new(type: "territory").territory?).to eq true
-      expect(USGeo::State.new(type: "district").territory?).to eq false
-    end
-  end
-
-end

data/spec/us_geo/urban_area_county_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-
-describe USGeo::UrbanAreaCounty do
-
-  describe "percentages" do
-    it "should return the percentage of the population of the urban area" do
-      urban_area = USGeo::UrbanArea.new(population: 20_000)
-      urban_area_county = urban_area.urban_area_counties.build(population: 5000)
-      expect(urban_area_county.percent_urban_area_population).to eq 0.25
-    end
-
-    it "should return the percentage of the land area of the urban area" do
-      urban_area = USGeo::UrbanArea.new(land_area: 200)
-      urban_area_county = urban_area.urban_area_counties.build(land_area: 50)
-      expect(urban_area_county.percent_urban_area_land_area).to eq 0.25
-    end
-
-    it "should return the percentage of the total area of the urban area" do
-      urban_area = USGeo::UrbanArea.new(land_area: 150, water_area: 50)
-      urban_area_county = urban_area.urban_area_counties.build(land_area: 30, water_area: 20)
-      expect(urban_area_county.percent_urban_area_total_area).to eq 0.25
-    end
-
-    it "should return the percentage of the population of the county" do
-      county = USGeo::County.new(population: 20_000)
-      urban_area_county = county.urban_area_counties.build(population: 5000)
-      expect(urban_area_county.percent_county_population).to eq 0.25
-    end
-
-    it "should return the percentage of the land area of the county" do
-      county = USGeo::County.new(land_area: 200)
-      urban_area_county = county.urban_area_counties.build(land_area: 50)
-      expect(urban_area_county.percent_county_land_area).to eq 0.25
-    end
-
-    it "should return the percentage of the total area of the county" do
-      county = USGeo::County.new(land_area: 150, water_area: 50)
-      urban_area_county = county.urban_area_counties.build(land_area: 30, water_area: 20)
-      expect(urban_area_county.percent_county_total_area).to eq 0.25
-    end
-  end
-
-  describe "associations" do
-    it "should have a county" do
-      urban_area_county = USGeo::UrbanAreaCounty.new
-      urban_area_county.county_geoid = "60304"
-      urban_area_county.urban_area_geoid = "00001"
-      expect{ urban_area_county.county }.to_not raise_error
-      expect(urban_area_county.build_county).to be_a(USGeo::County)
-    end
-
-    it "should have an urban area" do
-      urban_area_county = USGeo::UrbanAreaCounty.new
-      urban_area_county.county_geoid = "60304"
-      urban_area_county.urban_area_geoid = "00001"
-      expect{ urban_area_county.urban_area }.to_not raise_error
-      expect(urban_area_county.build_urban_area).to be_a(USGeo::UrbanArea)
-    end
-  end
-
-  describe "load" do
-    after { USGeo::UrbanAreaCounty.delete_all }
-
-    it "should load the fixture data" do
-      data = File.read(File.expand_path("../../data/dist/urban_area_counties.csv", __dir__))
-      stub_request(:get, "#{USGeo.base_data_uri}/urban_area_counties.csv").to_return(body: data, headers: {"Content-Type": "text/csv; charset=UTF-8"})
-      USGeo::UrbanAreaCounty.load!
-      expect(USGeo::UrbanAreaCounty.imported.count).to be > 4000
-      expect(USGeo::UrbanAreaCounty.removed.count).to eq 0
-
-      urban_area_counties = USGeo::UrbanAreaCounty.where(urban_area_geoid: "39430")
-      expect(urban_area_counties.size).to eq 2
-      expect(urban_area_counties.collect(&:county_geoid)).to match_array(["26005", "26139"])
-      urban_area_county = urban_area_counties.detect{ |z| z.county_geoid == "26005"}
-      expect(urban_area_county.population).to be > 9000
-      expect(urban_area_county.housing_units).to be > 4000
-      expect(urban_area_county.land_area.round).to eq 8
-      expect(urban_area_county.water_area.round(2)).to eq 0.03
-    end
-  end
-
-end

data/spec/us_geo/urban_area_spec.rb

@@ -1,98 +0,0 @@
-require 'spec_helper'
-
-describe USGeo::UrbanArea do
-
-  describe "associations" do
-    it "should have zctas" do
-      urban_area = USGeo::UrbanArea.new
-      urban_area.geoid = "00001"
-      expect{ urban_area.zctas }.to_not raise_error
-      expect{ urban_area.zcta_urban_areas }.to_not raise_error
-      expect(urban_area.zcta_urban_areas.build).to be_a(USGeo::ZctaUrbanArea)
-    end
-
-    it "should have counties" do
-      urban_area = USGeo::UrbanArea.new
-      urban_area.geoid = "00001"
-      expect{ urban_area.counties }.to_not raise_error
-      expect{ urban_area.urban_area_counties }.to_not raise_error
-      expect(urban_area.urban_area_counties.build).to be_a(USGeo::UrbanAreaCounty)
-    end
-
-    it "should have a primary county" do
-      urban_area = USGeo::UrbanArea.new
-      urban_area.geoid = "00001"
-      expect{ urban_area.primary_county }.to_not raise_error
-      expect(urban_area.build_primary_county).to be_a(USGeo::County)
-    end
-
-    it "should have a time zone via the primary county" do
-      urban_area = USGeo::UrbanArea.new
-      county = USGeo::County.new(time_zone_name: "America/Chicago")
-      urban_area.primary_county = county
-      expect(urban_area.time_zone).to eq ActiveSupport::TimeZone["America/Chicago"]
-    end
-
-    it "should have a state via the primary county" do
-      urban_area = USGeo::UrbanArea.new
-      state = USGeo::State.new
-      state.code = "XX"
-      county = USGeo::County.new(state_code: "XX")
-      county.state = state
-      urban_area.primary_county = county
-      expect(urban_area.state_code).to eq "XX"
-      expect(urban_area.state).to eq state
-    end
-
-    it "should have a core based statistical area via the primary county" do
-      urban_area = USGeo::UrbanArea.new
-      cbsa = USGeo::CoreBasedStatisticalArea.new
-      county = USGeo::County.new
-      county.core_based_statistical_area = cbsa
-      urban_area.primary_county = county
-      expect(urban_area.core_based_statistical_area).to eq cbsa
-    end
-
-    it "should have a designated market area via the primary county" do
-      urban_area = USGeo::UrbanArea.new
-      dma = USGeo::DesignatedMarketArea.new
-      county = USGeo::County.new
-      county.designated_market_area = dma
-      urban_area.primary_county = county
-      expect(urban_area.designated_market_area).to eq dma
-    end
-
-  end
-
-  describe "load" do
-    after { USGeo::UrbanArea.delete_all }
-
-    it "should load the fixture data" do
-      data = File.read(File.expand_path("../../data/dist/urban_areas.csv", __dir__))
-      stub_request(:get, "#{USGeo.base_data_uri}/urban_areas.csv").to_return(body: data, headers: {"Content-Type": "text/csv; charset=UTF-8"})
-      USGeo::UrbanArea.load!
-      expect(USGeo::UrbanArea.imported.count).to be > 3500
-      expect(USGeo::UrbanArea.removed.count).to eq 0
-
-      chicago = USGeo::UrbanizedArea.find("16264")
-      expect(chicago.name).to eq "Chicago, IL--IN Urbanized Area"
-      expect(chicago.short_name).to eq "Chicago, IL--IN"
-      expect(chicago.primary_county_geoid).to eq "17031"
-      expect(chicago.population).to be > 8_000_000
-      expect(chicago.housing_units).to be > 3_000_000
-      expect(chicago.land_area.round).to eq 2441
-      expect(chicago.water_area.round).to eq 43
-      expect(chicago.lat.round).to eq 42
-      expect(chicago.lng.round).to eq -88
-      expect(chicago.urbanized?).to eq true
-      expect(chicago.cluster?).to eq false
-
-      clinton = USGeo::UrbanCluster.find("17884")
-      expect(clinton.name).to eq "Clinton, IL Urban Cluster"
-      expect(clinton.short_name).to eq "Clinton, IL"
-      expect(chicago.urbanized?).to eq true
-      expect(chicago.cluster?).to eq false
-    end
-  end
-
-end

data/spec/us_geo/zcta_county_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-
-describe USGeo::ZctaCounty do
-
-  describe "percentages" do
-    it "should return the percentage of the population of the zcta" do
-      zcta = USGeo::Zcta.new(population: 20_000)
-      zcta_county = zcta.zcta_counties.build(population: 5000)
-      expect(zcta_county.percent_zcta_population).to eq 0.25
-    end
-
-    it "should return the percentage of the land area of the zcta" do
-      zcta = USGeo::Zcta.new(land_area: 200)
-      zcta_county = zcta.zcta_counties.build(land_area: 50)
-      expect(zcta_county.percent_zcta_land_area).to eq 0.25
-    end
-
-    it "should return the percentage of the total area of the zcta" do
-      zcta = USGeo::Zcta.new(land_area: 150, water_area: 50)
-      zcta_county = zcta.zcta_counties.build(land_area: 30, water_area: 20)
-      expect(zcta_county.percent_zcta_total_area).to eq 0.25
-    end
-
-    it "should return the percentage of the population of the county" do
-      county = USGeo::County.new(population: 20_000)
-      zcta_county = county.zcta_counties.build(population: 5000)
-      expect(zcta_county.percent_county_population).to eq 0.25
-    end
-
-    it "should return the percentage of the land area of the county" do
-      county = USGeo::County.new(land_area: 200)
-      zcta_county = county.zcta_counties.build(land_area: 50)
-      expect(zcta_county.percent_county_land_area).to eq 0.25
-    end
-
-    it "should return the percentage of the total area of the county" do
-      county = USGeo::County.new(land_area: 150, water_area: 50)
-      zcta_county = county.zcta_counties.build(land_area: 30, water_area: 20)
-      expect(zcta_county.percent_county_total_area).to eq 0.25
-    end
-  end
-
-  describe "associations" do
-    it "should have a zcta" do
-      zcta_county = USGeo::ZctaCounty.new
-      zcta_county.zipcode = "60304"
-      zcta_county.county_geoid = "00001"
-      expect{ zcta_county.zcta }.to_not raise_error
-      expect(zcta_county.build_zcta).to be_a(USGeo::Zcta)
-    end
-
-    it "should have a county" do
-      zcta_county = USGeo::ZctaCounty.new
-      zcta_county.zipcode = "60304"
-      zcta_county.county_geoid = "00001"
-      expect{ zcta_county.county }.to_not raise_error
-      expect(zcta_county.build_county).to be_a(USGeo::County)
-    end
-  end
-
-  describe "load" do
-    after { USGeo::ZctaCounty.delete_all }
-
-    it "should load the fixture data" do
-      data = File.read(File.expand_path("../../data/dist/zcta_counties.csv", __dir__))
-      stub_request(:get, "#{USGeo.base_data_uri}/zcta_counties.csv").to_return(body: data, headers: {"Content-Type": "text/csv; charset=UTF-8"})
-      USGeo::ZctaCounty.load!
-      expect(USGeo::ZctaCounty.imported.count).to be > 40_000
-      expect(USGeo::ZctaCounty.removed.count).to eq 0
-      
-      zcta_counties = USGeo::ZctaCounty.where(zipcode: "00601")
-      expect(zcta_counties.size).to eq 2
-      expect(zcta_counties.collect(&:county_geoid)).to match_array(["72001", "72141"])
-      zcta_county = zcta_counties.detect{ |z| z.county_geoid == "72001"}
-      expect(zcta_county.population).to be > 10_000
-      expect(zcta_county.housing_units).to be > 4000
-      expect(zcta_county.land_area.round).to eq 63
-      expect(zcta_county.water_area.round(1)).to eq 0.3
-    end
-  end
-
-end

data/spec/us_geo/zcta_place_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-
-describe USGeo::ZctaPlace do
-
-  describe "percentages" do
-    it "should return the percentage of the population of the zcta" do
-      zcta = USGeo::Zcta.new(population: 20_000)
-      zcta_place = zcta.zcta_places.build(population: 5000)
-      expect(zcta_place.percent_zcta_population).to eq 0.25
-    end
-
-    it "should return the percentage of the land area of the zcta" do
-      zcta = USGeo::Zcta.new(land_area: 200)
-      zcta_place = zcta.zcta_places.build(land_area: 50)
-      expect(zcta_place.percent_zcta_land_area).to eq 0.25
-    end
-
-    it "should return the percentage of the total area of the zcta" do
-      zcta = USGeo::Zcta.new(land_area: 150, water_area: 50)
-      zcta_place = zcta.zcta_places.build(land_area: 30, water_area: 20)
-      expect(zcta_place.percent_zcta_total_area).to eq 0.25
-    end
-
-    it "should return the percentage of the population of the zcta" do
-      place = USGeo::Place.new(population: 20_000)
-      zcta_place = place.zcta_places.build(population: 5000)
-      expect(zcta_place.percent_place_population).to eq 0.25
-    end
-
-    it "should return the percentage of the land area of the zcta" do
-      place = USGeo::Place.new(land_area: 200)
-      zcta_place = place.zcta_places.build(land_area: 50)
-      expect(zcta_place.percent_place_land_area).to eq 0.25
-    end
-
-    it "should return the percentage of the total area of the zcta" do
-      place = USGeo::Place.new(land_area: 150, water_area: 50)
-      zcta_place = place.zcta_places.build(land_area: 30, water_area: 20)
-      expect(zcta_place.percent_place_total_area).to eq 0.25
-    end
-  end
-
-  describe "associations" do
-    it "should have a zcta" do
-      zcta_place = USGeo::ZctaPlace.new
-      zcta_place.zipcode = "60304"
-      zcta_place.place_geoid = "0000001"
-      expect{ zcta_place.zcta }.to_not raise_error
-      expect(zcta_place.build_zcta).to be_a(USGeo::Zcta)
-    end
-
-    it "should have a place" do
-      zcta_place = USGeo::ZctaPlace.new
-      zcta_place.zipcode = "60304"
-      zcta_place.place_geoid = "0000001"
-      expect{ zcta_place.place }.to_not raise_error
-      expect(zcta_place.build_place).to be_a(USGeo::Place)
-    end
-  end
-
-  describe "load" do
-    after { USGeo::ZctaPlace.delete_all }
-
-    it "should load the fixture data" do
-      data = File.read(File.expand_path("../../data/dist/zcta_places.csv", __dir__))
-      stub_request(:get, "#{USGeo.base_data_uri}/zcta_places.csv").to_return(body: data, headers: {"Content-Type": "text/csv; charset=UTF-8"})
-      USGeo::ZctaPlace.load!
-      expect(USGeo::ZctaPlace.imported.count).to be > 45_000
-      expect(USGeo::ZctaPlace.removed.count).to eq 0
-
-      zcta_places = USGeo::ZctaPlace.where(zipcode: "53211")
-      expect(zcta_places.size).to eq 3
-      expect(zcta_places.collect(&:place_geoid)).to match_array(["5553000", "5573725", "5586700"])
-      zcta_place = zcta_places.detect{ |z| z.place_geoid == "5553000"}
-      expect(zcta_place.population).to be > 15_000
-      expect(zcta_place.housing_units).to be > 7000
-      expect(zcta_place.land_area.round(1)).to eq 1.9
-      expect(zcta_place.water_area.round(3)).to eq 0.055
-    end
-  end
-
-end

data/spec/us_geo/zcta_spec.rb

@@ -1,99 +0,0 @@
-require 'spec_helper'
-
-describe USGeo::Zcta do
-
-  describe "associations" do
-    it "should have a primary county" do
-      zcta = USGeo::Zcta.new
-      zcta.zipcode = "60304"
-      expect{ zcta.primary_county }.to_not raise_error
-      expect(zcta.build_primary_county).to be_a(USGeo::County)
-    end
-
-    it "should have counties" do
-      zcta = USGeo::Zcta.new
-      zcta.zipcode = "60304"
-      expect{ zcta.counties }.to_not raise_error
-      expect{ zcta.zcta_counties }.to_not raise_error
-      expect(zcta.zcta_counties.build).to be_a(USGeo::ZctaCounty)
-    end
-
-    it "should have a time zone via the primary county" do
-      zcta = USGeo::Zcta.new
-      zcta.zipcode = "60304"
-      county = USGeo::County.new(time_zone_name: "America/Chicago")
-      zcta.primary_county = county
-      expect(zcta.time_zone).to eq ActiveSupport::TimeZone["America/Chicago"]
-    end
-
-    it "should have a state via the primary county" do
-      zcta = USGeo::Zcta.new
-      zcta.zipcode = "60304"
-      state = USGeo::State.new
-      state.code = "XX"
-      county = USGeo::County.new(state_code: "XX")
-      county.state = state
-      zcta.primary_county = county
-      expect(zcta.state_code).to eq "XX"
-      expect(zcta.state).to eq state
-    end
-
-    it "should have a core based statistical area via the primary county" do
-      zcta = USGeo::Zcta.new
-      zcta.zipcode = "60304"
-      cbsa = USGeo::CoreBasedStatisticalArea.new
-      county = USGeo::County.new
-      county.core_based_statistical_area = cbsa
-      zcta.primary_county = county
-      expect(zcta.core_based_statistical_area).to eq cbsa
-    end
-
-    it "should have a designated market area via the primary county" do
-      zcta = USGeo::Zcta.new
-      zcta.zipcode = "60304"
-      dma = USGeo::DesignatedMarketArea.new
-      county = USGeo::County.new
-      county.designated_market_area = dma
-      zcta.primary_county = county
-      expect(zcta.designated_market_area).to eq dma
-    end
-
-    it "should have a primary urban area" do
-      zcta = USGeo::Zcta.new
-      zcta.zipcode = "60304"
-      expect{ zcta.primary_urban_area }.to_not raise_error
-      expect(zcta.build_primary_urban_area).to be_a(USGeo::UrbanArea)
-    end
-
-    it "should have urban areas" do
-      zcta = USGeo::Zcta.new
-      zcta.zipcode = "60304"
-      expect{ zcta.urban_areas }.to_not raise_error
-      expect{ zcta.zcta_urban_areas }.to_not raise_error
-      expect(zcta.zcta_urban_areas.build).to be_a(USGeo::ZctaUrbanArea)
-    end
-  end
-
-  describe "load" do
-    after { USGeo::Zcta.delete_all }
-
-    it "should load the fixture data" do
-      data = File.read(File.expand_path("../../data/dist/zctas.csv", __dir__))
-      stub_request(:get, "#{USGeo.base_data_uri}/zctas.csv").to_return(body: data, headers: {"Content-Type": "text/csv; charset=UTF-8"})
-      USGeo::Zcta.load!
-      expect(USGeo::Zcta.imported.count).to be > 30_000
-      expect(USGeo::Zcta.removed.count).to eq 0
-
-      zcta = USGeo::Zcta.find("60305")
-      expect(zcta.primary_county_geoid).to eq "17031"
-      expect(zcta.primary_urban_area_geoid).to eq "16264"
-      expect(zcta.population).to be > 10_000
-      expect(zcta.housing_units).to be > 4000
-      expect(zcta.land_area.round(1)).to eq 2.5
-      expect(zcta.water_area.round(3)).to eq 0.002
-      expect(zcta.lat.round).to eq 42
-      expect(zcta.lng.round).to eq -88
-    end
-  end
-
-end

data/spec/us_geo/zcta_urban_area_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-
-describe USGeo::ZctaUrbanArea do
-
-  describe "percentages" do
-    it "should return the percentage of the population of the zcta" do
-      zcta = USGeo::Zcta.new(population: 20_000)
-      zcta_urban_area = zcta.zcta_urban_areas.build(population: 5000)
-      expect(zcta_urban_area.percent_zcta_population).to eq 0.25
-    end
-
-    it "should return the percentage of the land area of the zcta" do
-      zcta = USGeo::Zcta.new(land_area: 200)
-      zcta_urban_area = zcta.zcta_urban_areas.build(land_area: 50)
-      expect(zcta_urban_area.percent_zcta_land_area).to eq 0.25
-    end
-
-    it "should return the percentage of the total area of the zcta" do
-      zcta = USGeo::Zcta.new(land_area: 150, water_area: 50)
-      zcta_urban_area = zcta.zcta_urban_areas.build(land_area: 30, water_area: 20)
-      expect(zcta_urban_area.percent_zcta_total_area).to eq 0.25
-    end
-
-    it "should return the percentage of the population of the urban area" do
-      urban_area = USGeo::UrbanArea.new(population: 20_000)
-      zcta_urban_area = urban_area.zcta_urban_areas.build(population: 5000)
-      expect(zcta_urban_area.percent_urban_area_population).to eq 0.25
-    end
-
-    it "should return the percentage of the land area of the urban area" do
-      urban_area = USGeo::UrbanArea.new(land_area: 200)
-      zcta_urban_area = urban_area.zcta_urban_areas.build(land_area: 50)
-      expect(zcta_urban_area.percent_urban_area_land_area).to eq 0.25
-    end
-
-    it "should return the percentage of the total area of the urban area" do
-      urban_area = USGeo::UrbanArea.new(land_area: 150, water_area: 50)
-      zcta_urban_area = urban_area.zcta_urban_areas.build(land_area: 30, water_area: 20)
-      expect(zcta_urban_area.percent_urban_area_total_area).to eq 0.25
-    end
-  end
-
-  describe "associations" do
-    it "should have a zcta" do
-      zcta_urban_area = USGeo::ZctaUrbanArea.new
-      zcta_urban_area.zipcode = "60304"
-      zcta_urban_area.urban_area_geoid = "00001"
-      expect{ zcta_urban_area.zcta }.to_not raise_error
-      expect(zcta_urban_area.build_zcta).to be_a(USGeo::Zcta)
-    end
-
-    it "should have an urban area" do
-      zcta_urban_area = USGeo::ZctaUrbanArea.new
-      zcta_urban_area.zipcode = "60304"
-      zcta_urban_area.urban_area_geoid = "00001"
-      expect{ zcta_urban_area.urban_area }.to_not raise_error
-      expect(zcta_urban_area.build_urban_area).to be_a(USGeo::UrbanArea)
-    end
-  end
-
-  describe "load" do
-    after { USGeo::ZctaUrbanArea.delete_all }
-
-    it "should load the fixture data" do
-      data = File.read(File.expand_path("../../data/dist/zcta_urban_areas.csv", __dir__))
-      stub_request(:get, "#{USGeo.base_data_uri}/zcta_urban_areas.csv").to_return(body: data, headers: {"Content-Type": "text/csv; charset=UTF-8"})
-      USGeo::ZctaUrbanArea.load!
-      expect(USGeo::ZctaUrbanArea.imported.count).to be > 15_000
-      expect(USGeo::ZctaUrbanArea.removed.count).to eq 0
-
-      zcta_urban_areas = USGeo::ZctaUrbanArea.where(urban_area_geoid: "39430")
-      expect(zcta_urban_areas.size).to eq 5
-      expect(zcta_urban_areas.collect(&:zipcode)).to match_array(["49423", "49424", "49434", "49460", "49464"])
-      zcta_urban_area = zcta_urban_areas.detect{ |z| z.zipcode == "49423"}
-      expect(zcta_urban_area.population).to be > 30_000
-      expect(zcta_urban_area.housing_units).to be > 12_000
-      expect(zcta_urban_area.land_area.round).to eq 20
-      expect(zcta_urban_area.water_area.round(1)).to eq 1.5
-    end
-  end
-
-end