neuron-client 0.2.6 → 0.3.0

data/spec/lib/model/ad_spec.rb

@@ -0,0 +1,253 @@
+module Neuron
+  module Client
+    describe Ad do
+      before(:each) do
+        @datetime = "2011-11-11T11:11:11Z"
+        @minimal_attributes = {
+          'acudeo_program_id'          => nil,
+          'approved'                   => 'Yes',
+          'clickthru_url'              => nil,
+          'companion_ad_html'          => nil,
+          'daily_cap'                  => nil,
+          'day_partitions'             => nil,
+          'end_datetime'               => nil,
+          'frequency_cap'              => nil,
+          'geo_target_netacuity_ids'   => {},
+          'ideal_impressions_per_hour' => nil,
+          'name'                       => nil,
+          'overall_cap'                => nil,
+          'pixel_ids'                  => [],
+          'redirect_url'               => nil,
+          'response_type'              => nil,
+          'social_urls'                => nil,
+          'start_datetime'             => @datetime,
+          'time_zone'                  => "UTC",
+          'vast_tracker_urls'          => nil,
+          'vast_url'                   => nil,
+          'video_flv_url'              => nil,
+          'zone_links'                 => {},
+        }
+      end
+      context "when connected to the admin server" do
+        before(:each) do
+          @connection = stub(:connection)
+          API.stub(:default_api).and_return(stub(:default_api, :connection => @connection, :connection_type => :admin, :validate? => true))
+        end
+
+        describe "all" do
+          before(:each) do
+            @response = [{'ad' => {
+              'id' => 1,
+              'name' => nil
+            }}]
+          end
+          it "returns a list of Ads" do
+            @connection.stub(:get).with("ads").and_return(@response)
+            ads = Ad.all
+            ads.should be_a(Array)
+            ads.length.should be > 0
+            ads.first.should be_a(Ad)
+          end
+
+          it "makes a get call" do
+            @connection.should_receive(:get).with("ads").once.and_return(@response)
+            Ad.all
+          end
+        end
+
+        describe "find" do
+          before(:each) do
+            @response = {'ad' => @minimal_attributes.merge(
+              'id' => 1,
+              'name' => "Ad 1",
+              'response_type' => 'Redirect',
+              'redirect_url' => 'http://example.com/',
+              'created_at' => @datetime,
+              'updated_at' => @datetime,
+              'today_impressed' => 0,
+              'total_impressed' => 0
+            )}
+          end
+
+          it "returns a Ad" do
+            @connection.stub(:get).with("ads/1").and_return(@response)
+            ad = Ad.find(1)
+            ad.should be_a(Ad)
+          end
+
+          it "makes a get call" do
+            @connection.should_receive(:get).with("ads/1").once.and_return(@response)
+            Ad.find(1)
+          end
+        end
+
+        describe "create" do
+          before(:each) do
+            @attrs = @minimal_attributes.merge(
+              'name' => "Ad 1",
+              'response_type' => 'VideoAd',
+              'video_flv_url' => 'http://example.com/ad.flv',
+              'clickthru_url' => 'http://example.com/buycrap',
+              'companion_ad_html' => '<a href="http://example.com/">nana!</a>',
+              'social_urls' => {},
+              'vast_tracker_urls' => {}
+            )
+            @response = {'ad' => @attrs.merge({
+              'id' => 1,
+              'created_at' => @datetime,
+              'updated_at' => @datetime,
+              'total_impressed' => 0,
+              'today_impressed' => 0
+            })}
+          end
+
+          it "posts json" do
+            @connection.should_receive(:post).with("ads", {'ad' => @attrs}).once.and_return(@response)
+            Ad.create(@attrs)
+          end
+
+          it "returns the created Ad" do
+            @connection.should_receive(:post).and_return(@response)
+            ad = Ad.create(@attrs)
+            ad.id.should == 1
+            ad.name.should == "Ad 1"
+          end
+
+          it "returns the created Ad with vast_tracker_urls" do
+            trackers = {"impression" => ["http://www.google.com"]}
+            @attrs.merge!('vast_tracker_urls' => trackers)
+            response = {'ad' => @attrs.merge({
+              'id' => 1,
+              'created_at' => @datetime,
+              'updated_at' => @datetime,
+              'total_impressed' => 0,
+              'today_impressed' => 0
+            })}
+            @connection.should_receive(:post).and_return(response)
+            ad = Ad.create(@attrs)
+            ad.id.should == 1
+            ad.vast_tracker_urls.should == trackers
+          end
+        end
+
+        describe "update_attributes" do
+          it "makes a put call" do
+            attrs = @minimal_attributes.merge(
+              'id' => 1,
+              'name' => "Ad 1",
+              'response_type' => 'Redirect',
+              'redirect_url' => 'http://example.com'
+            )
+            ad = Ad.new(attrs)
+            updated_attrs = attrs.merge('name' => 'Ad 2')
+            @connection.should_receive(:put).with("ads/1", {'ad' => updated_attrs}).and_return({'ad' => updated_attrs.merge(
+              'created_at' => @datetime,
+              'updated_at' => @datetime,
+              'total_impressed' => 0,
+              'today_impressed' => 0
+            )})
+            ad.update_attributes('name' => "Ad 2")
+          end
+
+          it "makes a put call with vast_tracker_urls" do
+            trackers = {'impression' => ["http://testurl.com"]}
+            updated_trackers = {'impression' => ['http://testurl.com/new']}
+            attrs = @minimal_attributes.merge(
+              'id' => 1,
+              'response_type' => 'VideoAd',
+              'video_flv_url' => 'http://example.com/ad.flv',
+              'clickthru_url' => 'http://example.com/buycrap',
+              'companion_ad_html' => '<a href="http://example.com/">nana!</a>',
+              'social_urls' => {},
+              'vast_tracker_urls' => trackers
+            )
+            updated_attrs = attrs.merge('vast_tracker_urls' => updated_trackers)
+            ad = Ad.new(attrs)
+            @connection.should_receive(:put).with("ads/1", {'ad' => updated_attrs}).and_return({'ad' => updated_attrs.merge(
+              'created_at' => @datetime,
+              'updated_at' => @datetime,
+              'total_impressed' => 0,
+              'today_impressed' => 0              
+            )})
+            ad.update_attributes(updated_attrs)
+          end
+        end
+
+        describe "recent(statistic, by=nil)" do
+          it "should call the expected method and return the expected result" do
+            ad = Ad.new(@minimal_attributes.merge('id' => 7))
+            @connection.should_receive(:get).with('ads/7/recent/impressions', {'by' => 'zone'}).and_return('return_value')
+
+            ad.recent('impressions', 'zone').should == 'return_value'
+          end
+        end
+
+        describe "unlink(zone_id)" do
+          it "should call the expected method and return the expected result" do
+            ad = Ad.new(@minimal_attributes.merge('id' => 7))
+            @connection.should_receive(:delete).with('ads/7/zones/z33').and_return('return_value')
+
+            ad.unlink('z33').should == 'return_value'
+          end
+        end
+      end
+
+      context "when connected to the membase server" do
+        before(:each) do
+          @connection = stub(:connection)
+          API.stub(:default_api).and_return(stub(:default_api, :connection => @connection, :connection_type => :membase, :validate? => true))
+        end
+        describe "total_impressed" do
+          it "should call the expected methods and return the expected value" do
+            ad = Ad.new(@minimal_attributes.merge('id' => 7))
+            @connection.stub(:get).with('count_delivery_ad_7',1).and_return('999.999')
+
+            ad.total_impressed.should == 999.999
+          end
+        end
+
+        describe "today_impressed" do
+          it "should call the expected methods and return the expected value" do
+            ad = Ad.new(@minimal_attributes.merge('id' => 7, 'time_zone' => 'time_zone_value'))
+            Time.stub_chain(:now, :in_time_zone).with('time_zone_value').and_return(Time.parse("2011-05-06 07:08"))
+            @connection.stub(:get).with('count_delivery_20110506_ad_7',1).and_return('99.99')
+
+            ad.today_impressed.should == 99.99
+          end
+        end
+
+        describe "Ad.find(id)" do
+          context "when the connection returns a value" do
+            it "should call the expected methods and return the expected value" do
+              connection = MembaseConnection.new("example.com:11211")
+              Ad.stub(:connection).and_return(connection)
+              attrs = @minimal_attributes.merge(
+                'id' => 7,
+                'response_type' => 'Redirect',
+                'redirect_url' => 'http://example.com/',
+                'created_at' => @datetime,
+                'updated_at' => @datetime,
+                'total_impressed' => 0,
+                'today_impressed' => 0
+              )
+              connection.stub(:get).with('Ad:7').and_return({'ad' => attrs}.to_json)
+              a = stub(:ad)
+              Ad.should_receive(:new).with(attrs).and_return(a)
+
+              Ad.find(7).should == a
+            end
+          end
+          context "when the connection returns nil" do
+            it "should call the expected methods and return nil" do
+              connection = MembaseConnection.new("example.com:11211")
+              Ad.stub(:connection).and_return(connection)
+              connection.stub(:get).with('Ad:7').and_return(nil)
+
+              Ad.find(7).should be_nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/model/ad_zone_spec.rb

