boty 0.0.17 → 0.0.17.1

data/spec/boty/cli_spec.rb

@@ -0,0 +1,87 @@
+require "spec_helper"
+require "boty/cli"
+
+module Boty
+  RSpec.describe CLI, :thor do
+    subject(:cli) { described_class.new }
+
+    before(:all) do
+      FileUtils.mkdir_p "tmp" if !Dir.exists? "tmp"
+      FileUtils.chdir "tmp"
+    end
+
+    before do
+      FileUtils.rm_rf "nice_bot" if Dir.exists? "nice_bot"
+
+      allow(cli).to receive(:ask).
+        and_return ENV["SLACK_COMPANY"], ENV["SLACK_BOT_API_TOKEN"]
+
+      allow(cli).to receive(:run)
+    end
+
+    after(:all) do
+      FileUtils.rm_rf "nice_bot" if Dir.exists? "nice_bot"
+      FileUtils.chdir "../"
+    end
+
+    describe "#new PROJECT" do
+      def create_nice_bot
+        capture(:stdout) do
+          cli.new "nice_bot"
+        end
+      end
+
+      it "creates a directory named after the PROJECT" do
+        expect { create_nice_bot }.to create_directory "nice_bot"
+      end
+
+      it "creates the executable" do
+        expect { create_nice_bot }.to create_file "nice_bot/bot"
+      end
+
+      it "creates the empty dir for scripts" do
+        expect { create_nice_bot }.to create_directory "nice_bot/script"
+      end
+
+      it "creates the empty dir for locales" do
+        expect { create_nice_bot }.to create_directory "nice_bot/locale"
+      end
+
+      it "creates the empty dir for bot development" do
+        expect { create_nice_bot }.to create_directory "nice_bot/app"
+      end
+
+      it "creates the Gemfile" do
+        expect { create_nice_bot }.to create_file "nice_bot/Gemfile"
+      end
+
+      it "creates the Procfile" do
+        expect { create_nice_bot }.to create_file "nice_bot/Procfile"
+      end
+
+      it "creates the README.md" do
+        expect { create_nice_bot }.to create_file "nice_bot/README.md"
+      end
+
+      context "/spec" do
+        it "creates the spec/ dir" do
+          expect { create_nice_bot }.to create_directory "nice_bot/spec"
+        end
+
+        it "creates the .rspec file" do
+          expect { create_nice_bot }.to create_file "nice_bot/.rspec"
+        end
+      end
+
+      it "turns the ./bot an executable file" do
+        expect(cli).to run "chmod +x bot"
+        create_nice_bot
+      end
+
+      it "runs bundle install after create the project" do
+        expect(cli).to run "bundle install"
+        create_nice_bot
+      end
+    end
+  end
+end

data/spec/boty/logger_spec.rb

@@ -0,0 +1,32 @@
+module Boty
+  RSpec.describe Logger do
+    class Client; include Logger end
+
+    let(:logger) { Boty::Logger }
+    let(:client) { Client.new }
+
+    describe ".adapter" do
+      it "changes the internal logger representation" do
+        memory_logger = Boty::Logger::Memory.new
+        logger.adapter = memory_logger
+        expect(memory_logger).to receive(:info).with "hello"
+
+        client.logger.info "hello"
+      end
+    end
+
+    describe Logger::Memory do
+      subject(:adapter) { described_class.new }
+
+      before do
+        logger.adapter = adapter
+      end
+
+      it "stores the logs in memory" do
+        client.logger.info "hello"
+
+        expect(adapter.logs.last).to eq "hello"
+      end
+    end
+  end
+end

data/spec/boty/message_spec.rb

@@ -0,0 +1,32 @@
+module Boty
+  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

data/spec/boty/rspec_spec.rb

