trackerific 0.6.2 → 0.7.0

data/spec/lib/trackerific/details_spec.rb

@@ -1,82 +1,17 @@
 require 'spec_helper'
 
 describe Trackerific::Details do
-  
-  before do
-    @required_details = {
-      :package_id => String.new,
-      :summary    => String.new,
-      :events     => Array.new
-    }
-    @valid_options = {
-      :weight     => Hash.new,
-      :via        => String.new
-    }
-  end
-  
-  context "with required options only" do
-    before { @details = Trackerific::Details.new(@required_details) }
-    
-    describe :events do
-      subject { @details.events }
-      it { should be_a Array }
-    end
-    
-    describe :package_id do
-      subject { @details.package_id }
-      it { should be_a String }
-    end
-    
-    describe :summary do
-      subject { @details.summary }
-      it { should be_a String }
-    end
-    
-    describe :weight do
-      subject { @details.weight }
-      it { should be_nil }
-    end
-    
-    describe :via do
-      subject { @details.via }
-      it { should be_nil }
-    end
-  end
-  
-  context "with all options" do
-    before { @details = Trackerific::Details.new(@required_details.merge(@valid_options)) }
-    
-    describe :events do
-      subject { @details.events }
-      it { should be_a Array }
-    end
-    
-    describe :package_id do
-      subject { @details.package_id }
-      it { should be_a String }
-    end
-    
-    describe :summary do
-      subject { @details.summary }
-      it { should be_a String }
-    end
-    
-    describe :weight do
-      subject { @details.weight }
-      it { should be_a Hash }
-    end
-    
-    describe :via do
-      subject { @details.via }
-      it { should be_a String }
-    end
-  end
-  
-  context "with no options" do
-    specify { lambda { Trackerific::Details.new }.should raise_error(ArgumentError) }
-  end
-  
-  context "with invalid options" do
-    specify { lambda { Trackerific::Details.new(:hello => "world")}.should raise_error(ArgumentError) }
-  end
+  let(:id) { "PACKAGE ID" }
+  let(:summary) { "SUMMARY" }
+  let(:events) { ["THESE", "EVENTS"] }
+  let(:weight) { "100lbs" }
+  let(:via) { "USPS" }
+
+  subject { described_class.new(id, summary, events, weight, via) }
+
+  its(:package_id) { should eq id }
+  its(:summary) { should eq summary }
+  its(:events) { should eq events }
+  its(:weight) { should eq weight }
+  its(:via) { should eq via }
 end

data/spec/lib/trackerific/error_spec.rb

@@ -1,9 +1,5 @@
 require 'spec_helper'
 
 describe Trackerific::Error do
-  
-  before { @error = Trackerific::Error.new }
-  subject { @error }
-  specify { should be_a StandardError }
-  
+  it { should be_a StandardError }
 end

data/spec/lib/trackerific/event_spec.rb

@@ -1,48 +1,19 @@
 require 'spec_helper'
 
 describe Trackerific::Event do
