chatterbot 1.0.2 → 2.0.0.pre

data/lib/chatterbot/tweet.rb

@@ -13,7 +13,6 @@ module Chatterbot
         debug "I'm in debug mode, otherwise I would tweet: #{txt}"
       else
         debug txt
-        log txt, original
         client.update txt, params
       end
     rescue Twitter::Error::Forbidden => e

data/lib/chatterbot/ui.rb

@@ -4,23 +4,30 @@ module Chatterbot
   # routines for outputting setup instructions
   #
   module UI
-
+    # Where to send users who need to get API keys
     API_SIGNUP_URL = "https://twitter.com/apps/new"
 
     
+    #:nocov:
     def red(str)
       puts str.colorize(:red)
     end
 
+    #:nocov:
     def green(str)
       puts str.colorize(:green)
     end
+
+    # print out a deprecation notice
+    def deprecated(msg, src)
+      red(msg)
+      green("Called from " + src)
+    end
     
     #
     # print out a message about getting a PIN from twitter, then output
     # the URL the user needs to visit to authorize
     #
-    #:nocov:
     def get_oauth_verifier
       green "****************************************"
       green "****************************************"

data/lib/chatterbot/utils.rb

@@ -1,9 +1,22 @@
 module Chatterbot
+
+  # Assorted handy utility methods
   module Utils
+
+    #
+    # return the id of a tweet, or the incoming object (likely already
+    # an ID)
+    #
+    # @param [Tweet] t the Tweet
     def id_from_tweet(t)
       t.is_a?(Twitter::Tweet) ? t.id : t
     end
 
+    #
+    # return the id of a User, or the incoming object (likely already
+    # an ID)
+    #
+    # @param [User] u the User
     def id_from_user(u)
       u.is_a?(Twitter::User) ? u.id : u
     end

data/lib/chatterbot/version.rb

@@ -1,3 +1,3 @@
 module Chatterbot
-  VERSION = "1.0.2"
+  VERSION = "2.0.0.pre"
 end

data/spec/blocklist_spec.rb

