garb-no-activesupport 0.7.3

data/test/unit/garb/data_request_test.rb

@@ -0,0 +1,106 @@
+require File.join(File.dirname(__FILE__), '..', '..', '/test_helper')
+
+module Garb
+  class DataRequestTest < MiniTest::Unit::TestCase
+    
+    context "An instance of the DataRequest class" do
+      setup do
+        @session = Session.new
+        @session.auth_token = 'abcdefg123456'
+      end
+
+      should "be able to build the query string from parameters" do
+        parameters = {'ids' => '12345', 'metrics' => 'country'}
+        data_request = DataRequest.new(@session, "", 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(@session, "")
+        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(@session, url).uri
+      end
+      
+      should "be able to send a request for a single user" do
+        @session.stubs(:single_user?).returns(true)
+        response = mock('Net::HTTPOK') do |m|
+          m.expects(:kind_of?).with(Net::HTTPSuccess).returns(true)
+        end
+
+        data_request = DataRequest.new(@session, 'https://example.com/data', 'key' => 'value')
+        data_request.stubs(:single_user_request).returns(response)
+        data_request.send_request
+
+        assert_received(data_request, :single_user_request)
+      end
+
+      should "be able to send a request for an oauth user" do
+        @session.stubs(:single_user?).returns(false)
+        @session.stubs(:oauth_user?).returns(true)
+        response = mock('Net::HTTPOK') do |m|
+          m.expects(:kind_of?).with(Net::HTTPSuccess).returns(true)
+        end
+
+        data_request = DataRequest.new(@session, 'https://example.com/data', 'key' => 'value')
+        data_request.stubs(:oauth_user_request).returns(response)
+        data_request.send_request
+
+        assert_received(data_request, :oauth_user_request)
+      end
+
+      should "raise if the request is unauthorized" do
+        @session.stubs(:single_user?).returns(false)
+        @session.stubs(:oauth_user?).returns(true)
+        response = mock('Net::HTTPUnauthorized', :body => 'Error')
+
+        data_request = DataRequest.new(@session, 'https://example.com/data', 'key' => 'value')
+        data_request.stubs(:oauth_user_request).returns(response)
+
+        assert_raises(Garb::DataRequest::ClientError) do
+          data_request.send_request
+        end
+      end
+
+      should "be able to request via the ouath access token" do
+        access_token = stub(:get => "responseobject")
+        @session.stubs(:access_token).returns(access_token)
+
+        data_request = DataRequest.new(@session, 'https://example.com/data', 'key' => 'value')
+        assert_equal 'responseobject', data_request.oauth_user_request
+
+        assert_received(@session, :access_token)
+        assert_received(access_token, :get) {|e| e.with('https://example.com/data?key=value')}
+      end
+
+      should "be able to request via http with an auth token" do
+        @session.expects(:auth_token).with().returns('toke')
+        response = mock
+
+        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(@session, 'https://example.com/data', 'key' => 'value')
+        assert_equal response, data_request.single_user_request
+      end
+    end
+
+  end
+end

data/test/unit/garb/filter_parameters_test.rb

@@ -0,0 +1,59 @@
+require File.join(File.dirname(__FILE__), '..', '..', '/test_helper')
+
+module Garb
+  class FilterParametersTest < MiniTest::Unit::TestCase
+    def self.should_define_operators(*operators)
+      operators.each do |operator|
+        should "create an operator and add to parameters for the #{operator} method" do
+          new_operator = stub
+          symbol = :foo
+
+          SymbolOperator.expects(:new).with(:bar, operator).returns(new_operator)
+          @filter_parameters.filters do
+            send(operator.to_sym, :bar, 100)
+          end
+
+          parameter = {new_operator => 100}
+          assert_equal parameter, @filter_parameters.parameters.last
+        end
+      end
+    end
+
+    context "A FilterParameters" do
+      setup do
+        @filter_parameters = FilterParameters.new
+      end
+
+      should_define_operators :eql, :not_eql, :gt, :gte, :lt, :lte,
+        :matches, :does_not_match, :contains, :does_not_contain, :substring, :not_substring
+
+      should "instance eval for filters" do
+        blk = lambda {"in a block"}
+
+        @filter_parameters.expects(:instance_eval)
+        @filter_parameters.filters(&blk)
+      end
+
+      context "when converting parameters hash into query string parameters" do
+        should "parameterize hash operators and join elements with AND" do
+          @filter_parameters.filters do
+            eql(:city, 'New York City')
+            eql(:state, 'New York')
+          end
+
+          params = ['ga:city%3D%3DNew+York+City', 'ga:state%3D%3DNew+York']
+          assert_equal params, @filter_parameters.to_params['filters'].split(';').sort
+        end
+
+        should "properly encode operators" do
+          @filter_parameters.filters do
+            contains(:page_path, 'New York')
+          end
+
+          params = {'filters' => 'ga:pagePath%3D~New+York'}
+          assert_equal params, @filter_parameters.to_params
+        end
+      end
+    end
+  end
+end

data/test/unit/garb/oauth_session_test.rb

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

data/test/unit/garb/profile_reports_test.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), '..', '..', '/test_helper')
+
+module Garb
+
+  Exits = Class.new
+
+  class FakeProfile
+    include ProfileReports
+  end
+
+  class ProfileReportsTest < MiniTest::Unit::TestCase
+    context "The ProfileReports module" do
+      should "define a new method when given a class" do
+        ProfileReports.add_report_method(Exits)
+        assert_equal true, FakeProfile.new.respond_to?(:exits)
+      end
+
+      should "return results from the given class with options" do
+        results = [1,2,3]
+        Exits.stubs(:results).returns(results)
+        ProfileReports.add_report_method(Exits)
+
+        profile = FakeProfile.new
+        assert_equal results, profile.exits(:start => "now")
+        assert_received(Exits, :results) {|e| e.with(profile, :start => "now")}
+      end
+    end
+  end
+end

