legato 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 304acd2f0f716bf682b425bea037c4445afc97fd
-  data.tar.gz: 4443a2410d7c782ae282bd4913ae5f5e6730cadd
+  metadata.gz: b9077eb3bf7200ccae8aaa176ae3199c983501ca
+  data.tar.gz: efd2b61790708f18b5be1bf612ae3267b99de0bd
 SHA512:
-  metadata.gz: d978c8ac87bcab86a9ac8003b7afb18735f8f7281203bb186f23d0cc773a33b2ac1cd5750f502ad1ed0490a47189c6311d63f5e09f005452614dc69a750ac501
-  data.tar.gz: c1d37f5c5b819ae0c14fc7a88b486165c5ad000d1762550ee8e12a15cbe63d36668c7fc69b743dcc22cda394a3cf76862ba651db1f522849a7e0e7749bb02b8c
+  metadata.gz: d90896b83ec99911d48a493cd990c731f5a6e05a11551162510ac2956339c343a0262730e065dddcc0690fbcefcdd024a8228c45e4c146c6055d85ba481ce0c0
+  data.tar.gz: 88fd641061a3b056833dba164ee8c7b22a9318c9b6fd922b687626f82f6f26da61c8cf85237ebb4f941200edba58b1f1eda96221f3028c4934744719dc978c7a

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## Legato 0.6.1 ##
+
+* Fix bug in `Query` where calling `results` did not retain previous basic options
+
+    *Tony Pitale*
+
 ## Legato 0.6.0 ##
 
 * Fix bug in `Query` where calling `results` after loading a collection would not load new data into the collection

data/lib/legato/query.rb

@@ -5,6 +5,11 @@ module Legato
     MONTH = 2592000
     REQUEST_FIELDS = 'columnHeaders/name,rows,totalResults,totalsForAllResults'
 
