chatterbot 0.7.1 → 0.9.0

data/spec/logging_spec.rb

@@ -1,29 +1,30 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'tempfile'
 
 describe "Chatterbot::Logging" do
   describe "debug logging" do
     before(:each) do
       @bot = Chatterbot::Bot.new
       @logger = double(Logger)
-      @bot.stub(:logger).and_return(@logger)
+      allow(@bot).to receive(:logger).and_return(@logger)
     end
 
     it "should call logger on debug" do
-      @bot.should_receive(:logging?).and_return(true)
-      @logger.should_receive(:debug).with("rspec hi!")
+      expect(@bot).to receive(:logging?).and_return(true)
+      expect(@logger).to receive(:debug).with("rspec hi!")
       @bot.debug "hi!"
     end
 
     it "should not call logger when not logging desired" do
-      @bot.should_receive(:logging?).and_return(false)
-      @logger.should_not_receive(:debug)
+      expect(@bot).to receive(:logging?).and_return(false)
+      expect(@logger).not_to receive(:debug)
       @bot.debug "hi!"
     end
 
     it "should call logger and also print output when critical" do
-      @bot.should_receive(:logging?).and_return(true)
-      @logger.should_receive(:debug).with("rspec hi!")      
-      @bot.should_receive(:puts).with("hi!")
+      expect(@bot).to receive(:logging?).and_return(true)
+      expect(@logger).to receive(:debug).with("rspec hi!")      
+      expect(@bot).to receive(:puts).with("hi!")
       @bot.critical "hi!"
     end
   end
@@ -36,28 +37,28 @@ describe "Chatterbot::Logging" do
       @bot = Chatterbot::Bot.new    
       @bot.config[:db_uri] = @db_uri
 
-      @bot.should_receive(:log_tweets?).and_return(true)
+      expect(@bot).to receive(:log_tweets?).and_return(true)
 
-      @bot.should_receive(:botname).and_return("logger")
-      Time.stub(:now).and_return(123)                
+      expect(@bot).to receive(:botname).and_return("logger")
+      allow(Time).to receive(:now).and_return(123)                
 
       @tweets_table = double(Object)     
