chatterbot 0.7.1 → 0.9.0

data/spec/db_spec.rb

@@ -11,10 +11,10 @@ describe "Chatterbot::DB" do
   context "prerequisites" do
     describe "get_connection" do
       it "should make sure sequel is actually installed" do
-        Chatterbot::Bot.any_instance.stub(:has_sequel?) { false }
+        allow_any_instance_of(Chatterbot::Bot).to receive(:has_sequel?) { false }
         @bot = Chatterbot::Bot.new
         @bot.config[:db_uri] = @db_uri
-        @bot.should_receive(:display_db_config_notice)
+        expect(@bot).to receive(:display_db_config_notice)
         @bot.db
       end
     end
@@ -23,7 +23,7 @@ describe "Chatterbot::DB" do
   context "db interactions" do
     before(:each) do
       @bot = Chatterbot::Bot.new
-      @bot.stub(:update_config_at_exit)
+      allow(@bot).to receive(:update_config_at_exit)
       @bot.config[:db_uri] = @db_uri
     end
 
@@ -35,7 +35,7 @@ describe "Chatterbot::DB" do
       [:blacklist, :tweets, :config].each do |table|
         it "should create table #{table}" do
           @tmp_conn = @bot.db
-          @tmp_conn.tables.include?(table).should == true
+          expect(@tmp_conn.tables.include?(table)).to eq(true)
         end
       end      
     end
@@ -46,7 +46,7 @@ describe "Chatterbot::DB" do
         @bot.config[:db_uri] = @db_uri
         
         @bot.db
-        @bot.store_database_config.should == true
+        expect(@bot.store_database_config).to eq(true)
       end
     end
   end

data/spec/dsl_spec.rb

@@ -6,28 +6,28 @@ describe "Chatterbot::DSL" do
       @bot = double(Chatterbot::Bot, :config => {})
       @bot.send :require, 'chatterbot/dsl'
 
-      Chatterbot::DSL.stub(:bot).and_return(@bot)
+      allow(Chatterbot::DSL).to receive(:bot).and_return(@bot)
     end
 
     describe "client" do
       it "returns the bot object" do
-        client.should eql(@bot.client)
+        expect(client).to eql(@bot.client)
       end
     end
 
     describe "blacklist" do
       it "#blacklist passes along to bot object" do
-        @bot.should_receive(:blacklist=).with(["foo"])
+        expect(@bot).to receive(:blacklist=).with(["foo"])
         blacklist ["foo"]
       end
 
       it "#blacklist turns single-string arg into an array" do
-        @bot.should_receive(:blacklist=).with(["foo"])
+        expect(@bot).to receive(:blacklist=).with(["foo"])
         blacklist "foo"
       end
 
       it "#blacklist turns comma-delimited string arg into an array" do
-        @bot.should_receive(:blacklist=).with(["foo", "bar"])
+        expect(@bot).to receive(:blacklist=).with(["foo", "bar"])
         blacklist "foo, bar"
       end
     end
@@ -35,117 +35,164 @@ describe "Chatterbot::DSL" do
     [:no_update, :debug_mode, :verbose].each do |method|
       describe method.to_s do
         it "#{method.to_s} with nil passes along true to bot object" do
-          @bot.should_receive("#{method.to_s}=").with(true)
+          expect(@bot).to receive("#{method.to_s}=").with(true)
           send method
         end
 
         it "#debug_mode with false is passed" do
-          @bot.should_receive("#{method.to_s}=").with(false)
+          expect(@bot).to receive("#{method.to_s}=").with(false)
           send method, false
         end
 
         it "#debug_mode with true is passed" do
-          @bot.should_receive("#{method.to_s}=").with(true)
+          expect(@bot).to receive("#{method.to_s}=").with(true)
           send method, true
         end
       end
     end
 
+    it "#badwords returns an array" do
+      expect(bad_words).to be_a(Array)
+    end
+    
     describe "exclude" do
       it "#exclude passes along to bot object" do
