chatterbot 1.0.2 → 2.0.0.pre

data/spec/dsl_spec.rb

@@ -3,10 +3,11 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 describe "Chatterbot::DSL" do
   describe "client routines" do
     before(:each) do
-      @bot = double(Chatterbot::Bot, :config => {})
+      @bot = instance_double(Chatterbot::Bot, :config => {})
       @bot.send :require, 'chatterbot/dsl'
 
       allow(Chatterbot::DSL).to receive(:bot).and_return(@bot)
+      allow(Chatterbot::DSL).to receive(:call_if_immediate)
     end
 
     describe "client" do
@@ -15,46 +16,44 @@ describe "Chatterbot::DSL" do
       end
     end
 
-    describe "blacklist" do
-      it "#blacklist passes along to bot object" do
-        expect(@bot).to receive(:blacklist=).with(["foo"])
-        blacklist ["foo"]
+    describe "blocklist" do
+      it "#blocklist passes along to bot object" do
+        expect(@bot).to receive(:blocklist=).with(["foo"])
+        blocklist ["foo"]
       end
 
-      it "#blacklist turns single-string arg into an array" do
-        expect(@bot).to receive(:blacklist=).with(["foo"])
-        blacklist "foo"
+      it "#blocklist turns single-string arg into an array" do
+        expect(@bot).to receive(:blocklist=).with(["foo"])
+        blocklist "foo"
       end
 
-      it "#blacklist turns comma-delimited string arg into an array" do
-        expect(@bot).to receive(:blacklist=).with(["foo", "bar"])
-        blacklist "foo, bar"
+      it "#blocklist turns comma-delimited string arg into an array" do
+        expect(@bot).to receive(:blocklist=).with(["foo", "bar"])
+        blocklist "foo, bar"
       end
     end
 
-    describe "whitelist" do
-      it "#whitelist passes along to bot object" do
-        expect(@bot).to receive(:whitelist=).with(["foo"])
-        whitelist ["foo"]
+    describe "safelist" do
+      it "#safelist passes along to bot object" do
+        expect(@bot).to receive(:safelist=).with(["foo"])
+        safelist ["foo"]
       end
 
-      it "#whitelist turns single-string arg into an array" do
-        expect(@bot).to receive(:whitelist=).with(["foo"])
-        whitelist "foo"
+      it "#safelist turns single-string arg into an array" do
+        expect(@bot).to receive(:safelist=).with(["foo"])
+        safelist "foo"
       end
 
-      it "#whitelist turns comma-delimited string arg into an array" do
-        expect(@bot).to receive(:whitelist=).with(["foo", "bar"])
-        whitelist "foo, bar"
+      it "#safelist turns comma-delimited string arg into an array" do
+        expect(@bot).to receive(:safelist=).with(["foo", "bar"])
+        safelist "foo, bar"
       end
     end
 
     describe "only_interact_with_followers" do
-      it "sets whitelist to be the bot's followers" do
-        f = fake_follower
-        allow(@bot).to receive(:followers).and_return([f])
-        expect(@bot).to receive(:whitelist=).with([f])
+      it "sets flag" do
         only_interact_with_followers
+        expect(@bot.config[:only_interact_with_followers]).to eq(true)
       end
     end
 
@@ -101,20 +100,53 @@ describe "Chatterbot::DSL" do
 
     describe "search" do
       it "passes along to bot object" do
-        expect(@bot).to receive(:search).with("foo", { })
-        search("foo")
+        allow(@bot).to receive(:run_or_stream)
+        expect(@bot).to receive(:register_handler).with(:search, ["foo"])
+        search("foo") {}
       end
 
       it "passes multiple queries along to bot object" do
-        expect(@bot).to receive(:search).with(["foo","bar"], { })
-        search(["foo","bar"])
+        expect(@bot).to receive(:register_handler).with(:search, [["foo", "bar"]])
+        search(["foo","bar"]) {}
       end
     end
 
+    describe "direct_messages" do
+      it "passes along to bot object" do
+        expect(@bot).to receive(:register_handler).with(:direct_messages, instance_of(Proc))
+        direct_messages {}
+      end
+    end
+
+    describe "favorited" do
+      it "passes along to bot object" do
+        expect(@bot).to receive(:register_handler).with(:favorited, instance_of(Proc))
+
+        favorited {}
+      end
+    end
+
+    describe "followed" do
+      it "passes along to bot object" do
+        expect(@bot).to receive(:register_handler).with(:followed, instance_of(Proc))
+
+        followed {}
+      end
+    end
+
+    describe "deleted" do
+      it "passes along to bot object" do
+        expect(@bot).to receive(:register_handler).with(:deleted, instance_of(Proc))
+
+        deleted {}
+      end
+    end
+
+   
     describe "streaming" do
       it "passes along to bot object" do
