ppc 1.0.6 → 1.3.0

data/spec/api_baidu_group_spec.rb

@@ -0,0 +1,50 @@
+describe ::PPC::API::Baidu::Group do
+  auth =  {}
+  auth[:username] = $baidu_username
+  auth[:password] = $baidu_password 
+  auth[:token] = $baidu_token
+
+  Test_plan_id = []
+  Test_group_id = []
+
+  it 'can get all group' do 
+    response = ::PPC::API::Baidu::Group::ids( auth )
+    is_successed( response ) 
+    pair = response['body']['campaignAdgroupIds'][0]
+    Test_plan_id << pair['campaignId']
+  end
+
+  it 'can add group' do 
+    group = { name: 'test_group', plan_id:Test_plan_id[0], price:500 }
+    response = ::PPC::API::Baidu::Group::add( auth, group )
+    is_success( response )
+    Test_group_id << response[:result][0][:id]
+  end
+  
+  it 'can update group' do 
+    group = { id: Test_group_id[0], price:600 }
+    response = ::PPC::API::Baidu::Group::update( auth, group )
+    is_success( response )
+  end
+
+  it 'can search group by group id' do
+    response = ::PPC::API::Baidu::Group::get( auth, Test_group_id )
+    is_success( response )
+  end
+  
+  it 'can search group id by group id' do
+    response = ::PPC::API::Baidu::Group::search_id_by_plan_id( auth, Test_plan_id )
+    is_success( response )
+  end
+
+  it 'search by plan id' do 
+    response = ::PPC::API::Baidu::Group::search_by_plan_id( auth, Test_plan_id )
+    is_success( response )
+  end  
+
+  it 'can delete group' do 
+    response = ::PPC::API::Baidu::Group::delete( auth, Test_group_id )
+    is_success( response )
+  end
+  
+end

data/spec/api_baidu_keyword_spec.rb

@@ -0,0 +1,64 @@
+describe ::PPC::API::Baidu::Keyword do
+  auth =  {}
+  auth[:username] = $baidu_username
+  auth[:password] = $baidu_password 
+  auth[:token] = $baidu_token
+
+  Test_group_id = ::PPC::API::Baidu::Group::ids( auth )[:result][0]['adgroupIds'][0]
+  Test_plan_id = ::PPC::API::Baidu::Plan::all( auth )[:result][0]['campaignId']
+  Test_keyword_id = []
+
+  Test_domain = $baidu_domain
+
+  it 'can search keyword by group id' do
+    response = ::PPC::API::Baidu::Keyword::search_by_group_id( auth, Test_group_id )
+    is_success( response )
+  end
+
+  it 'can add keyword' do
+    keyword = { group_id: Test_group_id, keyword: 'Test', match_type:'exact' }
+    response = ::PPC::API::Baidu::Keyword::add( auth, keyword )
+    is_success( response )
+    Test_keyword_id << response[:result][0][:id]
+  end
+
+  it 'can update keyword' do
+    update = { id:Test_keyword_id[0],  pc_destination: Test_domain, pause:true} 
+    response = ::PPC::API::Baidu::Keyword::update( auth, update )
+    is_success( response )
+  end
+
+  it 'can activate keyword' do
+    response = ::PPC::API::Baidu::Keyword::activate( auth, Test_keyword_id )
+    is_success( response )
+  end
+
+  it 'can get status' do
+    response1 = ::PPC::API::Baidu::Keyword::status( auth, Test_group_id, 'group' )
+    response2 = ::PPC::API::Baidu::Keyword::status( auth, Test_keyword_id, 'keyword' )
+    response3 = ::PPC::API::Baidu::Keyword::status( auth, Test_plan_id, 'plan' )
+    is_success( response1 ) 
+    is_success( response2 ) 
+    is_success( response3 ) 
+  end
+
+  # it 'can get quality' do
+  #   response1 = ::PPC::API::Baidu::Keyword::quality( auth, Test_group_id, 'group', true )
+  #   response2 = ::PPC::API::Baidu::Keyword::quality( auth, Test_keyword_id, 'keyword', true )
+  #   response3 = ::PPC::API::Baidu::Keyword::quality( auth, Test_plan_id, 'plan', true )
+  #   is_successed( response1 ) 
+  #   is_successed( response2 ) 
+  #   is_successed( response3 ) 
+  # end
+
+  it 'can get 10-quality' do
+    response = ::PPC::API::Baidu::Keyword::quality( auth, Test_keyword_id, 'keyword', 'pc' )
+    is_success( response )    
+  end
+
+  it 'can delete keyword' do
+    response = ::PPC::API::Baidu::Keyword::delete( auth, Test_keyword_id )
+    is_success( response )
+  end
+
+end

