rita 0.1.0 → 5.0.0.alpha.1

data/spec/lita/message_spec.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::Message do
+  let(:mention_name) { "LitaBot" }
+
+  let(:robot) do
+    instance_double("Lita::Robot", name: "Lita", mention_name: mention_name, alias: ".")
+  end
+
+  let(:source) { instance_double("Lita::Source") }
+
+  subject do
+    described_class.new(robot, "Hello", source)
+  end
+
+  it "has a body" do
+    expect(subject.body).to eq("Hello")
+  end
+
+  it "has a source" do
+    expect(subject.source).to eq(source)
+  end
+
+  describe "#extensions" do
+    it "can be populated with arbitrary data" do
+      subject.extensions[:foo] = :bar
+
+      expect(subject.extensions[:foo]).to eq(:bar)
+    end
+  end
+
+  describe "#args" do
+    it "returns an array of the 2nd through nth word in the message" do
+      subject = described_class.new(robot, "args foo bar", source)
+      expect(subject.args).to eq(%w[foo bar])
+    end
+
+    it "escapes messages that have mismatched quotes" do
+      subject = described_class.new(robot, "args it's working", source)
+      expect(subject.args).to eq(%w[it's working])
+    end
+  end
+
+  describe "#command!" do
+    it "marks a message as a command" do
+      subject.command!
+      expect(subject).to be_a_command
+    end
+  end
+
+  describe "#command?" do
+    context "when the message is addressed to the robot" do
+      subject { described_class.new(robot, "#{robot.mention_name}: hello", source) }
+
+      it "is true" do
+        expect(subject).to be_a_command
+      end
+    end
+
+    context "when the message is addressed to the robot with different capitalization" do
+      subject { described_class.new(robot, "#{robot.mention_name.upcase}: hello", source) }
+
+      it "is true" do
+        expect(subject).to be_a_command
+      end
+    end
+
+    context "when the message is addressed to the robot with a comma" do
+      subject { described_class.new(robot, "#{robot.mention_name.upcase}, hello", source) }
+
+      it "is true" do
+        expect(subject).to be_a_command
+      end
+    end
+
+    context "when the message is addressed to the robot with no trailing punctuation" do
+      subject { described_class.new(robot, "#{robot.mention_name.upcase} hello", source) }
+
+      it "is true" do
+        expect(subject).to be_a_command
+      end
+    end
+
+    context "when the message is addressed to the bot via alias with no space after it" do
+      subject { described_class.new(robot, "#{robot.alias}hello", source) }
+
+      it "is true" do
+        expect(subject).to be_a_command
+      end
+    end
+
+    context "when the message is addressed to the bot via alias with space after it" do
+      subject { described_class.new(robot, "#{robot.alias} hello", source) }
+
+      it "is true" do
+        expect(subject).to be_a_command
+      end
+    end
+
+    context "when the message incidentally starts with the mention name" do
+      let(:mention_name) { "sa" }
+
+      subject { described_class.new(robot, "salmon", source) }
+
+      it "is false" do
+        expect(subject).not_to be_a_command
+      end
+
+      it "does not affect the message body" do
+        expect(subject.body).to eq("salmon")
+      end
+    end
+
+    context "when a multi-line message contains a command past the beginning of the message" do
+      subject { described_class.new(robot, "```\n#{robot.mention_name}: hello\n```", source) }
+
+      it "is false" do
+        expect(subject).not_to be_a_command
+      end
+    end
+
+    it "is false when the message is not addressed to the Robot" do
+      expect(subject).not_to be_a_command
+    end
+  end
+
+  describe "#user" do
+    it "delegates to #source" do
+      expect(subject.source).to receive(:user)
+      subject.user
+    end
+  end
+
+  describe "#room_object" do
+    it "delegates to #source" do
+      expect(subject.source).to receive(:room_object)
+      subject.room_object
+    end
+  end
+
+  describe "#private_message?" do
+    it "delegates to #source" do
+      expect(subject.source).to receive(:private_message?)
+      subject.private_message?
+    end
+  end
+
+  describe "#reply" do
+    it "sends strings back to the source through the robot" do
+      expect(robot).to receive(:send_messages).with(source, "foo", "bar")
+      subject.reply("foo", "bar")
+    end
+  end
+
+  describe "#reply_privately" do
+    it "sends strings directly to the source user" do
+      subject = described_class.new(
+        robot,
+        "Hello",
+        Lita::Source.new(user: "Carl", room: "#room")
+      )
+      expect(robot).to receive(:send_messages) do |source, *strings|
+        expect(source).to be_a_private_message
+        expect(strings).to eq(%w[foo bar])
+      end
+      subject.reply_privately("foo", "bar")
+    end
+  end
+
+  describe "#reply_with_mention" do
+    it "prefixes strings with a user mention and sends them back to the source" do
+      expect(robot).to receive(:send_messages_with_mention).with(source, "foo", "bar")
+      subject.reply_with_mention("foo", "bar")
+    end
+  end
+end

data/spec/lita/plugin_builder_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::PluginBuilder, lita: true do
+  let(:robot) { instance_double("Lita::Robot") }
+  subject { plugin.new(robot) }
+
+  describe "#build_adapter" do
+    let(:builder) do
+      described_class.new(:test_adapter) do
+        def run
+          self.class.namespace
+        end
+      end
+    end
+
+    let(:plugin) { builder.build_adapter }
+
+    it "builds an adapter" do
+      expect(subject.run).to eq("test_adapter")
+    end
+  end
+
+  describe "#build_handler" do
+    builder = described_class.new(:test_handler) do
+      route(/namespace/) { |response| response.reply(self.class.namespace) }
+    end
+
+    plugin = builder.build_handler
+
+    describe plugin, lita_handler: true do
+      before { registry.register_handler(plugin) }
+
+      it "builds a handler from a block" do
+        send_message("namespace")
+        expect(replies.last).to eq("test_handler")
+      end
+    end
+  end
+end

data/spec/lita/response_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::Response do
+  subject { described_class.new(message, instance_double("Regexp")) }
+
+  let(:message) { instance_double("Lita::Message").as_null_object }
+
+  %i[args reply reply_privately reply_with_mention user command?].each do |method|
+    it "delegates :#{method} to #message" do
+      expect(message).to receive(method)
+      subject.public_send(method)
+    end
+  end
+
+  describe "#matches" do
+    it "matches the pattern against the message" do
+      expect(message).to receive(:match).with(subject.pattern)
+      subject.matches
+    end
+  end
+
+  describe "#match_data" do
+    let(:body) { instance_double("String") }
+
+    it "matches the message body against the pattern" do
+      allow(message).to receive(:body).and_return(body)
+      expect(subject.pattern).to receive(:match).with(message.body)
+      subject.match_data
+    end
+  end
+
+  describe "#extensions" do
+    it "can be populated with arbitrary data" do
+      subject.extensions[:foo] = :bar
+
+      expect(subject.extensions[:foo]).to eq(:bar)
+    end
+  end
+
+  describe "#user" do
+    it "delegates to #message" do
+      expect(subject.message).to receive(:user)
+      subject.user
+    end
+  end
+
+  describe "#room" do
+    it "delegates to #message" do
+      expect(subject.message).to receive(:room_object)
+      subject.room
+    end
+  end
+
+  describe "#private_message?" do
+    it "delegates to #message" do
+      expect(subject.message).to receive(:private_message?)
+      subject.private_message?
+    end
+  end
+end

data/spec/lita/robot_spec.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::Robot, lita: true do
+  subject { described_class.new(registry) }
+
+  before { registry.register_adapter(:shell, Lita::Adapters::Shell) }
+
+  it "triggers a loaded event after initialization" do
+    expect_any_instance_of(described_class).to receive(:trigger).with(:loaded, room_ids: [])
+    subject
+  end
+
+  context "when there are previously persisted rooms" do
+    before { %w[#foo #bar].each { |id| Lita.redis.sadd("persisted_rooms", id) } }
+
+    it "receives the room_ids in the payload" do
+      expect_any_instance_of(described_class).to receive(:trigger).with(
+        :loaded,
+        room_ids: %w[#foo #bar].sort,
+      )
+      subject
+    end
+  end
+
+  it "can have its name changed" do
+    subject.name = "Bongo"
+
+    expect(subject.name).to eq("Bongo")
+  end
+
+  it "can have its mention name changed" do
+    subject.mention_name = "wongo"
+
+    expect(subject.mention_name).to eq("wongo")
+  end
+
+  it "exposes Adapter#mention_format" do
+    expect(subject.mention_format(subject.mention_name)).to eq("Lita:")
+  end
+
+  it "exposes Adapter#roster" do
+    expect_any_instance_of(Lita::Adapters::Shell).to receive(:roster)
+
+    subject.roster(instance_double("Lita::Room"))
+  end
+
+  it "exposes Adapter#chat_service" do
+    expect { subject.chat_service }.not_to raise_error
+  end
+
+  context "with registered handlers" do
+    let(:handler_1) { Class.new(Lita::Handler) { namespace :test } }
+    let(:handler_2) { Class.new(Lita::Handler) { namespace :test } }
+
+    before do
+      registry.register_handler(handler_1)
+      registry.register_handler(handler_2)
+    end
+
+    describe "#receive" do
+      it "dispatches messages to every registered handler" do
+        expect(handler_1).to receive(:dispatch).with(subject, "foo")
+        expect(handler_2).to receive(:dispatch).with(subject, "foo")
+        subject.receive("foo")
+      end
+    end
+
+    describe "#trigger" do
+      it "triggers the supplied event on all registered handlers" do
+        expect(handler_1).to receive(:trigger).with(subject, :foo, bar: "baz")
+        expect(handler_2).to receive(:trigger).with(subject, :foo, bar: "baz")
+        subject.trigger(:foo, bar: "baz")
+      end
+    end
+  end
+
+  describe "#run" do
+    let(:thread) { instance_double("Thread", :abort_on_exception= => true, join: nil) }
+
+    before do
+      allow_any_instance_of(Lita::Adapters::Shell).to receive(:run)
+      allow_any_instance_of(Puma::Server).to receive(:run)
+      allow_any_instance_of(Puma::Server).to receive(:add_tcp_listener)
+
+      allow(Thread).to receive(:new) do |&block|
+        block.call
+        thread
+      end
+    end
+
+    it "starts the adapter" do
+      expect_any_instance_of(Lita::Adapters::Shell).to receive(:run)
+      subject.run
+    end
+
+    it "starts the web server" do
+      expect_any_instance_of(Puma::Server).to receive(:run)
+      subject.run
+    end
+
+    it "rescues interrupts and calls #shut_down" do
+      allow_any_instance_of(
+        Lita::Adapters::Shell
+      ).to receive(:run).and_raise(Interrupt)
+      expect_any_instance_of(Lita::Adapters::Shell).to receive(:shut_down)
+      subject.run
+    end
+
+    it "logs and quits if the specified adapter can't be found" do
+      registry.config.robot.adapter = :does_not_exist
+      expect(subject.logger).to receive(:fatal).with(/Unknown adapter/)
+      expect { subject.run }.to raise_error(SystemExit)
+    end
+
+    it "logs and aborts if the web server's port is in use" do
+      allow_any_instance_of(Puma::Server).to receive(:add_tcp_listener).and_raise(Errno::EADDRINUSE)
+
+      expect(subject.logger).to receive(:fatal).with(/web server/)
+      expect { subject.run }.to raise_error(SystemExit)
+    end
+
+    it "logs and aborts if the web server's port is privileged" do
+      allow_any_instance_of(Puma::Server).to receive(:add_tcp_listener).and_raise(Errno::EACCES)
+
+      expect(subject.logger).to receive(:fatal).with(/web server/)
+      expect { subject.run }.to raise_error(SystemExit)
+    end
+  end
+
+  describe "#join" do
+    before do
+      allow_any_instance_of(Lita::Adapters::Shell).to receive(:join)
+    end
+
+    context "when a Room object exists" do
+      let!(:room) { Lita::Room.create_or_update(1, name: "#lita.io") }
+
+      it "passes the room ID to the adapter when a string argument is provided" do
+        expect_any_instance_of(Lita::Adapters::Shell).to receive(:join).with("1")
+
+        subject.join("#lita.io")
+      end
+
+      it "passes the room ID to the adapter when a Room argument is provided" do
+        expect_any_instance_of(Lita::Adapters::Shell).to receive(:join).with("1")
+
+        subject.join(room)
+      end
+
+      it "adds the room ID to the persisted list" do
+        subject.join("#lita.io")
+
+        expect(subject.persisted_rooms).to include("1")
+      end
+    end
+
+    context "when no Room object exists" do
+      it "delegates to the adapter with the raw argument" do
+        expect_any_instance_of(Lita::Adapters::Shell).to receive(:join).with("#lita.io")
+
+        subject.join("#lita.io")
+      end
+    end
+  end
+
+  describe "#part" do
+    before do
+      allow_any_instance_of(Lita::Adapters::Shell).to receive(:join)
+      allow_any_instance_of(Lita::Adapters::Shell).to receive(:part)
+    end
+
+    context "when a Room object exists" do
+      let!(:room) { Lita::Room.create_or_update(1, name: "#lita.io") }
+
+      it "passes the room ID to the adapter when a string argument is provided" do
+        expect_any_instance_of(Lita::Adapters::Shell).to receive(:part).with("1")
+
+        subject.part("#lita.io")
+      end
+
+      it "passes the room ID to the adapter when a Room argument is provided" do
+        expect_any_instance_of(Lita::Adapters::Shell).to receive(:part).with("1")
+
+        subject.part(room)
+      end
+
+      it "removes the room ID from the persisted list" do
+        subject.join("#lita.io")
+
+        subject.part("#lita.io")
+
+        expect(subject.persisted_rooms).not_to include("1")
+      end
+    end
+
+    context "when no Room object exists" do
+      it "delegates to the adapter with the raw argument" do
+        expect_any_instance_of(Lita::Adapters::Shell).to receive(:part).with("#lita.io")
+
+        subject.part("#lita.io")
+      end
+    end
+  end
+
+  describe "#send_message" do
+    let(:source) { instance_double("Lita::Source") }
+
+    it "delegates to the adapter" do
+      expect_any_instance_of(
+        Lita::Adapters::Shell
+      ).to receive(:send_messages).with(
+        source, %w[foo bar]
+      )
+      subject.send_messages(source, "foo", "bar")
+    end
+  end
+
+  describe "#send_message_with_mention" do
+    let(:user) { instance_double("Lita::User", mention_name: "carl") }
+    let(:source) { instance_double("Lita::Source", private_message?: false, user: user) }
+
+    it "calls #send_message with the strings, prefixed with the user's mention name" do
+      allow_any_instance_of(Lita::Adapters::Shell).to receive(:mention_format).with(
+        "carl"
+      ).and_return("carl:")
+      expect_any_instance_of(Lita::Adapters::Shell).to receive(:send_messages).with(
+        source,
+        ["carl: foo", "carl: bar"]
+      )
+
+      subject.send_messages_with_mention(source, "foo", "bar")
+    end
+
+    it "strips whitespace from both sides of the formatted mention name" do
+      allow_any_instance_of(Lita::Adapters::Shell).to receive(:mention_format).with(
+        "carl"
+      ).and_return("   carl:   ")
+      expect_any_instance_of(Lita::Adapters::Shell).to receive(:send_messages).with(
+        source,
+        ["carl: foo", "carl: bar"]
+      )
+
+      subject.send_messages_with_mention(source, "foo", "bar")
+    end
+
+    it "calls #send_message directly if the original message was sent privately" do
+      allow(source).to receive(:private_message?).and_return(true)
+      expect_any_instance_of(Lita::Adapters::Shell).to receive(:send_messages).with(
+        source,
+        %w[foo bar]
+      )
+
+      subject.send_messages_with_mention(source, "foo", "bar")
+    end
+  end
+
+  describe "#set_topic" do
+    let(:source) { instance_double("Lita::Source") }
+
+    it "delegates to the adapter" do
+      expect_any_instance_of(Lita::Adapters::Shell).to receive(:set_topic).with(
+        source,
+        "New topic"
+      )
+      subject.set_topic(source, "New topic")
+    end
+  end
+
+  describe "#shut_down" do
+    before { allow_any_instance_of(Lita::Adapters::Shell).to receive(:puts) }
+
+    it "gracefully stops the adapter" do
+      expect_any_instance_of(Lita::Adapters::Shell).to receive(:shut_down)
+      subject.shut_down
+    end
+
+    it "triggers events for shut_down_started and shut_down_complete" do
+      expect(subject).to receive(:trigger).with(:shut_down_started).ordered
+      expect(subject).to receive(:trigger).with(:shut_down_complete).ordered
+      subject.shut_down
+    end
+  end
+end

data/spec/lita/room_spec.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::Room, lita: true do
+  describe ".create_or_update" do
+    subject { described_class.find_by_id(1) }
+
+    context "when no room with the given ID already exists" do
+      it "creates the room" do
+        described_class.create_or_update(1, name: "foo")
+
+        expect(subject.name).to eq("foo")
+      end
+    end
+
+    context "when a room with the given ID already exists" do
+      before { described_class.create_or_update(1, name: "foo") }
+
+      it "merges in new metadata" do
+        described_class.create_or_update(1, foo: "bar")
+
+        expect(subject.name).to eq("foo")
+        expect(subject.metadata["foo"]).to eq("bar")
+      end
+    end
+  end
+
+  describe ".find_by_id" do
+    context "when a matching room exists" do
+      before { described_class.new(1).save }
+
+      it "is found by ID" do
+        expect(described_class.find_by_id(1).id).to eq("1")
+      end
+    end
+
+    context "when no matching room exists" do
+      it "is not found" do
+        expect(described_class.find_by_id(1)).to be_nil
+      end
+    end
+  end
+
+  describe ".find_by_name" do
+    context "when a matching room exists" do
+      before { described_class.new(1, name: "foo").save }
+
+      it "is found by name" do
+        expect(described_class.find_by_name("foo").id).to eq("1")
+      end
+    end
+
+    context "when no matching room exists" do
+      it "is not found" do
+        expect(described_class.find_by_name("foo")).to be_nil
+      end
+    end
+  end
+
+  describe ".fuzzy_find" do
+    context "when a matching room exists" do
+      before { described_class.new(1, name: "foo").save }
+
+      it "is found by ID" do
+        expect(described_class.fuzzy_find(1).id).to eq("1")
+      end
+
+      it "is found by name" do
+        expect(described_class.fuzzy_find("foo").id).to eq("1")
+      end
+    end
+
+    context "when no matching room exists" do
+      it "is not found by ID" do
+        expect(described_class.fuzzy_find(1)).to be_nil
+      end
+
+      it "is not found by name" do
+        expect(described_class.fuzzy_find("foo")).to be_nil
+      end
+    end
+  end
+
+  context "with only an ID" do
+    subject { described_class.new(1) }
+
+    it "has a string ID" do
+      expect(subject.id).to eq("1")
+    end
+
+    it "is named with its ID" do
+      expect(subject.name).to eq("1")
+    end
+  end
+
+  context "with metadata" do
+    subject { described_class.new(1, foo: :bar) }
+
+    it "stores the metadata with string keys" do
+      expect(subject.metadata["foo"]).to eq(:bar)
+    end
+  end
+
+  describe "#==" do
+    subject { described_class.new(1) }
+
+    context "when the other room has the same ID" do
+      let(:other) { described_class.new(1) }
+
+      it "is equal" do
+        expect(subject).to eq(other)
+      end
+    end
+
+    context "when the other room has a different ID" do
+      let(:other) { described_class.new(2) }
+
+      it "is not equal" do
+        expect(subject).not_to eq(other)
+      end
+    end
+  end
+
+  describe "#save" do
+    context "with metadata not including name" do
+      subject { described_class.new(1, {}) }
+
+      it "adds the name to the metadata" do
+        subject.save
+
+        expect(subject.metadata["name"]).to eq("1")
+      end
+    end
+  end
+end