-        @bot.should_receive(:exclude=).with(["foo"])
+        expect(@bot).to receive(:exclude=).with(["foo"])
         exclude ["foo"]
       end
 
       it "#exclude turns single-string arg into an array" do
-        @bot.should_receive(:exclude=).with(["foo"])
+        expect(@bot).to receive(:exclude=).with(["foo"])
         exclude "foo"
       end
 
       it "#exclude turns comma-delimited string arg into an array" do
-        @bot.should_receive(:exclude=).with(["foo", "bar"])
+        expect(@bot).to receive(:exclude=).with(["foo", "bar"])
         exclude "foo, bar"
       end
     end
 
     describe "search" do
       it "passes along to bot object" do
-        @bot.should_receive(:search).with("foo", { })
+        expect(@bot).to receive(:search).with("foo", { })
         search("foo")
       end
 
       it "passes multiple queries along to bot object" do
-        @bot.should_receive(:search).with(["foo","bar"], { })
+        expect(@bot).to receive(:search).with(["foo","bar"], { })
         search(["foo","bar"])
       end
     end
 
+    describe "streaming" do
+      it "passes along to bot object" do
+        expect(@bot).to receive(:do_streaming)
+        streaming {}
+      end
+    end
+
+    
     it "#retweet passes along to bot object" do
-      @bot.should_receive(:retweet).with(1234)
+      expect(@bot).to receive(:retweet).with(1234)
       retweet(1234)
     end
 
+    it "#favorite passes along to bot object" do
+      expect(@bot).to receive(:favorite).with(1234)
+      favorite(1234)
+    end
+    
     it "#replies passes along to bot object" do
-      @bot.should_receive(:replies)
+      expect(@bot).to receive(:replies)
       replies
     end
 
+    it "#streaming_tweets passes along to bot object" do
+      expect(@bot).to receive(:streaming_tweets)
+      streaming_tweets
+    end
+    
     it "#followers passes along to bot object" do
-      @bot.should_receive(:followers)
+      expect(@bot).to receive(:followers)
       followers
     end
 
+    it "#follow passes along to bot object" do
+      expect(@bot).to receive(:follow).with(1234)
+      follow(1234)
+    end
+    
     it "#tweet passes along to bot object" do
-      @bot.should_receive(:tweet).with("hello sailor!", {:foo => "bar" }, nil)
+      expect(@bot).to receive(:tweet).with("hello sailor!", {:foo => "bar" }, nil)
       tweet "hello sailor!", {:foo => "bar"}
     end
 
     it "#reply passes along to bot object" do
-      @bot.should_receive(:reply).with("hello sailor!", { :source => "source "})
+      expect(@bot).to receive(:reply).with("hello sailor!", { :source => "source "})
       reply "hello sailor!", { :source => "source "}
     end
 
+    it "#profile_text setter passes along to bot object" do
+      expect(@bot).to receive(:profile_text).with("hello sailor!")
+      profile_text "hello sailor!"
+    end
+
+    it "#profile_text getter passes along to bot object" do
+      expect(@bot).to receive(:profile_text)
+      profile_text
+    end
+
+    it "#profile_website passes along to bot object" do
+      expect(@bot).to receive(:profile_website).with("http://hellosailor.com")
+      profile_website "http://hellosailor.com"
+    end
+
+    it "#profile_website getter passes along to bot object" do
+      expect(@bot).to receive(:profile_website)
+      profile_website
+    end
+    
     context "setters" do
       [:consumer_secret, :consumer_key, :token, :secret].each do |k|
         it "should be able to set #{k}" do
           send(k, "foo")
-          @bot.config[k].should == "foo"
+          expect(@bot.config[k]).to eq("foo")
         end
       end
     end
     
     describe "update_config" do
       it "should pass to bot object" do