@@ -0,0 +1,36 @@
+require "boty/rspec"
+
+module Boty
+  ::RSpec.describe Boty::RSpec::Bot do
+    include described_class
+
+    context "bot[Boty::Bot] instance" do
+      it "includes a `bot` instance in the example scope" do
+        expect(bot).to be_a Boty::ScriptDSL
+      end
+    end
+
+    context "have_responded matcher" do
+      it "provides a custom matcher to check against bot responses" do
+        expect(self).to respond_to(:have_responded)
+      end
+
+      it "makes `Bot#say` work with the custom `have_responded` matcher" do
+        bot.say "something"
+        expect(bot).to have_responded "something"
+      end
+
+      it "clears up the `Bot#_response` after check by matcher" do
+        bot.say "something"
+        expect(bot).to have_responded "something"
+      end
+    end
+
+    context "helpers" do
+      it "includes #message_event to fire `data['type'] = 'message' events" do
+        expect(@_bot).to receive(:event).with "type" => "message", "text" => "omg"
+        message "omg"
+      end
+    end
+  end
+end

data/spec/boty/session_spec.rb

@@ -0,0 +1,70 @@
+module Boty
+  RSpec.describe Session do
+    subject(:session) { described_class.new }
+
+    let(:rtm_start_json_response) {
+      JSON.parse '{
+        "url": "ws://example.org/slack/sse/url",
+        "self": {
+          "id": "1234"
+        }
+      }'
+    }
+
+    before do
+      allow(Slack.rtm).to receive(:start).and_return rtm_start_json_response
+    end
+
+    describe "#start", :em, :faye do
+      specify do
+        expect { |b| session.start(&b) }.to yield_control
+      end
+
+      it "logs in (request session url)" do
+        expect(Slack.rtm).to receive(:start).and_return rtm_start_json_response
+
+        session.start
+      end
+
+      it "creates the event loop" do
+        expect(EM).to receive(:run)
+
+        session.start
+      end
+
+      it "intializes the sse client with the session url" do
+        expect(Faye::WebSocket::Client).to receive(:new).
+          with("ws://example.org/slack/sse/url")
+
+        session.start
+      end
+
+      it "repasses `:message` event to `bot#event`" do
+        data = '{
+          "type": "omg",
+          "text": "lol"
+        }'
+        session.start do |dsl|
+          @dsl = dsl
+        end
+
+        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)
+
+          session.start
+        end
+      end
+    end
+  end
+end

data/spec/boty/slack/chat_spec.rb

@@ -0,0 +1,73 @@
+module Boty
+  module Slack
+    RSpec.describe Chat do
+      subject(:chat) { described_class.new }
+
+      let(:parameters) {
+        "as_user=true&channel=general"
+      }
+
+      let(:post_message_url) {
+        "https://slack.com/api/chat.postMessage?"+
+        "token=#{ENV['SLACK_BOT_API_TOKEN']}&#{parameters}"
+      }
+
+      describe "#post_message" do
+        it "uses api end point to send message with default parameters" do
+          expect(Slack::URL).to receive(:get).
+            with(post_message_url + "&text=omglolbbq")
+          chat.post_message "omglolbbq"
+        end
+
+        it "uri encodes the message" do
+          expect(Slack::URL).to receive(:get).
+            with(post_message_url + "&text=omg%20lol%20bbq")
+          chat.post_message "omg lol bbq"
+        end
+
+        it "accepts extra api parameters" do
+          expect(Slack::URL).to receive(:get).
+            with(post_message_url + "&text=omg&extra=param")
+          chat.post_message "omg", extra: "param"
+        end
+
+        context "sending to a specific channel" do
+          let(:parameters) { "as_user=true&channel=lol" }
+
+          it "sends to a specific channel when one is given" do
+            expect(Slack::URL).to receive(:get).
+              with(post_message_url + "&text=omg")
+            chat.post_message "omg", channel: "lol"
+          end
+        end
+      end
+
+      describe "#post_im" do
+        let(:im_open_url) {
+          "https://slack.com/api/im.open?"+
+          "token=#{ENV['SLACK_BOT_API_TOKEN']}&user=U1234"
+        }
+
+        before do
+          allow(Slack::URL).to receive(:get).with(im_open_url).
+            and_return("channel" => { "id" => "C4321" })
+          allow(chat).to receive(:post_message)
+        end
+
+        it "calls `#im.open` to open the channel" do
+          expect(chat.im).to receive(:open).with("U1234").
+            and_return Channel.new(id: "C4321", info: {})
+
+          chat.post_im "U1234", "message"
+        end
+
+        it "sends the message to the im channel returned by `#im.open`" do
+          expect(chat).to receive(:post_message).
+            with "message", channel: "C4321"
+
+          chat.post_im "U1234", "message"
+        end
+      end
+    end
+  end
+end

