readmedia-garb 0.9.1.1

data/test/unit/garb/goal_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+module Garb
+  class GoalTest < MiniTest::Unit::TestCase
+    context "A Goal" do
+      should "have a name, number, and value" do
+        goal = Goal.new({'name' => 'Read Blog', 'number' => '1', 'value' => '10.0', 'active' => 'true'})
+        assert_equal 'Read Blog', goal.name
+        assert_equal 1, goal.number
+        assert_equal 10.0, goal.value
+      end
+
+      should "know if it is active" do
+        goal = Goal.new({'name' => 'Read Blog', 'number' => '1', 'value' => '10.0', 'active' => 'true'})
+        assert goal.active?
+      end
+
+      should "know if it is not active" do
+        goal = Goal.new({'name' => 'Read Blog', 'number' => '1', 'value' => '10.0', 'active' => 'false'})
+        assert_equal false, goal.active?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+require 'test_helper'
+
+module Garb
+  module Management
+    class AccountTest < MiniTest::Unit::TestCase
+      context "The Account class" do
+        should "turn entries for path into array of accounts" do
+          feed = stub(:entries => ["entry1"])
+          Feed.stubs(:new).returns(feed)
+
+          Account.stubs(:new_from_entry)
+          Account.all
+
+          assert_received(Feed, :new) {|e| e.with(Session, '/accounts')}
+          assert_received(feed, :entries)
+          assert_received(Account, :new_from_entry) {|e| e.with("entry1", Session)}
+        end
+      end
+
+      context "an Account" do
+        setup do
+          entry = {
+            "title" => "Google Analytics Account Garb",
+            "link" => [{"rel" => "self", "href" => Feed::BASE_URL+"/accounts/123456"}],
+            "dxp:property" => [
+              {"name" => "ga:accountId", "value" => "123456"},
+              {"name" => "ga:accountName", "value" => "Garb"}
+            ]
+          }
+          @account = Account.new_from_entry(entry, Session)
+        end
+
+        should "extract id and title from GA entry" do
+          assert_equal "Garb", @account.title
+          assert_equal "123456", @account.id
+        end
+
+        should "extract a name from GA entry properties" do
+          assert_equal "Garb", @account.name
+        end
+
+        should "combine the Account.path and the id into an new path" do
+          assert_equal "/accounts/123456", @account.path
+        end
+
+        should "have a reference to the session it was created with" do
+          assert_equal Session, @account.session
+        end
+
+        should "have web properties" do
+          WebProperty.stubs(:for_account)
+          @account.web_properties
+          assert_received(WebProperty, :for_account) {|e| e.with(@account)}
+        end
+
+        should "have profiles" do
+          Profile.stubs(:for_account)
+          @account.profiles
+          assert_received(Profile, :for_account) {|e| e.with(@account)}
+        end
+
+        should "have goals" do
+          Goal.stubs(:for_account)
+          @account.goals
+          assert_received(Goal, :for_account) {|e| e.with(@account)}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+module Garb
+  module Management
+    class FeedTest < MiniTest::Unit::TestCase
+      context "a Feed" do
+        setup do
+          @request = stub
+          DataRequest.stubs(:new).returns(@request)
+          @feed = Feed.new(Garb::Session.new, '/accounts')
+        end
+
+        should "have a parsed response" do
+          Crack::XML.stubs(:parse)
+          @feed.stubs(:response).returns(stub(:body => 'response body'))
+          @feed.parsed_response
+
+          assert_received(Crack::XML, :parse) {|e| e.with('response body')}
+        end
+
+        should "have entries from the parsed response" do
+          @feed.stubs(:parsed_response).returns({'feed' => {'entry' => ['entry1', 'entry2']}})
+          assert_equal ['entry1', 'entry2'], @feed.entries
+        end
+
+        should "handle case of a single entry" do
+          @feed.stubs(:parsed_response).returns({'feed' => {'entry' => {'profile_id' => '12345'}}})
+          assert_equal [{'profile_id' => '12345'}], @feed.entries
+        end
+
+        should "have an empty array for entries without a response" do
+          @feed.stubs(:parsed_response).returns(nil)
+          assert_equal [], @feed.entries
+        end
+
+        should "have a response from the request" do
+          @request.stubs(:send_request)
+          @feed.response
+          assert_received(@request, :send_request)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+require 'test_helper'
+
+module Garb
+  module Management
+    class GoalTest < MiniTest::Unit::TestCase
+      context "the Goal class" do
+        should "turn entries for path into array of goals" do
+          feed = stub(:entries => ["entry1"])
+          Feed.stubs(:new).returns(feed)
+
+          Goal.stubs(:new_from_entry)
+          Goal.all
+
+          assert_received(Feed, :new) {|e| e.with(Session, '/accounts/~all/webproperties/~all/profiles/~all/goals')}
+          assert_received(feed, :entries)
+          assert_received(Goal, :new_from_entry) {|e| e.with("entry1", Session)}
+        end
+
+        should "find all goals for a given account" do
+          Goal.stubs(:all)
+          Goal.for_account(stub(:session => 'session', :path => '/accounts/123'))
+          assert_received(Goal, :all) {|e| e.with('session', '/accounts/123/webproperties/~all/profiles/~all/goals')}
+        end
+
+        should "find all goals for a given web_property" do
+          Goal.stubs(:all)
+          Goal.for_web_property(stub(:session => 'session', :path => '/accounts/123/webproperties/456'))
+          assert_received(Goal, :all) {|e| e.with('session', '/accounts/123/webproperties/456/profiles/~all/goals')}
+        end
+
+        should "find all goals for a given profile" do
+          Goal.stubs(:all)
+          Goal.for_profile(stub(:session => 'session', :path => '/accounts/123/webproperties/456/profiles/789'))
+          assert_received(Goal, :all) {|e| e.with('session', '/accounts/123/webproperties/456/profiles/789/goals')}
+        end
+      end
+
+      context "a Goal" do
+        setup do
+          entry = {
+            "link" => [{"rel" => "self", "href" => Feed::BASE_URL+"/accounts/1189765/webproperties/UA-1189765-1/profiles/98765"}],
+            "ga:goal" => {
+              "ga:destination"=>{"caseSensitive"=>"false","expression"=>"/blog.html","matchType"=>"head"},
+              "active"=>"true",
+              "name"=>"Read Blog",
+              "number"=>"1",
+              "value"=>"10.0"
+            }
+          }
+
+          @goal = Goal.new_from_entry(entry, Session)
+        end
+
+        should "have a name" do
+          assert_equal "Read Blog", @goal.name
+        end
+
+        should "have a number" do
+          assert_equal 1, @goal.number
+        end
+
+        should "have a value" do
+          assert_equal 10.0, @goal.value
+        end
+
+        should "know if it is active" do
+          assert_equal true, @goal.active?
+        end
+
+        should "know if it is not active" do
+          @goal.active = false
+          assert_equal false, @goal.active?
+        end
+
+        should "have a destination" do
+          assert_equal true, @goal.destination.is_a?(Destination)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+require 'test_helper'
+
+module Garb
+  module Management
+    class ProfileTest < MiniTest::Unit::TestCase
+      context "The Profile class" do
+        should "turn entries for path into array of profiles" do
+          feed = stub(:entries => ["entry1"])
+          Feed.stubs(:new).returns(feed)
+
+          Profile.stubs(:new_from_entry)
+          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)}
+        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')}          
+        end
+
+        should "find all profiles for a given web_property" do
+          Profile.stubs(:all)
+          Profile.for_web_property(stub(:session => 'session', :path => '/accounts/123/webproperties/456'))
+          assert_received(Profile, :all) {|e| e.with('session', '/accounts/123/webproperties/456/profiles')}
+        end
+      end
+
+      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)
+        end
+
+        should "have a title" do
+          assert_equal "example.com", @profile.title
+        end
+
+        should "have an id" do
+          assert_equal '98765', @profile.id
+        end
+
+        should "have an account_id" do
+          assert_equal '1189765', @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
+        end
+
+        should "have a path" do
+          assert_equal "/accounts/1189765/webproperties/UA-1189765-1/profiles/98765", @profile.path
+        end
+
+        should "have goals" do
+          Goal.stubs(:for_profile)
+          @profile.goals
+          assert_received(Goal, :for_profile) {|e| e.with(@profile)}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+module Garb
+  module Management
+    class SegmentTest < MiniTest::Unit::TestCase
+      context "The Segment class" do
+        should "turn entries for path into array of accounts" do
+          feed = stub(:entries => ["entry1"])
+          Feed.stubs(:new).returns(feed)
+
+          Segment.stubs(:new_from_entry)
+          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)}
+        end
+      end
+
+      context "A Segment" do
+        setup do
+          entry = {
+            "link" => [{"rel" => "self", "href" => Feed::BASE_URL+"/segments/12"}],
+            "dxp:segment" => {
+              "id" => "gaid::-3",
+              "name" => "Returning Visitor",
+              "dxp:definition" => "ga:visitorType==Returning Visitor"
+            }
+          }
+          @segment = Segment.new_from_entry(entry, Session)
+        end
+
+        should "have an id" do
+          assert_equal "gaid::-3", @segment.id
+        end
+
+        should "have a name" do
+          assert_equal "Returning Visitor", @segment.name
+        end
+
+        should "have a definition" do
+          assert_equal "ga:visitorType==Returning Visitor", @segment.definition
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+module Garb
+  module Management
+    class WebPropertyTest < MiniTest::Unit::TestCase
+      context "the WebProperty class" do
+        should "turn entries for path into array of web properties" do
+          feed = stub(:entries => ["entry1"])
+          Feed.stubs(:new).returns(feed)
+
+          WebProperty.stubs(:new_from_entry)
+          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)}
+        end
+
+        should "find all web properties for a given account" do
+          WebProperty.stubs(:all)
+          WebProperty.for_account(stub(:session => Session, :path => '/accounts/123456'))
+
+          assert_received(WebProperty, :all) do |e|
+            e.with(Session, '/accounts/123456/webproperties')
+          end
+        end
+      end
+
+      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'}
+            ]
+          }
+
+          @web_property = WebProperty.new_from_entry(entry, Session)
+        end
+
+        should "have an id" do
+          assert_equal "UA-1189765-1", @web_property.id
+        end
+
+        should "have an account_id" do
+          assert_equal "1189765", @web_property.account_id
+        end
+
+        should "have profiles" do
+          Profile.stubs(:for_web_property)
+          @web_property.profiles
+          assert_received(Profile, :for_web_property) {|e| e.with(@web_property)}
+        end
+
+        should "have goals" do
+          Goal.stubs(:for_web_property)
+          @web_property.goals
+          assert_received(Goal, :for_web_property) {|e| e.with(@web_property)}
+        end
+      end
+    end
+  end
+end