@@ -0,0 +1,15 @@
+module Neuron
+  module Client
+    describe AdZone do
+      describe "self.unlink(ad_id, zone_id)" do
+        it "should call the expected method and return the expected value" do
+          c = stub(:connection)
+          AdZone.stub(:connection).and_return(c)
+          c.should_receive(:delete).with('zones/z1/ads/2').and_return('return_value')
+
+          AdZone.unlink(2, "z1").should == 'return_value'
+        end
+      end
+    end
+  end
+end

data/spec/lib/model/base_spec.rb

@@ -1,89 +1,11 @@
 module Neuron
   module Client
-    module Model
-      module Mock
-        class BaseMockModel; end
-      end
-
-      class BaseMockModel < Base
-
-      end
-
-      describe Base do
-        describe "instance methods" do
-          describe "initialize(attrs=nil)" do
-            it "should set @proxied_model appropriately" do
-              pending "Not sure what the deal is here, it works outside of unit testing"
-
-              ctp = stub(:class_to_proxy)
-              Base.any_instance.should_receive(:class_to_proxy).and_return(ctp)
-              p = stub(:proxy)
-              ctp.should_receive(:new).with('attributes').and_return(p)
-              b = Base.new('attributes')
-
-              b.instance_variable_get(:@proxied_model).should == p
-            end
-          end
-
-          describe "method_missing(meth, *args, &block)" do
-            context "when method exists on the proxied model" do
-              it "should call the method on the proxied model"
-            end
-            context "when method does not exist on the proxied model" do
-              it "should call super.method_missing"
-            end
-          end
-        end
-
-        describe "class methods" do
-          describe "api" do
-            context "when @api exists" do
-              it "should return the expected value" do
-                a = stub(:api)
-                Base.instance_variable_set(:@api, a)
-
-                Base.api.should == a
-              end
-            end
-            context "when @api does not exist" do
-              it "should return the expected value" do
-                Base.instance_variable_set(:@api, nil)
-                a = stub(:default_api)
-                Neuron::Client::API.should_receive(:default_api).and_return(a)
-
-                Base.api.should == a
-              end
-            end
-          end
-
-          describe "connection" do
-            it "should call the expected methods and return the expected result" do
-              a = stub(:api)
-              Base.should_receive(:api).and_return(a)
-              c = stub(:connection)
-              a.should_receive(:connection).and_return(c)
-
-              Base.connection.should == c
-            end
-          end
-
-          describe "class_to_proxy" do
-            it "should call the expected methods and return the expected result" do
-              BaseMockModel.stub_chain(:api, :connection_type).and_return(:mock)
-              BaseMockModel.class_to_proxy.should == Neuron::Client::Model::Mock::BaseMockModel
-            end
-          end
+    class BaseMockModel
+      include Base
+    end
 
