garb 0.2.1

data/test/unit/authentication_request_test.rb

@@ -0,0 +1,91 @@
+require File.join(File.dirname(__FILE__), '..', '/test_helper')
+
+module Garb
+  class AuthenticationRequestTest < Test::Unit::TestCase
+    
+    context "An instance of the AuthenticationRequest class" do
+      
+      setup { @request = AuthenticationRequest.new('email', 'password') }
+      
+      should "have a collection of parameters that include the email and password" do
+        expected = 
+          {
+            'Email'       => 'user@example.com',
+            'Passwd'      => 'fuzzybunnies',
+            'accountType' => 'HOSTED_OR_GOOGLE',
+            'service'     => 'analytics',
+            'source'      => 'vigetLabs-garb-001'
+          }
+        
+        request = AuthenticationRequest.new('user@example.com', 'fuzzybunnies')
+        assert_equal expected, request.parameters
+      end
+      
+      should "have a URI" do
+        assert_equal URI.parse('https://www.google.com/accounts/ClientLogin'), @request.uri
+      end
+      
+      
+      should "be able to send a request to the GAAPI service" do        
+        @request.expects(:build_request).returns('post')
+        response = mock {|m| m.expects(:is_a?).with(Net::HTTPOK).returns(true) }
+        
+        http = mock do |m|
+          m.expects(:use_ssl=).with(true)
+          m.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
+          m.expects(:request).with('post').yields(response)
+        end
+        
+        Net::HTTP.expects(:new).with('www.google.com', 443).returns(http)
+        
+        @request.send_request
+      end
+      
+      should "be able to build a request for the GAAPI service" do
+        params = "param"
+        @request.expects(:parameters).with().returns(params)
+        
+        post = mock
+        post.expects(:set_form_data).with(params)
+        
+        Net::HTTP::Post.expects(:new).with('/accounts/ClientLogin').returns(post)
+        
+        @request.build_request
+      end
+      
+      should "be able to retrieve an auth_token from the body" do
+        response_data =
+          "SID=mysid\n" +
+          "LSID=mylsid\n" +
+          "Auth=auth_token\n"
+          
+        @request.expects(:send_request).with().returns(stub(:body => response_data))
+        
+        assert_equal 'auth_token', @request.auth_token
+      end
+      
+      should "raise an exception when requesting an auth_token when the authorization fails" do
+        @request.stubs(:build_request)
+        response = mock do |m|
+          m.expects(:is_a?).with(Net::HTTPOK).returns(false)
+        end
+        
+        http = stub do |s|
+          s.stubs(:use_ssl=)
+          s.stubs(:verify_mode=)
+          s.stubs(:request).yields(response)
+        end
+        
+        Net::HTTP.stubs(:new).with('www.google.com', 443).returns(http)
+        
+        assert_raise(Garb::AuthenticationRequest::AuthError) do
+          @request.send_request
+        end
+      end
+      
+    end
+    
+    
+    
+  end
+end

data/test/unit/data_request_test.rb

@@ -0,0 +1,52 @@
+require File.join(File.dirname(__FILE__), '..', '/test_helper')
+
+module Garb
+  class DataRequestTest < Test::Unit::TestCase
+    
+    context "An instance of the DataRequest class" do
+
+      should "be able to build the query string from parameters" do
+        parameters = {'ids' => '12345', 'metrics' => 'country'}
+        data_request = DataRequest.new("", parameters)
+        
+        query_string = data_request.query_string
+        
+        assert_match(/^\?/, query_string)
+        
+        query_string.sub!(/^\?/, '')
+        
+        assert_equal ["ids=12345", "metrics=country"], query_string.split('&').sort
+      end
+      
+      should "return an empty query string if parameters are empty" do
+        data_request = DataRequest.new("")
+        assert_equal "", data_request.query_string
+      end
+      
+      should "be able to build a uri" do
+        url        = 'http://example.com'
+        expected = URI.parse('http://example.com')
+        
+        assert_equal expected, DataRequest.new(url).uri
+      end
+      
+      should "be able to make a request to the GAAPI" do
+        Session.expects(:auth_token).with().returns('toke')
+        response = mock
+        response.expects(:is_a?).with(Net::HTTPOK).returns(true)
+        
+        http = mock do |m|
+          m.expects(:use_ssl=).with(true)
+          m.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
+          m.expects(:get).with('/data?key=value', 'Authorization' => 'GoogleLogin auth=toke').returns(response)
+        end
+        
+        Net::HTTP.expects(:new).with('example.com', 443).returns(http)
+        
+        data_request = DataRequest.new('https://example.com/data', 'key' => 'value')
+        assert_equal response, data_request.send_request
+      end
+    end
+
+  end
+end

data/test/unit/garb_test.rb

@@ -0,0 +1,9 @@
+require File.join(File.dirname(__FILE__), '..', '/test_helper')
+
+class GarbTest < Test::Unit::TestCase
+  context "A green egg" do
+    should "be served with ham" do
+      assert true
+    end
+  end  
+end

data/test/unit/oauth_session_test.rb

