planefinder 0.0.1

data/spec/planefinder/airplane_listing_spec.rb

@@ -0,0 +1,217 @@
+require 'spec_helper'
+
+module Planefinder
+  describe AirplaneListing do
+    context "constructor" do
+      it "should accept 1 argument: json" do
+        listing_hash = JSON.parse(file_fixture('da40xl_airplanes.json')).first
+        a = AirplaneListing.new(listing_hash)
+      end
+    end
+
+    context "properties" do 
+      let(:json) { JSON.parse(file_fixture('da40xl_airplanes.json')).first }
+      let(:listing) { AirplaneListing.new(json) }
+
+      it "should be accessible as instance variables after initialization" do
+        listing.model.should == "DA40XL"
+        listing.listing_id.should == "1581835"
+        listing.registration_number.should == "N866DS"
+        listing.total_time.should == "870"
+        listing.total_seats.should be_nil
+        listing.prop_4_time.should be_nil
+      end
+
+      it "should be accessible from the [] method by string or symbol" do
+        listing['model'].should == "DA40XL"
+        listing['total_time'].should == "870"
+        listing[:model].should == listing['model']
+        listing[:total_time].should == listing['total_time']
+      end
+    end
+
+    context "location" do
+      it "should default to nil location" do
+        a = AirplaneListing.new({})
+        a.location.should be_nil
+      end
+
+      it "should not be overridden if the listing has a 'location' attribute" do
+        a = AirplaneListing.new({'location' => 'Somewhere, USA'})
+        a.location.should be_nil
+      end
+
+      it "should have a value if the listing has a state" do
+        a = AirplaneListing.new({'state' => 'MA'})
+        a.location.should_not be_nil
+      end
+
+      it "should have a value if the listing has a city and state, different from the state value" do
+        state_only = AirplaneListing.new({'state' => 'MA'})
+        city_and_state = AirplaneListing.new({'state' => 'MA', 'city' => 'Boston'})
+        city_and_state.location.should_not be_nil
+        city_and_state.location.should_not == state_only.location
+      end
+
+      it "should use the zipcode location, regardless of state and city" do
+        zip_only = AirplaneListing.new({'zipcode' => '90210'})
+        zip_state = AirplaneListing.new({'zipcode' => '90210', 'state' => 'MA'})
+        zip_city_state = AirplaneListing.new({'zipcode' => '90210', 'state' => 'MA', 'city' => 'Boston'})
+        zip_only.location.should_not be_nil
+        [zip_state, zip_city_state].each { |l| l.location.should == zip_only.location }
+      end
+
+      it "should use phone area code if no zipcode and no city+state is available" do
+        phone_only = AirplaneListing.new({'home_phone' => '9785551212'})
+        zip_only = AirplaneListing.new({'zipcode' => '90210'})
+        state_only = AirplaneListing.new({'state' => 'MA'})
+        phone_zip = AirplaneListing.new({'zipcode' => '90210', 'home_phone' => '9785551212'})
+        phone_state = AirplaneListing.new({'state' => 'MA', 'home_phone' => '9785551212'})
+        phone_only.location.should_not be_nil
+        phone_zip.location.should == zip_only.location  # zipcode is more reliable than phone area code
+        phone_state.location.should == state_only.location # area code roughly gets you into a state
+      end
+
+      def check_location_with_phones(phones, expected)
+        listing = AirplaneListing.new(phones)
+        listing.location.should_not be_nil
+        listing.location.should == expected.location  
+      end
+
+      it "should use the best available phone number" do
+        best_phone_order = ['home_phone', 'work_phone', 'aff_home_phone', 'aff_work_phone']
+        phones = {'home_phone' => '111',
+                  'work_phone' => '222',
+                  'aff_home_phone' => '333',
+                  'aff_work_phone' => '444'}
+        listings_by_phone = {}
+        phones.each {|k, v| listings_by_phone[k] = AirplaneListing.new({k => v})}
+
+        check_location_with_phones(phones, listings_by_phone['home_phone'])
+        phones.delete('home_phone')
+        check_location_with_phones(phones, listings_by_phone['work_phone'])
+        phones.delete('work_phone')
+        check_location_with_phones(phones, listings_by_phone['aff_home_phone'])
+        phones.delete('aff_home_phone')
+        check_location_with_phones(phones, listings_by_phone['aff_work_phone'])
+      end
+
+      def check_location_with_zips(zips, expected)
+        listing = AirplaneListing.new(zips)
+        listing.location.should_not be_nil
+        listing.location.should == expected.location  
+      end
+
+      it "should use the best available phone number" do
+        best_zip_order = ['zipcode', 'aff_zip']
+        zips = {'zipcode' => '90210', 'aff_zip' => '02118'}
+        listings_by_zip = {}
+        zips.each {|k, v| listings_by_zip[k] = AirplaneListing.new({k => v})}
+
+        check_location_with_zips(zips, listings_by_zip['zipcode'])
+        zips.delete('zipcode')
+        check_location_with_zips(zips, listings_by_zip['aff_zip'])
+      end
+
+      it "should return a LatLng for state location" do
+        listing = AirplaneListing.new({"state" => 'MA'})
+        listing.location.class.should == Geokit::LatLng
+      end
+
+      it "should return a LatLng for city, state location" do
+        listing = AirplaneListing.new({"city" => "Boston", "state" => 'MA'})
+        listing.location.class.should == Geokit::LatLng
+      end
+
+      it "should return a LatLng for zipcode location" do
+        listing = AirplaneListing.new({"zipcode" => '90210'})
+        listing.location.class.should == Geokit::LatLng
+      end
+
+      it "should return a LatLng for phone number" do
+        listing = AirplaneListing.new({"home_phone" => '9785551212'})
+        listing.location.class.should == Geokit::LatLng
+      end
+
+      it "should return invalid location for long state name or invalid state" do
+        AirplaneListing.new({"state" => 'Massachusetts'}).location.should_not be_valid
+        AirplaneListing.new({"state" => 'XX'}).location.should_not be_valid
+      end
+
+      it "should return properties" do
+        initial_properties = {"state" => 'MA', "city" => "Boston"}
+        l = AirplaneListing.new(initial_properties)
+        l.properties.should == initial_properties
+      end
+
+      it "should support to_s" do
+        l = AirplaneListing.new({"state" => 'MA', "city" => "Boston"})
+        str = l.to_s
+        str.should == l.properties.inspect
+      end
+
+      it "should provide location for a real listing" do
+        l = AirplaneListing.new(JSON.parse(file_fixture('da40xl_airplanes.json')).first)
+        l.location.should be_valid
+      end
+
+      context "calculating location in a specific order" do
+        let(:properties) {
+        # zipcode, city+state, state, phone
+        # zipcode and city+state are about equivalent, and achieve the same accuracy
+        # state and phone area code achieve the same accuracy
+        # home info is better than seller/company info
+        { "zipcode" => "02118", # Boston, MA
+                      "city" => "Lowell",   # Lowell, MA (with state)
+                      "state" => "MA",      # just MA
+                      "home_phone" => "6035551212",   # NH
+                      "work_phone" => "2075551212",   # ME
+                      "fax" => "8025551212",          # VT
+                      "aff_zip" => "90210",           # CA
+                      "aff_city" => "Las Vegas",      # Las Vegas, NV
+                      "aff_state" => "NV",            # just NV
+                      "aff_home_phone" => "8015551212",  # UT
+                      "aff_work_phone" => "2065551212",  # WA
+                      "aff_fax" => "5035551212"          # OR
+        } }
+        let(:property_order) { ['zipcode', 'city', 'state', 'home_phone', 'work_phone', 'fax',
+                          'aff_zip', 'aff_city', 'aff_state', 'aff_home_phone', 'aff_work_phone', 'aff_fax'] }
+
+        it "should calculate location" do
+          Geokit::Geocoders::AirplaneGeocoder.stub(:geocode)
+          property_order.each do |p|
+            if p =~ /city/
+              Geokit::Geocoders::AirplaneGeocoder.should_receive(:geocode).with("#{properties[p]}, #{properties[p.gsub('city', 'state')]}")
+            else
+              Geokit::Geocoders::AirplaneGeocoder.should_receive(:geocode).with(properties[p])
+            end
+
+            listing = AirplaneListing.new(properties)
+            loc = listing.location
+            properties.delete(p)
+          end
+        end
+
+        it "should know location type and text description" do
+          Geokit::Geocoders::AirplaneGeocoder.stub(:geocode)
+          property_order.each do |p|
+            listing = AirplaneListing.new(properties)
+            if p =~ /city/
+              # there are 2 types of city/state: the normal one (city, state) and the affiliate one (aff_city, aff_state)
+              city = p
+              state = p.gsub('city', 'state')
+              listing.location_text.should == "#{properties[city]}, #{properties[state]}"
+              listing.location_type.should == "#{city}, #{state}"
+              listing.location_description.should == "#{city}, #{state}: #{properties[city]}, #{properties[state]}"
+            else
+              listing.location_text.should == "#{properties[p]}"
+              listing.location_type.should == "#{p}"
+              listing.location_description.should == "#{p}: #{properties[p]}"
+            end
+            properties.delete(p)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/planefinder/airplane_make_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+module Planefinder
+  describe AirplaneMake do
+    let(:json_make) { JSON.parse(file_fixture('single_engine_makes.json')).select{ |m| m['name'] == 'Diamond' }.first }
+    
+    it "should be initializable with a JSON object and a category" do
+      category = double(AirplaneCategory)
+      am = AirplaneMake.new(json_make, category)
+      am.count.should == 13
+      am.id.should == 155
+      am.name.should == "Diamond"
+      am.category.should == category
+    end
+
+    it "should support ==" do
+      a = AirplaneMake.new(json_make, 5)
+      b = AirplaneMake.new(json_make, 5)
+      c = AirplaneMake.new(json_make, 6)
+      a.should == b
+      b.should_not == c
+    end
+    
+    it "should be able to fetch models for its make" do
+      models = [1, 2, 3]
+      category = double(AirplaneCategory)
+      am = AirplaneMake.new(json_make, category)
+      Planefinder.should_receive(:get_models_for_category_and_make).with(category, am) { models }
+      am.get_models.should == models
+    end
+  end
+end

