legato 0.0.1

data/spec/lib/legato/list_parameter_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Legato::ListParameter do
+  context "an instance of ListParameter" do
+    before :each do
+      @list_parameter = Legato::ListParameter.new(:metrics, [:exits])
+    end
+
+    it 'appends to the list' do
+      @list_parameter << :pageviews
+      @list_parameter.elements.should == [:exits, :pageviews]
+    end
+
+    it 'has a name' do
+      @list_parameter.name.should == "metrics"
+    end
+
+    it 'knows if it is equal another list parameter' do
+      @list_parameter.should == Legato::ListParameter.new(:metrics, [:exits])
+    end
+
+    it 'knows it is not equal another list parameter with a different name' do
+      @list_parameter.should_not == Legato::ListParameter.new(:dimensions, [:exits])
+    end
+
+    it 'knows it is not equal another list parameter with different elements' do
+      @list_parameter.should_not == Legato::ListParameter.new(:metrics, [:exits, :pageviews])
+    end
+
+    it 'converts itself to params' do
+      @list_parameter << :pageviews
+      @list_parameter.to_params.should == {"metrics" => "ga:exits,ga:pageviews"}
+    end
+  end
+end

data/spec/lib/legato/management/account_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Legato::Management::Account do
+  context "The Account class" do
+    def self.subject_class_name
+      "accounts"
+    end
+
+    it_behaves_like "a management finder"
+
+    it 'creates a new account instance from a hash of attributes' do
+      user = stub
+      account = Legato::Management::Account.new({"id" => 12345, "name" => "Account 1"}, user)
+      account.user.should == user
+      account.id.should == 12345
+      account.name.should == "Account 1"
+    end
+  end
+
+  context "An Account instance" do
+    let(:account) {Legato::Management::Account.new({"id" => 123456}, stub)}
+
+    it 'builds the path for the account from the id' do
+      account.path.should == '/accounts/123456'
+    end
+
+    it 'has web properties beneath it' do
+      Legato::Management::WebProperty.stubs(:for_account).returns('web_properties')
+      account.web_properties.should == 'web_properties'
+      Legato::Management::WebProperty.should have_received(:for_account).with(account)
+    end
+
+    it 'has profiles beneath it' do
+      Legato::Management::Profile.stubs(:for_account).returns('profiles')
+      account.profiles.should == 'profiles'
+      Legato::Management::Profile.should have_received(:for_account).with(account)
+    end
+  end
+end

data/spec/lib/legato/management/profile_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Legato::Management::Profile do
+  context "The Profile class" do
+    def self.subject_class_name
+      "profiles"
+    end
+
+    it_behaves_like "a management finder"
+
+    it 'creates a new profile instance from a hash of attributes' do
+      user = stub
+      profile = Legato::Management::Profile.new({"id" => 12345, "name" => "Profile 1"}, user)
+      profile.user.should == user
+      profile.id.should == 12345
+      profile.name.should == "Profile 1"
+    end
+
+    it 'returns an array of all profiles available to a user under an account' do
+      account = stub(:user => 'user', :path => 'accounts/12345')
+      Legato::Management::Profile.stubs(:all)
+
+      Legato::Management::Profile.for_account(account)
+
+      Legato::Management::Profile.should have_received(:all).with('user', 'accounts/12345/webproperties/~all/profiles')
+    end
+
+    it 'returns an array of all profiles available to a user under an web property' do
+      web_property = stub(:user => 'user', :path => 'accounts/~all/webproperties/12345')
+      Legato::Management::Profile.stubs(:all)
+
+      Legato::Management::Profile.for_web_property(web_property)
+
+      Legato::Management::Profile.should have_received(:all).with('user', 'accounts/~all/webproperties/12345/profiles')
+    end
+  end
+
+  context "A Profile instance" do
+    it 'builds the path for the profile from the id' do
+      web_property = Legato::Management::Profile.new({"id" => 12345}, stub)
+      web_property.path.should == '/accounts/~all/webproperties/~all/profiles/12345'
+    end
+  end
+end
+

