adzerk 0.2 → 0.3

data/test/flight_api_spec.rb

@@ -60,6 +60,7 @@ describe "Flight API" do
     $flight_CampaignId = $campaign_id
     $flight_IsActive = true
     $flight_IsDeleted = false
+    $flight_GoalType = 1
 
     new_flight = {
       :no_end_date => false,
@@ -78,61 +79,66 @@ describe "Flight API" do
       :weight_override => $flight_WeightOverride,
       :campaign_id => $flight_CampaignId,
       :is_active => $flight_IsActive,
-      :is_deleted => $flight_IsDeleted
+      :is_deleted => $flight_IsDeleted,
+      :goal_type => $flight_GoalType
     }
     flight = @flights.create(new_flight)
     $flight_id = flight[:id].to_s
-    flight[:no_end_date].should eq(false)
-    flight[:priority_id].should eq($priority_id.to_i)
-    flight[:name].should eq($flight_Name)
+    expect(flight[:no_end_date]).to eq(false)
+    expect(flight[:priority_id]).to eq($priority_id.to_i)
+    expect(flight[:name]).to eq($flight_Name)
     # JSON.parse(response.body)["StartDate"].should == "/Date(1293840000000+0000)/"
     # JSON.parse(response.body)["EndDate"].should == "/Date(1325307600000-0500)/"
-    flight[:price].should eq(15.0)
-    flight[:option_type].should eq($flight_OptionType)
-    flight[:impressions].should eq($flight_Impressions)
-    flight[:is_unlimited].should eq($flight_IsUnlimited)
-    flight[:is_full_speed].should eq($flight_IsFullSpeed)
-    flight[:keywords].should eq($flight_Keywords)
-    flight[:user_agent_keywords].should eq($flight_UserAgentKeywords)
-    flight[:weight_override].should eq($flight_WeightOverride)
-    flight[:campaign_id].should eq($flight_CampaignId)
-    flight[:is_active].should eq($flight_IsActive)
-    flight[:is_deleted].should eq($flight_IsDeleted)
+    expect(flight[:price]).to eq(15.0)
+    expect(flight[:option_type]).to eq($flight_OptionType)
+    expect(flight[:impressions]).to eq($flight_Impressions)
+    expect(flight[:is_unlimited]).to eq($flight_IsUnlimited)
+    expect(flight[:is_full_speed]).to eq($flight_IsFullSpeed)
+    expect(flight[:keywords]).to eq($flight_Keywords)
+    expect(flight[:user_agent_keywords]).to eq($flight_UserAgentKeywords)
+    expect(flight[:weight_override]).to eq($flight_WeightOverride)
+    expect(flight[:campaign_id]).to eq($flight_CampaignId)
+    expect(flight[:is_active]).to eq($flight_IsActive)
+    expect(flight[:is_deleted]).to eq($flight_IsDeleted)
+    expect(flight[:goal_type]).to eq($flight_GoalType)
   end
 
   it "should list a specific flight" do
     flight = @flights.get($flight_id)