@@ -0,0 +1,170 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Chatterbot::Blocklist" do
+  before(:each) do
+    @bot = test_bot
+  end
+
+  it "has a list of excluded phrases" do
+    @bot.exclude = ["junk", "i hate bots", "foobar", "spam"]
+    expect(@bot.skip_me?("did you know that i hate bots?")).to eq(true)
+  end
+
+  describe "skip_me?" do
+    before(:each) do
+      @bot.exclude = ["junk", "i hate bots", "foobar", "spam"]
+    end
+
+    it "blocks tweets with phrases we don't want" do
+      expect(@bot.skip_me?("did you know that i hate bots?")).to eq(true)
+    end
+
+    it "isn't case-specific" do
+      expect(@bot.skip_me?("DID YOU KNOW THAT I HATE BOTS?")).to eq(true)
+    end
+
+    it "allows users we do want" do
+      expect(@bot.skip_me?("a tweet without any bad content")).to eq(false)
+    end
+
+    it "works with Tweet objects" do
+      expect(@bot.skip_me?(Twitter::Tweet.new(:id => 1, :text => "did you know that i hate bots?"))).to eq(true)
+      expect(@bot.skip_me?(Twitter::Tweet.new(:id => 1, :text => "a tweet without any bad content"))).to eq(false)
+    end
+  end
+
+  describe "on_blocklist?" do
+    before(:each) do
+      @bot.blocklist = ["skippy", "blippy", "dippy"]
+    end
+
+    it "blocks users we don't want" do
+      expect(@bot.on_blocklist?("skippy")).to eq(true)
+    end
+
+    it "allows users we do want" do
+      expect(@bot.on_blocklist?("flippy")).to eq(false)
+    end
+
+    it "isn't case-specific" do
+      expect(@bot.on_blocklist?("FLIPPY")).to eq(false)
+      expect(@bot.on_blocklist?("SKIPPY")).to eq(true)
+    end
+
+    it "works with result hashes" do
+      expect(@bot.on_blocklist?(Twitter::Tweet.new(:id => 1,
+                                            :user => {:id => 1, :screen_name => "skippy"}))).to eq(true)
+      expect(@bot.on_blocklist?(Twitter::Tweet.new(:id => 1,
+                                            :user => {:id => 1, :screen_name => "flippy"}))).to eq(false)
+    end   
+
+    it "works with users" do
+      expect(@bot.on_blocklist?(Twitter::User.new({:id => 1, :name => "skippy"}))).to eql(true)
+      expect(@bot.on_blocklist?(Twitter::User.new({:id => 1, :name => "flippy"}))).to eql(false)
+    end
+  end
+
+  describe "interact_with_user?" do
+    before(:each) do
+      @user = Twitter::User.new({:id => 1, :name => "flippy"})
+    end
+
+    it "is always true if only_interact_with_followers == false" do
+      @bot.only_interact_with_followers = false
+      expect(@bot.interact_with_user?(@user)).to eql(true)
+    end
+
+    context "when only_interact_with_followers == true" do
+      before(:each) do
+        @bot.only_interact_with_followers = true
+        @auth_user = double(Twitter::User)
+        allow(@bot).to receive(:authenticated_user).and_return(@auth_user)
+      end
+
+      it "is true if follower of account" do
+        expect(@bot.client).to receive(:friendship?).with(@user, @auth_user).and_return(true)
+        expect(@bot.interact_with_user?(@user)).to eql(true)
+      end
+
+      it "is false if not follower of account" do
+        expect(@bot.client).to receive(:friendship?).with(@user, @auth_user).and_return(false)
+        expect(@bot.interact_with_user?(@user)).to eql(false)
+      end   
+    end
+  end
+
+ 
+  describe "valid_tweet?" do
+    context "with safelist" do
+      before(:each) do
+        @bot.safelist = ["flippy"]
+      end
+
+      it "is true if on safelist" do
+        @user = Twitter::User.new({:id => 1, :name => "flippy"})
+        expect(@bot.valid_tweet?(@user)).to eql(true)       
+
+        @tweet = Twitter::Tweet.new(:id => 1, :user => {:id => 1, :screen_name => "flippy"})
+        expect(@bot.valid_tweet?(@tweet)).to eq(true)
+      end
+
+      it "is false if not on safelist" do
+        @user = Twitter::User.new({:id => 1, :name => "skippy"})
+        expect(@bot.valid_tweet?(@user)).to eql(false)
+
+
+        @tweet = Twitter::Tweet.new(:id => 1, :user => {:id => 1, :screen_name => "skippy"})
+        expect(@bot.valid_tweet?(@tweet)).to eq(false)
+      end
+    end
+
+    context "without safelist" do
+      # !skippable_retweet?(object) &&
+      #! on_blocklist?(object) &&
+      #! skip_me?(object) &&
+      #interact_with_user?(object)
+      before(:each) do
+        @tweet = Twitter::Tweet.new(:id => 1, :user => {:id => 1, :screen_name => "skippy"})
+      end
+      
+      it "is false if skippable_retweet" do
+        allow(@bot).to receive(:skippable_retweet?).with(@tweet).and_return(true)
+        expect(@bot.valid_tweet?(@tweet)).to eql(false)
+      end
+
+      it "is false if on blocklist" do
+        allow(@bot).to receive(:skippable_retweet?).with(@tweet).and_return(false)
+        allow(@bot).to receive(:on_blocklist?).with(@tweet).and_return(true)
+
+        expect(@bot.valid_tweet?(@tweet)).to eql(false)
+      end
+
+      it "is false if on exclude list" do
+        allow(@bot).to receive(:skippable_retweet?).with(@tweet).and_return(false)
+        allow(@bot).to receive(:on_blocklist?).with(@tweet).and_return(false)
+        allow(@bot).to receive(:skip_me?).with(@tweet).and_return(true)
+
+        expect(@bot.valid_tweet?(@tweet)).to eql(false)
+      end
+      
+      it "is false if ! interact_with_user" do
+        allow(@bot).to receive(:skippable_retweet?).with(@tweet).and_return(false)
+        allow(@bot).to receive(:on_blocklist?).with(@tweet).and_return(false)
+        allow(@bot).to receive(:skip_me?).with(@tweet).and_return(false)
+        allow(@bot).to receive(:interact_with_user?).with(@tweet).and_return(false)
+
+        expect(@bot.valid_tweet?(@tweet)).to eql(false)
+      end
+
+      it "is true otherwise" do
+        allow(@bot).to receive(:skippable_retweet?).with(@tweet).and_return(false)
+        allow(@bot).to receive(:on_blocklist?).with(@tweet).and_return(false)
+        allow(@bot).to receive(:skip_me?).with(@tweet).and_return(false)
+        allow(@bot).to receive(:interact_with_user?).with(@tweet).and_return(true)
+
+        expect(@bot.valid_tweet?(@tweet)).to eql(true)
+      end
+    end
+  end
+  
+end