data/spec/api_baidu_plan_spec.rb

@@ -0,0 +1,42 @@
+describe ::PPC::API::Baidu::Plan do
+  auth =  {}
+  auth[:username] = $baidu_username
+  auth[:password] = $baidu_password 
+  auth[:token] = $baidu_token
+
+  Test_plan_id = []
+
+  it "can get all plans" do
+    response = ::PPC::API::Baidu::Plan::all( auth )
+    is_success( response )
+  end
+
+  it "can get all plan id" do 
+    response = ::PPC::API::Baidu::Plan::ids( auth )
+    is_success( response )
+  end 
+
+  it "can add plan" do
+    test_plan = { name: "test_plan1", negative: ["test"] }
+    response = ::PPC::API::Baidu::Plan::add( auth, test_plan )
+    is_success( response )
+    Test_plan_id << response['body']['campaignTypes'][0]['campaignId']
+  end
+
+  it "can get plan by id" do
+    response = ::PPC::API::Baidu::Plan::get( auth, Test_plan_id )
+    is_success( response )
+  end
+
+  it 'can update plan' do
+    update = { id: Test_plan_id[0], name:"test_plan_update"}
+    response = ::PPC::API::Baidu::Plan::update( auth, update )
+    is_success( response )
+  end
+
+  it "can delete plan" do
+    response = ::PPC::API::Baidu::Plan::delete( auth, Test_plan_id )
+    is_success( response )
+  end
+
+end

data/spec/api_baidu_report_spec.rb

@@ -0,0 +1,32 @@
+describe ::PPC::API::Baidu::Report do
+  auth =  {}
+  auth[:username] = $baidu_username
+  auth[:password] = $baidu_password 
+  auth[:token] = $baidu_token
+
+  Test_report_id = []
+
+  it 'can get real time report' do
+    param = { type: 'plan', level:'plan',range:'plan',unit:'week',device:'all' }
+    response = ::PPC::API::Baidu::Report::get_realtime( auth, param, 'data' )
+    is_success( response )
+  end
+
+  it 'can get professional report id' do
+    param = { type: 'plan', level:'plan',range:'plan',unit:'week',device:'all' }
+    response = ::PPC::API::Baidu::Report::get_id( auth, param )
+    is_success( response )
+    Test_report_id << response[:result]
+  end
+
+  it 'can get professional report status' do
+    response = ::PPC::API::Baidu::Report::get_status( auth, Test_report_id[0] )
+    is_success( response )
+  end
+
+  it 'can get professional report download URL' do
+    response = ::PPC::API::Baidu::Report::get_file_url( auth, Test_report_id[0] )
+    is_success( response )
+  end
+
+end

data/spec/api_baidu_spec.rb