+    BASIC_OPTION_KEYS = [
+      :sort, :limit, :offset, :start_date, :end_date, :quota_user,
+      :user_ip, :sampling_level, :segment_id
+    ]
+
     VALID_TRACKING_SCOPES = {
       'ga' => 'ga',
       'mcf' => 'mcf',
@@ -101,11 +106,16 @@ module Legato
     end
 
     def apply_basic_options(options)
-      [:sort, :limit, :offset, :start_date, :end_date, :quota_user, :user_ip, :sampling_level, :segment_id].each do |key| #:segment
+      BASIC_OPTION_KEYS.each do |key| #:segment
         self.send("#{key}=".to_sym, options[key]) if options.has_key?(key)
       end
     end
 
+    # return a hash of basic options to merge
+    def basic_options
+      Hash[BASIC_OPTION_KEYS.map { |k| [k, send(k)] }].reject {|_,v| v.nil?}
+    end
+
     # def apply_filter_options(filter_options)
     #   join_character = Legato.and_join_character
     #
@@ -173,7 +183,7 @@ module Legato
       options, profile = profile, self.profile if profile.is_a?(Hash)
 
       query.profile = profile
-      query.apply_options(options)
+      query.apply_options(self.basic_options.merge(options))
       query
     end
 

data/lib/legato/version.rb

@@ -1,3 +1,3 @@
 module Legato
-  VERSION = "0.6.0"
+  VERSION = "0.6.1"
 end

data/spec/lib/legato/query_spec.rb

@@ -16,149 +16,154 @@ describe Legato::Query do
   end
 
   context "a query" do
+    let(:klass) { Class.new.tap { |k| k.extend(Legato::Model)} }
+    let(:query) { Legato::Query.new(klass) }
+
+    let(:default_options) { {:start_date => query.start_date, :end_date => query.end_date} }
+
     before :each do
-      @klass = Class.new
-      @klass.extend(Legato::Model)
-      @block = lambda {eql(:key, 1000)}
+      @klass = klass
       @klass.stubs(:filters).returns({:high => @block})
       @klass.stubs(:segments).returns([])
 
-      @query = Legato::Query.new(@klass)
+      @block = lambda {eql(:key, 1000)}
+
+      @query = query
     end
 
     it 'knows the parent class' do
-      @query.parent_klass.should == @klass
+      query.parent_klass.should == @klass
     end
 
     it 'defaults to an empty filter set' do
-      @query.filters.to_params.should == Legato::FilterSet.new.to_params
+      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 eq(true)
+      query.respond_to?(:high).should eq(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')
+      query.stubs(:apply_filter)
+      query.high('hi')
+      query.should have_received(:apply_filter).with('hi')
     end
 
     it 'does not load results by default' do
-      @query.loaded?.should == false
+      query.loaded?.should == false
     end
 
     it 'delegates the instance klass from the parent klass' do
       klass = Class.new
-      @query.parent_klass.stubs(:instance_klass).returns(klass)
-      @query.instance_klass.should == klass
+      query.parent_klass.stubs(:instance_klass).returns(klass)
+      query.instance_klass.should == klass
     end
 
     it "loads a collection of results" do
       response = stub(:collection => [], :total_results => 0, :totals_for_all_results => {})
       user = stub(:request => response)
-      @query.stubs(:profile => stub(:user => user))
+      query.stubs(:profile => stub(:user => user))
 
-      @query.load
+      query.load
 
-      @query.loaded?.should eq(true)
-      @query.profile.user.should have_received(:request).with(@query)
+      query.loaded?.should eq(true)
+      query.profile.user.should have_received(:request).with(query)
       response.should have_received(:collection)
       response.should have_received(:total_results)
       response.should have_received(:totals_for_all_results)
     end
 
     it "returns the collection" do
-      @query.stubs(:request_for_query).returns(stub(:collection => [1,2,3], :total_results => 3, :totals_for_all_results => {'foo' => 34.2}))
-      @query.load
-      @query.collection.should == [1,2,3]
-      @query.to_a.should == [1,2,3]
+      query.stubs(:request_for_query).returns(stub(:collection => [1,2,3], :total_results => 3, :totals_for_all_results => {'foo' => 34.2}))
+      query.load
+      query.collection.should == [1,2,3]
+      query.to_a.should == [1,2,3]
     end
 
     it "returns the total number of results" do
-      @query.stubs(:request_for_query).returns(stub(:collection => [1,2,3], :total_results => 3, :totals_for_all_results => {'foo' => 34.2}))
-      @query.load
-      @query.total_results.should == 3
+      query.stubs(:request_for_query).returns(stub(:collection => [1,2,3], :total_results => 3, :totals_for_all_results => {'foo' => 34.2}))
+      query.load
+      query.total_results.should == 3
     end
 
     it "returns the totals for all results" do
-      @query.stubs(:request_for_query).returns(stub(:collection => [1,2,3], :total_results => 3, :totals_for_all_results => {'foo' => 34.2}))
-      @query.load
-      @query.totals_for_all_results.should == {'foo' => 34.2}
+      query.stubs(:request_for_query).returns(stub(:collection => [1,2,3], :total_results => 3, :totals_for_all_results => {'foo' => 34.2}))
+      query.load
+      query.totals_for_all_results.should == {'foo' => 34.2}
     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.stubs(:collection).returns(collection)
+      query.stubs(:loaded?).returns(true)
 
-      @query.each {}
+      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.stubs(:profile).returns(profile)
 
-      @query.profile_id.should == 'ga:1234567890'
+      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
+      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.stubs(:profile=)
+      query.stubs(:apply_options)
 
-      @query.results('profile').should == @query
+      query.results('profile').should == query
 
-      @query.should have_received(:profile=).with('profile')
-      @query.should have_received(:apply_options).with({})
+      query.should have_received(:profile=).with('profile')
+      query.should have_received(:apply_options).with(default_options)
     end
 
     it 'sets options and returns self' do
-      profile = @query.profile
-      @query.stubs(:profile=)
-      @query.stubs(:apply_options)
+      profile = query.profile
+      query.stubs(:profile=)
+      query.stubs(:apply_options)
 
-      @query.results({:sort => [:city]}).should == @query
+      query.results({:sort => [:city]}).should == query
 
-      @query.should have_received(:profile=).with(profile)
-      @query.should have_received(:apply_options).with({:sort => [:city]})
+      query.should have_received(:profile=).with(profile)
+      query.should have_received(:apply_options).with(default_options.merge({:sort => [:city]}))
     end
 
     it 'creates a new query if collection has already been loaded' do
-      @query.stubs(:loaded?).returns(true)
+      query.stubs(:loaded?).returns(true)
 
-      new_query = @query.results({offset: 10_000})
+      new_query = query.results({offset: 10_000})
 
-      expect(new_query).to_not eql(@query)
+      expect(new_query).to_not eql(query)
       expect(new_query.offset).to eql(10_000)
     end
 
     context "when modifying dimensions" do
       it 'changes the query dimensions' do
-        @query.dimensions << :city
-        @query.dimensions.include?(:city).should eq(true)
+        query.dimensions << :city
+        query.dimensions.include?(:city).should eq(true)
       end
 
       it 'does not change the parent class dimensions' do
         empty_dimensions = Legato::ListParameter.new(:dimensions, [])
 
-        @query.dimensions << :city
+        query.dimensions << :city
         @klass.dimensions.should eq(empty_dimensions)
       end
 
       it 'accepts an array of dimensions' do
-        @query.dimensions << [:city, :browser]
-        @query.dimensions.include?(:city).should eq(true)
-        @query.dimensions.include?(:browser).should eq(true)
+        query.dimensions << [:city, :browser]
+        query.dimensions.include?(:city).should eq(true)
+        query.dimensions.include?(:browser).should eq(true)
       end
 
       it 'does not share metrics across queries' do
@@ -172,21 +177,21 @@ describe Legato::Query do
 
     context "when modifying metrics" do
       it 'changes the query metrics' do
-        @query.metrics << :pageviews
-        @query.metrics.include?(:pageviews).should eq(true)
+        query.metrics << :pageviews
+        query.metrics.include?(:pageviews).should eq(true)
       end
 
       it 'does not change the parent class metrics' do
         empty_metrics = Legato::ListParameter.new(:metrics, [])
 
-        @query.metrics << :pageviews
+        query.metrics << :pageviews
         @klass.metrics.should eq(empty_metrics)
       end
 
       it 'accepts an array of metrics' do
-        @query.metrics << [:pageviews, :sessions]
-        @query.metrics.include?(:pageviews).should eq(true)
-        @query.metrics.include?(:sessions).should eq(true)
+        query.metrics << [:pageviews, :sessions]
+        query.metrics.include?(:pageviews).should eq(true)
+        query.metrics.include?(:sessions).should eq(true)
       end
 
       it 'does not share metrics across queries' do
@@ -201,45 +206,45 @@ describe Legato::Query do
     context 'when applying filters' do
       before :each do
         @filter = Legato::Filter.new(:key, :eql, 1000, nil)
-        @query.stubs(:eql).returns(@filter)
+        query.stubs(:eql).returns(@filter)
 
         @filters = stub(:<<)
-        @query.stubs(:filters).returns(@filters)
+        query.stubs(:filters).returns(@filters)
       end
 
       it 'returns the query' do
-        @query.apply_filter(&@block).should == @query
+        query.apply_filter(&@block).should == query
       end
 
       it 'executes the block' do
-        @query.apply_filter(&@block)
-        @query.should have_received(:eql).with(:key, 1000)
+        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
+        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
+        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)
+        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
+        query.apply_filter(100, &block_with_arg)
+        query.profile.should_not == nil
       end
 
       it 'adds to the filter set' do
-        @query.apply_filter(&@block)
+        query.apply_filter(&@block)
 
         @filters.should have_received(:<<).with(@filter)
       end
@@ -248,7 +253,7 @@ describe Legato::Query do
         block = lambda {|*browsers| browsers.map {|browser| eql(:browser, browser)}}
         @filter.stubs(:join_character=)
 
-        @query.apply_filter('chrome', 'safari', &block)
+        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)
@@ -257,86 +262,86 @@ describe Legato::Query do
 
     context "when applying options" do
       it "returns the query" do