data/spec/bot_spec.rb

@@ -1,17 +1,92 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe "Chatterbot::Bot" do
-  after(:each) do
-    b = Chatterbot::Bot.new(:reset_since_id => false)
+  before(:each) do
+    @bot = Chatterbot::Bot.new
   end
 
-  describe "reset_bot?" do
-    it "should call reset_since_id and update_config" do
-      expect_any_instance_of(Chatterbot::Bot).to receive(:reset_since_id)
-      expect_any_instance_of(Chatterbot::Bot).to receive(:update_config)
-      allow_any_instance_of(Chatterbot::Bot).to receive(:exit)
-      b = Chatterbot::Bot.new(:reset_since_id => true)
+  describe "Streaming API" do
+    it "should call streaming_client.user" do
+      expect(@bot.streaming_client).to receive(:user)
+      @bot.stream!
     end
+  end
+
+  describe "REST API" do
+    it "should work" do
+      expect(@bot).to receive(:require_login).and_return(true)
+      expect(@bot).to receive(:client).and_return(fake_home_timeline(3))
+      @bot.register_handler(:home_timeline) {}
+      @bot.run!
+    end
+  end
+
+  describe "run_or_stream" do
+    it "should use streaming if specified" do
+      expect(@bot).to receive(:stream!)
+      @bot.streaming = true
+      @bot.run_or_stream
+    end
+
+    it "should use streaming if required by handler" do
+      expect(@bot).to receive(:stream!)
+      @bot.register_handler(:deleted) {}
+      @bot.run_or_stream
+    end
+
+    it "should use REST if specified" do
+      expect(@bot).to receive(:run!)
+      @bot.run_or_stream
+    end
+  end
+
+
+  
+  describe "stream!" do
+    before(:each) do
+      @sc = double(Twitter::Client)
+      expect(@bot).to receive(:streaming_client).and_return(@sc)
+    end
+
+    it "tweaks settings for searches" do
+      @bot.register_handler(:search, "hello") {}
+      expect(@sc).to receive(:filter)
 
+      @bot.stream!
+    end
+
+    it "calls :user for non-searches" do
+      @bot.register_handler(:home_timeline) {}
+      expect(@sc).to receive(:user)
+
+      @bot.stream!
+    end
   end
+  
+  describe "streamify_search_options" do
+    it "works with string" do
+      expect( @bot.streamify_search_options("hello there") ).
+        to eql({track:"hello there"})
+
+
+      expect( @bot.streamify_search_options("hello there, friend") ).
+        to eql({track:"hello there, friend"})
+    end
+
+    it "works with array" do
+      expect( @bot.streamify_search_options(["hello there"]) ).
+        to eql({track:"hello there"})
+
+      expect( @bot.streamify_search_options(["hello there", "friend"]) ).
+        to eql({track:"hello there, friend"})
+    end
+
+    it "works with hash" do
+      opts = {filter:"hello"}
+      expect( @bot.streamify_search_options(opts) ).
+        to eql(opts)
+
+    end
+  end
+
 end

data/spec/client_spec.rb

@@ -11,7 +11,43 @@ describe "Chatterbot::Client" do
   it "should initialize streaming client" do
     expect(@bot.streaming_client).to be_a(Twitter::Streaming::Client)
   end
+
+  describe "reset!" do
+    it "should reset a bunch of stuff" do
+      @bot.config[:since_id] = 1234
+      @bot.config[:since_id_reply] = 1234
+
+      @bot.reset!
+
+      expect(@bot.config[:since_id]).to eql(1)
+      expect(@bot.config[:since_id_reply]).to eql(1)
+    end
+  end
+  
+  describe "reset_since_id_counters" do
+    it "should reset a bunch of stuff" do
+      expect(@bot).to receive(:reset!)
+      expect(@bot).to receive(:reset_since_id)
+      expect(@bot).to receive(:reset_since_id_reply)
+      expect(@bot).to receive(:reset_since_id_home_timeline)
+      expect(@bot).to receive(:reset_since_id_dm)
+
+      @bot.reset_since_id_counters
+    end
+  end
   