-      @bot.stub(:db).and_return({ 
+      allow(@bot).to receive(:db).and_return({ 
                                    :tweets => @tweets_table
                                  })   
     end
     
     it "logs tweets to the db" do
-      @tweets_table.should_receive(:insert).with({ :txt => "TEST", :bot => "logger", :created_at => 123})
+      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 = {:from_user => "replytome", :id => 12345, :text => "i should trigger a bot" }
+      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"}      
       
-      @tweets_table.should_receive(:insert).with(params)
+      expect(@tweets_table).to receive(:insert).with(params)
      
       @bot.log "TEST", source_tweet
     end

data/spec/profile_spec.rb

@@ -0,0 +1,65 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Chatterbot::Profile" do
+  describe "#profile_text" do
+    let(:user) { fake_user('user', 100) }
+    let(:bot) { test_bot }
+
+
+    it "calls require_login" do
+      expect(bot).to receive(:require_login).and_return(false)
+      bot.profile_text "set my profile!"
+    end
+
+    context "data" do
+      before(:each) do
+        expect(bot).to receive(:require_login).and_return(true)
+        allow(bot).to receive(:client).and_return(double(Twitter::Client))
+
+        allow(bot).to receive(:debug_mode?).and_return(false)
+      end
+
+      it "calls client.user to get" do   
+        expect(bot.client).to receive(:user).and_return(user)
+        bot.profile_text
+      end
+
+      it "calls client.update_profile to set" do   
+        expect(bot.client).to receive(:update_profile).with(description:"hello")
+        bot.profile_text "hello"
+      end
+    end
+  end
+
+
+  describe "#profile_website" do
+    let(:user) { fake_user('user', 100) }
+    let(:bot) { test_bot }
+
+
+    it "calls require_login" do
+      expect(bot).to receive(:require_login).and_return(false)
+      bot.profile_website "set my profile!"
+    end
+
+    context "data" do
+      before(:each) do
+        expect(bot).to receive(:require_login).and_return(true)
+        allow(bot).to receive(:client).and_return(double(Twitter::Client))
+
+        allow(bot).to receive(:debug_mode?).and_return(false)
+      end
+
+      it "calls client.user to get" do   
+        expect(bot.client).to receive(:user).and_return(user)
+        bot.profile_website
+      end
+
+      it "calls client.update_profile to set" do   
+        expect(bot.client).to receive(:update_profile).with(url:"http://hello.com")
+        bot.profile_website "http://hello.com"
+      end
+    end
+  end
+  
+end

data/spec/reply_spec.rb

@@ -3,44 +3,44 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 describe "Chatterbot::Reply" do
   it "calls require_login" do
     bot = test_bot
-    bot.should_receive(:require_login).and_return(false)
+    expect(bot).to receive(:require_login).and_return(false)
     bot.replies
   end
 
   it "updates since_id_reply when complete" do
     bot = test_bot
-    bot.should_receive(:require_login).and_return(true)
+    expect(bot).to receive(:require_login).and_return(true)
     results = fake_replies(1, 1000)
 
-    bot.stub(:client).and_return(results)
+    allow(bot).to receive(:client).and_return(results)
     
     bot.replies do
     end
 
-    bot.config[:tmp_since_id_reply].should == 1000
+    expect(bot.config[:tmp_since_id_reply]).to eq(1000)
   end
 
   it "iterates results" do
     bot = test_bot
-    bot.should_receive(:require_login).and_return(true)
-    bot.stub(:client).and_return(fake_replies(3))
+    expect(bot).to receive(:require_login).and_return(true)
+    allow(bot).to receive(:client).and_return(fake_replies(3))
     
-    bot.should_receive(:update_since_id_reply).exactly(3).times
+    expect(bot).to receive(:update_since_id_reply).exactly(3).times
 
     indexes = []
     bot.replies do |x|
       indexes << x[:id]
     end
 
-    indexes.should == [1,2,3]
+    expect(indexes).to eq([1,2,3])
   end
 
   it "checks blacklist" do
     bot = test_bot
-    bot.should_receive(:require_login).and_return(true)
-    bot.stub(:client).and_return(fake_replies(3))
+    expect(bot).to receive(:require_login).and_return(true)
+    allow(bot).to receive(:client).and_return(fake_replies(3))
     
-    bot.stub(:on_blacklist?).and_return(true, false, false)
+    allow(bot).to receive(:on_blacklist?).and_return(true, false, false)
 
 
     indexes = []
@@ -48,17 +48,17 @@ describe "Chatterbot::Reply" do
       indexes << x[:id]
     end
 
-    indexes.should == [2,3]
+    expect(indexes).to eq([2,3])
   end
 
 
   it "passes along since_id_reply" do
     bot = test_bot
-    bot.should_receive(:require_login).and_return(true)
-    bot.stub(:client).and_return(fake_replies(100, 3))    
-    bot.stub(:since_id_reply).and_return(123)
+    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)
     
-    bot.client.should_receive(:mentions).with({:since_id => 123, :count => 200})
+    expect(bot.client).to receive(:mentions_timeline).with({:since_id => 123, :count => 200})
 
     bot.replies
   end
@@ -66,22 +66,22 @@ describe "Chatterbot::Reply" do
 
   it "doesn't pass along invalid since_id_reply" do
     bot = test_bot
-    bot.should_receive(:require_login).and_return(true)
-    bot.stub(:client).and_return(fake_replies(100, 3))    
-    bot.stub(:since_id_reply).and_return(0)
+    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)
     
-    bot.client.should_receive(:mentions).with({:count => 200})
+    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
-    bot.should_receive(:require_login).and_return(true)
-    bot.stub(:client).and_return(fake_replies(100, 3))
-    bot.stub(:since_id).and_return(12345)
+    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)
 