data/spec/lib/legato/management/web_property_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Legato::Management::WebProperty do
+  context "The WebProperty class" do
+    def self.subject_class_name
+      "web properties"
+    end
+
+    it_behaves_like "a management finder"
+
+    it 'creates a new web property instance from a hash of attributes' do
+      user = stub
+      web_property = Legato::Management::WebProperty.new({"id" => 12345, "name" => "WebProperty 1", "websiteUrl" => "http://google.com"}, user)
+      web_property.user.should == user
+      web_property.id.should == 12345
+      web_property.name.should == "WebProperty 1"
+      web_property.website_url.should == 'http://google.com'
+    end
+
+    it 'returns an array of all web properties available to a user under an account' do
+      account = stub(:user => 'user', :path => 'accounts/12345')
+      Legato::Management::WebProperty.stubs(:all)
+      Legato::Management::WebProperty.for_account(account)
+      Legato::Management::WebProperty.should have_received(:all).with('user', 'accounts/12345/webproperties')
+    end
+  end
+
+  context "A WebProperty instance" do
+    it 'builds the path for the web_property from the id' do
+      web_property = Legato::Management::WebProperty.new({"id" => 123456}, stub)
+      web_property.path.should == '/accounts/~all/webproperties/123456'
+    end
+  end
+end

data/spec/lib/legato/model_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe "Legato::Model" do
+  context "A Class extended with Legato::Model" do
+    def new_model_class
+      Class.new.tap do |klass|
+        klass.extend(Legato::Model)
+      end
+    end
+
+    before :each do
+      @model = new_model_class
+    end
+
+    it 'has a metric' do
+      @model.metrics :exits
+      @model.metrics.should == Legato::ListParameter.new(:metrics, [:exits])
+    end
+
+    it 'has metrics' do
+      @model.metrics :exits, :pageviews
+      @model.metrics.should == Legato::ListParameter.new(:metrics, [:exits, :pageviews])
+    end
+
+    it 'has a dimension' do
+      @model.dimensions :browser
+      @model.dimensions.should == Legato::ListParameter.new(:dimensions, [:browser])
+    end
+
+    it 'has dimensions' do
+      @model.dimensions :browser, :city
+      @model.dimensions.should == Legato::ListParameter.new(:dimensions, [:browser, :city])
+    end
+
+    context "with filters" do
+      before :each do
+        @block = lambda {}
+      end
+
+      it 'creates a class method' do
+        @model.filter :high, @block
+        @model.respond_to?(:high).should be_true
+      end
+
+      it 'stores the filter' do
+        @model.filter :high, @block
+        @model.filters[:high].should == @block
+      end
+
+      it 'returns a Query instance for a filter' do
+        query = stub(:apply_filter => "a query")
+        Legato::Query.stubs(:new).returns(query)
+
+        @model.filter :high, @block
+        @model.high('arg1').should == 'a query'
+
+        Legato::Query.should have_received(:new).with(@model)
+        query.should have_received(:apply_filter).with('arg1', @block)
+      end
+    end
+
+    # xit 'has an instance klass'
+    # xit 'sets an instance klass'
+
+    it 'has results' do
+      options = {}
+      profile = stub
+      query = stub(:results => "a query")
+      Legato::Query.stubs(:new).returns(query)
+
+      @model.results(profile, options).should == "a query"
+
+      Legato::Query.should have_received(:new).with(@model)
+      query.should have_received(:results).with(profile, options)
+    end
+  end
+end

data/spec/lib/legato/query_spec.rb