-    flight[:priority_id].should eq($priority_id.to_i)
-    flight[:name].should eq($flight_Name)
-    flight[:price].should eq(15.0)
-    flight[:option_type].should eq($flight_OptionType)
-    flight[:impressions].should eq($flight_Impressions)
-    flight[:is_unlimited].should eq($flight_IsUnlimited)
-    flight[:is_full_speed].should eq($flight_IsFullSpeed)
-    flight[:keywords].should eq($flight_Keywords)
-    flight[:user_agent_keywords].should eq($flight_UserAgentKeywords)
-    flight[:weight_override].should eq($flight_WeightOverride)
-    flight[:campaign_id].should eq($flight_CampaignId)
-    flight[:is_active].should eq($flight_IsActive)
-    flight[:is_deleted].should eq($flight_IsDeleted)
+    expect(flight[:priority_id]).to eq($priority_id.to_i)
+    expect(flight[:name]).to eq($flight_Name)
+    expect(flight[:price]).to eq(15.0)
+    expect(flight[:option_type]).to eq($flight_OptionType)
+    expect(flight[:impressions]).to eq($flight_Impressions)
+    expect(flight[:is_unlimited]).to eq($flight_IsUnlimited)
+    expect(flight[:is_full_speed]).to eq($flight_IsFullSpeed)
+    expect(flight[:keywords]).to eq($flight_Keywords)
+    expect(flight[:user_agent_keywords]).to eq($flight_UserAgentKeywords)
+    expect(flight[:weight_override]).to eq($flight_WeightOverride)
+    expect(flight[:campaign_id]).to eq($flight_CampaignId)
+    expect(flight[:is_active]).to eq($flight_IsActive)
+    expect(flight[:is_deleted]).to eq($flight_IsDeleted)
+    expect(flight[:goal_type]).to eq($flight_GoalType)
   end
 
   it "should update a flight" do
     flight = @flights.update(:id => $flight_id,
                              :campaign_id => $flight_CampaignId,
                              :name => "New Flight Name",
-                             :priority_id => $priority_id)
-    flight[:name].should eq("New Flight Name")
+                             :priority_id => $priority_id,
+                             :start_date => $flight_StartDate,
+                             :goal_type => $flight_GoalType)
+    expect(flight[:name]).to eq("New Flight Name")
   end
 
   it "should list all flights" do
     flights = @flights.list
-    flights.length.should > 0
+    expect(flights.length).to be > 0
   end
 
   it "should delete a new flight" do
     response = @flights.delete($flight_id)
-    response.body.should == '"Successfully deleted"'
+    expect(response.body).to eq('"Successfully deleted"')
   end
 
   it "should create a flight with geotargeting" do
@@ -160,52 +166,56 @@ describe "Flight API" do
       'CampaignId' => $flight_CampaignId,
       'IsActive' => $flight_IsActive,
       'IsDeleted' => $flight_IsDeleted,
-      'GeoTargeting' => geo
+      'GeoTargeting' => geo,
+      'GoalType' => $flight_GoalType
     }
     flight = @flights.create(new_flight)
     $flight_id = flight[:id].to_s
-    flight[:no_end_date].should eq(false)
-    flight[:priority_id].should eq($priority_id.to_i)
-    flight[:name].should eq($flight_Name)
+    expect(flight[:no_end_date]).to eq(false)
+    expect(flight[:priority_id]).to eq($priority_id.to_i)
+    expect(flight[:name]).to eq($flight_Name)
     # JSON.parse(response.body)["StartDate"].should == "/Date(1293840000000+0000)/"
     # JSON.parse(response.body)["EndDate"].should == "/Date(1325307600000-0500)/"
-    flight[:price].should eq(15.0)
-    flight[:option_type].should eq($flight_OptionType)
-    flight[:impressions].should eq($flight_Impressions)
-    flight[:is_unlimited].should eq($flight_IsUnlimited)
-    flight[:is_full_speed].should eq($flight_IsFullSpeed)
-    flight[:keywords].should eq($flight_Keywords)
-    flight[:user_agent_keywords].should eq($flight_UserAgentKeywords)
-    flight[:weight_override].should eq($flight_WeightOverride)
-    flight[:campaign_id].should eq($flight_CampaignId)
-    flight[:is_active].should eq($flight_IsActive)
-    flight[:is_deleted].should eq($flight_IsDeleted)
+    expect(flight[:price]).to eq(15.0)
+    expect(flight[:option_type]).to eq($flight_OptionType)
+    expect(flight[:impressions]).to eq($flight_Impressions)
+    expect(flight[:is_unlimited]).to eq($flight_IsUnlimited)
+    expect(flight[:is_full_speed]).to eq($flight_IsFullSpeed)
+    expect(flight[:keywords]).to eq($flight_Keywords)
+    expect(flight[:user_agent_keywords]).to eq($flight_UserAgentKeywords)
+    expect(flight[:weight_override]).to eq($flight_WeightOverride)
+    expect(flight[:campaign_id]).to eq($flight_CampaignId)
+    expect(flight[:is_active]).to eq($flight_IsActive)
+    expect(flight[:is_deleted]).to eq($flight_IsDeleted)
     geotargeting = flight[:geo_targeting].first