-          describe "method_missing(meth, *args, &block)" do
-            context "when method exists on the class to proxy" do
-              it "should call the method on the proxied model"
-            end
-            context "when method does not exist on the class to proxy" do
-              it "should call super.method_missing"
-            end
-          end
-        end
-      end
+    describe Base do
+      it "should have specs"
     end
   end
 end

data/spec/lib/model/blocked_referer_spec.rb

@@ -0,0 +1,36 @@
+module Neuron
+  module Client
+    describe BlockedReferer do
+      context "when connected to the membase server" do
+        before(:each) do
+          @connection = stub(:connection)
+          API.stub(:default_api).and_return(stub(:default_api, :connection => @connection, :connection_type => :membase, :validate? => true))
+        end
+        describe "BlockedReferer.all" do
+          context "when connection returns a value" do
+            it "should call the expected methods and return the expected value" do
+              conn = MembaseConnection.new("example.com:11211")
+              BlockedReferer.stub(:connection).and_return(conn)
+              conn.stub(:get).with('blocked_referers').and_return('[{"blocked_referer":{"id": 42, "referer": "127.0.0.1"}}, {"blocked_referer":{"id": 82, "referer": "an.example.com"}}]')
+              br = stub(:blocked_referer)
+              br2 = stub(:blocked_referer2)
+              BlockedReferer.should_receive(:new).with("id"=>42, "referer"=>"127.0.0.1").and_return(br)
+              BlockedReferer.should_receive(:new).with("id"=>82, "referer"=>"an.example.com").and_return(br2)
+
+              BlockedReferer.all.should == [br, br2]
+            end
+          end
+          context "when connection returns nil" do
+            it "should call the expected methods and return the expected value" do
+              conn = MembaseConnection.new("example.com:11211")
+              BlockedReferer.stub(:connection).and_return(conn)
+              conn.stub(:get).with('blocked_referers').and_return(nil)
+
+              BlockedReferer.all.should == []
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/model/blocked_user_agent_spec.rb

