chatterbot 1.0.2 → 2.0.0.pre

data/spec/config_spec.rb

@@ -14,12 +14,6 @@ describe "Chatterbot::Config" do
   end
   
   describe "loading" do
-    it "overrides with incoming params" do
-      expect(@bot).to receive(:global_config).and_return({:foo => :bar})      
-      tmp = @bot.load_config({:foo => :baz})
-      expect(tmp[:foo]).to eq(:baz)
-    end
-    
     it "loads config when we need a variable" do
       expect(@bot).to receive(:load_config).and_return({:foo => :bar})
       @bot.config = nil
@@ -27,30 +21,19 @@ describe "Chatterbot::Config" do
       expect(@bot.config[:foo]).to eq(:bar)
     end
 
-    it "loads both global config and local config" do
-      expect(@bot).to receive(:global_config).and_return({:foo => :bar, :a => :b})
-      expect(@bot).to receive(:bot_config).and_return({:foo => :baz, :custom => :value})
-
-      @bot.config = nil     
-      
-      expect(@bot.config[:foo]).to eq(:baz)
-      expect(@bot.config[:a]).to eq(:b)
-      expect(@bot.config[:custom]).to eq(:value)
-    end
-
     context "environment variables" do
       before(:each) do
         ENV["chatterbot_consumer_key"] = "env_chatterbot_consumer_key"
         ENV["chatterbot_consumer_secret"] = "env_chatterbot_consumer_secret"
-        ENV["chatterbot_token"] = "env_chatterbot_token"
-        ENV["chatterbot_secret"] = "env_chatterbot_secret"
+        ENV["chatterbot_access_token"] = "env_chatterbot_token"
+        ENV["chatterbot_access_secret"] = "env_chatterbot_secret"
       end
 
       after(:each) do
         ENV.delete "chatterbot_consumer_key"
         ENV.delete "chatterbot_consumer_secret"
-        ENV.delete "chatterbot_token"
-        ENV.delete "chatterbot_secret"
+        ENV.delete "chatterbot_access_token"
+        ENV.delete "chatterbot_access_secret"
       end
 
       it "checks for environment variables" do
@@ -59,16 +42,16 @@ describe "Chatterbot::Config" do
         
         expect(@bot.config[:consumer_key]).to eq("env_chatterbot_consumer_key")
         expect(@bot.config[:consumer_secret]).to eq("env_chatterbot_consumer_secret")
-        expect(@bot.config[:token]).to eq("env_chatterbot_token")
-        expect(@bot.config[:secret]).to eq("env_chatterbot_secret")
+        expect(@bot.config[:access_token]).to eq("env_chatterbot_token")
+        expect(@bot.config[:access_token_secret]).to eq("env_chatterbot_secret")
       end
 
       it "works if env var is nil" do
         ENV["chatterbot_consumer_key"] = nil
         @bot.config = nil
-        allow(@bot).to receive(:slurp_file).and_return({:chatterbot_consumer_key => "foo"})
+        allow(@bot).to receive(:slurp_file).and_return({:consumer_key => "foo"})
 
-        expect(@bot.config[:chatterbot_consumer_key]).to eq("foo")
+        expect(@bot.config[:consumer_key]).to eq("foo")
       end
     end
 
@@ -77,7 +60,7 @@ describe "Chatterbot::Config" do
     end
 
     it "update_config? is false if this is a dry run" do
-      @bot.config[:no_update] = true
+      @bot.no_update = true
       expect(@bot.update_config?).to eq(false)
     end
 
@@ -90,7 +73,7 @@ describe "Chatterbot::Config" do
     end
 
     it "checks for an auth_token" do
-      expect(@bot).to receive(:load_config).and_return({:token => "123"})
+      expect(@bot).to receive(:load_config).and_return({:access_token => "123"})
       @bot.config = nil
 
       expect(@bot.needs_auth_token?).to eq(false)
@@ -118,49 +101,35 @@ describe "Chatterbot::Config" do
   describe "debug_mode=" do
     it "works" do
       @bot.debug_mode = true
-      expect(@bot.config[:debug_mode]).to eq(true)
+      expect(@bot.debug_mode?).to eq(true)
     end
   end
 
   describe "no_update=" do
     it "works" do
       @bot.no_update = true
-      expect(@bot.config[:no_update]).to eq(true)
+      expect(@bot.no_update?).to eq(true)
     end
   end
 
   describe "verbose=" do
     it "works" do
+      expect(@bot.verbose?).to eq(false)
       @bot.verbose = true
-      expect(@bot.config[:verbose]).to eq(true)
-    end
-  end
-  
-  describe "reset_bot?" do
-    it "works when reset_bot isn't set" do
-      expect(@bot.reset_bot?).to eq(false)
-    end
-
-    it "works when reset_bot is set" do
-      @bot.config[:reset_since_id] = false
-      expect(@bot.reset_bot?).to eq(false)
-
-      @bot.config[:reset_since_id] = true
-      expect(@bot.reset_bot?).to eq(true)
+      expect(@bot.verbose?).to eq(true)
     end
   end