data/spec/planefinder/airplane_model_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+module Planefinder
+  describe AirplaneModel do
+    let(:diamond_models) { JSON.parse(file_fixture('diamond_models.json')) }
+    let(:da40) { diamond_models.select { |m| m['name'] == "DA40" }.first }
+    let(:da40xls) { diamond_models.select { |m| m['name'] == "DA40 XLS" }.first }
+    
+    describe "constructor" do
+      it "should take 3 arguments: json, category, make" do
+        am = AirplaneModel.new(da40, double(AirplaneCategory), double(AirplaneMake))
+      end
+      
+      it "should have appropriate values after creation" do
+        cat = double(AirplaneCategory)
+        make = double(AirplaneMake)
+        am = AirplaneModel.new(da40, cat, make)
+        am.name.should == "DA40"
+        am.model_group.should == "DA40 Series"
+        am.id.should == 4140
+        am.count.should == 5
+        am.category.should == cat
+        am.make.should == make
+      end
+    end
+    
+    it "should support ==" do
+      a = AirplaneModel.new(da40, 1, 155)
+      b = AirplaneModel.new(da40, 1, 155)
+      c = AirplaneModel.new(da40xls, 1, 155)
+      d = AirplaneModel.new(da40xls, 2, 155)
+      e = AirplaneModel.new(da40xls, 2, 400)
+      
+      a.should == b
+      b.should == a
+      a.should_not == c
+      b.should_not == c
+      c.should_not == d
+      d.should_not == e
+    end
+    
+    it "should be able to retrieve listings" do
+      make = double(Planefinder::AirplaneMake, :name => "Diamond")
+      cat = double(Planefinder::AirplaneCategory, :name => "Single Engine Piston")
+      am = AirplaneModel.new(da40, cat, make)
+      listing = AirplaneListing.new({})
+      Planefinder.stub(:search_by_model_make_category).and_return([listing])
+      Planefinder.should_receive(:search_by_model_make_category).with(am, make, cat)
+
+      listings = am.get_listings
+      listings.first.should == listing
+    end
+  end
+end

