garb 0.9.1 → 0.9.7

data/test/unit/garb/management/profile_test.rb

@@ -8,18 +8,18 @@ module Garb
           feed = stub(:entries => ["entry1"])
           Feed.stubs(:new).returns(feed)
 
-          Profile.stubs(:new_from_entry)
+          Profile.stubs(:new)
           Profile.all
 
           assert_received(Feed, :new) {|e| e.with(Session, '/accounts/~all/webproperties/~all/profiles')}
           assert_received(feed, :entries)
-          assert_received(Profile, :new_from_entry) {|e| e.with("entry1", Session)}
+          assert_received(Profile, :new) {|e| e.with("entry1", Session)}
         end
 
         should "find all profiles for a given account" do
           Profile.stubs(:all)
           Profile.for_account(stub(:session => 'session', :path => '/accounts/123'))
-          assert_received(Profile, :all) {|e| e.with('session', '/accounts/123/webproperties/~all/profiles')}          
+          assert_received(Profile, :all) {|e| e.with('session', '/accounts/123/webproperties/~all/profiles')}
         end
 
         should "find all profiles for a given web_property" do
@@ -31,43 +31,28 @@ module Garb
 
       context "A Profile" do
         setup do
-          entry = {
-            "link" => [{"rel" => "self", "href" => Feed::BASE_URL+"/accounts/1189765/webproperties/UA-1189765-1/profiles/98765"}],
-            "dxp:property" => [
-              {"name" => "ga:profileId", "value" => "98765"},
-              {"name" => "ga:accountId", "value" => "1189765"},
-              {"name" => "ga:webPropertyId", "value" => 'UA-1189765-1'},
-              {"name" => "ga:profileName", "value" => "example.com"},
-              {"name"=>"dxp:tableId", "value"=>"ga:4506"},
-              {"name"=>"ga:currency", "value"=>"USD"},
-              {"name"=>"ga:timezone", "value"=>"America/New_York"}
-            ]
-          }
-          @profile = Profile.new_from_entry(entry, Session)
+          entry = MultiJson.load(read_fixture("ga_profile_management.json"))["items"].first
+          @profile = Profile.new(entry, Session)
         end
 
-        should "have a title" do
-          assert_equal "example.com", @profile.title
+        should "have a name" do
+          assert_equal "the profile name", @profile.name
         end
 
         should "have an id" do
-          assert_equal '98765', @profile.id
+          assert_equal '2', @profile.id
         end
 
         should "have an account_id" do
-          assert_equal '1189765', @profile.account_id
+          assert_equal '1234', @profile.account_id
         end
 
         should "have a web_property_id" do
-          assert_equal 'UA-1189765-1', @profile.web_property_id
-        end
-
-        should "have a table_id (for old Garb::Report)" do
-          assert_equal 'ga:4506', @profile.table_id
+          assert_equal 'UA-5555-1', @profile.web_property_id
         end
 
         should "have a path" do
-          assert_equal "/accounts/1189765/webproperties/UA-1189765-1/profiles/98765", @profile.path
+          assert_equal "/accounts/1234/webproperties/UA-5555-1/profiles/2", @profile.path
         end
 
         should "have goals" do

data/test/unit/garb/management/segment_test.rb

@@ -8,12 +8,12 @@ module Garb
           feed = stub(:entries => ["entry1"])
           Feed.stubs(:new).returns(feed)
 
-          Segment.stubs(:new_from_entry)
+          Segment.stubs(:new)
           Segment.all
 
           assert_received(Feed, :new) {|e| e.with(Session, '/segments')}
           assert_received(feed, :entries)
-          assert_received(Segment, :new_from_entry) {|e| e.with("entry1", Session)}
+          assert_received(Segment, :new) {|e| e.with("entry1", Session)}
         end
       end
 
@@ -27,19 +27,20 @@ module Garb
               "dxp:definition" => "ga:visitorType==Returning Visitor"
             }
           }
-          @segment = Segment.new_from_entry(entry, Session)
+          entry = MultiJson.load(read_fixture("ga_segment_management.json"))["items"].first
+          @segment = Segment.new(entry, Session)
         end
 
         should "have an id" do