@@ -0,0 +1,36 @@
+module Neuron
+  module Client
+    describe BlockedUserAgent do
+      context "when connected to the membase server" do
+        before(:each) do
+          @connection = stub(:connection)
+          API.stub(:default_api).and_return(stub(:default_api, :connection => @connection, :connection_type => :membase, :validate? => true))
+        end
+        describe "BlockedUserAgent.all" do
+          context "when connection returns a value" do
+            it "should call the expected methods and return the expected value" do
+              conn = MembaseConnection.new("example.com:11211")
+              BlockedUserAgent.stub(:connection).and_return(conn)
+              conn.stub(:get).with('blocked_user_agents').and_return('[{"blocked_user_agent":{"id":42,"description":null,"user_agent":".*robot.*"}},{"blocked_user_agent":{"id":82,"description":null,"user_agent":"^Badbot"}}]')
+              bua = stub(:blocked_user_agent)
+              bua2 = stub(:blocked_user_agent2)
+              BlockedUserAgent.should_receive(:new).with("id"=>42, "description"=>nil, "user_agent"=>".*robot.*").and_return(bua)
+              BlockedUserAgent.should_receive(:new).with("id"=>82, "description"=>nil, "user_agent"=>"^Badbot").and_return(bua2)
+
+              BlockedUserAgent.all.should == [bua, bua2]
+            end
+          end
+          context "when connection returns nil" do
+            it "should call the expected methods and return the expected value" do
+              conn = MembaseConnection.new("example.com:11211")
+              BlockedUserAgent.stub(:connection).and_return(conn)
+              conn.stub(:get).with('blocked_user_agents').and_return(nil)
+
+              BlockedUserAgent.all.should == []
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/model/geo_target_spec.rb

@@ -0,0 +1,28 @@
+module Neuron
+  module Client
+    describe GeoTarget do
+      context "when connected to the admin server" do
+        describe "self.query(parameters)" do
+          it "should call the expected methods and return the expected value" do
+            c = stub(:connection)
+            GeoTarget.should_receive(:connection).and_return(c)
+            parameters = {:geo_type => 'COUNTRY', :search => 'USA', :limit => '10'}
+            gta = {'id' => 1, 'abbreviation' => 'XYZ', 'full_name' => 'XYZ', 'name' => 'XYZ', 'geo_type' => 'METRO', 'netacuity_id' => 1}
+            gta2 = gta.merge({'id' => 2})
+            r = [
+              {'geo_target' => gta},
+              {'geo_target' => gta2}
+            ]
+            c.should_receive(:get).with('geo_targets', parameters).and_return(r)
+            g = stub(:geo_target)
+            g2 = stub(:geo_target2)
+            GeoTarget.should_receive(:new).with(gta).and_return(g)
+            GeoTarget.should_receive(:new).with(gta2).and_return(g2)
+
+            GeoTarget.query(parameters).should == [g, g2]
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/model/pixel_spec.rb