@@ -0,0 +1,60 @@
+require 'json'
+require 'ppc/api/baidu/account'
+describe ::PPC::API::Baidu do
+
+  fake_response = "{\"header\":{\"desc\":\"success\",\"failures\":[],\"oprs\":1,\"oprtime\":0,
+                                 \"quota\":2,\"rquota\":34047,\"status\":0},\"body\":{
+                                  \"accountInfoType\":{\"userid\":5707012,\"balance\":0.0,\"cost\":0.0,
+                                  \"payment\":0.0,\"budgetType\":1,\"budget\":3000.0,\"regionTarget\":[9999999],
+                                  \"excludeIp\":[],\"openDomains\":[\"elong.com\"],\"regDomain\":\"elong.com\",
+                                  \"budgetOfflineTime\":[],\"weeklyBudget\":[],\"userStat\":null,\"isDynamicCreative\":null,
+                                    \"dynamicCreativeParam\":null,\"opt\":null}}}"
+
+  response = JSON.parse fake_response
+
+  Expected_success_result = [:id, :balance, :cost, :payment, 
+                                                :budget_type, :budget, :region, :exclude_ip, 
+                                                :open_domains, :reg_domain, :offline_time, 
+                                                :weekly_budget ]
+
+  Expected_failure_result = ["code", "message", "position", "content"] 
+
+  it 'can process response' do
+    response = ::PPC::API::Baidu::process( response, 'accountInfoType' ){|x| ::PPC::API::Baidu::Account::reverse_type(x)}
+    
+    p "HAHA"*12
+    p response
+
+    expect( response[:result][0].keys ).to eq Expected_success_result
+  end
+
+  # params for make_type and reverse_type test
+    test_map = 
+  [
+    [ :id , :campaignId],
+    [ :name , :campaignName],
+    [ :exclude_ip, :excludeIp],
+    [ :exact_negative , :exactNegativeWords],
+  ]
+
+  test_type = {  }
+  test_type['campaignId'] = 123
+  test_type['campaignName'] = 'test_plan'
+  test_type['excludeIp'] = [321,5432,52,1]
+  test_type['exactNegativeWords'] = ['wu','liaode']
+
+  test_param = { }
+  test_param[ :id] = 123
+  test_param[ :name] = 'testplan'
+  test_param[ :exclude_ip] =  [321,5432,52,1]
+  test_param[ :exact_negative] = ['test','plan']
+
+  expected_type = [{:campaignId=>123, :campaignName=>"testplan", :excludeIp=>[321, 5432, 52, 1], :exactNegativeWords=>["wu", "liaode"]}]
+  expexted_params = [{:id=>123, :name=>"test_plan", :exclude_ip=>[321, 5432, 52, 1], :exact_negative=>["wu", "liaode"]}]
+
+  it 'can make and reverse type' do
+    expect( ::PPC::API::Baidu::make_type( test_param , test_map) ).to eq expected_type
+    expect( ::PPC::API::Baidu::reverse_type(test_type, test_map) ).to eq expexted_params
+  end
+
+end

data/spec/baidu_account_spec.rb

@@ -0,0 +1,32 @@
+describe ::PPC::Baidu::Account do
+  subject{::PPC::Baidu::Account.new(
+            debug:true,
+            username:$baidu_username,
+            password:$baidu_password,
+            token:$baidu_token
+  )}
+
+  it "prints all info" do
+    expect(subject.info.keys).to eq ["userid", "balance", "cost", "payment", "budgetType", "budget", "regionTarget", "excludeIp", "openDomains", "regDomain", "budgetOfflineTime", "weeklyBudget", "userStat", "isDynamicCreative", "dynamicCreativeParam", "opt"]
+  end
+
+  it "prints all updated info" do
+    info = { budget_type: 1, budget: 3000 }
+    response = subject.update( info )
+
+    expect(response.keys).to eq ["userid", "balance", "cost", "payment", "budgetType", "budget", "regionTarget", "excludeIp", "openDomains", "regDomain", "budgetOfflineTime", "weeklyBudget", "userStat", "isDynamicCreative", "dynamicCreativeParam", "opt"]
+    expect(response["budgetType"]).to eq 1
+    expect(response["budget"]).to eq 3000
+  end
+
+
+
+  # it "could download all plan" do
+  #   result = subject.all
+  #   if result
+  #     expect(result.keys).to include :account_file_path
+  #   else
+  #     expect(subject.code).to eq '901162'
+  #   end
+  # end
+end

data/spec/baidu_bulk_spec.rb

@@ -0,0 +1,21 @@
+describe ::PPC::Baidu::Bulk do
+  subject{::PPC::Baidu::Bulk.new(
+            debug:true,
+            username:'',
+            password:'',
+            token:'')
+          }
+  it "could get file_id_of_all" do
+    begin
+      result = subject.file_id_of_all
+    rescue
+      expect(subject.code).to eq '901162'
+    end
+
+    if result.nil?
+      expect(subject.code).to eq '901162'
+    else
+      expect(result.size).to eq 32
+    end
+  end
+end