@@ -0,0 +1,11 @@
+require File.join(File.dirname(__FILE__), '..', '/test_helper')
+
+module Garb
+  class OAuthSessionTest < Test::Unit::TestCase
+    context "An instance of OAuthSession" do
+      should "have tests" do
+        assert true
+      end
+    end
+  end
+end

data/test/unit/operator_test.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__), '..', '/test_helper')
+
+class OperatorTest < Test::Unit::TestCase
+  context "An instance of an Operator" do
+    should "lower camelize the target" do
+      assert_equal "ga:uniqueVisits=", Operator.new(:unique_visits, "=").to_ga
+    end
+    
+    should "return target and operator together" do
+      assert_equal "ga:metric=", Operator.new(:metric, "=").to_ga
+    end
+    
+    should "prefix the operator to the target" do
+      assert_equal "-ga:metric", Operator.new(:metric, "-", true).to_ga
+    end
+    
+    should "know if it is equal to another operator" do
+      op1 = Operator.new(:hello, "==")
+      op2 = Operator.new(:hello, "==")
+      assert_equal op1, op2
+    end
+    
+    should "not be equal to another operator if target, operator, or prefix is different" do
+      op1 = Operator.new(:hello, "==")
+      op2 = Operator.new(:hello, "==", true)
+      assert_not_equal op1, op2
+      
+      op1 = Operator.new(:hello1, "==")
+      op2 = Operator.new(:hello2, "==")
+      assert_not_equal op1, op2
+      
+      op1 = Operator.new(:hello, "!=")
+      op2 = Operator.new(:hello, "==")
+      assert_not_equal op1, op2
+    end
+  end
+end

data/test/unit/profile_test.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(__FILE__), '..', '/test_helper')
+
+module Garb
+  class ProfileTest < Test::Unit::TestCase
+    
+    context "The Profile class" do
+      
+      should "be able to return a list of all profiles" do
+        Session.stubs(:email).with().returns('user@host.com')
+        
+        url = 'https://www.google.com/analytics/feeds/accounts/user@host.com'
+        
+        xml = read_fixture('profile_feed.xml')
+        
+        data_request = mock
+        data_request.expects(:send_request).with().returns(stub(:body => xml))
+        
+        DataRequest.expects(:new).with(url).returns(data_request)
+        
+        entries = [stub]
+        
+        Profile::Entry.expects(:parse).with(xml).returns(entries)
+                
+        profiles = []
+        entries.each do |entry|
+          profile = stub
+          profiles << profile
+          Garb::Profile.expects(:new).with(entry).returns(profile)
+        end
+        
+        assert_equal profiles, Profile.all
+      end
+      
+    end
+    
+    context "An instance of the Profile class" do
+      
+      setup do
+        @entry = (Profile::Entry.parse(read_fixture('profile_feed.xml'))).first
+        @profile = Profile.new(@entry)
+      end
+      
+      should "have a value for :title" do
+        assert_equal "Historical", @profile.title
+      end
+      
+      should "have a value for :table_id" do
+        assert_equal 'ga:12345', @profile.table_id
+      end
+      
+      should "have a value for :id" do
+        assert_equal '12345', @profile.id
+      end
+      
+    end
+
+  end
+end

data/test/unit/report_parameter_test.rb

@@ -0,0 +1,62 @@
+require File.join(File.dirname(__FILE__), '..', '/test_helper')
+
+module Garb
+  class ReportParameterTest < Test::Unit::TestCase
+    
+    context "An instance of the ReportParameter class" do
+      setup do
+        @metrics = ReportParameter.new(:metrics)
+      end
+      
+      should "have a name" do
+        assert_equal "metrics", @metrics.name
+      end
+      
+      should "have a list of elements" do
+        assert_equal [], @metrics.elements
+      end
+      
+      should "be able to add new elements" do
+        assert_equal(@metrics, @metrics << :request_uri)
+        assert_equal [:request_uri], @metrics.elements
+      end
+      
+      should "merge an array of elements" do
+        assert_equal(@metrics, @metrics << [:request_uri])
+        assert_equal [:request_uri], @metrics.elements
+      end
+
+      context "converting to params" do
+        should "be able to format the parameters into strings" do
+          @metrics << :request_uri
+          assert_equal({'metrics' => 'ga:requestUri'}, @metrics.to_params)
+        end
+
+        should "join multiple symbol elements" do
+          @metrics << :request_uri << :city
+          assert_equal({'metrics' => 'ga:requestUri,ga:city'}, @metrics.to_params)
+        end
+        
+        should "join operator elements" do
+          @metrics << :city.desc
+          assert_equal({'metrics' => '-ga:city'}, @metrics.to_params)
+        end
+        
+        should "parameterize hash operators and join elements" do
+          @metrics << {:city.eql => 'New York'}
+          params = {'metrics' => 'ga:city%3D%3DNew+York'}
+
+          assert_equal params, @metrics.to_params
+        end
+
+        should "properly encode operators" do
+          @metrics << {:request_uri.contains => 'New York'}
+          params = {'metrics' => 'ga:requestUri%3D~New+York'}
+
+          assert_equal params, @metrics.to_params
+        end
+      end
+    end
+    
+  end
+end