@@ -0,0 +1,36 @@
+module Neuron
+  module Client
+    describe Pixel do
+      context "when connected to the membase server" do
+        before(:each) do
+          @connection = stub(:connection)
+          API.stub(:default_api).and_return(stub(:default_api, :connection => @connection, :connection_type => :membase, :validate? => true))
+        end
+        describe "Pixel.find(id)" do
+          context "when the connection returns a value" do
+            it "should call the expected methods and return the expected value" do
+              p = stub(:pixel)
+              attrs = {
+                "id" => 7,
+                "ad_ids" => []
+              }
+              @connection.stub_chain(:local_cache, :fetch).with('Pixel:7').and_yield.and_return(p)
+              @connection.should_receive(:get).with('Pixel:7').and_return({'pixel' => attrs}.to_json)
+              Pixel.should_receive(:new).with(attrs).and_return(p)
+
+              Pixel.find(7).should == p
+            end
+          end
+          context "when the connection returns nil" do
+            it "should call the expected methods and return nil" do
+              @connection.stub_chain(:local_cache, :fetch).with('Pixel:7').and_yield.and_return(nil)
+              @connection.should_receive(:get).with('Pixel:7').and_return(nil)
+
+              Pixel.find(7).should be_nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/model/report_spec.rb

@@ -0,0 +1,17 @@
+module Neuron
+  module Client
+    describe Report do
+      describe "result" do
+        it "should call the expected methods and return the expected result" do
+          r = Report.allocate
+          c = stub(:connection)
+          r.stub(:connection).and_return(c)
+          r.should_receive(:id).and_return(7)
+          c.should_receive(:get).with('reports/7/result', :format => '').and_return('result_value')
+
+          r.result.should == 'result_value'
+        end
+      end
+    end
+  end
+end

data/spec/lib/{s3_file_spec.rb → model/s3_file_spec.rb}

@@ -1,10 +1,10 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
 require 'yajl'
 
 module Neuron
   module Client
-    module Model
-      describe S3File do
+    describe S3File do
+      context "when connected to the admin server" do
         before(:all) do
           API.default_api.configure do |config|
             config.connection_type = :admin
@@ -23,6 +23,7 @@ module Neuron
           it "returns the created S3File" do
             attrs = {:bucket => 'test',
                      :filename => "filename",
+                     :filesize => nil,
                      :purpose => 'RAW_EVENT_LOG'}
             s3file = S3File.create(attrs)
             s3file.id.should_not be_nil
@@ -38,14 +39,14 @@ module Neuron
             s3files = S3File.all
             s3files.should be_a(Array)
             s3files.length.should be > 0
-            s3files.first.should be_a(Admin::S3File)
+            s3files.first.should be_a(S3File)
           end
         end
 
         describe "find" do
           it "returns a S3File" do
             s3file = S3File.find(@@created_id)
-            s3file.should be_a(Admin::S3File)
+            s3file.should be_a(S3File)
           end
         end
 

data/spec/lib/model/zone_calculations_spec.rb

@@ -0,0 +1,49 @@
+module Neuron
+  module Client
+    class FakeZone
+      include ZoneCalculations
+      def initialize(ads, ad_links)
+        @ads = ads
+        @ad_links = ad_links
+      end
+      attr_reader :ad_links
+      def find_ad(ad_id)
+        @ads[ad_id]
+      end
+    end
+
+    class ZoneCalculationsSpecAd
+      def initialize(active, pressure)
+        @active = active
+        @pressure = pressure
+      end
+      attr_reader :pressure, :active
+      alias_method :active?, :active
+    end
+
+    describe ZoneCalculations do
+      describe ".calculate_ads_by_priority" do
+        it "should generate the expected result" do
+          ads = {
+            "0" => ZoneCalculationsSpecAd.new(false, 42.0),
+            "1" => ZoneCalculationsSpecAd.new(true, 11.1),
+            "2" => ZoneCalculationsSpecAd.new(true, 11.1),
+            "3" => ZoneCalculationsSpecAd.new(true, 22.2),
+            "4" => ZoneCalculationsSpecAd.new(true, 1000),
+            "5" => ZoneCalculationsSpecAd.new(true, 828282)
+          }
+          ad_links = {
+            "0" => {"priority" => 1, "weight" => 50},
+            "1" => {"priority" => 1, "weight" => 4},
+            "2" => {"priority" => 1, "weight" => 2},
+            "3" => {"priority" => 1, "weight" => 2},
+            "4" => {"priority" => 2, "weight" => 99.9}
+          }
+          zone = FakeZone.new(ads, ad_links)
+
+          zone.calculate_ads_by_priority.should == [[["1", 44.4], ["2", 22.2], ["3", 44.4]], [["4", 99900.0]]]
+        end
+      end
+    end
+  end
+end