-        @bot.should_receive(:update_config)
+        expect(@bot).to receive(:update_config)
         update_config
       end
     end
 
     describe "since_id" do
       it "should pass to bot object" do
-        @bot.should_receive(:config).and_return({:since_id => 1234})
-        since_id.should == 1234
+        expect(@bot).to receive(:config).and_return({:since_id => 1234})
+        expect(since_id).to eq(1234)
       end
 
       it "can be set" do
         since_id(1234)
-        @bot.config[:since_id].should == 1234
+        expect(@bot.config[:since_id]).to eq(1234)
       end
     end
 
     describe "since_id_reply" do
       it "should pass to bot object" do
-        @bot.should_receive(:config).and_return({:since_id_reply => 1234})
-        since_id_reply.should == 1234
+        expect(@bot).to receive(:config).and_return({:since_id_reply => 1234})
+        expect(since_id_reply).to eq(1234)
       end
     end
 
     describe "db" do
       it "should pass to bot object" do
         bot_db = double(Object)
-        @bot.should_receive(:db).and_return(bot_db)
+        expect(@bot).to receive(:db).and_return(bot_db)
 
-        db.should eql(bot_db)
+        expect(db).to eql(bot_db)
       end
     end
 

data/spec/favorite_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Chatterbot::Favorite" do
+  describe "#favorite" do
+    before(:each) do
+      @bot = test_bot
+      @t = Twitter::Tweet.new(:id => 7890, :text => "something awesome that you should fave")
+    end
+
+    it "calls require_login" do
+      expect(@bot).to receive(:require_login).and_return(false)
+      @bot.favorite @t
+    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.favorite with an id" do   
+        expect(@bot.client).to receive(:favorite).with(7890)
+        @bot.favorite(@t.id)
+      end
+
+      it "calls client.retweet with a tweet" do   
+        expect(@bot.client).to receive(:favorite).with(7890)
+        @bot.favorite(@t)
+      end
+    end
+  end
+end

data/spec/followers_spec.rb

@@ -1,19 +1,40 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe "Chatterbot::Followers" do
-  it "calls require_login" do
-    bot = test_bot
-    bot.should_receive(:require_login).and_return(false)
-    bot.followers
+  before(:each) do
+    @bot = test_bot
   end
 
-  it "returns followers" do
-    bot = test_bot
-    bot.should_receive(:require_login).and_return(true)
-    bot.stub(:client).and_return(fake_followers(3))
+  describe "followers" do
+    it "calls require_login" do
+      expect(@bot).to receive(:require_login).and_return(false)
+      @bot.followers
+    end
 
-    result = bot.followers
-    result.size.should == 3
-    result[0].name.should == "Follower 1"
+    it "returns followers" do
+      expect(@bot).to receive(:require_login).and_return(true)
+      allow(@bot).to receive(:client).and_return(fake_followers(3))
+
+      result = @bot.followers
+      expect(result.size).to eq(3)
+      expect(result[0].name).to eq("Follower 1")
+    end
   end
+
+  describe "follow" do
+    it "calls require_login" do
+      expect(@bot).to receive(:require_login).and_return(false)
+      @bot.follow(1234)
+    end
+
+    it "works" do
+      expect(@bot).to receive(:require_login).and_return(true)
+      allow(@bot).to receive(:client).and_return(double(Twitter::Client))
+      expect(@bot.client).to receive(:follow).with(1234)
+      
+      @bot.follow(1234)
+    end
+  end
+
+  
 end

data/spec/helpers_spec.rb

@@ -3,20 +3,20 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 describe "Chatterbot::Helpers" do
   it "#tweet_user works with [:from_user]" do
     bot = Chatterbot::Bot.new