-    bot.client.should_receive(:mentions).with({:count => 200, :since_id => 12345})
+    expect(bot.client).to receive(:mentions_timeline).with({:count => 200, :since_id => 12345})
 
     bot.replies
 

data/spec/retweet_spec.rb

@@ -7,21 +7,29 @@ describe "Chatterbot::Retweet" do
     end
 
     it "calls require_login when tweeting" do
-      @bot.should_receive(:require_login).and_return(false)
+      expect(@bot).to receive(:require_login).and_return(false)
       @bot.retweet "tweet test!"
     end
 
-    it "calls client.retweet with the right values" do
-      bot = test_bot
+    context "data" do
+      before(:each) do
+        expect(@bot).to receive(:require_login).and_return(true)
+        allow(@bot).to receive(:client).and_return(double(Twitter::Client))
 
-      bot.should_receive(:require_login).and_return(true)
-      bot.stub(:client).and_return(mock(Twitter::Client))
+        allow(@bot).to receive(:debug_mode?).and_return(false)
+      end
 
-      bot.stub(:debug_mode?).and_return(false)
+      it "calls client.retweet with an id" do   
+        tweet_id = 12345
+        expect(@bot.client).to receive(:retweet).with(tweet_id)
+        @bot.retweet(tweet_id)
+      end
 
-      tweet_id = 12345
-      bot.client.should_receive(:retweet).with(tweet_id)
-      bot.retweet(tweet_id)
+      it "calls client.retweet with a tweet" do   
+        t = Twitter::Tweet.new(:id => 7890, :text => "did you know that i hate bots?")
+        expect(@bot.client).to receive(:retweet).with(7890)
+        @bot.retweet(t)
+      end
     end
   end
 end

data/spec/search_spec.rb

@@ -7,41 +7,41 @@ describe "Chatterbot::Search" do
     end
 
     it "should tack onto query" do
-      @bot.exclude_retweets("foo").should == ("foo -include:retweets")
+      expect(@bot.exclude_retweets("foo")).to eq("foo -include:retweets")
     end
 
     it "shouldn't tack onto query" do
-      @bot.exclude_retweets("foo -include:retweets").should == ("foo -include:retweets")
+      expect(@bot.exclude_retweets("foo -include:retweets")).to eq("foo -include:retweets")
     end
 
     it "shouldn't tack onto query" do
-      @bot.exclude_retweets("foo include:retweets").should == ("foo include:retweets")
+      expect(@bot.exclude_retweets("foo include:retweets")).to eq("foo include:retweets")
     end
   end
 
   it "calls search" do
     bot = Chatterbot::Bot.new
-    bot.should_receive(:search)
+    expect(bot).to receive(:search)
     bot.search("foo")
   end
  
 
   it "calls update_since_id" do
     bot = test_bot
-
+    
     data = fake_search(100, 1)
-    bot.stub(:search_client).and_return(data)
-    bot.should_receive(:update_since_id).with(100)
+    allow(bot).to receive(:client).and_return(data)
+    expect(bot).to receive(:update_since_id).with(data.search)
     
     bot.search("foo")
   end
 
   it "accepts multiple searches at once" do
     bot = test_bot
-
-    bot.stub(:search_client).and_return(fake_search(100, 1))
-    bot.search_client.should_receive(:search).with("foo -include:retweets", {:result_type=>"recent"})
-    bot.search_client.should_receive(:search).with("bar -include:retweets", {:result_type=>"recent"})
+    
+    allow(bot).to receive(:client).and_return(fake_search(100, 1))
+    expect(bot.client).to receive(:search).once.ordered.with("foo -include:retweets", {:result_type=>"recent"})
+    expect(bot.client).to receive(:search).once.ordered.with("bar -include:retweets", {:result_type=>"recent"})
 
     bot.search(["foo", "bar"])
   end
@@ -49,8 +49,8 @@ describe "Chatterbot::Search" do
   it "accepts extra params" do
     bot = test_bot
 