-        @query.apply_options({}).should == @query
+        query.apply_options({}).should == query
       end
 
       it "stores the sort" do
-        @query.apply_options({:sort => [:page_path]})
-        @query.sort.should == Legato::ListParameter.new(:sort, [:page_path])
+        query.apply_options({:sort => [:page_path]})
+        query.sort.should == Legato::ListParameter.new(:sort, [:page_path])
       end
 
       it 'replaces the sort' do
-        @query.sort = [:pageviews]
-        @query.apply_options({:sort => [:page_path]})
-        @query.sort.should == Legato::ListParameter.new(:sort, [:page_path])
+        query.sort = [:pageviews]
+        query.apply_options({:sort => [:page_path]})
+        query.sort.should == Legato::ListParameter.new(:sort, [:page_path])
       end
 
       it "does not replace sort if option is omitted" do
-        @query.sort = [:pageviews]
-        @query.apply_options({})
-        @query.sort.should == Legato::ListParameter.new(:sort, [:pageviews])
+        query.sort = [:pageviews]
+        query.apply_options({})
+        query.sort.should == Legato::ListParameter.new(:sort, [:pageviews])
       end
 
       it "moves :sort option into sort" do
-        @query.apply_options({:sort => [:page_path]})
-        @query.sort.should == Legato::ListParameter.new(:sort, [:page_path])
+        query.apply_options({:sort => [:page_path]})
+        query.sort.should == Legato::ListParameter.new(:sort, [:page_path])
       end
 
       it "sets the limit" do