-  
-  before do
-    @date = Time.now
-    @description = 'description'
-    @location = 'location'
-    @required_parameters = {
-      :date         => @date,
-      :description  => @description,
-      :location     => @location
-    }
-  end
-  
-  context "with all required options" do
-    before { @event = Trackerific::Event.new(@required_parameters) }
-    
-    describe :date do
-      subject { @event.date }
-      it { should be @date }
-    end
-    
-    describe :description do
-      subject { @event.description }
-      it { should be @description }
-    end
-    
-    describe :location do
-      subject { @event.location }
-      it { should be @location }
-    end
-    
-    describe :to_s do
-      before { @regex = /(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (0[1-9]|[1-2][0-9]|3[01]) \d{2}:\d{2} (am|pm).*/ }
-      subject { @event.to_s }
-      it("should be in format mmm dd hh:mm am/pm.*") { should =~ @regex }
-    end
-  end
-  
-  context "missing some options" do
-    specify { lambda { Trackerific::Event.new(:date => Time.now, :description => '') }.should raise_error(ArgumentError) }
-  end
-  
-  context "with invalid options" do
-    specify { lambda { Trackerific::Event.new(:hello => "world") }.should raise_error(ArgumentError) }
+  let(:date) { Time.now }
+  let(:description) { "DESCRIPTION" }
+  let(:location) { "LOCATION" }
+
+  subject { described_class.new(date, description, location) }
+
+  its(:date) { should eq date }
+  its(:description) { should eq description }
+  its(:location) { should eq location }
+
+
+  let(:to_s_regex) do
+    /(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (0[1-9]|[1-2][0-9]|3[01]) \d{2}:\d{2} (am|pm).*/
   end
+  its(:to_s) { should =~ to_s_regex }
 end

data/spec/lib/trackerific/services/base_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Trackerific::Services::Base do
+  describe "#register" do
+    it "should register the service" do
+      # these classes were set up in support/test_services.rb
+      Trackerific::Services[:test].should eq TestService
+      Trackerific::Services[:another_test_service].should eq AnotherTestService
+      TestService.name.should eq :test
+      AnotherTestService.name.should eq :another_test_service
+    end
+  end
+end

data/spec/lib/trackerific/services/fedex_spec.rb

@@ -1,76 +1,73 @@
 require 'spec_helper'
-require 'fakeweb'
 
 FEDEX_TRACK_URL = "https://gateway.fedex.com/GatewayDC"
 
-describe Trackerific::FedEx do
-  include Fixtures
-  
-  specify("it should descend from Trackerific::Service") {
-    Trackerific::FedEx.superclass.should be Trackerific::Service
-  }
-  
-  describe :required_parameters do
-    subject { Trackerific::FedEx.required_parameters }
-    it { should include(:account) }
-    it { should include(:meter) }
+describe Trackerific::Services::FedEx do
+  it { should be_a Trackerific::Services::Base }
+
+  it "should be registered" do
+    Trackerific::Services[:fedex].should eq Trackerific::Services::FedEx
+    described_class.name.should eq :fedex
   end
-  
-  describe :valid_options do
-    it "should include required_parameters" do
-      valid = Trackerific::FedEx.valid_options
-      Trackerific::FedEx.required_parameters.each do |opt|
-        valid.should include opt
-      end
-    end
+
+  let(:valid_ids) { ["183689015000001", "999999999999999"] }
+  let(:invalid_ids) { %w[these are not fedex tracking ids] }
+
+  it "should match valid FedEx ids" do
+    valid_ids.all? {|id| described_class.can_track?(id) }.should be_true
   end
-  
-  describe :package_id_matchers do
-    subject { Trackerific::FedEx.package_id_matchers }
-    it("should be an Array of Regexp") { should each { |m| m.should be_a Regexp } }
+
+  it "should not match invalid FedEx ids" do
+    invalid_ids.all? {|id| described_class.can_track?(id) }.should be_false
   end
-  
-  describe :track_package do
-    before(:all) do
-      @package_id = "183689015000001"
-      @fedex = Trackerific::FedEx.new :account  => "123456789", :meter => "123456789"
+
+  describe "#track" do
+    let(:id) { "183689015000001" }
+    let(:credentials) { { account: "123456789", meter: "123456789" } }
+    let(:fedex) { described_class.new(credentials) }
+
+    before do
+      FakeWeb.register_uri(:post, FEDEX_TRACK_URL, body: fixture)
     end
-    
-    context "with a successful response from the server" do
-      
-      before(:all) do
-        FakeWeb.register_uri(:post, FEDEX_TRACK_URL, :body => load_fixture(:fedex_success_response))
-      end
-      
-      before(:each) do
-        @tracking = @fedex.track_package(@package_id)
-      end
-      
-      subject { @tracking }
-      it("should return a Trackerific::Details") { should be_a Trackerific::Details }
-      
-      describe "events.length" do
-        subject { @tracking.events.length }
-        it { should >= 1}
-      end
-      
-      describe :summary do
-        subject { @tracking.summary }
-        it { should_not be_empty }
+
+    after { FakeWeb.clean_registry }
+
+    context "with a successful response" do
+      let(:fixture) { Fixture.read('fedex/success.xml') }
+      subject { fedex.track(id) }
+      it { should be_a Trackerific::Details }
+      its(:package_id) { should eq id }
+      its(:summary) { should eq "Delivered" }
+
+      describe "#events" do
+        subject { fedex.track(id).events }
+        its(:length) { should eq 3 }
+
+        it "should be an Array of Trackerific::Event" do
+          subject.all? {|el| el.is_a?(Trackerific::Event) }.should be_true
+        end
+
+        it "should have the correct event values" do
+          subject[0].date.to_s.should eq "2010-07-01 10:43:51 -0600"
+          subject[0].description.should eq "Delivered"
+          subject[0].location.should eq "GA 30506"
+          subject[1].date.to_s.should eq "2010-07-01 08:48:00 -0600"
+          subject[1].description.should eq "On FedEx vehicle for delivery"
+          subject[1].location.should eq "GA 30601"
+          subject[2].date.to_s.should eq "2010-07-01 05:07:00 -0600"
+          subject[2].description.should eq "At local FedEx facility"
+          subject[2].location.should eq "GA 30601"
+        end
       end
-      
     end
-    
-    context "with an error response from the server" do
-      
-      before(:all) do
-        FakeWeb.register_uri(:post, FEDEX_TRACK_URL, :body => load_fixture(:fedex_error_response))
+
+    context "with an error response" do
+      let(:fixture) { Fixture.read('fedex/error.xml') }
+      it "should raise a Trackerific::Error" do
+        expect {
+          fedex.track(id)
+        }.to raise_error Trackerific::Error
       end
-      
-      specify { lambda { @fedex.track_package("invalid package id") }.should raise_error(Trackerific::Error) }
-      
     end
-    
   end
-  
 end

data/spec/lib/trackerific/services/mock_service_spec.rb

@@ -1,56 +1,43 @@
 require 'spec_helper'
+require 'trackerific/services/mock_service'
 
-describe Trackerific::MockService do
+describe Trackerific::Services::MockService do
+  it { should be_a Trackerific::Services::Base }
 
-  specify("it should descend from Trackerific::Service") {
-    Trackerific::MockService.superclass.should be Trackerific::Service
-  }
-  
-  describe :required_parameters do
-    subject { Trackerific::MockService.required_parameters }
-    it { should be_empty }
+  it "should be registered" do
+    Trackerific::Services[:mock_service].should eq described_class
   end
-  
-  describe :package_id_matchers do
-  
-    context "when in development or test mode" do
-      subject { Trackerific::MockService.package_id_matchers }
-      it("should be an Array of Regexp") { should each { |m| m.should be_a Regexp } }
-    end
-    
-    context "when in production mode" do
-      before { Rails.env = "production" }
-      subject { Trackerific::MockService.package_id_matchers }
-      it { should be_empty }
-      after { Rails.env = "test"}
-    end
+
+  describe "#package_id_matchers" do
+    subject { described_class.package_id_matchers }
+    it { should include /XXXXXXXXXX/ }
+    it { should include /XXXxxxxxxx/ }
   end
-  
-  describe :track_package do
-    before(:all) do
-      @service = Trackerific::MockService.new
-    end
-    
-    context "with valid package_id" do
-      before { @tracking = @service.track_package("XXXXXXXXXX") }
-      subject { @tracking }
-      it("should return a Trackerific::Details") { should be_a Trackerific::Details }
-      
-      describe "events.length" do
-        subject { @tracking.events.length }
-        it { should >= 1}
-      end
-      
-      describe :summary do
-        subject { @tracking.summary }
-        it { should_not be_empty }
+
+  describe "#track" do
+    let(:service) { described_class.new }
+
+    context "with a valid id" do
+      let(:id) { "XXXXXXXXXX" }
+      subject { service.track(id) }
+      it { should be_a Trackerific::Details }
+      its(:package_id) { should eq id }
+      its(:summary) { should eq "Your package was delivered." }
+      its(:events) { should be_a Array }
+
+      describe "#events" do
+        subject { service.track(id).events }
+        it { should be_a Array }
+        its(:count) { should eq 3 }
       end
     end
-    
-    context "with invalid package_id" do
-      specify { lambda { @service.track_package("XXXxxxxxxx") }.should raise_error(Trackerific::Error) }
+
+    context "with an invalid id" do
+      it "should raise a Trackerific::Error" do
+        expect {
+          service.track("XXXxxxxxxx")
+        }.to raise_error Trackerific::Error
+      end
     end
-    
   end
-  
 end

data/spec/lib/trackerific/services/ups_spec.rb

@@ -1,79 +1,59 @@
 require 'spec_helper'
-require 'fakeweb'
 
 UPS_TRACK_URL = 'https://wwwcie.ups.com/ups.app/xml/Track'
 
-describe "Trackerific::UPS" do
-  include Fixtures
-  
-  specify("it should descend from Trackerific::Service") {
-    Trackerific::UPS.superclass.should be Trackerific::Service
-  }
-  
-  describe :required_parameters do
-    subject { Trackerific::UPS.required_parameters }
-    it { should include(:key) }
-    it { should include(:user_id) }
-    it { should include(:password) }
-  end
-  
-  describe :valid_options do
-    it "should include required_parameters" do
-      valid = Trackerific::UPS.valid_options
-      Trackerific::UPS.required_parameters.each do |opt|
-        valid.should include opt
-      end
-    end
+describe Trackerific::Services::UPS do
+  it { should be_a Trackerific::Services::Base }
+
+  let(:valid_ids) { ["1Z12345E0291980793"] }
+  let(:invalid_ids) { %w[these are not valid tracking ids] }
+
+  it "should match valid tracking ids" do
+    valid_ids.all? {|id| described_class.can_track?(id) }.should be_true
   end
-  
-  describe :package_id_matchers do
-    subject { Trackerific::UPS.package_id_matchers }
-    it("should be an Array of Regexp") { should each { |m| m.should be_a Regexp } }
+
+  it "should not match invalid tracking ids" do
+    invalid_ids.all? {|id| described_class.can_track?(id) }.should be_false
   end
-  
-  describe :track_package do
-    before(:all) do
-      @package_id = '1Z12345E0291980793'
-      @ups = Trackerific::UPS.new :key => 'testkey', :user_id => 'testuser', :password => 'secret'
+
+  describe "#track" do
+    let(:id) { "1Z12345E0291980793" }
+    let(:credentials) { { key: 'testkey', user_id: 'testuser', password: 'secret' } }
+    let(:ups) { described_class.new(credentials) }
+
+    before do
+      FakeWeb.register_uri(:post, UPS_TRACK_URL, body: fixture)
     end
-    
-    context "with a successful response from the server" do
-      
-      before(:all) do
-        FakeWeb.register_uri(:post, UPS_TRACK_URL, :body => load_fixture(:ups_success_response))
-      end
-      
-      before(:each) do
-        @tracking = @ups.track_package(@package_id)
-      end
-      
-      subject { @tracking }
-      it("should return a Trackerific::Details") { should be_a Trackerific::Details }
-      
-      describe "events.length" do
-        subject { @tracking.events.length }
-        it { should >= 1 }
-      end
-      
-      describe :summary do
-        subject { @tracking.summary }
-        it { should_not be_empty }
+
+    after { FakeWeb.clean_registry }
+
+    context "with a successful response" do
+      let(:fixture) { Fixture.read('ups/success.xml') }
+      subject { ups.track(id) }
+      it { should be_a Trackerific::Details }
+      its(:package_id) { should eq id }
+      its(:summary) { should eq "DELIVERED" }
+      its(:weight) { should be_nil }
+      its(:via) { should be_nil }
+
+      describe "#events" do
+        subject { ups.track(id).events }
+        its(:length) { should eq 1 }
+        it "should have the correct values" do
+          subject[0].date.to_s.should eq "2003-03-13T16:00:00+00:00"
+          subject[0].description.should eq "DELIVERED"
+          subject[0].location.should eq "MAYSVILLE 26833   9700 US"
+        end
       end
-      
     end
-    
-    context "with an error response from the server" do
-      
-      before(:all) do
-        FakeWeb.register_uri(:post, UPS_TRACK_URL, :body => load_fixture(:ups_error_response))
+
+    context "with an error response" do
+      let(:fixture) { Fixture.read('ups/error.xml') }
+      it "should raise a Trackerific::Error" do
+        expect {
+          ups.track(id)
+        }.to raise_error Trackerific::Error
       end
-      
-      specify { lambda { @ups.track_package("invalid package id") }.should raise_error(Trackerific::Error) }
-      
     end
-    
-    pending "when server returns corrupted xml"
-    
   end
-  
 end