chatterbot 0.2.0

data/spec/bot_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Chatterbot::Bot" do
+  
+end

data/spec/client_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Chatterbot::Client" do
+  before(:each) do
+    @bot = Chatterbot::Bot.new
+    @bot.client = mock(Object)
+  end
+
+  it "runs init_client and login on #require_login" do
+    @bot.should_receive(:init_client).and_return(true)
+    @bot.should_receive(:login).and_return(true)
+    @bot.require_login
+  end
+
+  it "reset_client resets the client instance" do
+    @bot.should_receive(:init_client).and_return(true)
+    @bot.reset_client
+  end
+  
+  describe "api setup" do
+    it "calls get_api_key" do
+      @bot.should_receive(:needs_api_key?).and_return(true)
+      @bot.should_receive(:needs_auth_token?).and_return(false)
+      @bot.should_receive(:get_api_key)
+      @bot.login
+    end
+  end
+  
+  describe "oauth validation" do
+    before(:each) do
+      @bot.should_receive(:needs_api_key?).and_return(false)
+      @bot.should_receive(:needs_auth_token?).and_return(true)
+      @bot.should_receive(:get_oauth_verifier).and_return("pin")
+      @bot.client.should_receive(:request_token).and_return(
+                                                            mock(:token => "token",
+                                                                 :secret => "secret"
+                                                                 )
+                                                            )
+      @bot.client.should_receive(:authorize).
+        with("token", "secret", { :oauth_verifier => "pin"}).
+        and_return(mock(:token => "access_token", :secret => "access_secret"))
+    end
+
+    it "handles getting an auth token" do
+      @bot.client.should_receive(:authorized?).and_return(true)
+      @bot.should_receive(:update_config)
+      
+      @bot.login
+
+      @bot.config[:token].should == "access_token"
+      @bot.config[:secret].should == "access_secret"     
+    end
+
+    it "handles errors" do
+      @bot.client.should_receive(:authorized?).and_return(false)
+      @bot.should_receive(:display_oauth_error)
+      @bot.login
+    end
+  end
+end

data/spec/config_spec.rb