data/test/unit/garb/profile_test.rb

@@ -0,0 +1,87 @@
+require File.join(File.dirname(__FILE__), '..', '..', '/test_helper')
+
+module Garb
+  class ProfileTest < MiniTest::Unit::TestCase
+    
+    context "The Profile class" do
+      setup {@session = Session.new}
+      
+      should "be able to return a list of all profiles" do
+        url = 'https://www.google.com/analytics/feeds/accounts/default'
+        
+        xml = read_fixture('profile_feed.xml')
+        
+        data_request = mock
+        data_request.expects(:send_request).with().returns(stub(:body => xml))
+        
+        DataRequest.expects(:new).with(@session, 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, @session).returns(profile)
+        end
+        
+        assert_equal profiles, Profile.all(@session)
+      end
+
+      should "return the first profile for a given web property id" do
+        profile1 = stub(:web_property_id => '12345', :id => 'abcdef')
+        profile2 = stub(:web_property_id => '67890', :id => 'ghijkl')
+        entries = [profile1, profile2]
+
+        Garb::Profile.stubs(:all).returns(entries)
+
+        assert_equal profile1, Garb::Profile.first('12345', @session)
+
+        assert_received(Garb::Profile, :all) {|e| e.with(@session)}
+      end
+
+      should "return the first profile for a given table id" do
+        profile1 = stub(:id => '12345', :web_property_id => 'abcdef')
+        profile2 = stub(:id => '67890', :web_property_id => 'ghijkl')
+        entries = [profile1, profile2]
+
+        Garb::Profile.stubs(:all).returns(entries)
+
+        assert_equal profile2, Garb::Profile.first('67890', @session)
+
+        assert_received(Garb::Profile, :all) {|e| e.with(@session)}
+      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, Session)
+      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
+
+      should "have a value for :account_id" do
+        assert_equal '1111', @profile.account_id
+      end
+
+      should "have a value for :account_name" do
+        assert_equal 'Blog Beta', @profile.account_name
+      end
+    end
+
+  end
+end

data/test/unit/garb/report_parameter_test.rb

@@ -0,0 +1,43 @@
+require File.join(File.dirname(__FILE__), '..', '..', '/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
+      end
+
+      context "converting to params" do
+        should "be able to format the parameters into strings" do
+          @metrics << :page_path
+          assert_equal({'metrics' => 'ga:pagePath'}, @metrics.to_params)
+        end
+
+        should "join multiple symbol elements" do
+          @metrics << :page_path << :city
+          assert_equal({'metrics' => 'ga:pagePath,ga:city'}, @metrics.to_params)
+        end
+      end
+    end
+    
+  end
+end

data/test/unit/garb/report_response_test.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), '..', '..', '/test_helper')
+
+module Garb
+  class ReportResponseTest < MiniTest::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/garb/report_test.rb