-        @query.apply_options({:limit => 100})
-        @query.limit.should == 100
+        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
+        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
+        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
+        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
+        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
+        query.offset = 200
+        query.apply_options({})
+        query.offset.should == 200
       end
 
       it "sets the quota_user" do
-        @query.apply_options({:quota_user => 'an id'})
-        @query.quota_user.should == 'an id'
+        query.apply_options({:quota_user => 'an id'})
+        query.quota_user.should == 'an id'
       end
 
       it "replaces the quota_user" do
-        @query.quota_user = 'an id'
-        @query.apply_options({:quota_user => 'a different id'})
-        @query.quota_user.should == 'a different id'
+        query.quota_user = 'an id'
+        query.apply_options({:quota_user => 'a different id'})
+        query.quota_user.should == 'a different id'
       end
 
       it "does not replace quota_user if option is omitted" do
-        @query.quota_user = 'an id'
-        @query.apply_options({})
-        @query.quota_user.should == 'an id'
+        query.quota_user = 'an id'
+        query.apply_options({})
+        query.quota_user.should == 'an id'
       end
 
       it "sets the segment_id" do
         segment_id = '123122534'
-        @query.apply_options({:segment_id => segment_id})
-        @query.segment_id.should == "gaid::#{segment_id}"
+        query.apply_options({:segment_id => segment_id})
+        query.segment_id.should == "gaid::#{segment_id}"
       end
 
       context "with Time" do
@@ -349,46 +354,46 @@ describe Legato::Query do
         end
 
         it "replaces the start date" do
-          @query.apply_options({:start_date => (@now-2000)})
-          @query.start_date.should == (@now-2000)
+          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)
+          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)
+          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)
+          query.apply_options({})
+          Legato.format_time(query.end_date).should == Legato.format_time(@now)
         end
       end
     end
 
     context "with the scope set" do
       it 'raises when an invalid scope is passed in' do
-        @query.tracking_scope = "what"
-        expect { @query.base_url }.to raise_error
+        query.tracking_scope = "what"
+        expect { query.base_url }.to raise_error
       end
 
       it 'sets the correct endpoint url' do
-        @query.tracking_scope = "mcf"
-        expect(@query.base_url).to eql("https://www.googleapis.com/analytics/v3/data/mcf")
+        query.tracking_scope = "mcf"
+        expect(query.base_url).to eql("https://www.googleapis.com/analytics/v3/data/mcf")
       end
 
       it 'has the correct api endpoint' do
-        @query.tracking_scope = "ga"
-        expect(@query.base_url).to eql("https://www.googleapis.com/analytics/v3/data/ga")
+        query.tracking_scope = "ga"
+        expect(query.base_url).to eql("https://www.googleapis.com/analytics/v3/data/ga")
       end
 
       it 'has the realtime api endpoint' do
-        @query.tracking_scope = "rt"
-        expect(@query.base_url).to eql("https://www.googleapis.com/analytics/v3/data/realtime")
+        query.tracking_scope = "rt"
+        expect(query.base_url).to eql("https://www.googleapis.com/analytics/v3/data/realtime")
       end
     end
 
@@ -397,15 +402,15 @@ describe Legato::Query do
 
     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))
+        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.stubs(:profile_id).returns('ga:1234567890')
 