data/test/unit/report_response_test.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), '..', '/test_helper')
+
+module Garb
+  class ReportResponseTest < Test::Unit::TestCase
+    context "An instance of the ReportResponse class" do
+      setup do
+        @xml = File.read(File.join(File.dirname(__FILE__), '..', "/fixtures/report_feed.xml"))
+        @response = ReportResponse.new(@xml)
+      end
+      
+      should "parse xml response with happymapper" do
+        h1 = {"city"=>"(not set)", "pageviews"=>"33", "country"=>"(not set)"}
+        h2 = {"city"=>"Kabul", "pageviews"=>"2", "country"=>"Afghanistan"}
+        h3 = {"city"=>"Tirana", "pageviews"=>"1", "country"=>"Albania"}
+        
+        OpenStruct.expects(:new).with(h1).returns('entry1')
+        OpenStruct.expects(:new).with(h2).returns('entry2')
+        OpenStruct.expects(:new).with(h3).returns('entry3')
+        
+        assert_equal(['entry1', 'entry2', 'entry3'], @response.parse)
+      end
+
+      should "have results or parse them" do
+        @response.expects(:parse)
+        @response.results
+      end
+    end
+  end
+end

data/test/unit/report_test.rb

@@ -0,0 +1,71 @@
+require File.join(File.dirname(__FILE__), '..', '/test_helper')
+
+module Garb
+  # Also tests Garb::Resource, which is the basis for Garb::Report
+  class ReportTest < Test::Unit::TestCase    
+    context "An instance of the Report class" do
+      setup do
+        @now = Time.now
+        Time.stubs(:now).returns(@now)
+        @profile = stub(:table_id => 'ga:1234')
+        @report = Report.new(@profile)
+      end
+
+      %w(metrics dimensions filters sorts).each do |param|
+        should "have parameters for #{param}" do
+          assert @report.send(:"#{param}").is_a?(ReportParameter)
+        end
+      end
+
+      should "have default parameters" do
+        @report.stubs(:format_time).returns('2009-08-01')
+        params = {'ids' => 'ga:1234', 'start-date' => '2009-08-01', 'end-date' => '2009-08-01'}
+        assert_equal params, @report.default_params
+      end
+
+      should "collect params from metrics, dimensions, filters, sort, and defaults" do
+        @report.stubs(:metrics).returns(stub(:to_params => {'metrics' => 6}))
+        @report.stubs(:dimensions).returns(stub(:to_params => {'dimensions' => 5}))
+        @report.stubs(:filters).returns(stub(:to_params => {'filters' => 4}))
+        @report.stubs(:sorts).returns(stub(:to_params => {'sort' => 3}))
+        @report.stubs(:page_params).returns({'page_params' => 2})
+        @report.stubs(:default_params).returns({'default_params' => 1})
+        
+        params = {'metrics' => 6, 'dimensions' => 5, 'filters' => 4, 'sort' => 3, 'page_params' => 2, 'default_params' => 1}
+        assert_equal params, @report.params
+      end
+
+      should "format time" do
+        assert_equal @now.strftime('%Y-%m-%d'), @report.format_time(@now)
+      end
+
+      should "send a data request to GA" do
+        response = mock {|m| m.expects(:body).returns('response body') }
+        request = mock {|m| m.expects(:send_request).returns(response) }
+        @report.expects(:params).returns('params')
+
+        DataRequest.expects(:new).with(Garb::Report::URL, 'params').returns(request)
+        assert_equal 'response body', @report.send_request_for_body
+      end
+
+      should "fetch and parse results from GA" do
+        @report.expects(:send_request_for_body).with().returns('xml')
+        ReportResponse.expects(:new).with('xml').returns(mock(:results => ['entry']))
+        assert_equal ['entry'], @report.results
+      end
+    end
+    
+    context "An instance of the Report class with initial options" do
+      setup do
+        @profile = stub(:table_id => 'ga:1234')
+        @report = Report.new(@profile, :limit => 10, :offset => 20)
+      end
+
+      should "have page paramaters" do
+        params = {'max-results' => 10, 'start-index' => 20}
+        assert_equal params, @report.page_params
+      end
+    end
+
+  end
+end

data/test/unit/resource_test.rb

@@ -0,0 +1,19 @@
+require File.join(File.dirname(__FILE__), '..', '/test_helper')
+
+class TestReport
+  include Garb::Resource
+end
+
+# Most of the resource testing is done as a part of ReportTest
+class ResourceTest < Test::Unit::TestCase
+
+  context "A class with Garb::Resource mixed in" do
+    should "get results from GA" do
+      profile = stub
+      TestReport.expects(:send_request_for_body).returns('xml')
+      Garb::ReportResponse.expects(:new).with('xml').returns(mock(:results => 'analytics'))
+
+      assert_equal 'analytics', TestReport.results(profile)
+    end
+  end
+end