data/spec/boty/slack/im_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+module Boty
+  module Slack
+    RSpec.describe IM do
+      subject(:im) { described_class.new }
+
+      let(:action) { :open }
+
+      let(:im_url) {
+        "https://slack.com/api/im.#{action}?"+
+        "token=#{ENV['SLACK_BOT_API_TOKEN']}"
+      }
+
+      describe "#open" do
+        it "calls Slack::URL get with token and user" do
+          expect(Slack::URL).to receive(:get).with(im_url + "&user=U1234")
+
+          im.open "U1234"
+        end
+
+        it "returns a channel object with the im channel information" do
+          expect(Slack::URL).to receive(:get).with(im_url + "&user=U1234").
+            and_return(
+              "ok" => true,
+              "channel" => { "id" => "D024BFF1M" }
+            )
+
+          expect(im.open("U1234").id).to eq "D024BFF1M"
+        end
+      end
+    end
+  end
+end

data/spec/boty/slack/rtm_spec.rb

@@ -0,0 +1,20 @@
+module Boty
+  module Slack
+    RSpec.describe RTM do
+      subject(:rtm) { described_class.new }
+
+      let(:url_with_default_parameters) {
+        "https://#{ENV["SLACK_COMPANY"]}.slack.com/api/rtm.start?"+
+        "token=#{ENV["SLACK_BOT_API_TOKEN"]}&"+
+        "simple_latest=true&no_unreads=true"
+      }
+
+      describe "#start" do
+        it "uses api to start the session" do
+          expect(Slack::URL).to receive(:get).with(url_with_default_parameters)
+          rtm.start
+        end
+      end
+    end
+  end
+end

data/spec/boty/slack/url_spec.rb

@@ -0,0 +1,71 @@
+module Boty
+  module Slack
+    RSpec.describe URL do
+      class Pseudo
+        include URL
+        url "http://example.org"
+
+        def omg(parameters: {}, path: nil)
+          parameterize parameters, path
+        end
+      end
+
+      context "when included" do
+        subject(:client_class) { Pseudo }
+
+        it "injects the configuration method .url" do
+          expect(client_class).to respond_to :url
+        end
+
+        it "injects the #parameterize" do
+          expect(client_class.new.respond_to?(:parameterize, true)).to eq true
+        end
+      end
+
+      describe ".get" do
+        subject(:url) { described_class }
+
+        it "sends the http request" do
+          expect(Net::HTTP).to receive(:get).with(URI("http://example.org"))
+          url.get "http://example.org"
+        end
+
+        it "parses the json response" do
+          expect(Net::HTTP).to receive(:get).with(URI("http://example.org")).
+            and_return "{\"it\": \"works\"}"
+          response = url.get "http://example.org"
+          expect(response).to eq "it" => "works"
+        end
+      end
+
+      describe "#parameterize" do
+        subject(:client) { Pseudo.new }
+
+        it "appends a path to the configured url" do
+          url = client.send :parameterize, {}, path: "/omg"
+          expect(url).to include "/omg?"
+        end
+
+        it "appends the api token" do
+          url = client.send :parameterize, {}
+          expect(url).to include "token=#{ENV["SLACK_BOT_API_TOKEN"]}"
+        end
+
+        it "add extra parameters" do
+          url = client.send :parameterize, {really: "omg"}
+          expect(url).to include "really=omg"
+        end
+
+        it "uses the url configured by #url" do
+          url = client.send :parameterize, {}
+          expect(url).to include "http://example.org"
+        end
+
+        it "applies URI.encode to parameter values" do
+          url = client.send :parameterize, {really: "omg lol"}
+          expect(url).to include "really=omg%20lol"
+        end
+      end
+    end
+  end
+end