-    geotargeting[:country_code].should eq("US")
-    geotargeting[:region].should eq("NC")
-    geotargeting[:metro_code].should eq(560)
+    expect(geotargeting[:country_code]).to eq("US")
+    expect(geotargeting[:region]).to eq("NC")
+    expect(geotargeting[:metro_code]).to eq(560)
+    expect(flight[:goal_type]).to eq($flight_GoalType)
   end
 
   it "should not create a flight for a campaign in a different network" do
-    flight = @flights.create(
-      :no_end_date => false,
-      :priority_id => $priority_id,
-      :name => $flight_Name,
-      :start_date => $flight_StartDate,
-      :end_date => $flight_EndDate,
-      :no_end_date => $flight_NoEndDate,
-      :price => $flight_Price,
-      :option_type => $flight_OptionType,
-      :impressions => $flight_Impressions,
-      :is_unlimited => $flight_IsUnlimited,
-      :is_full_speed => $flight_IsFullSpeed,
-      :keywords => $flight_Keywords,
-      :user_agent_keywords => $flight_UserAgentKeywords,
-      :weight_override => $flight_WeightOverride,
-      :campaign_id => 123,
-      :is_active => $flight_IsActive,
-      :is_deleted => $flight_IsDeleted
-    )
-    flight[:message].should == "This campaign is not part of your network"
+    expect{
+      flight = @flights.create(
+        :no_end_date => false,
+        :priority_id => $priority_id,
+        :name => $flight_Name,
+        :start_date => $flight_StartDate,
+        :end_date => $flight_EndDate,
+        :no_end_date => $flight_NoEndDate,
+        :price => $flight_Price,
+        :option_type => $flight_OptionType,
+        :impressions => $flight_Impressions,
+        :is_unlimited => $flight_IsUnlimited,
+        :is_full_speed => $flight_IsFullSpeed,
+        :keywords => $flight_Keywords,
+        :user_agent_keywords => $flight_UserAgentKeywords,
+        :weight_override => $flight_WeightOverride,
+        :campaign_id => 123,
+        :is_active => $flight_IsActive,
+        :is_deleted => $flight_IsDeleted,
+        :goal_type => $flight_GoalType
+      )
+    }.to raise_error "This campaign is not part of your network"
   end
 end

data/test/geo_targeting_api_spec.rb

