ac-summarization-utils 0.0.47.rc1

data/lib/ac-summarization-utils/version.rb

@@ -0,0 +1,3 @@
+module ACSummarizationUtils
+    VERSION = "0.0.47.rc1"
+end

data/spec/errors_handler_spec.rb

@@ -0,0 +1,52 @@
+require 'a15-worker'
+require_relative '../lib/ac-summarization-utils/errors_handler'
+
+include ACSummarizationUtils
+
+describe "Errors Handler#" do
+  include A15::Worker
+  def mock_producer
+    @producer_mock = mock("Producer")
+    Producer.stub(:new).with(any_args()).and_return(@producer_mock)
+  end
+
+  def mock_logger
+    @log_mock = mock("logger")
+    @log_mock.stub(:log)
+  end
+
+  class TestQueriesEror < RuntimeError
+      attr_accessor :queries
+    end
+
+  it "should send input errors one by one for 2 generated messages" do
+      mock_logger
+      mock_producer
+      @producer_mock.should_receive(:publish).with(any_args()).exactly(2).times
+
+      target = ErrorsHandler.new("", "", "", "", "")
+      target.send_input_errors(@log_mock, [{"1" => "a"}, {"2" => "b"}])
+  end
+
+  it "should generate and send input errors one by one for 2 messages " do
+      mock_logger
+      mock_producer
+      @producer_mock.should_receive(:publish).with(any_args()).exactly(2).times
+
+      target = ErrorsHandler.new("", "", "", "","")
+      target.gen_and_send_input_errors(@log_mock, ["1", "2"], Exception.new("bla"))
+
+  end
+
+
+  it "should send db error with 2 messages" do
+      mock_logger
+      mock_producer
+      @producer_mock.should_receive(:publish).with(any_args()).exactly(1).times
+
+      target = ErrorsHandler.new("", "", "", "","")
+      target.gen_and_send_db_errors(@log_mock, ["1", "2"], TestQueriesEror.new("bla"))
+
+  end
+
+end

data/spec/general_utils_spec.rb

@@ -0,0 +1,35 @@
+require 'rspec'
+require_relative '../lib/ac-summarization-utils/general_utils'
+
+include ACSummarizationUtils
+include ACSummarizationUtils::GeneralUtils
+
+describe "General Utils#" do
+  context "convert_country_code#" do
+
+    it "should return 'oth' for unsupported country code" do
+      convert_country_code('shuki').should == 'oth'
+      convert_country_code('muki').should == 'oth'
+      convert_country_code('neverland').should == 'oth'
+    end
+
+    it "should return specific country for country in supported list" do
+      convert_country_code('us').should == 'us'
+      convert_country_code('gb').should == 'gb'
+      convert_country_code('it').should == 'it'
+      convert_country_code('fr').should == 'fr'
+    end
+
+    it "should return 'latin_am' for country in SUPPORTED_LATIN_COUNTRIES" do
+      convert_country_code('gt').should == 'latin_am'
+      convert_country_code('sv').should == 'latin_am'
+      convert_country_code('br').should == 'latin_am'
+    end
+
+    it "should return 'f_east' for country in SUPPORTED_FAR_EAST" do
+      convert_country_code('jp').should == 'f_east'
+      convert_country_code('ph').should == 'f_east'
+    end
+
+  end
+end

data/spec/lookup_cache_spec.rb