data/spec/planefinder_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe Planefinder do
+  it "should have a version" do
+    Planefinder::VERSION.should_not be_empty
+  end
+
+  context "retrieving categories" do
+    it "should retrieve aircraft categories" do
+      categories = Planefinder.get_categories
+      categories.length.should == 9
+      categories.each { |c| c.class.should == Planefinder::AirplaneCategory }
+    end
+
+    it "should ignore the 'special_use_counts' category" do
+      categories = Planefinder.get_categories
+      categories.each { |c| c.id.should be > 0 }
+    end
+  end
+
+  context "retrieving makes" do
+    %w[get_makes_for_category get_makes].each do |method_name|
+      describe "##{method_name}" do   
+        it "should retrieve a list of Single Engine makes for category 1" do
+          cat = mock(Planefinder::AirplaneCategory, :id => 1)
+          makes = Planefinder.send(method_name, cat)
+          makes.length.should == 136
+          makes.select { |m| m.name == 'Cessna' }.length.should == 1
+        end
+
+        it "should retrieve a list of Jet makes for category 4" do
+          cat = double(Planefinder::AirplaneCategory, :id => 4)
+          makes = Planefinder.send(method_name, cat)
+          makes.length.should == 28
+          makes.select { |m| m.name == 'Boeing' }.length.should == 1
+        end
+
+        it "should retrieve a list of Helicopter makes for category 100" do
+          cat = double(Planefinder::AirplaneCategory, :id => 100)
+          makes = Planefinder.send(method_name, cat)
+          makes.length.should == 9
+          makes.select { |m| m.name == 'Robinson' }.length.should == 1
+        end
+
+        it "should create AirplaneMakes with real category objects" do
+          cat = double(Planefinder::AirplaneCategory, :id => 100)
+          makes = Planefinder.send(method_name, cat)
+          makes.first.category.should == cat          
+        end
+      end
+    end
+  end
+  
+  context "retrieving models" do
+    %w[get_models_for_category_and_make get_models].each do |method_name|
+      describe "##{method_name}" do    
+        it "should retrieve an array of AirplaneModel" do
+          cat = double(Planefinder::AirplaneCategory, :id => 1)
+          make = double(Planefinder::AirplaneMake, :id => 155)
+          Planefinder.send(method_name, cat, make).each do |model|
+            model.class.should == Planefinder::AirplaneModel
+          end
+        end
+      
+        it "should retrieve a list of Diamond aircraft models for category 1, make 155" do
+          cat = double(Planefinder::AirplaneCategory, :id => 1)
+          make = double(Planefinder::AirplaneMake, :id => 155)
+          models = Planefinder.send(method_name, cat, make)
+          models.select { |m| m.name == 'DA40' }.length.should == 1
+        end
+      
+        it "should retrieve a list of Robinson helicopter models for category 100, make 406" do
+          cat = double(Planefinder::AirplaneCategory, :id => 100)
+          make = double(Planefinder::AirplaneMake, :id => 406)
+          models = Planefinder.send(method_name, cat, make)
+          models.select { |m| m.name == 'R44' }.length.should == 1
+        end
+
+        it "should create AirplaneModels with real category and make objects" do
+          cat = double(Planefinder::AirplaneCategory, :id => 100)
+          make = double(Planefinder::AirplaneMake, :id => 406)
+          models = Planefinder.send(method_name, cat, make)
+          models.first.category.should == cat
+          models.first.make.should == make
+        end
+      end
+    end
+  end
+  
+  context "retrieving airplane listings" do
+    describe "#search_by_model_make_category" do
+      it "should retrieve an array of AirplaneListing" do
+        model = double(Planefinder::AirplaneModel, :name => "DA40XL")
+        make = double(Planefinder::AirplaneMake, :name => "Diamond")
+        cat = double(Planefinder::AirplaneCategory, :name => "Single Engine Piston")
+        listings = Planefinder.search_by_model_make_category(model, make, cat)
+        listings.each { |l| l.class.should == Planefinder::AirplaneListing }
+        listings.length.should == 6
+      end
+    end
+  end
+
+  context "searching by freeform string" do
+    pending "should be supported"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,57 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require 'planefinder'
+require 'fakeweb'
+
+def file_fixture(filename)
+  open(File.join(File.dirname(__FILE__), 'fixtures', "#{filename.to_s}")).read
+end
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+  config.add_setting :fixture_path
+  config.fixture_path = 'foo'
+  
+  config.before(:suite) do
+    FakeWeb.allow_net_connect = false
+    FakeWeb.register_uri(:get, 
+                         'http://www.trade-a-plane.com/app_ajax/get_categories?listing_type_id=1',
+                         :body => file_fixture('airplane_categories.json'))
+    FakeWeb.register_uri(:get, 
+                         'http://www.trade-a-plane.com/app_ajax/get_aircraft_models?category_id=1&make_id=155',
+                         :body => file_fixture('diamond_models.json'))
+    FakeWeb.register_uri(:get, 
+                         'http://www.trade-a-plane.com/app_ajax/get_aircraft_models?category_id=100&make_id=406',
+                         :body => file_fixture('robinson_models.json'))
+    FakeWeb.register_uri(:get, 
+                         'http://www.trade-a-plane.com/app_ajax/get_aircraft_makes?category_id=1&make_type_id=1',
+                         :body => file_fixture('single_engine_makes.json'))
+    FakeWeb.register_uri(:get, 
+                         'http://www.trade-a-plane.com/app_ajax/get_aircraft_makes?category_id=4&make_type_id=1',
+                         :body => file_fixture('jet_makes.json'))
+    FakeWeb.register_uri(:get, 
+                         'http://www.trade-a-plane.com/app_ajax/get_aircraft_makes?category_id=100&make_type_id=1',
+                         :body => file_fixture('piston_helicopter_makes.json'))
+    FakeWeb.register_uri(:get, 
+                         'http://www.trade-a-plane.com/app_ajax/search?s-type=aircraft&model=DA40XL&make=Diamond&category=Single%20Engine%20Piston',
+                         :body => file_fixture('diamond_models.json'))
+  end
+
+  config.after(:suite) do
+    FakeWeb.allow_net_connect = true
+  end
+end