@@ -0,0 +1,122 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "GeoTargeting API" do
+
+
+  before(:all) do
+    new_advertiser = {
+      'Title' => "Test"
+    }
+    client = Adzerk::Client.new(API_KEY)
+    @flights= client.flights
+    @advertisers = client.advertisers
+    @channels = client.channels
+    @campaigns = client.campaigns
+    @priorities = client.priorities
+    @geotargetings = client.geotargetings
+    advertiser = @advertisers.create(:title => "test")
+    $advertiserId = advertiser[:id].to_s
+
+    channel = @channels.create(:title => 'Test Channel ' + rand(1000000).to_s,
+                               :commission => '0.0',
+                               :engine => 'CPM',
+                               :keywords => 'test',
+                               'CPM' => '10.00',
+                               :ad_types =>  [1,2,3,4])
+    $channel_id = channel[:id].to_s
+
+    priority = @priorities.create(:name => "High Priority Test",
+                                  :channel_id => $channel_id,
+                                  :weight => 1,
+                                  :is_deleted => false)
+    $priority_id = priority[:id].to_s
+
+    campaign = @campaigns.
+      create(:name => 'Test campaign ' + rand(1000000).to_s,
+             :start_date => "1/1/2011",
+             :end_date => "12/31/2011",
+             :is_active => false,
+             :price => '10.00',
+             :advertiser_id => $advertiserId,
+             :flights => [],
+             :is_deleted => false)
+    $campaign_id = campaign[:id]
+
+    new_flight = {
+      :no_end_date => false,
+      :priority_id => $priority_id,
+      :name => 'Test flight ' + rand(1000000).to_s,
+      :start_date => "1/1/2011",
+      :end_date => "12/31/2011",
+      :no_end_date => false,
+      :price => '15.00',
+      :option_type => 1,
+      :impressions => 10000,
+      :is_unlimited => false,
+      :is_full_speed => false,
+      :keywords => "test, test2",
+      :user_agent_keywords => nil,
+      :weight_override => nil,
+      :campaign_id => $campaign_id,
+      :is_active => true,
+      :is_deleted => false,
+      :goal_type => 1
+    }
+    flight = @flights.create(new_flight)
+    $flight_id = flight[:id].to_s
+
+  end
+
+  it "should create a geotargeting" do
+    $geo_CountryCode = "US";
+    $geo_Region = "NC";
+    $geo_MetroCode = 560;
+    $geo_IsExclude = true;
+
+    new_geo = {
+      :country_code => $geo_CountryCode,
+      :region => $geo_Region,
+      :metro_code => $geo_MetroCode,
+      :is_exclude => true,
+    }
+ 
+    geo = @geotargetings.create($flight_id, new_geo)
+    expect(geo[:country_code]).to eq($geo_CountryCode)
+    expect(geo[:region]).to eq($geo_Region)
+    expect(geo[:metro_code]).to eq($geo_MetroCode)
+    expect(geo[:is_exclude]).to eq(true)
+    $geo_id = geo[:location_id]
+
+  end
+
+  it "should retrieve a geotargeting" do
+    geo = @geotargetings.get($flight_id,$geo_id)
+  end
+
+  it "should update a geotargeting" do
+    data = {
+      :country_code => $geo_CountryCode,
+      :region => $geo_Region,
+      :metro_code => 517,
+      :is_exclude => true,
+    }
+    geo = @geotargetings.update($flight_id,$geo_id,data)
+    expect(geo[:metro_code]).to eq(517)
+  end
+
+  it "should delete a geotargeting" do
+    geo = @geotargetings.delete($flight_id,$geo_id)
+  end
+
+  it "should error when deleting a geotargeting that does not exist" do
+    expect{ geo = @geotargetings.delete($flight_id,1) }.to raise_error
+  end
+
+  it "should check if a flight is not a part of your network" do
+    non_network_flight = 123;
+    expect{ @geotargetings.delete(non_network_flight,1) }.to raise_error("Flight is not a part of your network")
+    expect{ @geotargetings.get(non_network_flight,1) }.to raise_error("Flight is not a part of your network")
+    expect{ @geotargetings.update(non_network_flight,1,{}) }.to raise_error("Flight is not a part of your network")
+  end
+
+end

data/test/invitation_api_spec.rb

@@ -15,18 +15,18 @@ describe "Invitation API" do
     response = @client.invitations.invite_publisher(:email => 'test@adzerk.com',
                                         :site_id => @site_id,
                                         :advertiser_id => @advertiser_id)
-    response.body.should_not == ""
-    response.body.length.should > 10
-    response.body.length.should < 100
+    expect(response.body).not_to eq("")
+    expect(response.body.length).to be > 10
+    expect(response.body.length).to be < 100
   end
 
   it "should create a new advertiser invitation" do
     response = @client.invitations.invite_advertiser(:email => 'test@adzerk.com',
                                                  :site_id => @site_id,
                                                  :advertiser_id => @advertiser_id)
-    response.body.should_not == ""
-    response.body.length.should > 10
-    response.body.length.should < 100
+    expect(response.body).not_to eq("")
+    expect(response.body.length).to be > 10
+    expect(response.body.length).to be < 100
   end
 
 end

data/test/login_api_spec.rb

@@ -2,35 +2,37 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe "Login_API" do
 
+  puts ENV['ADZERK_API_KEY']
+
   before do
     @logins = Adzerk::Client.new(API_KEY).logins
   end
 
   it "should create a new login" do