-        @query.to_params.should == {
+        query.to_params.should == {
           'ids' => 'ga:1234567890',
           'start-date' => Legato.format_time(Time.now-Legato::Query::MONTH),
           'fields' => Legato::Query::REQUEST_FIELDS,
@@ -415,9 +420,9 @@ describe Legato::Query do
 
       it 'includes the start and end dates' do
         now = Time.now
-        @query.start_date = now
-        @query.end_date = now
-        @query.to_params.should == {
+        query.start_date = now
+        query.end_date = now
+        query.to_params.should == {
           'start-date' => Legato.format_time(now),
           'fields' => Legato::Query::REQUEST_FIELDS,
           'end-date' => Legato.format_time(now)
@@ -425,10 +430,10 @@ describe Legato::Query do
       end
 
       it "supports string formatted dates" do
-        @query.start_date = "2014-01-01"
-        @query.end_date = "yesterday"
+        query.start_date = "2014-01-01"
+        query.end_date = "yesterday"
 
-        @query.to_params.should == {
+        query.to_params.should == {
           'start-date' => "2014-01-01",
           'end-date' => "yesterday",
           'fields' => Legato::Query::REQUEST_FIELDS,
@@ -436,86 +441,86 @@ describe Legato::Query do
       end
 
       it 'includes the limit' do
-        @query.limit = 1000
-        @query.to_params['max-results'].should == 1000
+        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
+        query.offset = 50
+        query.to_params['start-index'].should == 50
       end
 
       it 'includes the quotaUser if quota_user is set' do
-        @query.quota_user = 'an id'
-        @query.to_params['quotaUser'].should == 'an id'
+        query.quota_user = 'an id'
+        query.to_params['quotaUser'].should == 'an id'
       end
 
       it 'excludes the quotaUser if quota_user is not set' do
-        @query.to_params.keys.should_not include('quotaUser')
+        query.to_params.keys.should_not include('quotaUser')
       end
 
       it 'includes the samplingLevel if sampling_level is set' do
-        @query.sampling_level = 'FASTER'
-        @query.to_params['samplingLevel'].should == 'FASTER'
+        query.sampling_level = 'FASTER'
+        query.to_params['samplingLevel'].should == 'FASTER'
       end
 
       it 'excludes the samplingLevel if sampling_level is not set' do
-        @query.to_params.keys.should_not include('samplingLevel')
+        query.to_params.keys.should_not include('samplingLevel')
       end
 
       it 'includes filters' do
         filters = stub(:to_params => 'filter set parameters')
-        @query.stubs(:filters).returns(filters)
+        query.stubs(:filters).returns(filters)
 
-        @query.to_params['filters'].should == 'filter set parameters'
+        query.to_params['filters'].should == 'filter set parameters'
       end
 
       it 'includes the session level conditional segment' do
         segment_filters = stub(:to_params => 'ga::parameter', :any? => true)
-        @query.stubs(:segment_filters).returns(segment_filters)
+        query.stubs(:segment_filters).returns(segment_filters)
 
-        @query.to_params['segment'].should == 'sessions::condition::ga::parameter'
+        query.to_params['segment'].should == 'sessions::condition::ga::parameter'
       end
 
       it 'includes segment_id' do
-        @query.stubs(:segment_id).returns('gaid::12453453')
+        query.stubs(:segment_id).returns('gaid::12453453')
 
-        @query.to_params['segment'].should == 'gaid::12453453'
+        query.to_params['segment'].should == 'gaid::12453453'
       end
 
       it 'includes segment_id and segment_filters' do
         segment_filters = stub(:to_params => 'ga::parameter', :any? => true)
-        @query.stubs(:segment_filters).returns(segment_filters)
-        @query.stubs(:segment_id).returns('gaid::12453453')
+        query.stubs(:segment_filters).returns(segment_filters)
+        query.stubs(:segment_id).returns('gaid::12453453')
 
-        @query.to_params['segment'].should == 'gaid::12453453'
+        query.to_params['segment'].should == 'gaid::12453453'
       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.stubs(:metrics).returns(metrics)
 
-        @query.to_params['metrics'].should == 'pageviews,exits'
+        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.stubs(:dimensions).returns(dimensions)
 
-        @query.to_params['dimensions'].should == 'browser,country'
+        query.to_params['dimensions'].should == 'browser,country'
       end
 
       it 'includes sort' do
         sort = Legato::ListParameter.new(:sort)
         sort.stubs(:to_params).returns({'sort' => 'pageviews'})
         sort.stubs(:empty?).returns(false)
-        @query.stubs(:sort).returns(sort)
+        query.stubs(:sort).returns(sort)
 
-        @query.to_params['sort'].should == 'pageviews'
+        query.to_params['sort'].should == 'pageviews'
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legato
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Tony Pitale