+  describe "reset_since_id" do
+    it "runs a search to get a new max_id" do
+      bot = test_bot
+
+      allow(bot).to receive(:client).and_return(fake_search(100, 1))
+      expect(bot.client).to receive(:search).with("a", anything)
+      bot.reset_since_id
+
+      expect(bot.config[:since_id]).to eq(100)
+    end
+  end
+
   describe "reset_since_id_reply" do
     it "gets the id of the last reply" do
       bot = test_bot
@@ -20,21 +56,32 @@ describe "Chatterbot::Client" do
 
       bot.reset_since_id_reply
 
-      expect(bot.config[:tmp_since_id_reply]).to eq(1000)
+      expect(bot.config[:since_id_reply]).to eq(1000)
     end
   end
 
-  describe "reset_since_id" do
-    it "runs a search to get a new max_id" do
+  describe "reset_since_id_home_timeline" do
+    it "gets the id of the last tweet in timeline" do
       bot = test_bot
+      allow(bot).to receive(:client).and_return(fake_home_timeline(3))
 
-      allow(bot).to receive(:client).and_return(fake_search(100, 1))
-      expect(bot.client).to receive(:search).with("a")
-      bot.reset_since_id
+      bot.reset_since_id_home_timeline
 
-      expect(bot.config[:tmp_since_id]).to eq(100)
+      expect(bot.config[:since_id_home_timeline]).to eq(3)
     end
   end
+
+  describe "reset_since_id_dm" do
+    it "gets the id of the last direct message" do
+      bot = test_bot
+      allow(bot).to receive(:client).and_return(fake_direct_messages(3))
+
+      bot.reset_since_id_dm
+
+      expect(bot.config[:since_id_dm]).to eq(3)
+    end
+  end
+
   
   it "runs init_client and login on #require_login" do
     expect(@bot).to receive(:init_client).and_return(true)
@@ -121,6 +168,13 @@ describe "Chatterbot::Client" do
     end
   end
   
+  describe "authenticated_user" do
+    let(:bot) { test_bot }
+    it "should get user from client" do
+      expect(bot.client).to receive(:user).and_return('user')
+      expect(bot.authenticated_user).to eql('user')
+    end
+  end
 
 
 end

data/spec/config_manager_spec.rb

@@ -0,0 +1,59 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'tempfile'
+
+describe "Chatterbot::ConfigManager" do
+  before(:each) do
+    @tmp_config_dest = "/tmp/bot.yml"
+    @config = Chatterbot::ConfigManager.new(@tmp_config_dest, {:consumer_key => "bar"})
+  end
+  after(:each) do
+    if File.exist?(@tmp_config_dest)
+      File.unlink(@tmp_config_dest)
+    end
+  end
+
+  describe "delete" do
+    it "deletes a key" do
+      expect(@config.delete(:baz)).to be_nil
+    end
+
+    it "works with missing key" do
+
+    end
+
+    it "retains read-only data" do
+      expect(@config[:consumer_key]).to eql("bar")
+      expect(@config.delete(:consumer_key)).to be_nil
+      expect(@config[:consumer_key]).to eql("bar")
+    end
+  end
+
+  describe "[]=" do
+    it "writes a key" do
+      expect(@config[:baz]).to be_nil
+      @config[:baz] = "hello"
+      expect(@config[:baz]).to eql("hello")
+    end
+
+    it "does not overwrite read-only data" do
+      expect(@config[:consumer_key]).to eql("bar")
+      @config[:consumer_key] = "baz"
+      expect(@config[:consumer_key]).to eql("bar")
+    end
+  end
+
+  describe "[]" do
+    it "works with missing key" do
+      expect(@config[:baz]).to be_nil
+    end
+
+    it "works with read-only data" do
+      expect(@config[:consumer_key]).to eql("bar")
+    end
+
+    it "works with present key" do
+      @config[:baz] = "hello"
+      expect(@config[:baz]).to eql("hello")
+    end
+  end
+end