-    email = "test@email_#{rand(1000)}.com"
+    email = "test@email_#{rand(1000000)}.com"
     login = @logins.create(:email => email,
                            :password => '1234567',
                            :name => "John Doe")
     $login_id = login[:id]
-    login[:email].should eq(email)
-    login[:password].should eq("1234567")
-    login[:name].should eq("John Doe")
+    expect(login[:email]).to eq(email)
+    expect(login[:password]).to eq("1234567")
+    expect(login[:name]).to eq("John Doe")
   end
 
   it "should list all logins" do
     logins = @logins.list
-    logins[:items].last[:id].should eq($login_id)
+    expect(logins[:items].last[:id]).to eq($login_id)
   end
 
   it "should list a specific login" do
     login = @logins.get($login_id)
-    login[:name].should eq("John Doe")
+    expect(login[:name]).to eq("John Doe")
   end
 
   it "should update a login" do
     login = @logins.update(:id => $login_id,
                            :name => "New Name")
-    login[:name].should eq("New Name")
+    expect(login[:name]).to eq("New Name")
   end
 
 end

data/test/priority_api_spec.rb

@@ -27,18 +27,18 @@ describe "Priority API" do
                                   :weight => $priority_weight,
                                   :is_deleted => $priority_is_deleted)
     $priority_id = priority[:id].to_s
-    $priority_name.should == priority[:name]
-    $priority_channel_id.to_f.should == priority[:channel_id]
-    $priority_weight.should == priority[:weight]
-    $priority_is_deleted.should == priority[:is_deleted]
+    expect($priority_name).to eq(priority[:name])
+    expect($priority_channel_id.to_f).to eq(priority[:channel_id])
+    expect($priority_weight).to eq(priority[:weight])
+    expect($priority_is_deleted).to eq(priority[:is_deleted])
   end
 
   it "should list a specific priority" do
     priority = @priorities.get($priority_id)
-    $priority_name.should == priority[:name]
-    $priority_channel_id.to_f.should == priority[:channel_id]
-    $priority_weight.should == priority[:weight]
-    $priority_is_deleted.should == priority[:is_deleted]
+    expect($priority_name).to eq(priority[:name])
+    expect($priority_channel_id.to_f).to eq(priority[:channel_id])
+    expect($priority_weight).to eq(priority[:weight])
+    expect($priority_is_deleted).to eq(priority[:is_deleted])
     priority = @priorities.get($priority_id)
   end
 
@@ -50,26 +50,26 @@ describe "Priority API" do
              :weight => 2,
              :is_deleted => $priority_is_deleted)
 
-    $priority_name.should == priority[:name]
-    $priority_channel_id.to_f.should == priority[:channel_id]
-    priority[:weight].should == 2
-    $priority_is_deleted.should == priority[:is_deleted]
+    expect($priority_name).to eq(priority[:name])
+    expect($priority_channel_id.to_f).to eq(priority[:channel_id])
+    expect(priority[:weight]).to eq(2)
+    expect($priority_is_deleted).to eq(priority[:is_deleted])
   end
 
   it "should list all priorities" do
     result = @priorities.list
-    result.length.should > 0
+    expect(result.length).to be > 0
     priority = result[:items].last
     priority[:id].to_s == $priority_id 
-    $priority_name.should == priority[:name]
-    $priority_channel_id.to_f.should == priority[:channel_id]
-    priority[:weight].should == 2
-    $priority_is_deleted.should == priority[:is_deleted]
+    expect($priority_name).to eq(priority[:name])
+    expect($priority_channel_id.to_f).to eq(priority[:channel_id])
+    expect(priority[:weight]).to eq(2)
+    expect($priority_is_deleted).to eq(priority[:is_deleted])
   end
 
   it "should delete a new priority" do
     response = @priorities.delete($priority_id)
-    response.body.should == '"Successfully deleted"'
+    expect(response.body).to eq('"Successfully deleted"')
   end
 end