data/spec/baidu_group_spec.rb

@@ -0,0 +1,56 @@
+describe ::PPC::Baidu::Group do
+  subject{::PPC::Baidu::Group.new(
+            debug:true,
+            username:$baidu_username,
+            password:$baidu_password,
+            token:$baidu_token
+  )}
+
+  Test_group1 = {plan_id: 8537330, name:"test_group1",maxprice: 500 }
+  Test_group2 = {plan_id: 8537330, name:"test_group2",maxprice: 500 }
+  Test_groups = [ Test_group1, Test_group2 ]
+  $test_group_ids = []
+  $test_plan_ids = []
+
+  it " can get all group info " do
+    response = subject.all()
+    response.each{  |campaign|
+      expect( campaign.keys ).to eq ["campaignId", "adgroupIds"] 
+      $test_plan_ids << campaign["campaignId"]
+    }
+  end
+
+  it " can add group " do
+    response = subject.add( Test_groups, true )
+    expect( response['header']['desc'] ).to eq 'success'
+
+    # store test_group _id s
+    response = response['body']['adgroupTypes']
+    response.each{  |group|
+     $test_group_ids << group[ 'adgroupId' ]
+    }
+  end
+
+  it " can update group " do
+    updates = [ { group_id: $test_group_ids[0], maxprice:550 } , 
+                      { group_id: $test_group_ids[1], maxprice:550 } ]
+    response = subject.update( updates, true )
+    expect( response['header']['desc'] ).to eq 'success'
+  end
+
+  it "can search group by group id" do
+    response = subject.search_by_groupid( $test_group_ids ,  true)
+    expect( response["header"]["desc"] ).to eq "success"
+  end
+
+  it " can delete group " do
+    response = subject.delete( $test_group_ids )
+    expect( response ).to eq "success"
+  end
+
+  it "can search group by planId" do
+    response = subject.search_by_planid( $test_plan_ids , true)
+    expect( response["header"]["desc"] ).to eq "success"
+  end
+  
+end

data/spec/baidu_plan_spec.rb

