boty 0.0.17 → 0.0.17.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d60d83658211dd0b17fdfeb269033ce2c73ee291
-  data.tar.gz: 29148f8ba9a8d4dfa83d36f612c2a97959f5e5ef
+  metadata.gz: 0ebb5950dfa8625a01e2aca017fbd5ed259c499d
+  data.tar.gz: 463e6b73167a63d36ec7441c9205784bf74a5520
 SHA512:
-  metadata.gz: 4e583ec20c26d42226cf1e52bedfebab6b184bbccca3a3ecab576fe305a0adb96ea1a6d56a1d19d0e115cb1e1c5682c81ddb15b8505956b8a6e32f2a525269b9
-  data.tar.gz: cef240051671e266025c744489090c199c54177305da4dd0343b131076c270ad8278c1350be895e8d9b726c5af8224658cac95fc774fc3e8deb49f63cbfd0d91
+  metadata.gz: 5ad60851ef2067df1eaafc8a6bf9be654c2494cf1be814a33a920df05f1b702a8f818d4661d4144c5771bb5dfde15b7e6054227ece9d3208fd296b413bab6577
+  data.tar.gz: 9fa330463454c9be3297c034a4189d7f6663d8a5ad6bfff6b474d0f9866ab33fbc2d1bf6a541431e70771545f5ee46bd97cb4356f6111ddcde0d6d8a438976c6

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    boty (0.0.17)
+    boty (0.0.17.1)
       eventmachine
       faraday
       faye-websocket

data/boty.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |spec|
   spec.homepage      = "http://github.com/ricardovaleriano/boty"
   spec.license       = "MIT"
 
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(features)/}) }
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]

data/lib/boty/version.rb

@@ -1,3 +1,3 @@
 module Boty
-  VERSION = "0.0.17"
+  VERSION = "0.0.17.1"
 end

data/spec/boty/bot_spec.rb