-
-  
+    
   describe "debug_mode?" do
     it "works when debug_mode isn't set" do
       expect(@bot.debug_mode?).to eq(false)
     end
 
     it "works when debug_mode is set" do
-      @bot.config[:debug_mode] = false
+      @bot.debug_mode = false
       expect(@bot.debug_mode?).to eq(false)
 
-      @bot.config[:debug_mode] = true
+      @bot.debug_mode = true
       expect(@bot.debug_mode?).to eq(true)
     end
   end
@@ -169,39 +138,31 @@ describe "Chatterbot::Config" do
     it "works" do
 
       @bot.since_id_reply = 123
-      expect(@bot.config[:tmp_since_id_reply]).to eq(123)
+      expect(@bot.config[:since_id_reply]).to eq(123)
     end
   end
 
   describe "update_since_id_reply" do
     it "works with tweets" do
-      @bot.config[:tmp_since_id_reply] = 100
+      @bot.config[:since_id_reply] = 100
 
       data = fake_tweet(1000, 1000)
       @bot.update_since_id_reply(data)
-      expect(@bot.config[:tmp_since_id_reply]).to eq(1000)
-    end
-
-    it "doesn't work with searches" do
-      data = fake_search(1000, 1).search
-
-      @bot.config[:tmp_since_id_reply] = 100
-      @bot.update_since_id_reply(data)
-      expect(@bot.config[:tmp_since_id_reply]).to eq(100)
+      expect(@bot.config[:since_id_reply]).to eq(1000)
     end
 
     it "never rolls back" do
-      @bot.config[:tmp_since_id_reply] = 100
+      @bot.config[:since_id_reply] = 100
       data = fake_tweet(50, 50)
       @bot.update_since_id(data)
-      expect(@bot.config[:tmp_since_id_reply]).to eq(100)
+      expect(@bot.config[:since_id_reply]).to eq(100)
     end
   end
 
   describe "since_id=" do
     it "works" do
       @bot.since_id = 123
-      expect(@bot.config[:tmp_since_id]).to eq(123)
+      expect(@bot.config[:since_id]).to eq(123)
     end
   end
 
@@ -209,42 +170,21 @@ describe "Chatterbot::Config" do
     it "works with searches" do
       data = fake_search(1000, 1).search
 
-      @bot.config[:tmp_since_id] = 100
+      @bot.config[:since_id] = 100
       @bot.update_since_id(data)
-      expect(@bot.config[:tmp_since_id]).to eq(1000)
-    end
-
-    it "works with SearchResults" do
-      s = Twitter::SearchResults.new(
-        double(Twitter::REST::Request,
-               :client => nil,
-               :verb => nil,
-               :path => nil,
-               :options => nil,
-               :perform => {
-                 :search_metadata => {
-                   :max_id => 1000
-                 }
-               }
-              )
-      )
-      
-      
-      @bot.config[:tmp_since_id] = 100
-      @bot.update_since_id(s)
-      expect(@bot.config[:tmp_since_id]).to eq(1000)
+      expect(@bot.config[:since_id]).to eq(1000)
     end
     
     it "works with tweets" do
-      @bot.config[:tmp_since_id] = 100
+      @bot.config[:since_id] = 100
 
       data = fake_tweet(1000, 1000)
       @bot.update_since_id(data)
-      expect(@bot.config[:tmp_since_id]).to eq(1000)
+      expect(@bot.config[:since_id]).to eq(1000)
     end
 
     it "works with arrays" do
-      @bot.config[:tmp_since_id] = 100
+      @bot.config[:since_id] = 100
 
       data = [
               fake_tweet(500, 1000),
@@ -253,60 +193,24 @@ describe "Chatterbot::Config" do
              ]
               
       @bot.update_since_id(data)
-      expect(@bot.config[:tmp_since_id]).to eq(1000)
+      expect(@bot.config[:since_id]).to eq(1000)
     end
 
     it "works with an id" do
-      @bot.config[:tmp_since_id] = 100
+      @bot.config[:since_id] = 100
               
       @bot.update_since_id(1000)
-      expect(@bot.config[:tmp_since_id]).to eq(1000)
+      expect(@bot.config[:since_id]).to eq(1000)
     end
     
     it "never rolls back" do
-      @bot.config[:tmp_since_id] = 100
+      @bot.config[:since_id] = 100
       data = fake_tweet(50, 50)
       @bot.update_since_id(data)
-      expect(@bot.config[:tmp_since_id]).to eq(100)     
+      expect(@bot.config[:since_id]).to eq(100)     
     end
   end
   