@@ -0,0 +1,956 @@
+require 'redis'
+require 'mysql2'
+require_relative '../lib/ac-summarization-utils/lookup_cache'
+
+include ACSummarizationUtils
+
+describe "Lookup Cache#" do
+
+  def mock_db
+    @db_mock = mock("Mysql2::Client")
+    Mysql2::Client.stub(:new).with(any_args()).and_return(@db_mock)
+  end
+
+  def mock_redis
+    @redis_client_mock = mock('Redis::Client')
+    Redis.stub!(:connect).and_return(@redis_client_mock)
+  end
+
+  it "should raise ResourcesError if db unavailable" do
+      expiration = 2
+      mock_redis
+      @redis_client_mock.stub!(:client).with(no_args()).and_return(nil)
+      Mysql2::Client.stub(:new).with(any_args()).and_raise(Mysql2::Error)
+      lambda {LookupCache.new("", "", expiration, "", "", "", "db_name")}.should raise_error(LookupCache::ResourcesError)
+  end
+
+  it "should raise ResourcesError if redis is unavailable" do
+      expiration = 2
+      mock_redis
+      Redis.stub!(:client).with(no_args()).and_return(nil)
+      Redis.stub!(:connect).and_raise(Exception)
+      lambda{LookupCache.new("", "", expiration, "", "", "", "db_name")}.should raise_error(LookupCache::ResourcesError)
+  end
+
+  context "adgroup_id calculations#" do
+
+    it "should calculate adgroup_id from DB and add to redis if ad_id exist in DB" do
+      adgroup_id = 10
+      query_result = [{"adgroup_id" => adgroup_id}]
+      ad_id = 1
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:adgroup:#{ad_id}").and_return(nil)
+      @redis_client_mock.should_receive(:setex).with("k:adgroup:#{ad_id}",expiration,adgroup_id)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_adgroup_id(ad_id).should == adgroup_id
+    end
+
+    it "should not go to DB cache if data exists in redis" do
+      adgroup_id = 10
+      ad_id = 1
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:adgroup:#{ad_id}").and_return(adgroup_id)
+      @db_mock.should_not_receive(:query).with(any_args())
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_adgroup_id(ad_id).should.should == adgroup_id
+    end
+
+
+    it "should raise error if requested to calculate adgroup_id and ad_id doesn't exist in DB" do
+      ad_id = 1
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:adgroup:#{ad_id}").and_return(nil)
+      @db_mock.should_receive(:query).with(any_args()).and_return([{}])
+
+      target = LookupCache.new("", "", "", "", "", "", "db_name")
+      lambda { target.get_adgroup_id(ad_id)}.should raise_error(LookupCache::InputError)
+    end
+
+    
+  end
+
+  context "campaign_id calculations#" do
+
+    it "should calculate campaign_id from DB and add to redis if ad_id exist in DB" do
+      campaign_id = 100
+      query_result = [{"campaign_id" => campaign_id}]
+      ad_id = 1
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:campaign:#{ad_id}").and_return(nil)
+      @redis_client_mock.should_receive(:setex).with("k:campaign:#{ad_id}", expiration, campaign_id)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_campaign_id(ad_id).should == campaign_id
+    end
+
+    it "should not go to DB cache if data exists in redis" do
+      campaign_id = 100
+      ad_id = 1
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:campaign:#{ad_id}").and_return(campaign_id)
+      @db_mock.should_not_receive(:query).with(any_args())
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_campaign_id(ad_id).should == campaign_id
+    end
+
+
+    it "should raise error if requested to calculate campaign_id and ad_id doesn't exist in DB" do
+      ad_id = 1
+      mock_db
+      mock_redis
+
+      @redis_client_mock.should_receive(:get).with("k:campaign:#{ad_id}").and_return(nil)
+      @db_mock.should_receive(:query).with(any_args()).and_return([{}])
+
+      target = LookupCache.new("", "", "", "", "", "", "db_name")
+      lambda {target.get_campaign_id(ad_id)}.should raise_error(LookupCache::InputError)
+    end
+
+  end
+
+  context "campaign pricing rate" do
+
+    it "should get pricing_rate from DB and add to redis if campaign_id exists in DB" do
+      pricing_rate = 4
+      query_result = [{"pricing_rate" => pricing_rate}]
+      campaign_id = 1
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:campaign_pricing_rate:#{campaign_id}").and_return(nil)
+      @redis_client_mock.should_receive(:setex).with("k:campaign_pricing_rate:#{campaign_id}", expiration, pricing_rate)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_campaign_pricing_rate(campaign_id).should == pricing_rate
+    end
+
+    it "should not go to DB cache if data exists in redis" do
+      pricing_rate = 4
+      campaign_id = 1
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:campaign_pricing_rate:#{campaign_id}").and_return(pricing_rate)
+      @db_mock.should_not_receive(:query).with(any_args())
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_campaign_pricing_rate(campaign_id).should == pricing_rate
+    end
+
+
+    it "should raise error if requested to get pricing_rate for campaign_id doesn't exist in DB" do
+      campaign_id = 1
+      mock_db
+      mock_redis
+
+      @redis_client_mock.should_receive(:get).with("k:campaign_pricing_rate:#{campaign_id}").and_return(nil)
+      @db_mock.should_receive(:query).with(any_args()).and_return([{}])
+
+      target = LookupCache.new("", "", "", "", "", "", "db_name")
+      lambda {target.get_campaign_pricing_rate(campaign_id)}.should raise_error(LookupCache::InputError)
+    end
+  end
+
+
+  context "engagement type get" do
+
+    it "should get ad_type_id from DB and add to redis if ad_id exists in DB" do
+      ad_type_id = 4
+      query_result = [{"ad_type_id" => ad_type_id}]
+      ad_id = 1
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:engagement_ad_type:#{ad_id}").and_return(nil)
+      @redis_client_mock.should_receive(:setex).with("k:engagement_ad_type:#{ad_id}", expiration, ad_type_id)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_engagement_type(ad_id).should == ad_type_id
+    end
+
+    it "should not go to DB cache if data exists in redis" do
+      ad_type_id = 4
+      ad_id = 1
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:engagement_ad_type:#{ad_id}").and_return(ad_type_id)
+      @db_mock.should_not_receive(:query).with(any_args())
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_engagement_type(ad_id).should == ad_type_id
+    end
+
+
+    it "should raise error if requested to get ad_type_id for ad_id doesn't exist in DB" do
+      ad_id = 1
+      mock_db
+      mock_redis
+
+      @redis_client_mock.should_receive(:get).with("k:engagement_ad_type:#{ad_id}").and_return(nil)
+      @db_mock.should_receive(:query).with(any_args()).and_return([{}])
+
+      target = LookupCache.new("", "", "", "", "", "", "db_name")
+      lambda {target.get_engagement_type(ad_id)}.should raise_error(LookupCache::InputError)
+    end
+
+  end
+
+  context "engagement video length get" do
+
+    it "should get ad video length from DB and add to redis if ad_id exist in DB" do
+      video_len = 3500
+      query_result = [{"rm_time_millis" => video_len}]
+      ad_id = 1
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:engagement_ad_video:#{ad_id}").and_return(nil)
+      @redis_client_mock.should_receive(:setex).with("k:engagement_ad_video:#{ad_id}", expiration, video_len)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_engagement_video_length(ad_id).should == video_len
+    end
+
+    it "should not go to DB cache if data exists in redis" do
+      video_len = 3500
+      ad_id = 1
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:engagement_ad_video:#{ad_id}").and_return(video_len)
+      @db_mock.should_not_receive(:query).with(any_args())
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_engagement_video_length(ad_id).should == video_len
+    end
+
+
+    it "should raise error if requested to get video length for ad_id doesn't exist in DB" do
+      ad_id = 1
+      mock_db
+      mock_redis
+
+      @redis_client_mock.should_receive(:get).with("k:engagement_ad_video:#{ad_id}").and_return(nil)
+      @db_mock.should_receive(:query).with(any_args()).and_return([{}])
+
+      target = LookupCache.new("", "", "", "", "", "", "db_name")
+      lambda {target.get_engagement_video_length(ad_id)}.should raise_error(LookupCache::InputError)
+    end
+
+  end
+  
+  context "is engagement by precentage" do
+  	it "get engagment as 1/0" do
+  		ad_id = 123
+  		expiration = 20
+  		[0,1].each do |should_engaged_by_per|
+				query_result = [{"engagment_by_percentage" => should_engaged_by_per}]
+				mock_db
+		 		mock_redis
+				
+				@redis_client_mock.should_receive(:get).and_return(nil)
+		    @redis_client_mock.should_receive(:setex).with("k:engagment_by_percentage:#{ad_id}", expiration, should_engaged_by_per)
+				@db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+				
+		    target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+				target.get_is_engagement_by_percentage(ad_id).should == should_engaged_by_per
+			end
+  	end
+  	
+  	it "should not go to DB cache if data exists in redis" do
+      ad_id = 1
+      expiration = 2
+      mock_db
+      mock_redis
+      should_engaged_by_per = 0
+      @redis_client_mock.should_receive(:get).with("k:engagment_by_percentage:#{ad_id}").and_return(should_engaged_by_per)
+      @db_mock.should_not_receive(:query).with(any_args())
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_is_engagement_by_percentage(ad_id).should == should_engaged_by_per
+    end
+  	
+  	it "should raise error if requested to get engagement percentage for ad_id doesn't exist in DB" do
+      ad_id = 1
+      mock_db
+      mock_redis
+
+      @redis_client_mock.should_receive(:get).with("k:engagment_by_percentage:#{ad_id}").and_return(nil)
+      @db_mock.should_receive(:query).with(any_args()).and_return([{}])
+
+      target = LookupCache.new("", "", "", "", "", "", "db_name")
+      lambda {target.get_is_engagement_by_percentage(ad_id)}.should raise_error(LookupCache::InputError)
+    end
+  end
+
+  context "account_id calculations#" do
+
+    it "should calculate account_id from DB and add to redis if ad_id exist in DB" do
+      account_id = 1000
+      query_result = [{"account_id" => account_id}]
+      ad_id = 1
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:account:#{ad_id}").and_return(nil)
+      @redis_client_mock.should_receive(:setex).with("k:account:#{ad_id}", expiration, account_id)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_account_id(ad_id).should == account_id
+    end
+
+    it "should not go to DB cache if data exists in redis" do
+      account_id = 1000
+      ad_id = 1
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:account:#{ad_id}").and_return(account_id)
+      @db_mock.should_not_receive(:query).with(any_args())
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_account_id(ad_id).should == account_id
+    end
+
+
+    it "should raise error if requested to calculate account_id and ad_id doesn't exist in DB" do
+      ad_id = 1
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:account:#{ad_id}").and_return(nil)
+      @db_mock.should_receive(:query).with(any_args()).and_return([{}])
+
+      target = LookupCache.new("", "", "", "", "", "", "db_name")
+      lambda {target.get_account_id(ad_id)}.should raise_error(LookupCache::InputError)
+    end
+
+  end
+
+  context "date calculations#" do
+
+    it "should calculate date from record's date" do
+      mock_db
+      mock_redis
+
+      target = LookupCache.new("", "", "", "", "", "", "db_name")
+      target.get_date("2011-09-25 17:27:02.614").should == "2011-09-25"
+    end
+
+    it "should calculate date from record's date as fixnum" do
+      mock_db
+      mock_redis
+
+      target = LookupCache.new("", "", "", "", "", "", "db_name")
+      target.get_date(1317911311).should == "2011-10-06"
+    end
+
+    it "should return nil if date cannot be parsed" do
+      mock_db
+      mock_redis
+
+      target = LookupCache.new("", "", "", "", "", "", "db_name")
+      lambda{ target.get_date("2011-09 17:27:02.614")}.should raise_error(LookupCache::InputError)
+    end
+
+    it "should return nil if date is nil" do
+
+      mock_db
+      mock_redis
+
+      target = LookupCache.new("", "", "", "", "", "", "db_name")
+      target.get_date(nil).should == nil
+    end
+
+  end
+
+  context "adgroup topics calculations#" do
+
+    it "should calculate relevant adgroup topics from DB and add to redis if topics exists in DB if page topics is an array" do
+      adgroup_id = 1000
+      query_result = [{"subtopic" => "1"},{"subtopic" => "2"}]
+      page_subtopics = ["1","2"]
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:adgroup_topics:#{adgroup_id}").and_return(nil)
+      @redis_client_mock.should_receive(:setex).with("k:adgroup_topics:#{adgroup_id}", expiration, page_subtopics.to_json)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+      @redis_client_mock.should_receive(:get).with("k:adgroup_topics:#{adgroup_id}").exactly(3).times.and_return(page_subtopics.to_json)
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_relevant_topic_ids([],adgroup_id).should == []
+      target.get_relevant_topic_ids(page_subtopics,adgroup_id).should == [1,2]
+      target.get_relevant_topic_ids(["1"],adgroup_id).should == [1]
+      target.get_relevant_topic_ids(["2"],adgroup_id).should == [2]
+      target.get_relevant_topic_ids(["4"],adgroup_id).should == []
+    end
+
+     it "should calculate relevant adgroup topics from DB and add to redis if topics exists in DB if page topics is a string with +" do
+      adgroup_id = 1000
+      query_result = [{"subtopic" => "1"},{"subtopic" => "2"}]
+      page_subtopics= "1+2"
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:adgroup_topics:#{adgroup_id}").and_return(nil)
+      @redis_client_mock.should_receive(:setex).with("k:adgroup_topics:#{adgroup_id}", expiration, ["1","2"].to_json)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+      @redis_client_mock.should_receive(:get).with("k:adgroup_topics:#{adgroup_id}").exactly(3).times.and_return(["1","2"].to_json)
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_relevant_topic_ids("",adgroup_id).should == []
+      target.get_relevant_topic_ids(page_subtopics,adgroup_id).should == [1,2]
+      target.get_relevant_topic_ids("1",adgroup_id).should == [1]
+      target.get_relevant_topic_ids("2",adgroup_id).should == [2]
+      target.get_relevant_topic_ids("4",adgroup_id).should == []
+     end
+
+    it "should calculate relevant adgroup topics from DB and add to redis if topics exists in DB if page topics is a string with spaces" do
+      adgroup_id = 1000
+      query_result = [{"subtopic" => "1"},{"subtopic" => "2"}]
+      page_subtopics= "1 2"
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:adgroup_topics:#{adgroup_id}").and_return(nil)
+      @redis_client_mock.should_receive(:setex).with("k:adgroup_topics:#{adgroup_id}", expiration, ["1","2"].to_json)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+      @redis_client_mock.should_receive(:get).with("k:adgroup_topics:#{adgroup_id}").exactly(3).times.and_return(["1","2"].to_json)
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_relevant_topic_ids("",adgroup_id).should == []
+      target.get_relevant_topic_ids(page_subtopics,adgroup_id).should == [1,2]
+      target.get_relevant_topic_ids("1",adgroup_id).should == [1]
+      target.get_relevant_topic_ids("2",adgroup_id).should == [2]
+      target.get_relevant_topic_ids("4",adgroup_id).should == []
+    end
+
+    it "should not go to DB cache if data exists in redis" do
+      adgroup_id = 1000
+      subtopics_result = [1,2]
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:adgroup_topics:#{adgroup_id}").twice.and_return(subtopics_result.to_json)
+      @db_mock.should_not_receive(:query).with(any_args())
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_relevant_topic_ids(["1","2"], adgroup_id).should == subtopics_result
+      target.get_relevant_topic_ids("1+2", adgroup_id).should == subtopics_result
+    end
+
+
+    it "should return empty topics if subtopics don't exist in DB" do
+      adgroup_id = 1000
+      query_result = []
+      subtopics_result = []
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:adgroup_topics:#{adgroup_id}").and_return(nil)
+      @redis_client_mock.should_receive(:setex).with("k:adgroup_topics:#{adgroup_id}", expiration, subtopics_result.to_json)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+      @redis_client_mock.should_receive(:get).with("k:adgroup_topics:#{adgroup_id}").and_return(subtopics_result.to_json)
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_relevant_topic_ids("1", adgroup_id).should == subtopics_result
+      target.get_relevant_topic_ids(["1"], adgroup_id).should == subtopics_result
+    end
+
+  end
+
+  context "adgroup publisher pubgroups calculations#" do
+
+    it "should adgroup publisher pubgroups from DB and add to redis if got matching pubgorups from DB" do
+      adgroup_id = 1000
+      publisher_id = 131821
+      query_result = [{"pubgroup_id" => "1"},{"pubgroup_id" => "2"}]
+      pubgroup_ids = ['1','2']
+      expiration = 2
+      mock_db
+      mock_redis
+      key = "k:adgroup_publisher_pubgroups:#{adgroup_id}:#{publisher_id}"
+      @redis_client_mock.should_receive(:get).with(key).and_return(nil)
+      @redis_client_mock.should_receive(:setex).with(key, expiration, pubgroup_ids.to_json)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+      @redis_client_mock.should_receive(:get).with(key).and_return(pubgroup_ids.to_json)
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_pubgroup_ids(adgroup_id,nil).should == []
+      target.get_pubgroup_ids(nil,publisher_id).should == []
+      target.get_pubgroup_ids(adgroup_id,publisher_id).should == pubgroup_ids.map{|pg| pg.to_i}
+      target.get_pubgroup_ids(adgroup_id,publisher_id).should == pubgroup_ids.map{|pg| pg.to_i}
+    end
+
+    it "should not go to DB cache if data exists in redis" do
+      adgroup_id = 1000
+      publisher_id = 131821
+      pubgroups_ids = [3,4]
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:adgroup_publisher_pubgroups:#{adgroup_id}:#{publisher_id}").and_return(pubgroups_ids.to_json)
+      @db_mock.should_not_receive(:query).with(any_args())
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_pubgroup_ids(adgroup_id,publisher_id).should == pubgroups_ids
+    end
+
+    it "should return  pubgroup -1 if none were found in DB" do
+      adgroup_id = 1000
+      publisher_id = 131821
+      query_result = []
+      pubgroups_ids = [-1]
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:adgroup_publisher_pubgroups:#{adgroup_id}:#{publisher_id}").and_return(nil)
+      @redis_client_mock.should_receive(:setex).with("k:adgroup_publisher_pubgroups:#{adgroup_id}:#{publisher_id}", expiration, pubgroups_ids.to_json)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+      @redis_client_mock.should_receive(:get).with("k:adgroup_publisher_pubgroups:#{adgroup_id}:#{publisher_id}").and_return(pubgroups_ids.to_json)
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_pubgroup_ids(adgroup_id,publisher_id).should == pubgroups_ids #check that got default value from DB
+      target.get_pubgroup_ids(adgroup_id,publisher_id).should == pubgroups_ids #check that got default value Cache either.
+    end
+
+  end
+  
+  context "duplicate value tests#" do
+    it "should return nil if value for the first time and set it" do
+      key = "test"
+      expiration = 2
+      mock_redis
+      mock_db
+      @redis_client_mock.should_receive(:get).with("k:dup:#{key}").and_return(nil)
+      @redis_client_mock.should_receive(:setex).with("k:dup:#{key}", expiration, true)
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      res = target.get_and_set_duplicate_value(key,expiration)
+      res.should == nil
+    end
+  
+    it "should return true value for the second time" do
+      key = "test"
+      expiration = 2
+      mock_redis
+      mock_db
+      @redis_client_mock.should_receive(:get).with("k:dup:#{key}").and_return(nil)
+      @redis_client_mock.should_receive(:setex).with("k:dup:#{key}", expiration, true)
+      @redis_client_mock.should_receive(:get).with("k:dup:#{key}").and_return(true)
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      res = target.get_and_set_duplicate_value(key,expiration)
+      res = target.get_and_set_duplicate_value(key,expiration)
+      res.should == true
+    end
+  
+    it "should clear key for redis" do
+      key = "test"
+      mock_redis
+      mock_db
+      @redis_client_mock.should_receive(:del).with("k:dup:#{key}")
+      target = LookupCache.new("", "", 606060606060606060606060606060606060606060606060606060606060606060606060606060606060606060606060606060606060606060606060, "", "", "", "db_name")
+      target.clear_duplicate_value(key) 
+    end
+  end
+
+  context "advertiser share info#" do
+    it "should get advertiser shares from DB and add to redis" do
+      advertiser_id = 7753
+      query_result = [{"reserveShare" => 0.1, "advertiserShare" => 0.3, "reserve" => 0.0}]
+      expected = {"reserve_share" => 0.1, "adv_share" => 0.3, "campaign_reserve" => 0.0}
+      expiration = 2
+      mock_db
+      mock_redis
+      key = "k:advertiser_shares:#{advertiser_id}"
+      @redis_client_mock.should_receive(:get).with(key).and_return(nil)
+      @redis_client_mock.should_receive(:setex).with(key, expiration, expected.to_json)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+      @redis_client_mock.should_receive(:get).with(key).and_return(expected.to_json)
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_advertiser_shares(nil,nil).should == {}
+      shares = target.get_advertiser_shares(advertiser_id,nil)
+      shares.should == expected
+      target.get_advertiser_shares(advertiser_id,nil).should == expected
+    end
+
+    it "should not go to DB cache if data exists in redis" do
+      advertiser_id = 8
+      campaign_id = 55555
+      adv_shares = {"reserve_share" => 0.1, "adv_share" => 0.3, "campaign_reserve" => 0.12}
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:advertiser_shares:#{advertiser_id}:#{campaign_id}").and_return(adv_shares.to_json)
+      @db_mock.should_not_receive(:query).with(any_args())
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_advertiser_shares(advertiser_id,campaign_id).should == adv_shares
+    end
+
+    it "should return empty response if advertiser was not found in DB" do
+      advertiser_id = 23121
+      campaign_id = nil
+      query_result = []
+      adv_shares = {"reserve_share" => 0.0, "adv_share" => 0.0, "campaign_reserve" => 0.0}
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:advertiser_shares:#{advertiser_id}").and_return(nil)
+      @redis_client_mock.should_receive(:setex).with("k:advertiser_shares:#{advertiser_id}", expiration, adv_shares.to_json)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+
+      @redis_client_mock.should_receive(:get).with("k:advertiser_shares:#{advertiser_id}").and_return(adv_shares.to_json)
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_advertiser_shares(advertiser_id,campaign_id).should == adv_shares #check that got default value from DB
+      target.get_advertiser_shares(advertiser_id,campaign_id).should == adv_shares #check that got default value Cache either.
+    end
+  end
+
+  context "publisher payment info#" do
+    it "should get publisher payment info from DB and add to redis" do
+      publisher_id = 131821
+      query_result = [{"site_payment_type_id" => 2, "cpm" => 232 , "rev_share" => 0.0}]
+      expected = {"payment_type" => 2, "cpm" => 232.0 , "rev_share" => 0.0}
+      expiration = 2
+      mock_db
+      mock_redis
+      key = "k:publisher_payments_info:#{publisher_id}"
+      @redis_client_mock.should_receive(:get).with(key).and_return(nil)
+      @redis_client_mock.should_receive(:setex).with(key, expiration, expected.to_json)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+      @redis_client_mock.should_receive(:get).with(key).and_return(expected.to_json)
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_publisher_payment_info(nil).should == {}
+      shares = target.get_publisher_payment_info(publisher_id)
+      shares.should == expected
+      target.get_publisher_payment_info(publisher_id).should == expected
+    end
+
+    it "should not go to DB cache if data exists in redis" do
+      publisher_id = 4042
+      payment_info =  {"payment_type" => 1, "cpm" => 0 , "rev_share" => 0.23}
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:publisher_payments_info:#{publisher_id}").and_return(payment_info.to_json)
+      @db_mock.should_not_receive(:query).with(any_args())
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_publisher_payment_info(publisher_id).should == payment_info
+    end
+
+    it "should return empty response if publisher was not found in DB" do
+      publisher_id = 22222
+      query_result = []
+      payment_info = {"payment_type" => 1, "cpm" => 0.0, "rev_share" => 0.0}
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:publisher_payments_info:#{publisher_id}").and_return(nil)
+      @redis_client_mock.should_receive(:setex).with("k:publisher_payments_info:#{publisher_id}", expiration, payment_info.to_json)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+      @redis_client_mock.should_receive(:get).with("k:publisher_payments_info:#{publisher_id}").and_return(payment_info.to_json)
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_publisher_payment_info(publisher_id).should == payment_info #check that got default value from DB
+      target.get_publisher_payment_info(publisher_id).should == payment_info #check that got default value Cache either.
+    end
+  end
+
+  context "campaign_engagement_qualifier#" do
+    it "should get  engagement qualifier for campaign" do
+      campaign_id = 3
+			expected = 4
+			json_value = "{\"value\":#{expected}}"
+      query_result = [{"engagement_qualifier" => "{\"value\":4}"}]
+      mock_db
+      mock_redis
+      redis_key = "k:engagement_threshold:#{campaign_id}"
+			@redis_client_mock.should_receive(:get).with(redis_key).and_return(nil)
+			@redis_client_mock.should_receive(:setex).with(redis_key, expiration=5, json_value)
+			@db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+      
+			target = LookupCache.new("", "", expiration=5, "", "", "", "db_name")
+			target.get_engagement_threshold(campaign_id).should == expected # from db
+
+			@redis_client_mock.should_receive(:get).with(redis_key).and_return(json_value)
+			target.get_engagement_threshold(campaign_id).should == expected # from redis
+    end
+
+ 		it "should have no engagement qualifier for campaign" do
+      campaign_id = 33
+			expected = 4
+			json_value = "{\"value\":#{expected}}"
+      query_result = [{"engagement_qualifier" => "{\"value\":4}"}]
+      mock_db
+      mock_redis
+      redis_key = "k:engagement_threshold:#{campaign_id}"
+			@redis_client_mock.should_receive(:get).with(redis_key).and_return(nil)
+			@db_mock.should_receive(:query).with(any_args()).and_return(nil)
+      
+			target = LookupCache.new("", "", expiration=5, "", "", "", "db_name")
+			target.get_engagement_threshold(campaign_id).should == nil # from db
+
+			target.get_engagement_threshold(campaign_id+1).should == nil # campaign not set
+    end
+  end
+
+  context "campaign cpm data#" do
+    it "should get campaign cpm rate from DB and add to redis" do
+      campaign_id = 2
+      query_result = [{"cpm_rate" => 0.04}]
+      expected = 0.04
+      expiration = 2
+      mock_db
+      mock_redis
+      key = "k:campaign_cpm:#{campaign_id}"
+      @redis_client_mock.should_receive(:get).with(key).and_return(nil)
+      @redis_client_mock.should_receive(:setex).with(key, expiration, expected)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+      @redis_client_mock.should_receive(:get).with(key).and_return(expected)
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_campaign_cpm(nil).should == 0.0
+      cpm = target.get_campaign_cpm(campaign_id)
+      cpm.should == expected
+      target.get_campaign_cpm(campaign_id).should == expected
+    end
+
+    it "should not go to DB cache if data exists in redis" do
+      campaign_id = 2
+      expected = 0.04
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:campaign_cpm:#{campaign_id}").and_return(expected)
+      @db_mock.should_not_receive(:query).with(any_args())
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_campaign_cpm(campaign_id).should == expected
+    end
+
+    it "should return raise exception if campaign was not found in DB" do
+      campaign_id = 1
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:campaign_cpm:#{campaign_id}").and_return(nil)
+      @db_mock.should_receive(:query).with(any_args()).and_return([{}])
+
+      target = LookupCache.new("", "", "", "", "", "", "db_name")
+      lambda {target.get_campaign_cpm(campaign_id)}.should raise_error(LookupCache::InputError)
+    end
+  end
+
+  context "campaign pricing data#" do
+    it "should get campaign pricing type from DB and add to redis" do
+      campaign_id = 2
+      query_result = [{"pricing_type_id" => 3}]
+      expected = 3
+      expiration = 2
+      mock_db
+      mock_redis
+      key = "k:pricing_type_id:#{campaign_id}"
+      @redis_client_mock.should_receive(:get).with(key).and_return(nil)
+      @redis_client_mock.should_receive(:setex).with(key, expiration, expected)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+      @redis_client_mock.should_receive(:get).with(key).and_return(expected)
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      #target.get_campaign_pricing_type_id(nil).should == 0.0
+      pricing_type_id = target.get_campaign_pricing_type_id(campaign_id)
+      pricing_type_id.should == expected
+      target.get_campaign_pricing_type_id(campaign_id).should == expected
+    end
+
+    it "should not go to DB cache if data exists in redis" do
+      campaign_id = 2
+      expected = 3 
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:pricing_type_id:#{campaign_id}").and_return(expected)
+      @db_mock.should_not_receive(:query).with(any_args())
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_campaign_pricing_type_id(campaign_id).should == expected
+    end
+
+    it "should return raise exception if campaign was not found in DB" do
+      campaign_id = 1
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:pricing_type_id:#{campaign_id}").and_return(nil)
+      @db_mock.should_receive(:query).with(any_args()).and_return([{}])
+
+      target = LookupCache.new("", "", "", "", "", "", "db_name")
+      lambda {target.get_campaign_pricing_type_id(campaign_id)}.should raise_error(LookupCache::InputError)
+    end
+
+  end
+
+  context "Channel publishers#" do
+    it "should get all channel publishers from DB and add to redis" do
+      query_result = [{"id"=>15},{"id" => 17}]
+      expected = [15,17]
+      expiration = 2
+      mock_db
+      mock_redis
+      key = "k:channel_publishers"
+      @redis_client_mock.should_receive(:get).with(key).and_return(nil)
+      @redis_client_mock.should_receive(:setex).with(key, expiration, expected)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+      @redis_client_mock.should_receive(:get).with(key).and_return(expected)
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_channel_publishers.should == expected
+      target.get_channel_publishers.should == expected
+    end
+
+    it "should not go to DB cache if data exists in redis" do
+      expected = [15,17]
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:channel_publishers").and_return(expected)
+      @db_mock.should_not_receive(:query).with(any_args())
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_channel_publishers.should == expected
+    end
+  end
+
+  context "campaign cpc data#" do
+    it "should get campaign cpc rate from DB and add to redis" do
+      campaign_id = 3
+      query_result = [{"cpc_rate" => 0.03}]
+      expected = 0.03
+      expiration = 2
+      mock_db
+      mock_redis
+      key = "k:campaign_cpc:#{campaign_id}"
+      @redis_client_mock.should_receive(:get).with(key).and_return(nil)
+      @redis_client_mock.should_receive(:setex).with(key, expiration, expected)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+      @redis_client_mock.should_receive(:get).with(key).and_return(expected)
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_campaign_cpc(nil).should == 0.0
+      cpm = target.get_campaign_cpc(campaign_id)
+      cpm.should == expected
+      target.get_campaign_cpc(campaign_id).should == expected
+    end
+  end
+
+  context "inimage_publisher_id#" do
+    it "should get publisher id from DB and add to redis" do
+      account_id="1176592e370"
+      query_result = [{"publisher_id"=>20}]
+      expected = 20
+      expiration = 2
+      mock_db
+      mock_redis
+      key = "k:inimage_publisher_id_map:#{account_id}"
+      @redis_client_mock.should_receive(:get).with(key).and_return(nil)
+      @redis_client_mock.should_receive(:setex).with(key, expiration, expected)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+      @redis_client_mock.should_receive(:get).with(key).and_return(expected)
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_publisher_id_by_inimage_id(account_id).should == expected
+      target.get_publisher_id_by_inimage_id(account_id).should == expected
+    end
+
+    it "should not go to DB cache if data exists in redis" do
+      account_id="1176592e370"
+      expected = 20
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:inimage_publisher_id_map:#{account_id}").and_return(expected)
+      @db_mock.should_not_receive(:query).with(any_args())
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_publisher_id_by_inimage_id(account_id).should == expected
+    end
+  end
+
+  context "inimage publisher payment info#" do
+    it "should get inimage publisher payment info from DB and add to redis" do
+      publisher_id = 131821
+      #query_result = [{"payment_type" => 0, "cpm" => 232 , "rev_share" => 0.0}]
+      query_result = [{"payment_type_id" => 2, "cpm" => 4 , "rev_share" => 0.0}]
+      expected = {"payment_type" => 2, "cpm" => 4.0 , "rev_share" => 0.0}
+      expiration = 2
+      mock_db
+      mock_redis
+      key = "k:inimage_publisher_payments_info:#{publisher_id}"
+      @redis_client_mock.should_receive(:get).with(key).and_return(nil)
+      @redis_client_mock.should_receive(:setex).with(key, expiration, expected.to_json)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+      @redis_client_mock.should_receive(:get).with(key).and_return(expected.to_json)
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_inimage_publisher_payment_info(nil).should == {}
+      shares = target.get_inimage_publisher_payment_info(publisher_id)
+      shares.should == expected
+      target.get_inimage_publisher_payment_info(publisher_id).should == expected
+    end
+
+    it "should not go to DB cache if data exists in redis" do
+      publisher_id = 4042
+      payment_info =  {"payment_type" => 1, "cpm" => 0 , "rev_share" => 0.23}
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:inimage_publisher_payments_info:#{publisher_id}").and_return(payment_info.to_json)
+      @db_mock.should_not_receive(:query).with(any_args())
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_inimage_publisher_payment_info(publisher_id).should == payment_info
+    end
+
+    it "should return empty response if publisher was not found in DB" do
+      publisher_id = 22222
+      query_result = []
+      payment_info = {"payment_type" => 1, "cpm" => 0.0, "rev_share" => 0.0}
+      expiration = 2
+      mock_db
+      mock_redis
+      @redis_client_mock.should_receive(:get).with("k:inimage_publisher_payments_info:#{publisher_id}").and_return(nil)
+      @redis_client_mock.should_receive(:setex).with("k:inimage_publisher_payments_info:#{publisher_id}", expiration, payment_info.to_json)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+      @db_mock.should_receive(:query).with(any_args()).and_return(query_result)
+      @redis_client_mock.should_receive(:get).with("k:inimage_publisher_payments_info:#{publisher_id}").and_return(payment_info.to_json)
+
+      target = LookupCache.new("", "", expiration, "", "", "", "db_name")
+      target.get_inimage_publisher_payment_info(publisher_id).should == payment_info #check that got default value from DB
+      target.get_inimage_publisher_payment_info(publisher_id).should == payment_info #check that got default value Cache either.
+    end
+  end
+
+end