data/test/unit/garb/model_test.rb

@@ -0,0 +1,141 @@
+require 'test_helper'
+
+class ResultKlass
+  def initialize(attrs)
+  end
+end
+
+module Garb
+  class ModelTest < MiniTest::Unit::TestCase
+    context "A class extended with Garb::Model" do
+      setup do
+        @test_model = Class.new
+        @test_model.extend(Garb::Model)
+      end
+
+      # public API
+      should "be able to define metrics" do
+        report_parameter = stub(:<<)
+        ReportParameter.stubs(:new).returns(report_parameter)
+
+        @test_model.metrics :visits, :pageviews
+
+        assert_received(ReportParameter, :new) {|e| e.with(:metrics)}
+        assert_received(report_parameter, :<<) {|e| e.with([:visits, :pageviews])}
+      end
+
+      should "be able to define dimensions" do
+        report_parameter = stub(:<<)
+        ReportParameter.stubs(:new).returns(report_parameter)
+
+        @test_model.dimensions :page_path, :event_category
+
+        assert_received(ReportParameter, :new) {|e| e.with(:dimensions)}
+        assert_received(report_parameter, :<<) {|e| e.with([:page_path, :event_category])}
+      end
+
+      should "be able to se the instance klass" do
+        @test_model.set_instance_klass ResultKlass
+        assert_equal ResultKlass, @test_model.instance_klass
+      end
+
+      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)
+        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']))
+
+            @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)
+
+            # p @profile.id
+
+            @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
+
+          should "get all results" do
+            assert_equal ['result'], @test_model.results(@profile)
+            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 => '/'})
+
+            assert_data_params(@params.merge({'filters' => 'params'}))
+            assert_received(filter_parameters, :<<) {|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_data_params(@params.merge({'segment' => 'gaid::1'}))
+          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_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_data_params(@params.merge({'max-results' => 20}))
+          end
+
+          should "be able to offset" do
+            assert_equal ['result'], @test_model.results(@profile, :offset => 10)
+            assert_data_params(@params.merge({'start-index' => 10}))
+          end
+
+          should "be able to shift the date range" do
+            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_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_received(ReportResponse, :new) {|e| e.with("raw report data", ResultKlass)}
+          end
+        end
+
+        # should "return results as an array of the class it belongs to, if that class is an ActiveRecord descendant"
+        # should "return results as an array of the class it belongs to, if that class is a DataMapper descendant"
+        # should "return results as an array of the class it belongs to, if that class is a MongoMapper descendant"
+        # should "return results as an array of the class it belongs to, if that class is a Mongoid descendant"
+      end
+    end
+  end
+end

data/test/unit/garb/oauth_session_test.rb

@@ -0,0 +1,11 @@
+require '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 '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,77 @@
+require '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
+        afr = AccountFeedRequest.new
+        afr.stubs(:parsed_response).returns(Crack::XML.parse(read_fixture('profile_feed.xml')))
+        AccountFeedRequest.stubs(:new).returns(afr)
+
+        assert_equal ['12345', '12346'], Profile.all(@session).map(&:id)
+        assert_received(AccountFeedRequest, :new) {|e| e.with(@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]
+
+        Profile.stubs(:all).returns(entries)
+
+        assert_equal profile1, Profile.first('12345', @session)
+
+        assert_received(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]
+
+        Profile.stubs(:all).returns(entries)
+
+        assert_equal profile2, Profile.first('67890', @session)
+
+        assert_received(Profile, :all) {|e| e.with(@session)}
+      end
+    end
+
+    context "A Profile" do
+      setup do
+        afr = AccountFeedRequest.new
+        afr.stubs(:parsed_response).returns(Crack::XML.parse(read_fixture('profile_feed.xml')))
+
+        entry = afr.entries.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
+
+      should "have goals" do
+        assert_equal 4, @profile.goals.size
+      end
+    end
+  end
+end