-        expect(@bot).to receive(:do_streaming)
-        streaming {}
+        expect(@bot).to receive(:streaming=).with(true)
+        use_streaming
       end
     end
 
@@ -130,18 +162,13 @@ describe "Chatterbot::DSL" do
     end
     
     it "#replies passes along to bot object" do
-      expect(@bot).to receive(:replies)
-      replies
+      expect(@bot).to receive(:register_handler).with(:replies, instance_of(Proc))
+      replies {}
     end
     
     it "#home_timeline passes along to bot object" do
-      expect(@bot).to receive(:home_timeline)
-      home_timeline
-    end
-
-    it "#streaming_tweets passes along to bot object" do
-      expect(@bot).to receive(:streaming_tweets)
-      streaming_tweets
+      expect(@bot).to receive(:register_handler).with(:home_timeline, instance_of(Proc))
+      home_timeline { |x| "foo" }
     end
     
     it "#followers passes along to bot object" do
@@ -164,6 +191,19 @@ describe "Chatterbot::DSL" do
       reply "hello sailor!", { :source => "source "}
     end
 
+    describe "#direct_message" do
+      it "passes along to bot object" do
+        expect(@bot).to receive(:direct_message).with("hello sailor!", nil)
+        direct_message "hello sailor!"
+      end
+
+      it "passes along to bot object with user, if specified" do
+        user = fake_user("DM user")
+        expect(@bot).to receive(:direct_message).with("hello sailor!", user)
+        direct_message "hello sailor!", user
+      end
+    end
+
     it "#profile_text setter passes along to bot object" do
       expect(@bot).to receive(:profile_text).with("hello sailor!")
       profile_text "hello sailor!"
@@ -185,10 +225,21 @@ describe "Chatterbot::DSL" do
     end
     
     context "setters" do
-      [:consumer_secret, :consumer_key, :token, :secret].each do |k|
-        it "should be able to set #{k}" do
-          send(k, "foo")
-          expect(@bot.config[k]).to eq("foo")
+      before(:each) do
+        allow(@bot).to receive(:deprecated)
+      end
+      [
+        {:consumer_secret => :consumer_secret},
+        {:consumer_key => :consumer_key},
+        {:token => :access_token},
+        {:secret => :access_token_secret}
+      ].each do |k|
+        key = k.keys.first
+        value = k[key]
+
+        it "should be able to set #{key}" do
+          send(key, "foo")
+          expect(@bot.config[value]).to eq("foo")
         end
       end
     end
@@ -219,14 +270,5 @@ describe "Chatterbot::DSL" do
       end
     end
 
-    describe "db" do
-      it "should pass to bot object" do
-        bot_db = double(Object)
-        expect(@bot).to receive(:db).and_return(bot_db)
-
-        expect(db).to eql(bot_db)
-      end
-    end
-
   end
 end

data/spec/handler_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Chatterbot::Handler" do
+  it "accepts a block" do
+    @foo = nil
+    h = Chatterbot::Handler.new({}) do |_|
+      @foo = "bar"
+    end
+
+    h.call
+
+    expect(@foo).to eql("bar")
+  end
+
+  it "accepts a proc/etc directly" do
+    @foo = nil
+    @proc = Proc.new do |_|
+      @foo = "bar"
+    end
+
+    h = Chatterbot::Handler.new(@proc)
+    h.call
+
+    expect(@foo).to eql("bar")
+
+  end
+end

data/spec/helpers_spec.rb

@@ -1,16 +1,16 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe "Chatterbot::Helpers" do
-  it "#tweet_user works with [:from_user]" do
+  it "#tweet_user works with Tweet" do
     bot = Chatterbot::Bot.new
-    expect(bot.tweet_user({:from_user => "foo"})).to eq("@foo")
-    expect(bot.tweet_user({:from_user => "@foo"})).to eq("@foo")    
+    t = Twitter::Tweet.new(:id => 1, :user => {:id => 1, :screen_name => "skippy"})
+    expect(bot.tweet_user(t)).to eq("@skippy")
   end
 