@@ -0,0 +1,129 @@
+describe ::PPC::Baidu::Plan do
+  subject{::PPC::Baidu::Plan.new(
+            debug:true,
+            username:$baidu_username,
+            password:$baidu_password,
+            token:$baidu_token
+  )}
+
+
+  it "can update one plan" do
+    random_plan_id = subject.ids.first
+    new_name = "测试计划#{Time.now.to_i}"
+    response = subject.update_by_id(random_plan_id,{campaignName: new_name})
+    expect(response.class).to be Array
+    expect(response.first.class).to be Hash
+    expect(response.first['campaignName']).to eq new_name
+  end
+
+  it "can update two plans" do
+    random_plan_id1 = subject.ids[0]
+    random_plan_id2 = subject.ids[1]
+
+    new_name1 = "测试计划1_#{Time.now.to_i}"
+    new_name2 = "测试计划2_#{Time.now.to_i}"
+
+    plans = []
+    plans << {campaignId: random_plan_id1,campaignName: new_name1}
+    plans << {campaignId: random_plan_id2,campaignName: new_name2}
+    response = subject.update(plans)
+    expect(response.class).to be Array
+    expect(response.first.class).to be Hash
+    expect(response[0]['campaignName']).to eq new_name1
+    expect(response[1]['campaignName']).to eq new_name2
+  end
+  it "can get all plans" do
+    response = subject.plans
+    expect(response.class).to be Array
+    expect(response.first.class).to be Hash
+    expect(response.first['campaignId']).to be > 0
+  end
+
+  it "can add a plan" do
+    response = subject.add({name:"测试计划#{Time.now.to_i}"})
+    expect(response).to have_key 'campaignId'
+    expect(response['campaignId']).to be > 0
+  end
+
+  it "can add two plans" do
+    plan1 = {name:"测试计划1#{Time.now.to_i}"}
+    plan2 = {name:"测试计划2#{Time.now.to_i}"}
+
+    response = subject.add([plan1,plan2])
+    expect(response.class).to be Array
+    expect(response.first['campaignId']).to be > 0
+    expect(response[1]['campaignId']).to be > 0
+  end
+
+  it "can get all plan ids" do
+    response = subject.ids()
+    expect(response.class).to be Array
+  end
+
+  it "can get plans by one id" do
+    id = subject.ids().first
+    response = subject.get(id)
+    expect(response.class).to be Hash
+    expect(response['campaignId']).to be id
+    expect(response).to have_key 'campaignName'
+  end
+
+  it "can delete one plan by the id" do
+    ids = subject.ids()
+    response = subject.delete(ids.first)
+    expect(response).to be true
+  end
+
+  it "can delete two plans by the ids" do
+    ids = subject.ids()
+    pending if ids.size < 2
+    response = subject.delete(ids[0..1])
+    expect(response).to be true
+  end
+  # it "could download all plan" do
+  #   result = subject.all
+  #   if result
+  #     expect(result.keys).to include :account_file_path
+  #   else
+  #     expect(subject.code).to eq '901162'
+  #   end
+  # end
+  it "enables one plan by id" do
+    id = subject.ids().first
+
+    response = subject.enable(id)
+    expect(response.class).to be Array
+    expect(response.first.class).to be Hash
+    expect(response.first['pause']).to be false
+  end
+
+  it "enables two plans by ids" do
+    id1 = subject.ids()[0]
+    id2 = subject.ids()[1]
+
+    response = subject.enable([id1,id2])
+    expect(response.class).to be Array
+    expect(response.first.class).to be Hash
+    expect(response[0]['pause']).to be false
+    expect(response[1]['pause']).to be false
+  end
+
+  it "pauses one plan by id" do
+    id = subject.ids().first
+
+    response = subject.pause(id)
+    expect(response.class).to be Array
+    expect(response.first.class).to be Hash
+    expect(response.first['pause']).to be true
+  end
+
+  it "pauses two plans by ids" do
+    id1 = subject.ids()[0]
+    id2 = subject.ids()[1]
+    response = subject.pause([id1,id2])
+    expect(response.class).to be Array
+    expect(response.first.class).to be Hash
+    expect(response[0]['pause']).to be true
+    expect(response[1]['pause']).to be true
+  end
+end

data/spec/operation_spec.rb