-    bot.tweet_user({:from_user => "foo"}).should == "@foo"
-    bot.tweet_user({:from_user => "@foo"}).should == "@foo"    
+    expect(bot.tweet_user({:from_user => "foo"})).to eq("@foo")
+    expect(bot.tweet_user({:from_user => "@foo"})).to eq("@foo")    
   end
 
   it "#tweet_user works with [:user][:screen_name]" do
     bot = Chatterbot::Bot.new
-    bot.tweet_user({:user => {:screen_name => "foo"}}).should == "@foo"
-    bot.tweet_user({:user => {:screen_name => "@foo"}}).should == "@foo"    
+    expect(bot.tweet_user({:user => {:screen_name => "foo"}})).to eq("@foo")
+    expect(bot.tweet_user({:user => {:screen_name => "@foo"}})).to eq("@foo")    
   end
    
   it "#tweet_user works with string" do
     bot = Chatterbot::Bot.new
-    bot.tweet_user("foo").should == "@foo"
-    bot.tweet_user("@foo").should == "@foo"    
+    expect(bot.tweet_user("foo")).to eq("@foo")
+    expect(bot.tweet_user("@foo")).to eq("@foo")    
   end
 
   describe "#from_user" do
@@ -25,15 +25,21 @@ describe "Chatterbot::Helpers" do
     end
 
     it "should accept strings" do
-      @bot.from_user("x").should == "x"
+      expect(@bot.from_user("x")).to eq("x")
     end
 
-    it "should accept :from_user tweet" do
-      @bot.from_user(Twitter::Tweet.new(:id => 123, :from_user => "x")).should == "x"
+    it "should accept tweet" do
+      t = Twitter::Tweet.new(:id => 123, :text => 'Tweet text.', :user => {:id => 123, :screen_name => "x"})
+      expect(@bot.from_user(t)).to eq("x")
     end
 
+    it "should accept user" 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
-      @bot.from_user(:user => {:screen_name => "x"}).should == "x"
+      expect(@bot.from_user(:user => {:screen_name => "x"})).to eq("x")
     end
   end
   
@@ -41,28 +47,27 @@ describe "Chatterbot::Helpers" do
     before(:each) do
       class TestBot < Chatterbot::Bot; end
       @bot = Chatterbot::Bot.new
-      #@bot.client = mock(Object)
     end
 
     it "can set botname" do
       @bot = TestBot.new
       @bot.botname = "foo"
-      @bot.botname.should == "foo"
+      expect(@bot.botname).to eq("foo")
     end
     
     it "calls botname smartly for inherited classes" do
       @bot2 = TestBot.new
-      @bot2.botname.should == "testbot"
+      expect(@bot2.botname).to eq("testbot")
     end
 
     it "calls botname for non-inherited bots" do
-      File.should_receive(:basename).and_return("bot")
-      @bot.botname.should == "bot"
+      expect(File).to receive(:basename).and_return("bot")
+      expect(@bot.botname).to eq("bot")
     end
 
     it "uses specified name" do
       @bot = Chatterbot::Bot.new(:name => 'xyzzy')
-      @bot.botname.should == "xyzzy"
+      expect(@bot.botname).to eq("xyzzy")
     end
   end
 
@@ -73,16 +78,16 @@ describe "Chatterbot::Helpers" do
     end
 
     it "should replace username by calling tweet_user" do
-      @bot.should_receive(:tweet_user).and_return("@foobar")
-      @bot.replace_variables("#USER#", @tweet).should == "@foobar"
+      expect(@bot).to receive(:tweet_user).and_return("@foobar")
+      expect(@bot.replace_variables("#USER#", @tweet)).to eq("@foobar")
     end
     
     it "should be fine with not replacing anything" do
-      @bot.replace_variables("foobar", @tweet).should == "foobar"
+      expect(@bot.replace_variables("foobar", @tweet)).to eq("foobar")
     end
     
     it "should be fine without a tweet" do
-      @bot.replace_variables("foobar").should == "foobar"
+      expect(@bot.replace_variables("foobar")).to eq("foobar")
     end
   end  
 end