-          assert_equal "gaid::-3", @segment.id
+          assert_equal "gaid::1", @segment.id
         end
 
         should "have a name" do
-          assert_equal "Returning Visitor", @segment.name
+          assert_equal "derpy", @segment.name
         end
 
         should "have a definition" do
-          assert_equal "ga:visitorType==Returning Visitor", @segment.definition
+          assert_equal "ga:pagePath=@derpy", @segment.definition
         end
       end
     end

data/test/unit/garb/management/web_property_test.rb

@@ -8,12 +8,12 @@ module Garb
           feed = stub(:entries => ["entry1"])
           Feed.stubs(:new).returns(feed)
 
-          WebProperty.stubs(:new_from_entry)
+          WebProperty.stubs(:new)
           WebProperty.all
 
           assert_received(Feed, :new) {|e| e.with(Session, '/accounts/~all/webproperties')}
           assert_received(feed, :entries)
-          assert_received(WebProperty, :new_from_entry) {|e| e.with("entry1", Session)}
+          assert_received(WebProperty, :new) {|e| e.with("entry1", Session)}
         end
 
         should "find all web properties for a given account" do
@@ -28,23 +28,21 @@ module Garb
 
       context "a WebProperty" do
         setup do
-          entry = {
-            "link" => [{"rel" => "self", "href" => Feed::BASE_URL+"/accounts/1189765/webproperties/UA-1189765-1"}],
-            "dxp:property" => [
-              {"name" => "ga:accountId", "value" => "1189765"},
-              {"name" => "ga:webPropertyId", "value" => 'UA-1189765-1'}
-            ]
-          }
+          entry = MultiJson.load(read_fixture("ga_webproperty_management.json"))["items"].first
 
-          @web_property = WebProperty.new_from_entry(entry, Session)
+          @web_property = WebProperty.new(entry, Session)
         end
 
         should "have an id" do
-          assert_equal "UA-1189765-1", @web_property.id
+          assert_equal "UA-7777-1", @web_property.id
         end
 
         should "have an account_id" do
-          assert_equal "1189765", @web_property.account_id
+          assert_equal "1", @web_property.account_id
+        end
+
+        should "combine the WebProperty.path and the id into an new path" do
+          assert_equal "/accounts/1/webproperties/UA-7777-1", @web_property.path
         end
 
         should "have profiles" do

data/test/unit/garb/model_test.rb

@@ -41,77 +41,96 @@ module Garb
 
       context "with a profile" do
         setup do
-          entry = {
-            "title" => "Google Analytics Profile example.com",
-            "link" => [{"rel" => "self", "href" => Garb::Management::Feed::BASE_URL+"/accounts/1189765/webproperties/UA-1189765-1/profiles/98765"}],
-            "dxp:property" => [
-              {"name" => "ga:profileId", "value" => "98765"},
-              {"name" => "ga:accountId", "value" => "1189765"},
-              {"name" => "ga:webPropertyId", "value" => 'UA-1189765-1'}
-            ]
-          }
-
-          @profile = Garb::Management::Profile.new_from_entry(entry, Session)
+          entry = MultiJson.load(read_fixture('ga_profile_management.json'))['items'].first
+
+          @profile = Garb::Management::Profile.new(entry, Session)
         end
 
         context "when getting results" do
           setup do
             @response = stub(:body => "raw report data")
-            DataRequest.stubs(:new).returns(stub(:send_request => @response))
-            ReportResponse.stubs(:new).returns(stub(:results => ['result']))
+            Request::Data.stubs(:new).returns(stub(:send_request => @response))
+            @results = ResultSet.new(Array.new(10) { |i| 'result #%d' % i })
+            ReportResponse.stubs(:new).returns(stub(:results => @results))
 
             @test_model.stubs(:metrics).returns(stub(:to_params => {'metrics' => 'ga:visits'}))
             @test_model.stubs(:dimensions).returns(stub(:to_params => {'dimensions' => 'ga:pagePath'}))
 
             now = Time.now
             Time.stubs(:now).returns(now)
+            @params = {
+              'ids'         => Garb.to_ga(@profile.id),
+              'start-date'  => (now - Model::MONTH).strftime('%Y-%m-%d'),
+              'end-date'    => now.strftime('%Y-%m-%d'),
+              'metrics'     => 'ga:visits',
+              'dimensions'  => 'ga:pagePath'
+            }
+          end
 