-    bot.stub(:search_client).and_return(fake_search(100, 1))
-    bot.search_client.should_receive(:search).with("foo -include:retweets", {:lang => "en", :result_type=>"recent"})
+    allow(bot).to receive(:client).and_return(fake_search(100, 1))
+    expect(bot.client).to receive(:search).with("foo -include:retweets", {:lang => "en", :result_type=>"recent"})
 
     bot.search("foo", :lang => "en")
   end
@@ -58,19 +58,19 @@ describe "Chatterbot::Search" do
   it "accepts a single search query" do
     bot = test_bot
 
-    bot.stub(:search_client).and_return(fake_search(100, 1))
-    bot.search_client.should_receive(:search).with("foo -include:retweets", {:result_type=>"recent"})
+    allow(bot).to receive(:client).and_return(fake_search(100, 1))
+    expect(bot.client).to receive(:search).with("foo -include:retweets", {:result_type=>"recent"})
 
     bot.search("foo")
   end
 
   it "passes along since_id" do
     bot = test_bot
-    bot.stub(:since_id).and_return(123)
-    bot.stub(:since_id_reply).and_return(456)
+    allow(bot).to receive(:since_id).and_return(123)
+    allow(bot).to receive(:since_id_reply).and_return(456)
     
-    bot.stub(:search_client).and_return(fake_search(100, 1))
-    bot.search_client.should_receive(:search).with("foo -include:retweets", {:since_id => 123, :result_type => "recent", :since_id_reply => 456})
+    allow(bot).to receive(:client).and_return(fake_search(100, 1))
+    expect(bot.client).to receive(:search).with("foo -include:retweets", {:since_id => 123, :result_type => "recent", :since_id_reply => 456})
 
     bot.search("foo")
   end
@@ -78,36 +78,36 @@ describe "Chatterbot::Search" do
   it "updates since_id when complete" do
     bot = test_bot
     results = fake_search(1000, 1)
-    bot.stub(:search_client).and_return(results)
+    allow(bot).to receive(:client).and_return(results)
     
-    bot.should_receive(:update_since_id).with(1000)
+    expect(bot).to receive(:update_since_id).with(results.search)
     bot.search("foo")
   end
   
   it "iterates results" do
     bot = test_bot
-    bot.stub(:search_client).and_return(fake_search(100, 3))
+    allow(bot).to receive(:client).and_return(fake_search(100, 3))
     indexes = []
 
     bot.search("foo") do |x|
       indexes << x.attrs[:index]
     end
     
-    indexes.should == [1,2,3]
+    expect(indexes).to eq([100, 99, 98])
   end
 
   it "checks blacklist" do
     bot = test_bot
-    bot.stub(:search_client).and_return(fake_search(100, 3))
+    allow(bot).to receive(:client).and_return(fake_search(100, 3))
     
-    bot.stub(:on_blacklist?).and_return(true, false)
+    allow(bot).to receive(:on_blacklist?).and_return(true, false)
     
     indexes = []
     bot.search("foo") do |x|
       indexes << x.attrs[:index]
     end
 
-    indexes.should == [2,3]
+    expect(indexes).to eq([99, 98])
   end
 
 end

data/spec/skeleton_spec.rb

@@ -11,19 +11,19 @@ describe "Chatterbot::Skeleton" do
       :secret => "secret",
       :token => "token"
     }
-    @bot.stub(:botname).and_return("Skelley_The_Skeleton")
+    allow(@bot).to receive(:botname).and_return("Skelley_The_Skeleton")
 
     @output = Chatterbot::Skeleton.generate(@bot)
   end
 
   it "should have name" do
-    @output.should include("Skelley_The_Skeleton")
+    expect(@output).to include("Skelley_The_Skeleton")
   end 
 
   it "should have auth info" do