@@ -0,0 +1,87 @@
+require 'operation_spec_helper'
+
+  Auth =  {}
+  Auth[:username] = $baidu_username
+  Auth[:password] = $baidu_password 
+  Auth[:token] = $baidu_token
+  Auth[:se] = 'baidu'
+  preparation = ::PPC::API::Baidu::Group::ids( Auth )
+  Test_plan_id = preparation[:result][0][:plan_id]
+  Test_group_id = preparation[:result][0][:group_ids][0]
+
+
+describe ::PPC::Operation::Account do
+  subject{
+    ::PPC::Operation::Account.new( Auth )
+  }
+
+  it_should_behave_like( "it can operate itself", {budget:2990})
+  it_should_behave_like( "it can get all sub_objects", 'plan')
+
+  it_should_behave_like( "it can operate sub_objects", 'plan', {name:'operation_test_plan'},  
+                                      {name:'updated_operation_test_plan'})
+
+  it_should_behave_like( "it can operate sub_objects", 'group', 
+                                      {name:'test_operation_group',plan_id:Test_plan_id, price:500},
+                                      {name:'updated_operation_test_group'} )  
+
+  it_should_behave_like( "it can operate sub_objects", 'keyword', 
+                                      { keyword:'testKeyword', group_id:Test_group_id, match_type:'exact'},
+                                      { match_type:'wide'})
+
+  it_should_behave_like( "it can operate sub_objects", 'creative', 
+                                       { group_id: Test_group_id, 
+                                          title: 'OperationTestCreative', preference:1, 
+                                          description1:'this is rest',
+                                          description2:'also is a test',
+                                          pc_destination:$baidu_domain,
+                                          pc_display:$baidu_domain },
+                                      {title:'OperationTestCreative', description1:'what the fuck'})
+end
+
+describe ::PPC::Operation::Plan do
+  # get test subject
+  subject{
+    ::PPC::Operation::Plan.new( Auth.merge({id:Test_plan_id}) )
+  }
+
+  it_should_behave_like( "it can operate itself", {budget:2000})
+  it_should_behave_like( "it can operate sub_objects", 'group', 
+                                      {name:'test_operation_group', price:500},
+                                      {name:'updated_operation_test_group'} )  
+  it_should_behave_like( "it can get all sub_objects", 'group')
+end
+
+describe ::PPC::Operation::Group do
+  # get test subject
+  subject{
+    ::PPC::Operation::Group.new( Auth.merge({id:Test_group_id}) )
+  }
+
+  it_should_behave_like( "it can operate itself", {price:200})
+  it_should_behave_like( "it can operate sub_objects", 'keyword', 
+                                      { keyword:'testKeyword', group_id:Test_group_id, match_type:'exact'},
+                                      { match_type:'wide'})
+  it_should_behave_like( "it can get all sub_objects", 'keyword')
+end
+
+# describe ::PPC::Operation::Keyword do
+  # # get test subject
+  # subject{
+  #   ::PPC::Operation::Keyword.new( Auth.merge({id:?}) )
+  # }
+
+  # it_should_behave_like( "it can operate itself", {price:200})
+# end
+
+# describe ::PPC::Operation::Creative do
+  # # get test subject
+  # subject{
+  #   ::PPC::Operation::Creative.new( Auth.merge({id:?}) )
+  # }
+
+  # it_should_behave_like( "it can operate itself", {price:200})
+# end
+
+
+

data/spec/operation_spec_helper.rb

@@ -0,0 +1,53 @@
+shared_examples "it can operate itself" do 
+  | update |
+  it 'can get info' do
+    result = subject.info
+    is_success( result )
+  end
+
+  it 'can update it self' do
+    result = subject.update(  update )
+    is_success( result )
+  end
+end
+
+# 在这之前要describ object
+shared_examples "it can operate sub_objects" do 
+  |object_name,  add_info, update_info |
+  object_id = 0
+  
+  it 'can add object' do
+    method_name = "add_"+object_name
+    result = subject.send( method_name.to_sym, add_info )
+    is_success( result )
+    p "HAHAHAAAHA"*12
+    p result
+    object_id = result[:result][0][:id]
+  end
+
+  it 'can update object' do
+    method_name = "update_"+object_name
+    result = subject.send( method_name.to_sym, update_info.merge( {id:object_id} ) )
+    is_success( result )
+  end
+
+  it 'can delete object' do
+    method_name = "delete_"+object_name
+    result = subject.send( method_name.to_sym, object_id )
+    is_success( result )
+  end
+end
+
+  shared_examples "it can get all sub_objects" do
+    | object_name| 
+    it 'can get all objects'do
+      result = subject.send( (object_name + 's').to_sym ) 
+      is_success( result )
+    end 
+
+    it 'can get all object ids' do
+      result = subject.send( (object_name + '_ids').to_sym ) 
+      is_success( result )
+    end
+end
+

data/spec/spec_helper.rb

@@ -1,3 +1,4 @@
+# -*- coding:utf-8 -*-
 # This file was generated by the `rspec --init` command. Conventionally, all
 # specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
 # The generated `.rspec` file contains `--require spec_helper` which will cause this
@@ -78,4 +79,20 @@ RSpec.configure do |config|
 end
 
 
-require 'ppc'
+require 'ppc'
+
+$baidu_domain = ''
+$baidu_username = ''
+$baidu_password = ''
+$baidu_token = ''
+$qihu_username = ''
+$qihu_password = ''
+$qihu_token = ''
+$sogou_username = ''
+$sogou_password = ''
+$sogou_token = ''
+
+def is_success( result )
+  expect( result[:succ] ).to eq true
+end
+