boty 0.0.17.1 → 0.1.0

data/spec/boty/bot_spec.rb

@@ -1,85 +1,6 @@
 module Boty
-  RSpec.describe "happy brighty shiny path", :session do
-    before do
-      start_session
-    end
-
-    let(:user_id) { "U5678" }
-
-    before do
-      bot.hear(/jeeba/i) do
-        say "Ohay <@#{user.id}>! I'm here, that's for sure."
-      end
-
-      bot.hear(/anybody there\?/i) do
-        say "Me! Here."
-      end
-
-      bot.match(/with match/i) do
-        say "Ohay <@#{user.id}>! It matched."
-      end
-
-      bot.command(/do stuff/i) do
-        say "Doing some stuff"
-      end
-
-      bot.command(/exec command/i) do
-        say "Command issued."
-      end
-    end
-
-    it "responds to a message" do
-      expect(bot).to receive(:say).
-        with "Ohay <@U5678>! I'm here, that's for sure."
-      faye.message "jeeba, are you there?", user: "U5678"
-    end
-
-    it "responds to a match" do
-      expect(bot).to receive(:say).
-        with "Ohay <@U5678>! It matched."
-      faye.message "called with match?", user: "U5678"
-    end
-
-    it "does not respond to a message not binded" do
-      expect(bot).to_not receive(:say)
-      faye.message "are you there?"
-    end
-
-    it "understands #hear as a message binding" do
-      expect(bot).to receive(:say).with("Me! Here.")
-      faye.message "anybody there?"
-    end
-
-    context "Direct message" do
-      it "responds when mentioned by name" do
-        expect(bot).to receive(:say).with "Doing some stuff"
-        faye.message "<@jeeba>: do stuff!"
-      end
-
-      it "responds when mentioned by id" do
-        expect(bot).to receive(:say).with "Doing some stuff"
-        faye.message "<@U1234>: do stuff!"
-      end
-
-      it "responds just once" do
-        expect(bot).to receive(:im).once
-        faye.message "<@U1234>: knows"
-      end
-
-      it "responds when mentioned by both name and id in the same message" do
-        expect(bot).to receive(:im).once
-        faye.message "<@U1234|jabber>: knows"
-      end
-
-      it "understands `#command` bindings" do
-        expect(bot).to receive(:say).with "Command issued."
-        faye.message "<@U1234>: exec command xpto"
-      end
-    end
-  end
-
   RSpec.describe Bot do