@@ -0,0 +1,324 @@
+require 'spec_helper'
+
+describe Legato::Query do
+  def self.it_defines_operators(*operators)
+    operators.each do |operator|
+      it "creates a method for the operator #{operator}" do
+        @query.respond_to?(operator).should be_true
+      end
+
+      it "returns a new filter for #{operator} to the set" do
+        Legato::Filter.stubs(:new).returns("a filter")
+        filter = @query.send(operator, :key, 2000)
+        Legato::Filter.should have_received(:new).with(:key, operator, 2000)
+      end
+    end
+  end
+
+  context "a query" do
+    before :each do
+      @klass = Class.new
+      @block = lambda {eql(:key, 1000)}
+      @klass.stubs(:filters).returns({:high => @block})
+
+      @query = Legato::Query.new(@klass)
+    end
+
+    it 'knows the parent class' do
+      @query.parent_klass.should == @klass
+    end
+
+    it 'defaults to an empty filter set' do
+      @query.filters.to_params.should == Legato::FilterSet.new.to_params
+    end
+
+    it 'has filters defined from the parent class' do
+      @query.respond_to?(:high).should be_true
+    end
+
+    it "has filter methods that call apply with the given block" do
+      @query.stubs(:apply_filter)
+      @query.high('hi')
+      @query.should have_received(:apply_filter).with('hi', @block)
+    end
+
+    it 'does not load results by default' do
+      @query.loaded?.should == false
+    end
+
+    it "loads a collection of results" do
+      response = stub(:collection => [])
+      user = stub(:request => response)
+      @query.stubs(:profile => stub(:user => user))
+
+      @query.load
+
+      @query.loaded?.should be_true
+      @query.profile.user.should have_received(:request).with(@query)
+      response.should have_received(:collection)
+    end
+
+    it "returns the collection" do
+      @query.stubs(:request_for_query).returns(stub(:collection => [1,2,3]))
+      @query.load
+      @query.collection.should == [1,2,3]
+      @query.to_a.should == [1,2,3]
+    end
+
+    it "behaves like an enumerable delegating to the collection" do
+      collection = []
+      collection.stubs(:each)
+      @query.stubs(:collection).returns(collection)
+      @query.stubs(:loaded?).returns(true)
+
+      @query.each {}
+
+      collection.should have_received(:each)
+    end
+
+    it 'has a profile id after being given a profile' do
+      profile = stub(:id => '1234567890')
+      @query.stubs(:profile).returns(profile)
+
+      @query.profile_id.should == 'ga:1234567890'
+
+      profile.should have_received(:id)
+    end
+
+    it 'has no profile id by default' do
+      @query.stubs(:profile).returns(nil)
+      @query.profile_id.should be_nil
+    end
+
+    it 'sets the profile and applies options, returns itself' do
+      @query.stubs(:profile=)
+      @query.stubs(:apply_options)
+
+      @query.results('profile').should == @query
+
+      @query.should have_received(:profile=).with('profile')
+      @query.should have_received(:apply_options).with({})
+    end
+
+    context 'when applying filters' do
+      before :each do
+        @filter = Legato::Filter.new(:key, :eql, 1000)
+        @query.stubs(:eql).returns(@filter)
+
+        @filters = stub(:<<)
+        @query.stubs(:filters).returns(@filters)
+      end
+
+      it 'returns the query' do
+        @query.apply_filter(@block).should == @query
+      end
+
+      it 'executes the block' do
+        @query.apply_filter(@block)
+        @query.should have_received(:eql).with(:key, 1000)
+      end
+
+      it 'accepts a profile as the first argument' do
+        profile = Legato::Management::Profile.new({}, stub)
+        @query.apply_filter(profile, @block)
+        @query.should have_received(:eql)
+        @query.profile.should == profile
+      end
+
+      it 'accepts a profile as the last argument' do
+        profile = Legato::Management::Profile.new({}, stub)
+        block_with_arg = lambda {|count| eql(:key, count)}
+        @query.apply_filter(100, profile, block_with_arg)
+        @query.should have_received(:eql).with(:key, 100)
+        @query.profile.should == profile
+      end
+
+      it 'does not override the existing profile if none is provide' do
+        @query.profile = Legato::Management::Profile.new({}, stub)
+        block_with_arg = lambda {|count| eql(:key, count)}
+        @query.apply_filter(100, block_with_arg)
+        @query.profile.should_not == nil
+      end
+
+      it 'adds to the filter set' do
+        @query.apply_filter(@block)
+
+        @filters.should have_received(:<<).with(@filter)
+      end
+
+      it 'joins an array of filters with OR' do
+        block = lambda {|*browsers| browsers.map {|browser| eql(:browser, browser)}}
+        @filter.stubs(:join_character=)
+
+        @query.apply_filter('chrome', 'safari', block)
+
+        @filter.should have_received(:join_character=).with(Legato.and_join_character)
+        @filter.should have_received(:join_character=).with(Legato.or_join_character)
+      end
+    end
+
+    context "when applying options" do
+      it "returns the query" do
+        @query.apply_options({}).should == @query
+      end
+
+      it "stores the order" do
+        @query.apply_options({:order => [:page_path]})
+        @query.order.should == Legato::ListParameter.new(:order, [:page_path])
+      end
+
+      it 'replaces the order' do
+        @query.order = [:pageviews]
+        @query.apply_options({:order => [:page_path]})
+        @query.order.should == Legato::ListParameter.new(:order, [:page_path])
+      end
+
+      it "does not replace order if option is omitted" do
+        @query.order = [:pageviews]
+        @query.apply_options({})
+        @query.order.should == Legato::ListParameter.new(:order, [:pageviews])
+      end
+
+      it "moves :sort option into order" do
+        @query.apply_options({:sort => [:page_path]})
+        @query.order.should == Legato::ListParameter.new(:order, [:page_path])
+      end
+
+      it "sets the limit" do
+        @query.apply_options({:limit => 100})
+        @query.limit.should == 100
+      end
+
+      it "replaces the limit" do
+        @query.limit = 200
+        @query.apply_options({:limit => 100})
+        @query.limit.should == 100
+      end
+
+      it "does not replace the limit if option is omitted" do
+        @query.limit = 200
+        @query.apply_options({})
+        @query.limit.should == 200
+      end
+
+      it "sets the offset" do
+        @query.apply_options({:offset => 100})
+        @query.offset.should == 100
+      end
+
+      it "replaces the offset" do
+        @query.offset = 200
+        @query.apply_options({:offset => 100})
+        @query.offset.should == 100
+      end
+
+      it "does not replace offset if option is omitted" do
+        @query.offset = 200
+        @query.apply_options({})
+        @query.offset.should == 200
+      end
+
+      context "with Time" do
+        before :each do
+          @now = Time.now
+          Time.stubs(:now).returns(@now)
+        end
+
+        it 'defaults the start date to 30 days ago' do
+        end
+
+        it "replaces the start date" do
+          @query.apply_options({:start_date => (@now-2000)})
+          @query.start_date.should == (@now-2000)
+        end
+
+        it "does not replace the start date if option is omitted" do
+          @query.apply_options({})
+          Legato.format_time(@query.start_date).should == Legato.format_time(@now-Legato::Query::MONTH)
+        end
+
+        it "replaces the end date" do
+          @query.apply_options({:end_date => (@now+2000)})
+          @query.end_date.should == (@now+2000)
+        end
+
+        it "does not replace the end date if option is omitted" do
+          @query.apply_options({})
+          Legato.format_time(@query.end_date).should == Legato.format_time(@now)
+        end
+      end
+    end
+
+    it_defines_operators :eql, :not_eql, :gt, :gte, :lt, :lte, :matches,
+      :does_not_match, :contains, :does_not_contain, :substring, :not_substring
+
+    context "as a hash of parameters" do
+      before :each do
+        @query.stubs(:metrics).returns(nil)
+        @query.stubs(:dimensions).returns(nil)
+        @query.stubs(:filters).returns(stub(:to_params => nil))
+      end
+
+      it 'includes the profile id' do
+        @query.stubs(:profile_id).returns('ga:1234567890')
+
+        @query.to_params.should == {
+          'ids' => 'ga:1234567890',
+          'start-date' => Legato.format_time(Time.now-Legato::Query::MONTH),
+          'end-date' => Legato.format_time(Time.now)
+        }
+      end
+
+      it 'includes the start and end dates' do
+        now = Time.now
+        @query.start_date = now
+        @query.end_date = now
+        @query.to_params.should == {'start-date' => Legato.format_time(now), 'end-date' => Legato.format_time(now)}
+      end
+
+      it 'includes the limit' do
+        @query.limit = 1000
+        @query.to_params['max-results'].should == 1000
+      end
+
+      it 'includes the offset' do
+        @query.offset = 50
+        @query.to_params['start-index'].should == 50
+      end
+
+      it 'includes filters' do
+        filters = stub(:to_params => 'filter set parameters')
+        @query.stubs(:filters).returns(filters)
+
+        @query.to_params['filters'].should == 'filter set parameters'
+      end
+
+      it 'includes metrics' do
+        metrics = Legato::ListParameter.new(:metrics)
+        metrics.stubs(:to_params).returns({'metrics' => 'pageviews,exits'})
+        metrics.stubs(:empty?).returns(false)
+        @query.stubs(:metrics).returns(metrics)
+
+        @query.to_params['metrics'].should == 'pageviews,exits'
+      end
+
+      it 'includes dimensions' do
+        dimensions = Legato::ListParameter.new(:dimensions)
+        dimensions.stubs(:to_params).returns({'dimensions' => 'browser,country'})
+        dimensions.stubs(:empty?).returns(false)
+        @query.stubs(:dimensions).returns(dimensions)
+
+        @query.to_params['dimensions'].should == 'browser,country'
+      end
+
+      it 'includes order' do
+        order = Legato::ListParameter.new(:order)
+        order.stubs(:to_params).returns({'order' => 'pageviews'})
+        order.stubs(:empty?).returns(false)
+        @query.stubs(:order).returns(order)
+
+        @query.to_params['order'].should == 'pageviews'
+      end
+    end
+  end
+end