@@ -0,0 +1,419 @@
+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 }
+
+    let(:bot_info) {{
+      "id" => "666",
+      "name" => "jabber"
+    }}
+
+    describe "#on" do
+      it "binds an event `'type'` to a block" do
+        data = {
+          "type" => "omg",
+          "text" => "lol"
+        }
+
+        expect { |b|
+          bot.on :omg, &b
+          bot.event data
+        }.to yield_with_args data
+      end
+    end
+
+    describe "#off" do
+      let(:data) {{
+        "type" => "bbq",
+        "text" => "omg. wtf."
+      }}
+
+      it "unbounds an event by type AND block, just if the block is the same" do
+        @permanent_executed = false
+        permanent_block = ->(_){ @permanent_executed = true }
+        bot.on :bbq, &permanent_block
+
+        @ephemeral_executed = false
+        ephemeral_block = ->(_){ @ephemeral_executed = true }
+        bot.on :bbq, &ephemeral_block
+        bot.off :bbq, &ephemeral_block
+
+        bot.event data
+
+        expect(@permanent_executed).to eq true
+        expect(@ephemeral_executed).to eq false
+      end
+
+      it "unbounds all events by type" do
+        @first_block = @second_block = @third_block = false
+        bot.on(:bbq) { |_| @first_block = true }
+        bot.on(:bbq) { |_| @second_block = true }
+        bot.on(:bbq) { |_| @third_block = true }
+        bot.off(:bbq)
+
+        bot.event data
+
+        expect(@first_block).to eq false
+        expect(@second_block).to eq false
+        expect(@third_block).to eq false
+      end
+    end
+
+    describe "#match", :users do
+      let(:data) { {"type" => "message", "text" => "bbq omg lol"} }
+
+      it "binds a regex to events of `type => message`" do
+        _message = nil
+        bot.match(/omg/i) do
+          _message = message
+        end
+        bot.event data
+
+        expect(_message).to be_a Message
+        expect(_message.text).to eq "bbq omg lol"
+        expect(_message.match[0]).to eq "omg"
+      end
+
+      it "binds various actions to events of type message" do
+        iterations = []
+        bot.match(/omg/i) do iterations << "first" end
+        bot.match(/omg/i) do iterations << "second" end
+        bot.event data
+
+        expect(iterations).to eq ["first", "second"]
+      end
+
+      it "passes the matched strings as parameters to block action" do
+        _lol, _bbq = nil
+        bot.match(/(bbq) omg (lol)/i) do |bbq, lol|
+          _lol, _bbq = lol, bbq
+        end
+        bot.event data
+
+        expect(_lol).to eq "lol"
+        expect(_bbq).to eq "bbq"
+      end
+    end
+
+    describe "#respond", :users do
+      let(:data) {{
+        "type" => "message",
+        "text" => "hey <@jabber>, omg me"
+      }}
+
+      it "binds actions for messages only when there is a mention (@bot)" do
+        expect { |b|
+          bot.respond(/omg me/, &b)
+          bot.event data
+        }.to yield_control
+      end
+
+      it "recognizes the id when it's mentioned" do
+        data["text"] = "hey <@666>: omg me"
+        expect { |b|
+          bot.respond(/omg me/, &b)
+          bot.event data
+        }.to yield_control
+      end
+
+      it "does not bind when regex matches but there is no mention" do
+        data["text"] = "hey <@other_bot>, omg me"
+
+        expect { |b|
+          bot.respond(/omg me/, &b)
+          bot.event data
+        }.to_not yield_control
+      end
+
+      it "ignores mentions from itself" do
+        data["user"] = "666"
+
+        expect { |b|
+          bot.respond(/omg me/, &b)
+          bot.event data
+        }.to_not yield_control
+      end
+
+      it "evals the block in the context of the bot" do
+        dsl = nil
+        bot.respond(/omg me/) { dsl = self }
+        bot.event data
+
+        expect(dsl.bot).to eq bot
+      end
+    end
+
+    context "removing binds for messages and responses", :session do
+      before do
+        start_session
+      end
+
+      describe "#no_message" 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)
+
+          ephemeral_executed = false
+          ephemeral_block = ->() { ephemeral_executed = true }
+          bot.hear(/omg/i, &ephemeral_block)
+          bot.no_match(/omg/i, &ephemeral_block)
+
+          dsl.bot.event data
+
+          expect(permanent_executed).to eq true
+          expect(ephemeral_executed).to eq false
+        end
+
+        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.no_match(/omg/i)
+
+          dsl.bot.event data
+
+          expect(first).to eq false
+          expect(second).to eq false
+        end
+      end
+
+      describe "#no_respond" do
+        let(:data) {{
+          "type" => "message",
+          "text" => "hey <@#{bot.name}>, omg me"
+        }}
+
+        it "removes a message based on the regex AND the block" do
+          permanent_executed = false
+          permanent_block = ->() { permanent_executed = true }
+          bot.respond(/omg/i, &permanent_block)
+
+          ephemeral_executed = false
+          ephemeral_block = ->() { ephemeral_executed = true }
+          bot.respond(/omg/i, &ephemeral_block)
+          bot.no_respond(/omg/i, &ephemeral_block)
+
+          dsl.bot.event data
+
+          expect(permanent_executed).to eq true
+          expect(ephemeral_executed).to eq false
+        end
+
+        it "removes all binds for a specific regex" do
+          first = second = false
+          bot.respond(/omg/i) { first = true }
+          bot.respond(/omg/i) { second = true }
+          bot.no_respond(/omg/i)
+
+          dsl.bot.event data
+
+          expect(first).to eq false
+          expect(second).to eq false
+        end
+      end
+    end
+
+    describe "#say", :users do
+      let(:data) {{
+        "type" => "message",
+        "text" => "hey <@jabber>, omg me",
+        "channel" => "omg"
+      }}
+
+      it "sends a string using the slack api to general (default) channel" do
+        expect(Slack.chat).to receive(:post_message).
+          with "something", channel: "general"
+        bot.say "something"
+      end
+
+      it "send a message to the channel specified by a current binded message" do
+        expect(Slack.chat).to receive(:post_message).
+          with "omg pugs!", channel: "omg"
+
+        bot.respond(/omg me/) { say "omg pugs!" }
+        bot.event data
+      end
+    end
+
+    describe "#im", :session, :users do
+      before do
+        start_session
+      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
+      end
+    end
+
+    describe "#brain", :users do
+      it "exposes a hash that lives while bot is alive. =)" do
+        bot.brain[:something] = "going on"
+        expect(bot.brain[:something]).to eq "going on"
+      end
+    end
+
+    context "loading script/**/*.rb files", :fakefs, :users do
+      let(:data) {{
+        "type" => "message",
+        "text" => "hey <@jabber>, pug me"
+      }}
+
+      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(bot).to receive(:say).with "omg"
+        bot.event data
+      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 within command usage" do
+          expect(bot.know_how).to include({
+            "pug me" => "show some pretty random pug"
+          })
+        end
+
+        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
+
+        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 sensitive" do
+          expect(bot.know_how).to include({
+            "/without desc sensitive/" => nil
+          })
+        end
+      end
+    end
+  end
+end