@@ -0,0 +1,204 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'tempfile'
+
+describe "Chatterbot::Config" do
+  before(:each) do
+    @bot = Chatterbot::Bot.new    
+  end
+  
+  describe "loading" do
+    it "loads config when we need a variable" do
+      @bot.should_receive(:load_config).and_return({:foo => :bar})
+      @bot.config = nil
+
+      @bot.config[:foo].should == :bar
+    end
+
+    it "loads both global config and local config" do
+      @bot.should_receive(:global_config).and_return({:foo => :bar, :a => :b})
+      @bot.should_receive(:bot_config).and_return({:foo => :baz, :custom => :value})
+
+      @bot.config = nil
+      
+      
+      @bot.config[:foo].should == :baz
+      @bot.config[:a].should == :b
+      @bot.config[:custom].should == :value
+    end
+
+    it "returns a log dest" do
+      @bot.should_receive(:load_config).and_return({:log_dest => :bar})    
+      @bot.config = nil
+
+      @bot.log_dest.should == :bar
+    end
+
+    it "checks for an auth_token" do
+      @bot.should_receive(:load_config).and_return({:token => "123"})
+      @bot.config = nil
+
+      @bot.needs_auth_token?.should == false
+    end
+
+    it "checks for an auth_token" do
+      @bot.should_receive(:load_config).and_return({})
+      @bot.config = nil
+
+      @bot.needs_auth_token?.should == true
+    end
+
+
+    it "checks for an API key" do
+      @bot.should_receive(:load_config).and_return({})
+      @bot.config = nil
+
+      @bot.needs_api_key?.should == true
+
+      @bot.config = {:consumer_key => "ck", :consumer_secret => "cs" }
+      @bot.needs_api_key?.should == false
+    end
+  end
+
+  describe "debug_mode?" do
+    it "works when debug_mode isn't set" do
+      @bot.debug_mode?.should == false
+    end
+
+    it "works when debug_mode is set" do
+      @bot.config[:debug_mode] = false
+      @bot.debug_mode?.should == false
+
+      @bot.config[:debug_mode] = true
+      @bot.debug_mode?.should == true
+    end
+  end
+
+  describe "since_id=" do
+    it "works" do
+      @bot.since_id = 123
+      @bot.config[:tmp_since_id].should == 123
+    end
+  end
+  
+  describe "update_since_id" do
+    it "works with searches" do
+      @bot.config[:tmp_since_id] = 100
+      @bot.update_since_id({ "max_id" => 1000 })
+      @bot.config[:tmp_since_id].should == 1000
+    end
+
+    it "works with tweets" do
+      @bot.config[:tmp_since_id] = 100
+      @bot.update_since_id({ :id => 1000 })
+      @bot.config[:tmp_since_id].should == 1000
+    end
+
+    it "handles weird results" do
+      @bot.config[:tmp_since_id] = 100
+      @bot.update_since_id({ :foo => 1000 })
+      @bot.config[:tmp_since_id].should == 100
+    end
+
+    it "never rolls back" do
+      @bot.config[:tmp_since_id] = 100
+      @bot.update_since_id({ :id => 50 })
+      @bot.config[:tmp_since_id].should == 100     
+    end
+  end
+  
+  
+  describe "update_config" do
+    it "doesn't update the config if update_config? is false" do
+      @bot.should_receive(:update_config?).and_return(false)
+      @bot.should_not_receive(:has_db?)
+      @bot.update_config
+    end
+
+    it "doesn't update keys from the global config" do
+      @bot.stub!(:global_config).and_return({:foo => :bar, :a => :b})
+      @bot.stub!(:bot_config).and_return({:foo => :bar, :custom => :value})      
+
+      @bot.config = nil
+      
+      @bot.config_to_save.should == { :custom => :value }
+    end
+    
+    it "does update keys from the global config if they've been customized" do
+      @bot.stub!(:global_config).and_return({:foo => :bar, :a => :b})
+      @bot.stub!(:bot_config).and_return({:foo => :baz, :custom => :value})      
+
+      @bot.config = nil
+      
+      @bot.config_to_save.should == { :foo => :baz, :custom => :value }
+    end
+
+    it "updates since_id" do
+      @bot.config[:tmp_since_id] = 100
+      @bot.config_to_save[:since_id].should == 100
+    end
+  end
+
+  
+  describe "global config files" do
+    it "has an array of global_config_files" do
+      ENV["chatterbot_config"] = "/tmp/foo.yml"
+      @bot.global_config_files.first.should == "/etc/chatterbot.yml"
+      @bot.global_config_files[1].should == "/tmp/foo.yml"
+      @bot.global_config_files.last.should include("/global.yml")
+    end
+
+    it "slurps in all the global_config_files" do
+      @bot.stub(:global_config_files).and_return(["config.yml", "config2.yml", "config3.yml"])
+      @bot.should_receive(:slurp_file).with("config.yml").and_return({:a => 1 })
+      @bot.should_receive(:slurp_file).with("config2.yml").and_return({:b => 2 })
+      @bot.should_receive(:slurp_file).with("config3.yml").and_return({:c => 3 })      
+
+      @bot.global_config.should == { :a => 1, :b => 2, :c => 3}
+    end
+
+    it "priorities last file in list" do
+      @bot.stub(:global_config_files).and_return(["config.yml", "config2.yml", "config3.yml"])
+      @bot.should_receive(:slurp_file).with("config.yml").and_return({:a => 1 })
+      @bot.should_receive(:slurp_file).with("config2.yml").and_return({:b => 2 })
+      @bot.should_receive(:slurp_file).with("config3.yml").and_return({:a => 100, :b => 50, :c => 3 })      
+      @bot.global_config.should == { :a => 100, :b => 50, :c => 3}
+    end
+  end
+
+
+  describe "file I/O" do
+    it "loads in some YAML" do
+      tmp = {:since_id => 0}
+      
+      src = Tempfile.new("config")
+      src << tmp.to_yaml
+      src.flush
+      
+      @bot.slurp_file(src.path).should == tmp
+    end
+
+    it "symbolizes keys" do
+      tmp = {'since_id' => 0}
+      
+      src = Tempfile.new("config")
+      src << tmp.to_yaml
+      src.flush
+      
+      @bot.slurp_file(src.path).should == { :since_id => 0 }
+    end
+  
+    it "doesn't store local file if we can store to db instead" do
+      @bot.should_receive(:has_db?).and_return(true)
+      @bot.should_receive(:store_database_config)
+      @bot.update_config     
+    end
+  
+    it "stores local file if no db" do
+      @bot.should_receive(:has_db?).and_return(false)
+      @bot.should_not_receive(:store_database_config)
+      @bot.should_receive(:store_local_config)      
+      @bot.update_config     
+    end
+  end
+  
+end