data/spec/lib/legato/response_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Legato::Response do
+  context "An instance of Response" do
+    before :each do
+      raw_body = File.read(File.dirname(__FILE__) + '/../../fixtures/simple_response.json')
+
+      @response = Legato::Response.new(stub(:body => raw_body))
+    end
+
+    it 'has a collection of OpenStruct instances' do
+      @response.collection.first.should == OpenStruct.new({:browser=>"Android Browser", :pageviews=>"93"})
+    end
+  end
+end

data/spec/lib/legato/user_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Legato::User do
+  context "an instance of Legato::User" do
+    before :each do
+      @access_token = stub
+      @user = Legato::User.new(@access_token)
+    end
+
+    it 'returns a response for a given query' do
+      @access_token.stubs(:get).returns('a response')
+      Legato::Response.stubs(:new)
+
+      @user.request(stub(:to_params => "params"))
+
+      Legato::Response.should have_received(:new).with('a response')
+      @access_token.should have_received(:get).with(Legato::User::URL, :params => "params")
+    end
+
+    it 'has accounts' do
+      Legato::Management::Account.stubs(:all)
+      @user.accounts
+      Legato::Management::Account.should have_received(:all).with(@user)
+    end
+
+    it 'has web_properties' do
+      Legato::Management::WebProperty.stubs(:all)
+      @user.web_properties
+      Legato::Management::WebProperty.should have_received(:all).with(@user)
+    end
+
+    it 'has profiles' do
+      Legato::Management::Profile.stubs(:all)
+      @user.profiles
+      Legato::Management::Profile.should have_received(:all).with(@user)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require 'bundler'
+Bundler.setup(:test)
+
+require 'rspec'
+require 'mocha'
+require 'bourne'
+require 'vcr'
+
+require File.expand_path('../../lib/legato', __FILE__)
+
+Dir["./spec/support/**/*.rb"].each {|f| require f}
+
+VCR.configure do |config|
+  config.cassette_library_dir = File.expand_path('../cassettes', __FILE__)
+  config.default_cassette_options = {:record => :new_episodes, :serialize_with => :json}
+end
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+
+  config.extend VCR::RSpec::Macros
+  config.include Support::Macros::OAuth
+end