-  it "#tweet_user works with [:user][:screen_name]" do
+  it "#tweet_user works with User" do
     bot = Chatterbot::Bot.new
-    expect(bot.tweet_user({:user => {:screen_name => "foo"}})).to eq("@foo")
-    expect(bot.tweet_user({:user => {:screen_name => "@foo"}})).to eq("@foo")    
+    u = Twitter::User.new({:id => 1, :name => "skippy"})
+    expect(bot.tweet_user(u)).to eq("@skippy")
   end
    
   it "#tweet_user works with string" do
@@ -37,10 +37,6 @@ describe "Chatterbot::Helpers" do
       u = Twitter::User.new(:id => 123, :name => "x")
       expect(@bot.from_user(fake_user("x"))).to eq("x")
     end
-    
-    it "should accept :screen_name" do
-      expect(@bot.from_user(:user => {:screen_name => "x"})).to eq("x")
-    end
   end
   
   describe "#botname" do    
@@ -61,7 +57,7 @@ describe "Chatterbot::Helpers" do
     end
 
     it "calls botname for non-inherited bots" do
-      expect(File).to receive(:basename).and_return("bot")
+      allow(File).to receive(:basename).and_return("bot")
       expect(@bot.botname).to eq("bot")
     end
 

data/spec/home_timeline_spec.rb

@@ -2,52 +2,63 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe "Chatterbot::HomeTimeline" do
   it "calls require_login" do
-    bot = test_bot
-    expect(bot).to receive(:require_login).and_return(false)
-    bot.home_timeline
+    @bot = test_bot
+    expect(@bot).to receive(:require_login).and_return(false)
+    @bot.home_timeline
   end
 
   it "updates since_id when complete" do
-    bot = test_bot
-    expect(bot).to receive(:require_login).and_return(true)
+    @bot = test_bot
+    expect(@bot).to receive(:require_login).and_return(true)
     results = fake_home_timeline(1, 1000)
 
-    allow(bot).to receive(:client).and_return(results)
-    
-    bot.home_timeline do
+    allow(@bot).to receive(:client).and_return(results)
+
+    @bot.home_timeline do
     end
 
-    expect(bot.config[:tmp_since_id]).to eq(1000)
+    expect(@bot.config[:since_id_home_timeline]).to eq(1000)
   end
 
-  it "iterates results" do
-    bot = test_bot
-    expect(bot).to receive(:require_login).and_return(true)
-    allow(bot).to receive(:client).and_return(fake_home_timeline(3))
-    
-    expect(bot).to receive(:update_since_id).exactly(3).times
-
-    indexes = []
-    bot.home_timeline do |x|
-      indexes << x[:id]
+  describe "handling results" do
+    before(:each) do
+      @bot = test_bot
+      expect(@bot).to receive(:require_login).and_return(true)
+      allow(@bot).to receive(:client).and_return(fake_home_timeline(3))
     end
 
-    expect(indexes).to eq([1,2,3])
-  end
+    it "iterates results" do
+      expect(@bot).to receive(:update_since_id_home_timeline).exactly(3).times
 
-  it "checks blacklist" do
-    bot = test_bot
-    expect(bot).to receive(:require_login).and_return(true)
-    allow(bot).to receive(:client).and_return(fake_home_timeline(3))
-    
-    allow(bot).to receive(:on_blacklist?).and_return(true, false, false)
+      indexes = []
+      @bot.home_timeline do |x|
+        indexes << x.id
+      end
+
+      expect(indexes).to eq([1,2,3])
+    end
 
+    it "checks blocklist" do
+      allow(@bot).to receive(:on_blocklist?).and_return(true, false, false)
 
-    indexes = []
-    bot.home_timeline do |x|
-      indexes << x[:id]
+      indexes = []
+      @bot.home_timeline do |x|
+        indexes << x.id
+      end
+
+      expect(indexes).to eq([2,3])
     end
 
-    expect(indexes).to eq([2,3])
+    it "checks safelist" do
+      allow(@bot).to receive(:has_safelist?).and_return(true)
+      allow(@bot).to receive(:on_safelist?).and_return(true, false, false)
+
+      indexes = []
+      @bot.home_timeline do |x|
+        indexes << x.id
+      end
+
+      expect(indexes).to eq([1])
+    end
   end
 end

data/spec/logging_spec.rb

@@ -29,38 +29,4 @@ describe "Chatterbot::Logging" do
     end
   end
   