@@ -0,0 +1,91 @@
+require File.join(File.dirname(__FILE__), '..', '..', '/test_helper')
+
+module Garb
+  # Also tests Garb::Resource, which is the basis for Garb::Report
+  class ReportTest < MiniTest::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', :session => Session)
+        @report = Report.new(@profile)
+      end
+
+      %w(metrics dimensions sort).each do |param|
+        should "have parameters for #{param}" do
+          assert @report.send(:"#{param}").is_a?(ReportParameter)
+        end
+
+        should "clear parameters for #{param}" do
+          assert_equal({}, @report.send(:"clear_#{param}").to_params)
+        end
+      end
+
+      should "have filter parameters for filters" do
+        assert @report.filters.is_a?(FilterParameters)
+      end
+
+      should "add new filters to filter parameters" do
+        @report.clear_filters
+        hash = {:thing.gt => 'val'}
+        @report.filters hash
+
+        assert_equal hash, @report.filters.parameters.first
+      end
+
+      should "clear filter parameters for filters" do
+        assert_equal({}, @report.clear_filters.to_params)
+      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(:sort).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(Session, 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/garb/resource_test.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__), '..', '..', '/test_helper')
+
+class TestReport
+  extend Garb::Resource
+end
+
+# Most of the resource testing is done as a part of ReportTest
+class ResourceTest < MiniTest::Unit::TestCase
+
+  context "A class with Garb::Resource mixed in" do
+    should "get results from GA" do
+      profile = stub(:is_a? => true)
+      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
+
+    should "get results from GA using a specific user session" do
+      profile = '123'
+      session = Garb::Session.new
+      TestReport.expects(:send_request_for_body).returns('xml')
+      Garb::ReportResponse.expects(:new).with('xml').returns(mock(:results => 'analytics'))
+      Garb::Profile.expects(:first).with(profile, session).returns(mock('Garb::Profile'))
+
+      assert_equal 'analytics', TestReport.results(profile, :session => session)
+    end
+
+    should "return an empty result set if profile is invalid" do
+      profile = '123'
+      TestReport.expects(:send_request_for_body).never
+      Garb::ReportResponse.expects(:new).never
+
+      Garb::Profile.expects(:first).returns(nil)
+      assert_equal [], TestReport.results(profile)
+    end
+  end
+end

data/test/unit/garb/session_test.rb

@@ -0,0 +1,84 @@
+require File.join(File.dirname(__FILE__), '..', '..', '/test_helper')
+
+module Garb
+  class SessionTest < MiniTest::Unit::TestCase
+    
+    context "The Session class" do
+      
+      should "be able retrieve an auth_token for a user" do
+        auth_request = mock {|m| m.expects(:auth_token).with({}).returns('toke') }
+        AuthenticationRequest.expects(:new).with('email', 'password', {}).returns(auth_request)
+
+        Session.login('email', 'password')
+        assert_equal 'toke', Session.auth_token
+      end
+
+      should "be able retrieve an auth_token for a user with secure ssl" do
+        opts = {:secure => true, :account_type => 'GOOGLE'}
+        auth_request = mock {|m| m.expects(:auth_token).with(opts).returns('toke') }
+        AuthenticationRequest.expects(:new).with('email', 'password', opts).returns(auth_request)
+
+        Session.login('email', 'password', opts)
+        assert_equal 'toke', Session.auth_token
+      end
+      
+      should "retain the email address for this session" do
+        AuthenticationRequest.stubs(:new).returns(stub(:auth_token => 'toke'))
+        
+        Session.login('email', 'password')
+        assert_equal 'email', Session.email
+      end
+
+      should "know if the Session is for a single user" do
+        Session.auth_token = "abcdefg1234567"
+        assert_equal true, Session.single_user?
+      end
+
+      should "know if the Session is for oauth" do
+        Session.access_token = 'some_oauth_access_token'
+        assert_equal true, Session.oauth_user?
+      end
+    end
+
+    context "A Session" do
+      setup do
+        @session = Session.new
+      end
+      
+      should "be able retrieve an auth_token for a user" do
+        auth_request = mock {|m| m.expects(:auth_token).with({}).returns('toke') }
+        AuthenticationRequest.expects(:new).with('email', 'password', {}).returns(auth_request)
+
+        @session.login('email', 'password')
+        assert_equal 'toke', @session.auth_token
+      end
+
+      should "be able retrieve an auth_token for a user with secure ssl" do
+        opts = {:secure => true, :account_type => 'GOOGLE'}
+        auth_request = mock {|m| m.expects(:auth_token).with(opts).returns('toke') }
+        AuthenticationRequest.expects(:new).with('email', 'password', opts).returns(auth_request)
+
+        @session.login('email', 'password', opts)
+        assert_equal 'toke', @session.auth_token
+      end
+      
+      should "retain the email address for this session" do
+        AuthenticationRequest.stubs(:new).returns(stub(:auth_token => 'toke'))
+        
+        @session.login('email', 'password')
+        assert_equal 'email', @session.email
+      end
+
+      should "know if the Session is for a single user" do
+        @session.auth_token = "abcdefg1234567"
+        assert_equal true, @session.single_user?
+      end
+
+      should "know if the Session is for oauth" do
+        @session.access_token = 'some_oauth_access_token'
+        assert_equal true, @session.oauth_user?
+      end
+    end
+
+  end
+end

data/test/unit/garb_test.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), '..', '/test_helper')
+
+class GarbTest < MiniTest::Unit::TestCase
+  context "The Garb module" do
+    should 'prefix a string with ga: for GA' do
+      assert_equal '-ga:bob', Garb.to_google_analytics(stub(:to_google_analytics => '-ga:bob'))
+      assert_equal 'ga:bob', Garb.to_google_analytics('bob')
+    end
+
+    should 'remove ga: prefix' do
+      assert_equal 'bob', Garb.from_google_analytics('ga:bob')
+    end
+  end
+end

data/test/unit/symbol_operator_test.rb

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