data/spec/db_spec.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'sequel'
+
+describe "Chatterbot::DB" 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
+  end
+  
+  describe "table creation" do
+    [:blacklist, :tweets, :config].each do |table|
+      it "should create table #{table}" do
+        @bot.db
+        @tmp_conn = Sequel.connect(@db_uri)
+        @tmp_conn.tables.include?(table).should == true
+      end
+    end      
+  end
+  
+  describe "store_database_config" do
+    it "doesn't fail" do
+      @bot = Chatterbot::Bot.new    
+      @bot.config[:db_uri] = @db_uri
+
+      @bot.db      
+      @bot.store_database_config.should == true
+    end
+  end
+end

data/spec/dsl_spec.rb

@@ -0,0 +1,73 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Chatterbot::DSL" do
+  describe "client routines" do
+    before(:each) do
+      @bot = mock(Chatterbot::Bot)
+      @bot.send :require, 'chatterbot/dsl'
+
+      Chatterbot::DSL.stub!(:bot).and_return(@bot)
+    end
+  
+    describe "blacklist" do
+      it "#blacklist passes along to bot object" do
+        @bot.should_receive(:blacklist=).with(["foo"])
+        blacklist ["foo"]
+      end
+
+      it "#blacklist turns single-string arg into an array" do
+        @bot.should_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"])
+        blacklist "foo, bar"
+      end
+    end
+  
+    describe "exclude" do
+      it "#exclude passes along to bot object" do
+        @bot.should_receive(:exclude=).with(["foo"])
+        exclude ["foo"]
+      end
+
+      it "#exclude turns single-string arg into an array" do
+        @bot.should_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"])
+        exclude "foo, bar"
+      end
+    end
+    
+    
+    it "#search passes along to bot object" do
+      @bot.should_receive(:search).with("foo")
+      search("foo")
+    end
+
+    it "#search passes along to bot object" do
+      @bot.should_receive(:search).with(["foo","bar"])
+      search(["foo","bar"])
+    end
+    
+    it "#replies passes along to bot object" do
+      @bot.should_receive(:replies)
+      replies
+    end
+
+    it "#tweet passes along to bot object" do
+      @bot.should_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 "})
+      reply "hello sailor!", { :source => "source "}
+    end
+    
+  end
+end

data/spec/helpers_spec.rb

@@ -0,0 +1,40 @@
+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"    
+  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"    
+  end
+   
+  it "#tweet_user works with string" do
+    bot = Chatterbot::Bot.new
+    bot.tweet_user("foo").should == "@foo"
+    bot.tweet_user("@foo").should == "@foo"    
+  end
+ 
+  describe "#botname" do    
+    before(:each) do
+      @bot = Chatterbot::Bot.new
+      @bot.client = mock(Object)
+    end
+
+    it "calls botname smartly for inherited classes" do
+      class TestBot < Chatterbot::Bot; end
+      @bot2 = TestBot.new
+      @bot2.botname.should == "testbot"
+    end
+
+    it "calls botname for non-inherited bots" do
+      File.should_receive(:basename).and_return("bot")
+      @bot.botname.should == "bot"
+    end
+  end
+  
+end

data/spec/logging_spec.rb

@@ -0,0 +1,65 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Chatterbot::Logging" do
+  describe "debug logging" do
+    before(:each) do
+      @bot = Chatterbot::Bot.new
+      @logger = mock(Logger)
+      @bot.stub!(:logger).and_return(@logger)
+    end
+
+    it "should call logger on debug" do
+      @bot.should_receive(:logging?).and_return(true)
+      @logger.should_receive(:debug).with("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)
+      @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("hi!")      
+      @bot.should_receive(:puts).with("hi!")
+      @bot.critical "hi!"
+    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
+
+      @bot.should_receive(:log_tweets?).and_return(true)
+
+      @bot.should_receive(:botname).and_return("logger")
+      Time.stub!(:now).and_return(123)                
+
+      @tweets_table = mock(Object)     
+      @bot.stub!(: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})
+      @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" }
+
+      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)
+     
+      @bot.log "TEST", source_tweet
+    end
+  end
+end