-            # p @profile.id
+          should "get results" do
+            assert_equal @results, @test_model.results(@profile)
+            assert_received(ReportResponse, :new) {|e| e.with('raw report data', OpenStruct)}
+            assert_data_params(@params)
+          end
 
-            @params = {'ids' => Garb.to_ga(@profile.id),
-              'start-date' => (now - Model::MONTH).strftime('%Y-%m-%d'),
-              'end-date' => now.strftime('%Y-%m-%d'),
-              'metrics' => 'ga:visits',
-              'dimensions' => 'ga:pagePath'}
+          should "get subset of results using bracket notation" do
+            assert_equal @results[0..2], @test_model.results(@profile)[0..2]
+            assert_received(ReportResponse, :new) {|e| e.with('raw report data', OpenStruct)}
+            assert_data_params(@params)
           end
 
-          should "get all results" do
-            assert_equal ['result'], @test_model.results(@profile)
-            assert_received(ReportResponse, :new) {|e| e.with("raw report data", OpenStruct)}
+          should "get one of the results using bracket notation" do
+            assert_equal @results[2], @test_model.results(@profile)[2]
+            assert_received(ReportResponse, :new) {|e| e.with('raw report data', OpenStruct)}
             assert_data_params(@params)
           end
 
           should "be able to filter" do
-            filter_parameters = stub(:<<)
-            FilterParameters.stubs(:new).returns(stub(:parameters => filter_parameters, :to_params => {'filters' => "params"}))
-            assert_equal ['result'], @test_model.results(@profile, :filters => {:page_path => '/'})
+            FilterParameters.stubs(:new).returns(stub(:to_params => {'filters' => 'params'}))
+            assert_equal @results, @test_model.results(@profile, :filters => {:page_path => '/'})
 
             assert_data_params(@params.merge({'filters' => 'params'}))
-            assert_received(filter_parameters, :<<) {|e| e.with({:page_path => '/'})}
+            assert_received(FilterParameters, :new) {|e| e.with({:page_path => '/'})}
           end
 
           should "be able to set the filter segment by id" do
-            assert_equal ['result'], @test_model.results(@profile, :segment_id => 1)
+            assert_equal @results, @test_model.results(@profile, :segment_id => 1)
             assert_data_params(@params.merge({'segment' => 'gaid::1'}))
           end
 
+          should "be able to set the filter segment by alphanumeric id" do
+            assert_equal @results, @test_model.results(@profile, :segment_id => '1a')
+            assert_data_params(@params.merge({'segment' => 'gaid::1a'}))
+          end
+
+          should "be able to filter with a dynamic segment" do
+            # parse_filters called first...
+            filter_parameters = stub(:<<)
+            filters = stub(:parameters => filter_parameters, :to_params => {'filters' => nil})
+            segments = stub(:parameters => filter_parameters, :to_params => {'filters' => 'dynamic_segment_params'})
+            FilterParameters.stubs(:new).returns(filters).then.returns(segments)
+
+            assert_equal @results, @test_model.results(@profile, :dynamic_segment => 'dynamic_segment_params')
+            assert_data_params(@params.merge({'segment' => 'dynamic::dynamic_segment_params'}))
+          end
+
           should "be able to sort" do
             sort_parameter = stub(:<<)
             sort_parameter.stubs(:to_params => {'sort' => 'sort value'})
             ReportParameter.stubs(:new).returns(sort_parameter)
 
-            assert_equal ['result'], @test_model.results(@profile, :sort => [:visits])
+            assert_equal @results, @test_model.results(@profile, :sort => [:visits])
             assert_received(sort_parameter, :<<) {|e| e.with([:visits])}
             assert_data_params(@params.merge({'sort' => 'sort value'}))
           end
 
           should "be able to limit" do
-            assert_equal ['result'], @test_model.results(@profile, :limit => 20)
+            assert_equal @results, @test_model.results(@profile, :limit => 20)
             assert_data_params(@params.merge({'max-results' => 20}))
           end
 
           should "be able to offset" do