-    @output.should include("'consumer_key'")
-    @output.should include("'consumer_secret'")
-    @output.should include("'secret'")
-    @output.should include("'token'")
+    expect(@output).to include("'consumer_key'")
+    expect(@output).to include("'consumer_secret'")
+    expect(@output).to include("'secret'")
+    expect(@output).to include("'token'")
   end 
 end

data/spec/spec_helper.rb

@@ -1,72 +1,84 @@
 # -*- coding: utf-8 -*-
 require 'simplecov'
 SimpleCov.start
-#$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-#$LOAD_PATH.unshift(File.dirname(__FILE__))
 
 require 'bundler/setup'
 Bundler.require
 
-#require "twitter_oauth"
 require "twitter"
 
-#require 'tempfile'
-#require 'sqlite3'
-
-
 # Requires supporting files with custom matchers and macros, etc,
 # in ./support/ and its subdirectories.
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
 
+RSpec.configure do |config|
+  config.mock_with :rspec do |mocks|
+
+    # This option should be set when all dependencies are being loaded
+    # before a spec run, as is the case in a typical spec helper. It will
+    # cause any verifying double instantiation for a class that does not
+    # exist to raise, protecting against incorrectly spelt names.
+    mocks.verify_doubled_constant_names = true
+
+  end
+end
 
 def test_bot
   bot = Chatterbot::Bot.new
-  bot.stub(:load_config).and_return({})
-  bot.stub(:update_config_at_exit)
+  allow(bot).to receive(:load_config).and_return({})
+  allow(bot).to receive(:update_config_at_exit)
+  bot.reset!
   bot
 end
 
+def stubbable_client
+  c = Twitter::Client.new
+  allow(c).to receive_messages(:credentials? => true)
+  c
+end
+
 def fake_search(max_id = 100, result_count = 0, id_base=0)
-  double(Twitter::Client,
-       :credentials? => true,
-       :search => Twitter::SearchResults.new(:search_metadata => {:max_id => max_id},
-                                             :statuses => 1.upto(result_count).collect { |i| fake_tweet(i, id_base) } )
-       )
+  result = 1.upto(result_count).each_with_index.map { |x, i|
+    fake_tweet(max_id - i, id_base)
+  }
+  allow(result).to receive(:max_id).and_return(max_id)
+
+  c = stubbable_client
+  allow(c).to receive_messages(:search => result)
+  c
 end
 
 def fake_replies(result_count = 0, id_base = 0)
-  double(Twitter::Client,
-       {
-         :credentials? => true,
-         :mentions => 1.upto(result_count).collect { |i| fake_tweet(i, id_base, true) }
-       }
-       )
+  c = stubbable_client
+  allow(c).to receive_messages(:mentions_timeline => 1.upto(result_count).collect { |i| fake_tweet(i, id_base)})
+  c
 end
 
 def fake_followers(count)
-  double(Twitter::Client,
-       {
-         :credentials? => true,
-         :followers => 1.upto(count).collect { |i| fake_follower(i) }
-       }
-       )
+  c = stubbable_client
+  allow(c).to receive_messages(:followers => 1.upto(count).collect { |i| fake_follower(i) })
+  c
 end
 
-def fake_tweet(index, id=0, as_object = false)
+def fake_tweet(index, id=0)
   id = index if id <= 0
   x = {
     :from_user => "chatterbot",
     :index => index,
     :id => id,
-    :user => {
-      'screen_name' => "chatterbot"
-    }
+    :text => "I am a tweet",
+    :user => { :id => 1, :screen_name => "chatterbot" }
   }
 
-  as_object == true ? Twitter::Tweet.new(x) : x
+  Twitter::Tweet.new(x)
 end
 
 def fake_follower(index=0)
-  Twitter::User.new(:id => index, :name => "Follower #{index}")
+  Twitter::User.new(:id => index, :name => "Follower #{index}",
+                    :screen_name => "follower#{index}")
+end
+
+def fake_user(name, id = 1)
+  Twitter::User.new(:id => id, :name => name, :screen_name => name)
 end