-  describe "#log to database" do
-    before(:each) do
-      @db_tmp = Tempfile.new("config.db")
-      @db_uri = "sqlite://#{@db_tmp.path}"
-
-      @bot = Chatterbot::Bot.new    
-      @bot.config[:db_uri] = @db_uri
-
-      expect(@bot).to receive(:log_tweets?).and_return(true)
-
-      expect(@bot).to receive(:botname).and_return("logger")
-      allow(Time).to receive(:now).and_return(123)                
-
-      @tweets_table = double(Object)     
-      allow(@bot).to receive(:db).and_return({ 
-                                   :tweets => @tweets_table
-                                 })   
-    end
-    
-    it "logs tweets to the db" do
-      expect(@tweets_table).to receive(:insert).with({ :txt => "TEST", :bot => "logger", :created_at => 123})
-      @bot.log "TEST"
-    end
-
-    it "logs tweets with some source info to the db" do
-      source_tweet = Twitter::Tweet.new({:id => 12345, :text => "i should trigger a bot", :user => {:screen_name => "replytome", :id => 456}})
-
-      params = {:txt=>"TEST", :bot=>"logger", :created_at=>123, :user=>"replytome", :source_id=>12345, :source_tweet=>"i should trigger a bot"}      
-      
-      expect(@tweets_table).to receive(:insert).with(params)
-     
-      @bot.log "TEST", source_tweet
-    end
-  end
 end

data/spec/reply_spec.rb

@@ -13,39 +13,39 @@ describe "Chatterbot::Reply" do
     results = fake_replies(1, 1000)
 
     allow(bot).to receive(:client).and_return(results)
-    
+
     bot.replies do
     end
 
-    expect(bot.config[:tmp_since_id_reply]).to eq(1000)
+    expect(bot.config[:since_id_reply]).to eq(1000)
   end
 
   it "iterates results" do
     bot = test_bot
     expect(bot).to receive(:require_login).and_return(true)
     allow(bot).to receive(:client).and_return(fake_replies(3))
-    
+
     expect(bot).to receive(:update_since_id_reply).exactly(3).times
 
     indexes = []
     bot.replies do |x|
-      indexes << x[:id]
+      indexes << x.id
     end
 
     expect(indexes).to eq([1,2,3])
   end
 
-  it "checks blacklist" do
+  it "checks blocklist" do
     bot = test_bot
     expect(bot).to receive(:require_login).and_return(true)
     allow(bot).to receive(:client).and_return(fake_replies(3))
-    
-    allow(bot).to receive(:on_blacklist?).and_return(true, false, false)
+
+    allow(bot).to receive(:on_blocklist?).and_return(true, false, false)
 
 
     indexes = []
     bot.replies do |x|
-      indexes << x[:id]
+      indexes << x.id
     end
 
     expect(indexes).to eq([2,3])
@@ -53,37 +53,13 @@ describe "Chatterbot::Reply" do
 
 
   it "passes along since_id_reply" do
-    bot = test_bot
-    expect(bot).to receive(:require_login).and_return(true)
-    allow(bot).to receive(:client).and_return(fake_replies(100, 3))    
-    allow(bot).to receive(:since_id_reply).and_return(123)
-    
-    expect(bot.client).to receive(:mentions_timeline).with({:since_id => 123, :count => 200})
-
-    bot.replies
-  end
-  
-
-  it "doesn't pass along invalid since_id_reply" do
-    bot = test_bot
-    expect(bot).to receive(:require_login).and_return(true)
-    allow(bot).to receive(:client).and_return(fake_replies(100, 3))    
-    allow(bot).to receive(:since_id_reply).and_return(0)
-    
-    expect(bot.client).to receive(:mentions_timeline).with({:count => 200})
-
-    bot.replies
-  end
-
-  it "pass along since_id if since_id_reply is nil or zero" do
     bot = test_bot
     expect(bot).to receive(:require_login).and_return(true)
     allow(bot).to receive(:client).and_return(fake_replies(100, 3))
-    allow(bot).to receive(:since_id).and_return(12345)
+    allow(bot).to receive(:since_id_reply).and_return(123)
 
-    expect(bot.client).to receive(:mentions_timeline).with({:count => 200, :since_id => 12345})
+    expect(bot.client).to receive(:mentions_timeline).with({:since_id => 123, :count => 200})
 
     bot.replies
-
   end
 end