data/spec/support/examples/management_finder.rb

@@ -0,0 +1,18 @@
+shared_examples_for "a management finder" do
+  it "returns an array of all #{subject_class_name} available to a user" do
+    JSON.stubs(:parse).returns({'items' => ['item1', 'item2']})
+    response = stub(:body => 'some json')
+    access_token = stub(:get => response)
+    user = stub(:access_token => access_token)
+    described_class.stubs(:new).returns('thing1', 'thing2')
+
+    described_class.all(user).should == ['thing1', 'thing2']
+
+    user.should have_received(:access_token)
+    access_token.should have_received(:get).with('https://www.googleapis.com/analytics/v3/management'+described_class.default_path)
+    response.should have_received(:body)
+    JSON.should have_received(:parse).with('some json')
+    described_class.should have_received(:new).with('item1', user)
+    described_class.should have_received(:new).with('item2', user)
+  end
+end

data/spec/support/macros/oauth.rb

@@ -0,0 +1,26 @@
+module Support
+  module Macros
+    module OAuth
+      def token
+        # fill me in if you add more tests here, use the rake task oauth:token, update vcr to :record => :all
+        "ya29.AHES6ZREobGegWLc3tyxuuQAkKF7lg071UgpTeLe_4jTcV35uW8"
+      end
+
+      def client
+        opts = {
+          :authorize_url => 'https://accounts.google.com/o/oauth2/auth',
+          :token_url => 'https://accounts.google.com/o/oauth2/token'
+        }
+
+        OAuth2::Client.new('779170787975.apps.googleusercontent.com', 'mbCISoZiSwyVQIDEbLj4EeEc', opts) do |builder|
+          builder.use VCR::Middleware::Faraday
+          builder.adapter :net_http
+        end
+      end
+
+      def access_token
+        OAuth2::AccessToken.new(client, token)
+      end
+    end
+  end
+end