-  
-  describe "update_config" do
-    it "doesn't update the config if update_config? is false" do
-      expect(@bot).to receive(:update_config?).and_return(false)
-      expect(@bot).not_to receive(:has_db?)
-      @bot.update_config
-    end
-
-    it "doesn't update keys from the global config" do
-      allow(@bot).to receive(:global_config).and_return({:foo => :bar, :a => :b})
-      allow(@bot).to receive(:bot_config).and_return({:foo => :bar, :custom => :value})      
-
-      @bot.config = nil
-      
-      expect(@bot.config_to_save).to eq({ :custom => :value })
-    end
-    
-    it "does update keys from the global config if they've been customized" do
-      allow(@bot).to receive(:global_config).and_return({:foo => :bar, :a => :b})
-      allow(@bot).to receive(:bot_config).and_return({:foo => :baz, :custom => :value})      
-
-      @bot.config = nil
-      
-      expect(@bot.config_to_save).to eq({ :foo => :baz, :custom => :value })
-    end
-
-    it "updates since_id" do
-      @bot.config[:tmp_since_id] = 100
-      expect(@bot.config_to_save[:since_id]).to eq(100)
-    end
-
-    it "updates since_id_reply" do
-      @bot.config[:tmp_since_id_reply] = 100
-      expect(@bot.config_to_save[:since_id_reply]).to eq(100)
-    end
-  end
 
   
   describe "global config files" do
@@ -368,35 +272,6 @@ describe "Chatterbot::Config" do
       
       expect(@bot.slurp_file(src.path)).to eq({ :since_id => 0 })
     end
-  
-    it "doesn't store local file if we can store to db instead" do
-      expect(@bot).to receive(:has_db?).and_return(true)
-      expect(@bot).to receive(:store_database_config)
-      @bot.update_config     
-    end
-  
-    it "stores local file if no db" do
-      expect(@bot).to receive(:has_db?).and_return(false)
-      expect(@bot).not_to receive(:store_database_config)
-      expect(@bot).to receive(:store_local_config)      
-      @bot.update_config     
-    end
   end
 
-  describe "store_local_config" do
-    before(:each) do
-      tmp = {:x => 123, :foo => :bar}
-      
-      @src = Tempfile.new("config")
-
-      allow(@bot).to receive(:config_file).and_return(@src.path)
-      allow(@bot).to receive(:config_to_save).and_return(tmp)
-    end
-
-    it "should work" do
-      @bot.store_local_config
-      expect(@bot.slurp_file(@src.path)).to eq({ :x => 123, :foo => :bar })
-    end
-  end
-  
 end

data/spec/direct_messages_spec.rb

@@ -0,0 +1,115 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Chatterbot::DirectMessages" do
+  let(:bot) { test_bot }
+
+  describe "direct_message" do
+    it "calls require_login" do
+      expect(bot).to receive(:require_login).and_return(false)
+      bot.direct_message("hello")
+    end
+
+    context "when authenticated" 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 create_direct_message" do
+        test_str = "test!"
+        test_user = fake_user("DM Enthusiast")
+
+        expect(bot.client).to receive(:create_direct_message).with(test_user, test_str)
+        bot.direct_message(test_str, test_user)
+      end
+
+      it "grabs user from most recent tweet object if needed" do
+        test_str = "test!"
+        test_user = fake_user("DM Enthusiast", 1000)
+
+        x = {
+          :from_user => "chatterbot",
+          :id => 100,
+          :text => "I am a tweet",
+          :user => { :id => 1000, :screen_name => "DM Enthusiast" }
+        }
+
+        t = Twitter::Tweet.new(x)
+        bot.instance_variable_set(:@current_tweet, t)
+
+        expect(bot.client).to receive(:create_direct_message).with(test_user, test_str)
+        bot.direct_message(test_str)
+      end
+    end
+  end
+
+  describe "direct_messages" do
+    it "calls require_login" do
+      expect(bot).to receive(:require_login).and_return(false)
+      bot.direct_messages
+    end
+
+    it "updates since_id_dm when complete" do
+      expect(bot).to receive(:require_login).and_return(true)
+      results = fake_direct_messages(1, 1000)
+
+      allow(bot).to receive(:client).and_return(results)
+
+      bot.direct_messages do
+      end
+
+      expect(bot.config[:since_id_dm]).to eq(1000)
+    end
+
+    describe "results handling" do
+      before(:each) do
+        expect(bot).to receive(:require_login).and_return(true)
+        allow(bot).to receive(:client).and_return(fake_direct_messages(3))
+      end
+
+      it "iterates results" do
+
+        expect(bot).to receive(:update_since_id_dm).exactly(3).times
+
+        indexes = []
+        bot.direct_messages 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.direct_messages do |x|
+          indexes << x.id
+        end
+
+        expect(indexes).to eq([2,3])
+      end
+
+      it "checks safelist" do
+        allow(bot).to receive(:has_safelist?).and_return(true)
+        allow(bot).to receive(:on_safelist?).and_return(false, true, false)
+
+        indexes = []
+        bot.direct_messages do |x|
+          indexes << x.id
+        end
+
+        expect(indexes).to eq([2])
+      end
+
+
+      it "passes along since_id_dm" do
+        allow(bot).to receive(:since_id_dm).and_return(123)
+
+        expect(bot.client).to receive(:direct_messages_received).with({:since_id => 123, :count => 200})
+
+        bot.direct_messages
+      end
+    end
+  end
+end