titanous-garb 0.8.5

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,54 @@
+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)
+          Account.all
+
+          assert_received(Feed, :new) {|e| e.with(Session, '/accounts')}
+          assert_received(feed, :entries)
+          assert_received(Account, :new) {|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(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"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+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 profile" do
+          feed = stub(:entries => ["entry1"])
+          Feed.stubs(:new).returns(feed)
+
+          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) {|e| e.with("entry1", Session)}
+        end
+
+        should "find all web properties for a given account"
+        should "find all web properties for a given web_property"
+      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"}
+            ]
+          }
+          @profile = Profile.new(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 path" do
+          assert_equal "/accounts/1189765/webproperties/UA-1189765-1/profiles/98765", @profile.path
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+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)
+          WebProperty.all
+
+          assert_received(Feed, :new) {|e| e.with(Session, '/accounts/~all/webproperties')}
+          assert_received(feed, :entries)
+          assert_received(WebProperty, :new) {|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(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
+      end
+    end
+  end
+end

data/test/unit/garb/model_test.rb

@@ -0,0 +1,134 @@
+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(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(:new).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
+
+          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"
+
+          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 "have a block syntax for filtering results"
+        # 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