-            assert_equal ['result'], @test_model.results(@profile, :offset => 10)
+            assert_equal @results, @test_model.results(@profile, :offset => 10)
             assert_data_params(@params.merge({'start-index' => 10}))
           end
 
@@ -119,16 +138,35 @@ module Garb
             start_date = (Time.now - 1296000)
             end_date = Time.now
 
-            assert_equal ['result'], @test_model.results(@profile, :start_date => start_date, :end_date => end_date)
+            assert_equal @results, @test_model.results(@profile, :start_date => start_date, :end_date => end_date)
             assert_data_params(@params.merge({'start-date' => start_date.strftime('%Y-%m-%d'), 'end-date' => end_date.strftime('%Y-%m-%d')}))
           end
 
           should "return a set of results in the defined class" do
             @test_model.stubs(:instance_klass).returns(ResultKlass)
 
-            assert_equal ['result'], @test_model.results(@profile)
+            assert_equal @results, @test_model.results(@profile)
             assert_received(ReportResponse, :new) {|e| e.with("raw report data", ResultKlass)}
           end
+
+          should "be able to fetch multiple pages of results" do
+            @results.total_results = 25
+            results = @test_model.all_results(@profile)
+            assert_equal results.size, 30
+          end
+
+          should "be able to pass :all symbol to fetch multiple pages of results" do
+            @results.results = ['result']
+            @results.total_results = 25
+            results = @test_model.results(@profile, :all => true)
+            assert_equal results.size, @results.total_results
+          end
+
+          should "be able to fetch multiple pages of results with a limit" do
+            @results.total_results = 25
+            results = @test_model.all_results(@profile, :limit => 1)
+            assert_equal results.size, 1
+          end
         end
 
         # should "return results as an array of the class it belongs to, if that class is an ActiveRecord descendant"

data/test/unit/garb/report_parameter_test.rb

@@ -2,25 +2,25 @@ require 'test_helper'
 
 module Garb
   class ReportParameterTest < MiniTest::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 << :page_path)
         assert_equal [:page_path], @metrics.elements
       end
-      
+
       should "merge an array of elements" do
         assert_equal(@metrics, @metrics << [:page_path])
         assert_equal [:page_path], @metrics.elements
@@ -38,6 +38,6 @@ module Garb
         end
       end
     end
-    
+
   end
 end

data/test/unit/garb/report_response_test.rb

@@ -7,38 +7,48 @@ module Garb
     context "A ReportResponse" do
       context "with a report feed" do
         setup do
-          @xml = File.read(File.join(File.dirname(__FILE__), '..', '..', "/fixtures/report_feed.xml"))
+          @json = File.read(File.join(File.dirname(__FILE__), '..', '..', "/fixtures/report_feed.json"))
         end
 
-        should "parse results from atom xml" do
-          response = ReportResponse.new(@xml)
-          assert_equal ['33', '2', '1'], response.results.map(&:pageviews)
+        should "parse results from json" do
+          response = ReportResponse.new(@json)
+          assert_equal ['4', '4', '17', '1', '5'], response.results.map(&:pageviews)
         end
 
         should "default to returning an array of OpenStruct objects" do
-          response = ReportResponse.new(@xml)
-          assert_equal [OpenStruct, OpenStruct, OpenStruct], response.results.map(&:class)
+          response = ReportResponse.new(@json)
+          assert_equal [OpenStruct, OpenStruct, OpenStruct, OpenStruct, OpenStruct], response.results.map(&:class)
         end
 
         should "return an array of instances of a specified class" do
-          response = ReportResponse.new(@xml, SpecialKlass)
-          assert_equal [SpecialKlass, SpecialKlass, SpecialKlass], response.results.map(&:class)
+          response = ReportResponse.new(@json, SpecialKlass)
+          assert_equal [SpecialKlass, SpecialKlass, SpecialKlass, SpecialKlass, SpecialKlass], response.results.map(&:class)
         end
 
         should "know the total number of results" do
-          response = ReportResponse.new(@xml)
-          assert_equal 18, response.results.total_results
+          response = ReportResponse.new(@json)
+          assert_equal 1261, response.results.total_results
         end
 
         should "know if the data has been sampled" do
-          response = ReportResponse.new(@xml)
+          response = ReportResponse.new(@json)
           assert_equal true, response.results.sampled?
         end