-    subject(:bot) { described_class.new bot_info, Session.new }
+    subject(:bot) { described_class.new bot_info }
 
     let(:bot_info) {{
       "id" => "666",
@@ -138,7 +59,10 @@ module Boty
     end
 
     describe "#match", :users do
-      let(:data) { {"type" => "message", "text" => "bbq omg lol"} }
+      let(:data) {{
+        "type" => "message",
+        "text" => "bbq omg lol"
+      }}
 
       it "binds a regex to events of `type => message`" do
         _message = nil
@@ -147,7 +71,7 @@ module Boty
         end
         bot.event data
 
-        expect(_message).to be_a Message
+        expect(_message).to be_a Boty::Slack::Message
         expect(_message.text).to eq "bbq omg lol"
         expect(_message.match[0]).to eq "omg"
       end
@@ -171,6 +95,14 @@ module Boty
         expect(_lol).to eq "lol"
         expect(_bbq).to eq "bbq"
       end
+
+      it "evals the block in the context of the bot" do
+        dsl = nil
+        bot.match(/omg/) { dsl = self }
+        bot.event data
+
+        expect(dsl.bot).to eq bot
+      end
     end
 
     describe "#respond", :users do
@@ -226,20 +158,23 @@ module Boty
         start_session
       end
 
-      describe "#no_message" do
-        let(:data) { {"type" => "message", "text" => "bbq omg lol"} }
+      describe "#no_match" do
+        let(:data) {{
+          "type" => "message",
+          "text" => "bbq omg lol"
+        }}
 
         it "removes a message based on the regex AND the block" do
           permanent_executed = false
           permanent_block = ->() { permanent_executed = true }
-          bot.hear(/omg/i, &permanent_block)
+          bot.match(/omg/i, &permanent_block)
 
           ephemeral_executed = false
           ephemeral_block = ->() { ephemeral_executed = true }
-          bot.hear(/omg/i, &ephemeral_block)
+          bot.match(/omg/i, &ephemeral_block)
           bot.no_match(/omg/i, &ephemeral_block)
 
-          dsl.bot.event data
+          bot.event data
 
           expect(permanent_executed).to eq true
           expect(ephemeral_executed).to eq false
@@ -247,11 +182,11 @@ module Boty
 
         it "removes all binds for a specific regex" do
           first = second = false
-          bot.hear(/omg/i) { first = true }
-          bot.hear(/omg/i) { second = true }
+          bot.match(/omg/i) { first = true }
+          bot.match(/omg/i) { second = true }
           bot.no_match(/omg/i)
 
-          dsl.bot.event data
+          bot.event data
 
           expect(first).to eq false
           expect(second).to eq false
@@ -294,45 +229,70 @@ module Boty
       end
     end
 
-    describe "#say", :users do
-      let(:data) {{
-        "type" => "message",
-        "text" => "hey <@jabber>, omg me",
-        "channel" => "omg"
-      }}
-
+    describe "#say" do
       it "sends a string using the slack api to general (default) channel" do
         expect(Slack.chat).to receive(:post_message).
-          with "something", channel: "general"
+          with "something", channel: "#general"
+
         bot.say "something"
       end
 
-      it "send a message to the channel specified by a current binded message" do
+      it "sends a message to the channel specified by parameter" do
         expect(Slack.chat).to receive(:post_message).
-          with "omg pugs!", channel: "omg"
+          with "omg pugs!", channel: "#omg"
 
-        bot.respond(/omg me/) { say "omg pugs!" }
-        bot.event data
+        bot.say "omg pugs!", channel: "#omg"
+      end
+
+      it "accepts extra parameters and send them to the slack api" do
+        expect(Slack.chat).to receive(:post_message).
+          with "omg pugs!", channel: "#omg", omg: "lol"
+
+        bot.say "omg pugs!", channel: "#omg", omg: "lol"
+      end
+
+      it "logs the response for the request sending the message" do
+        logger = Boty::Logger.adapter = Boty::Logger::Memory.new
+        allow(Slack.chat).to receive(:post_message).and_return "yay"
+        bot.say "omg pugs!", channel: "#omg", omg: "lol"
+
+        expect(logger.logs.last).to eq "Post response: yay."
       end
     end
 
-    describe "#im", :session, :users do
+    describe "#im" do
       before do
-        start_session
+        allow(Slack.users).to receive(:by_name).
+          with("julian").
+          and_return(Boty::Slack::User.new "id" => "U123", "name" => "julian")
       end
 
-      let(:user_id) { "U4321" }
-      let(:data) {{
-        "type" => "message",
-        "text" => "<@#{bot.name}>: omg",
-        "user" => "U4321"
-      }}
-
       it "sends a message in the back channel (particular, im...)" do
-        bot.respond(/omg/) { im "lol" }
         expect(Boty::Slack.chat).to receive(:post_im).with "U4321", "lol"
 
-        dsl.bot.event data
+        bot.im "lol", user_id: "U4321"
+      end
+
+      it "sends a message in the back channel to a particular user" do
+        expect(Slack.chat).to receive(:post_im).with "U123", "lol"
+
+        bot.im "lol", destiny: "julian"
+      end
+
+      it "logs that it will send an im", :logger do
+        allow(Slack.chat).to receive(:post_im)
+        bot.im "lol", destiny: "julian"
+
+        expect(logger.logs.last).to eq "Sending lol to julian."
+      end
+
+      it "logs when fails on discover the destiny", :logger do
+        allow(Slack.users).to receive(:by_name).
+          with("omg_doesnt_exists").
+          and_return nil
+        bot.im "lol", destiny: "omg_doesnt_exists"
+
+        expect(logger.logs.last).to eq "User not found, refusing to send im."
       end
     end
 
@@ -343,76 +303,47 @@ module Boty
       end
     end
 
-    context "loading script/**/*.rb files", :fakefs, :users do
-      let(:data) {{
-        "type" => "message",
-        "text" => "hey <@jabber>, pug me"
-      }}
+    describe "#desc" do
+      it "describes the next command to be created" do
+        bot.desc "omg", "lol all the way down"
+        bot.respond(/omg/) {}
 
-      before do
-        FileUtils.mkdir "script" unless Dir.exists? "script"
-        File.open "script/omg.rb", "w" do |f|
-          f.write <<-RUBY
-            respond(/pug me/i) do
-              say "omg"
-            end
-          RUBY
-        end
+        expect(bot.know_how).to include({
+          "omg" => "lol all the way down"
+        })
       end
 
-      it "uses the logic in the script located at script/omg.rb" do
-        expect(bot).to receive(:say).with "omg"
-        bot.event data
+      it "describes the next match do be created" do
+        bot.desc "ula", "babula"
+        bot.match(/ula/) {}
+
+        expect(bot.know_how).to include({
+          "ula" => "babula"
+        })
       end
 
-      context "describing commands", :fakefs, :users do
-        before do
-          File.open "script/omg.rb", "w" do |f|
-            f.write <<-RUBY
-              desc "pug me", "show some pretty random pug"
-              respond(/pug me/i) do
-                say "omg"
-              end
-
-              desc "just a description"
-              respond(/just desc/i) do
-                say "just description, raw command"
-              end
-
-              respond(/without desc/i) do
-                say "no desc, raw command"
-              end
-
-              respond(/without desc sensitive/) do
-                say "no desc, raw command"
-              end
-            RUBY
-          end
-        end
+      it "stores the description for a regex when no command usage is given" do
+        bot.desc "just a description"
+        bot.match(/just desc/i) {}
+        expect(bot.know_how).to include({
+          "/just desc/i" => "just a description"
+        })
+      end
 
-        it "stores the description within command usage" do
-          expect(bot.know_how).to include({
-            "pug me" => "show some pretty random pug"
-          })
-        end
+      it "presents the commands without description as regexes" do
+        bot.match(/without desc/i) {}
 
-        it "stores the description for a regex when no command usage is given" do
-          expect(bot.know_how).to include({
-            "/just desc/i" => "just a description"
-          })
-        end
+        expect(bot.know_how).to include({
+          "/without desc/i" => nil
+        })
+      end
 
-        it "presents the commands without description as regexes" do
-          expect(bot.know_how).to include({
-            "/without desc/i" => nil
-          })
-        end
+      it "knows when a regex is case insensitive" do
+        bot.match(/without desc insensitive/)
 
-        it "knows when a regex is case sensitive" do
-          expect(bot.know_how).to include({
-            "/without desc sensitive/" => nil
-          })
-        end
+        expect(bot.know_how).to include({
+          "/without desc insensitive/" => nil
+        })
       end
     end
   end

data/spec/boty/dsl_spec.rb

@@ -0,0 +1,125 @@
+module Boty
+  RSpec.describe DSL do
+    let(:bot) { Bot.new({"id" => "U123", "name" => "jeeba"}) }
+    subject(:dsl) { described_class.new bot }
+
+    def message(text, extras = {})
+      bot.event({
+        "type" => "message",
+        "text" => text,
+        "user" => "U5678"
+      }.merge(extras))
+    end
+
+    before do
+      # used by message class
+      allow(Slack.users).to receive(:info).with("U5678").
+        and_return(Slack::User.new("id" => "U5678", "name" => "julian"))
+    end
+
+    methods_from_bot = [ :name, :brain, :know_how, :im, :say,
+                         :desc, :respond, :match ]
+    methods_from_bot.each do |bot_method|
+      it "responds to :#{bot_method}" do
+        expect(dsl.respond_to?(bot_method)).to eq true
+      end
+    end
+
+    describe "#http" do
+      subject(:http) { dsl.http }
+
+      it { should be_a Boty::HTTP }
+    end
+
+    it "responds to a message" do
+      dsl.hear(/jeeba/i) do
+        say "Ohay <@#{user.id}>! I'm here, that's for sure."
+      end
+
+      expect(dsl).to receive(:say).
+        with "Ohay <@U5678>! I'm here, that's for sure."
+
+      message "jeeba, are you there?"
+    end
+
+    it "responds to a match" do
+      dsl.match(/with match/i) do
+        say "Ohay <@#{user.id}>! It matched."
+      end
+
+      expect(bot).to receive(:say).
+        with "Ohay <@U5678>! It matched."
+
+      message "called with match?"
+    end
+
+    it "does not respond to a message not binded" do
+      expect(bot).to_not receive(:say)
+
+      message "are you there?"
+    end
+
+    it "understands #hear as a message binding" do
+      dsl.hear(/anybody there\?/i) do
+        say "Me! Here."
+      end
+
+      expect(bot).to receive(:say).with("Me! Here.")
+
+      message "anybody there?"
+    end
+
+    it "uses the system logger", :logger do
+      dsl.logger.debug "x"
+
+      expect(dsl.logger.logs.last).to eq "x"
+    end
+
+    context "Binding strings" do
+      it "binds a string with #match" do
+        executed = false
+        dsl.match "omg" do executed = true end
+
+        expect { message "bbq omg lol." }.
+          to change { executed }.from(false).to true
+      end
+
+      it "binds a string with #respond" do
+        executed = false
+        dsl.respond "omg" do executed = true end
+
+        expect { message "<@jeeba>: bbq omg lol." }.
+          to change { executed }.from(false).to true
+      end
+    end
+
+    context "Direct message" do
+      before do
+        dsl.command(/do stuff/i) do
+          say "Doing some stuff"
+        end
+      end
+
+      it "responds when mentioned by name" do
+        expect(bot).to receive(:say).with "Doing some stuff"
+
+        message "<@jeeba>: do stuff!"
+      end
+
+      it "responds when mentioned by id" do
+        expect(bot).to receive(:say).with "Doing some stuff"
+        message "<@U1234>: do stuff!"
+      end
+
+      it "responds just once" do
+        expect(bot).to receive(:im).once
+        message "<@U1234>: knows"
+      end
+
+      it "responds when mentioned by both name and id in the same message" do
+        expect(bot).to receive(:im).once
+        message "<@U1234|jabber>: knows"
+      end
+    end
+  end
+end

data/spec/boty/http_spec.rb

@@ -0,0 +1,5 @@
+module Boty
+  RSpec.describe Boty::HTTP do
+    subject(:http) { Boty::HTTP.new }
+  end
+end

data/spec/boty/logger_spec.rb

@@ -15,6 +15,39 @@ module Boty
       end
     end
 
+    describe "#logger" do
+      it "returns the current adapter" do
+        memory_logger = Boty::Logger::Memory.new
+        logger.adapter = memory_logger
+        expect(client.logger).to eq memory_logger
+      end
+    end
+
+    describe Logger::Multi do
+      let(:adapter1) { double }
+      let(:adapter2) { double }
+
+      subject(:multi) { described_class.new [adapter1, adapter2] }
+
+      describe "#add" do
+        it "delegates the #add invocation to the underlying adapters" do
+          expect(adapter1).to receive(:add).with("omg", "lol")
+          expect(adapter2).to receive(:add).with("omg", "lol")
+
+          multi.add("omg", "lol")
+        end
+      end
+
+      describe "#level=" do
+        it "delegates the #level= invocation to the underlying adapters" do
+          expect(adapter1).to receive(:level=).with(::Logger::INFO)
+          expect(adapter2).to receive(:level=).with(::Logger::INFO)
+
+          multi.level = ::Logger::INFO
+        end
+      end
+    end
+
     describe Logger::Memory do
       subject(:adapter) { described_class.new }
 

data/spec/boty/rspec_spec.rb

@@ -6,7 +6,7 @@ module Boty
 
     context "bot[Boty::Bot] instance" do
       it "includes a `bot` instance in the example scope" do
-        expect(bot).to be_a Boty::ScriptDSL
+        expect(bot).to be_a Boty::DSL
       end
     end
 

data/spec/boty/script_loader_spec.rb

@@ -0,0 +1,27 @@
+module Boty
+  RSpec.describe Boty::ScriptLoader, :fakefs, :users do
+    let(:dsl) { Boty::DSL.new Bot.new({ "name" => "jabber", "id" => "123" }) }
+    let(:data) {{
+      "type" => "message",
+      "text" => "hey <@jabber>, pug me"
+    }}
+
+    subject(:loader) { described_class.new Boty::DSL.new(bot) }
+
+    before do
+      FileUtils.mkdir "script" unless Dir.exists? "script"
+      File.open "script/omg.rb", "w" do |f|
+        f.write <<-RUBY
+          respond(/pug me/i) do
+            say "omg"
+          end
+        RUBY
+      end
+    end
+
+    it "uses the logic in the script located at script/omg.rb" do
+      expect(dsl).to receive(:say).with "omg"
+      dsl.bot.event data
+    end
+  end
+end

data/spec/boty/session_spec.rb

@@ -44,25 +44,23 @@ module Boty
           "type": "omg",
           "text": "lol"
         }'
-        session.start do |dsl|
-          @dsl = dsl
+        dsl = nil
+        session.start do
+          dsl = self
         end
 
-        expect(@dsl.bot).to receive(:event).with(JSON.parse data)
+        expect(dsl.bot).to receive(:event).with(JSON.parse data)
         faye.send_event :message, OpenStruct.new(data: data)
       end
 
       context "bot instantiation" do
-        it "creates the Bot instance" do
-          session.start do |bot|
-            expect(bot).to be_a ScriptDSL
-          end
-        end
-
         it "intializes the Bot with the right data" do
-          expect(Bot).to receive(:new).with({"id" => "1234"}, session)
+          bot_id = nil
+          session.start do
+            bot_id = bot.id
+          end
 
-          session.start
+          expect(bot_id).to eq "1234"
         end
       end
     end

data/spec/boty/slack/message_spec.rb

@@ -0,0 +1,34 @@
+module Boty
+  module Slack
+    RSpec.describe Message, :users do
+      subject(:message) { described_class.new message_json }
+
+      let(:user_id) { "U7777" }
+      let(:user_name) { "julian" }
+
+      let(:message_json) {{
+        "type" => "message",
+        "text" => "omg lol bbq",
+        "user" => "U7777",
+        "channel" => "333",
+        "ts" => "1234",
+        "team" => "3452"
+      }}
+
+      it "uses Slack.users.info to create a User instance" do
+        expect(message.user.id).to eq "U7777"
+        expect(message.user.name).to eq "julian"
+      end
+
+      describe "#from?" do
+        it "returns true if the param is the message author" do
+          expect(message.from? "U7777").to eq true
+        end
+
+        it "returns true if the param `respond_to? :id` returning the message author" do
+          expect(message.from? OpenStruct.new(id: "U7777")).to eq true
+        end
+      end
+    end
+  end
+end