+
+        should "return results as ResultSet which acts as Array proxy" do
+          response = ReportResponse.new(@json, SpecialKlass)
+          results = response.results
+          results_subset = results[0..1]
+          
+          assert_equal ResultSet, results.class
+          assert_equal ResultSet, results_subset.class
+          assert_equal results_subset.results, results.results[0..1]
+        end
       end
 
       should "return an empty array if there are no results" do
-        response = ReportResponse.new("result xml")
-        Crack::XML.stubs(:parse).with("result xml").returns({'feed' => {'entry' => nil}})
+        response = ReportResponse.new('result json')
+        MultiJson.stubs(:load).with('result json').returns({'rows' => []})
 
         assert_equal [], response.results.to_a
       end

data/test/unit/garb/request/authentication_test.rb

@@ -0,0 +1,152 @@
+require 'test_helper'
+
+module Garb
+  module Request
+    class AuthenticationTest < MiniTest::Unit::TestCase
+
+      context "An instance of the Request::Authentication class" do
+
+        setup do
+          @request = Request::Authentication.new('email', 'password')
+          Garb.ca_cert_file = File.join(File.dirname(__FILE__), '..', '/cacert.pem')
+        end
+        teardown do
+          Garb.proxy_address = nil
+          Garb.proxy_port = nil
+          Garb.ca_cert_file = nil
+        end
+
+        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'      => "sija-garb-v#{Garb::VERSION}"
+            }
+
+          request = Request::Authentication.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 with proper ssl" 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(:open_timeout=).with(Garb.open_timeout)
+            m.expects(:read_timeout=).with(Garb.read_timeout)
+            m.expects(:use_ssl=).with(true)
+            m.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
+            m.expects(:ca_file=).with(Garb.ca_cert_file)
+            m.expects(:request).with('post').yields(response)
+          end
+
+          Net::HTTP.expects(:new).with('www.google.com', 443, nil, nil).returns(http)
+
+          @request.send_request(OpenSSL::SSL::VERIFY_PEER)
+        end
+
+        should "be able to send a request to the GAAPI service with ignoring ssl" 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(:open_timeout=).with(Garb.open_timeout)
+            m.expects(:read_timeout=).with(Garb.read_timeout)
+            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, nil, nil).returns(http)
+
+          @request.send_request(OpenSSL::SSL::VERIFY_NONE)
+        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(OpenSSL::SSL::VERIFY_NONE).returns(stub(:body => response_data))
+
+          assert_equal 'auth_token', @request.auth_token
+        end
+
+        should "use VERIFY_PEER if auth_token needs to be secure" do
+          response_data =
+            "SID=mysid\n" +
+            "LSID=mylsid\n" +
+            "Auth=auth_token\n"
+
+          @request.expects(:send_request).with(OpenSSL::SSL::VERIFY_PEER).returns(stub(:body => response_data))
+
+          assert_equal 'auth_token', @request.auth_token(:secure => true)
+        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.expects(:open_timeout=).with(Garb.open_timeout)
+            s.expects(:read_timeout=).with(Garb.read_timeout)
+            s.stubs(:verify_mode=)
+            s.stubs(:request).yields(response)
+          end
+
+          Net::HTTP.stubs(:new).with('www.google.com', 443, nil, nil).returns(http)
+
+          assert_raises(Garb::AuthError) do
+            @request.send_request(OpenSSL::SSL::VERIFY_NONE)
+          end
+        end
+
+        should "make use of Garb proxy settings in Net::HTTP request" do
+          @request.expects(:build_request).returns('post')
+
+          response = stub {|s| s.stubs(:is_a?).returns(true) }
+
+          http = mock do |m|
+            m.stubs(:open_timeout=)
+            m.stubs(:read_timeout=)
+            m.stubs(:use_ssl=)
+            m.stubs(:verify_mode=)
+            m.stubs(:request).yields(response)
+          end
+
+          Garb.proxy_address = '127.0.0.1'
+          Garb.proxy_port = '1234'
+
+          Net::HTTP.expects(:new).with('www.google.com', 443, '127.0.0.1', '1234').returns(http)
+
+          @request.send_request(nil)
+        end
+      end
+    end
+  end
+end