rita 0.1.0 → 5.0.0.alpha.2

data/spec/lita/rspec/handler_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+handler_class = Class.new(Lita::Handler) do
+  namespace "testclass"
+
+  def self.name
+    "Lita::Handlers::Test"
+  end
+end
+
+additional_handler_class = Class.new(Lita::Handler) do
+  namespace "testclass"
+
+  config :test_property, type: String, default: "a string"
+
+  def self.name
+    "Lita::Handlers::TestBase"
+  end
+end
+
+describe handler_class, lita_handler: true, additional_lita_handlers: additional_handler_class do
+  context 'when the "additional_lita_handlers" metadata is provided' do
+    it "loads additional handlers into the registry" do
+      expect(registry.handlers).to include(additional_handler_class)
+    end
+
+    it "populates config from additional handlers" do
+      expect(registry.config.handlers.testclass.test_property).to eq("a string")
+    end
+  end
+end

data/spec/lita/rspec_spec.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+handler_class = Class.new(Lita::Handler) do
+  route(/^message$/, :message)
+  route(/^channel$/, :channel)
+  route(/^private message$/, :private_message)
+  route(/^command$/, :command, command: true)
+  route("restricted", :restricted, restrict_to: :some_group)
+  route("admins only", :admins_only, restrict_to: :admins)
+
+  http.get "web", :web
+
+  on :connected, :greet
+
+  def message(response)
+    response.reply(response.user.name)
+  end
+
+  def channel(response)
+    if (room = response.message.source.room_object)
+      response.reply(room.id)
+      response.reply(room.name)
+    else
+      response.reply("No room")
+    end
+  end
+
+  def private_message(response)
+    if response.private_message?
+      response.reply("Private")
+    else
+      response.reply("Public")
+    end
+  end
+
+  def command(response)
+    response.reply("a", "command")
+  end
+
+  def restricted(_response); end
+
+  def web(_request, _response); end
+
+  def greet(_payload); end
+
+  def self.name
+    "Lita::Handlers::Test"
+  end
+end
+
+describe handler_class, lita_handler: true do
+  describe "routing messages" do
+    it { is_expected.to route("message") }
+    it { is_expected.to route("message").to(:message) }
+    it { is_expected.not_to route("message").to(:not_a_message) }
+  end
+
+  describe "routing channels" do
+    it { is_expected.to route("channel") }
+    it { is_expected.to route("channel").to(:channel) }
+    it { is_expected.not_to route("channel").to(:not_a_channel) }
+  end
+
+  describe "routing commands" do
+    it { is_expected.to route_command("command") }
+    it { is_expected.not_to route("command") }
+    it { is_expected.not_to route_command("not a command") }
+    it { is_expected.to route_command("command").to(:command) }
+    it { is_expected.not_to route_command("command").to(:not_a_command) }
+  end
+
+  describe "routing to restricted routes" do
+    it { is_expected.not_to route("restricted") }
+    it { is_expected.to route("restricted").with_authorization_for(:some_group) }
+    it { is_expected.not_to route("restricted").with_authorization_for(:wrong_group) }
+    it { is_expected.to route("admins only").with_authorization_for(:admins) }
+    it { is_expected.to route("restricted").with_authorization_for(:some_group).to(:restricted) }
+    it { is_expected.not_to route("restricted").with_authorization_for(:some_group).to(:nothing) }
+  end
+
+  describe "routing HTTP routes" do
+    it { is_expected.to route_http(:get, "web") }
+    it { is_expected.to route_http(:get, "web").to(:web) }
+    it { is_expected.not_to route_http(:get, "web").to(:message) }
+    it { is_expected.not_to route_http(:post, "web") }
+  end
+
+  describe "routing events" do
+    it { is_expected.to route_event(:connected) }
+    it { is_expected.to route_event(:connected).to(:greet) }
+    it { is_expected.not_to route_event(:not_an_event) }
+    it { is_expected.not_to route_event(:connected).to(:message) }
+  end
+
+  describe "#message" do
+    it "replies with a string" do
+      send_message("message")
+      expect(replies).to eq(["Test User"])
+    end
+
+    it "does not memoize #replies on first access" do
+      replies
+      send_message("message")
+      expect(replies).to eq(["Test User"])
+    end
+  end
+
+  describe "#channel" do
+    it "replies with channel id if sent from room" do
+      room = Lita::Room.create_or_update(1, name: "Room")
+      send_message("channel", from: room)
+      expect(replies).to eq(%w[1 Room])
+    end
+
+    it "replies with no channel if not sent from room" do
+      send_message("channel")
+      expect(replies).to eq(["No room"])
+    end
+  end
+
+  describe "#private_message" do
+    let(:another_user) do
+      Lita::User.create(2, name: "Another User")
+    end
+
+    let(:room) do
+      Lita::Room.create_or_update(1, name: "Room")
+    end
+
+    it "replies with Private in response to a private message" do
+      send_message("private message", as: another_user, privately: true)
+      expect(source).to be_a_private_message
+      expect(replies.last).to eq("Private")
+    end
+
+    it "replies with Private in response to a private command" do
+      send_command("private message", as: another_user, privately: true)
+      expect(source).to be_a_private_message
+      expect(replies.last).to eq("Private")
+    end
+
+    it "replies with Public in response to a public message" do
+      send_message("private message", as: another_user, from: room)
+      expect(replies.last).to eq("Public")
+    end
+  end
+
+  describe "#command" do
+    it "replies with two strings" do
+      send_command("command")
+      expect(replies).to eq(%w[a command])
+    end
+  end
+
+  it "allows the sending user to be specified" do
+    another_user = Lita::User.create(2, name: "Another User")
+    send_message("message", as: another_user)
+    expect(replies.last).to eq("Another User")
+  end
+end

data/spec/lita/source_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::Source do
+  subject { described_class.new(user: user, room: room, private_message: pm) }
+
+  let(:pm) { false }
+  let(:room) { Lita::Room.new(1) }
+  let(:user) { Lita::User.new(1) }
+
+  describe "#room" do
+    it "returns the room as a string" do
+      expect(subject.room).to eq("1")
+    end
+  end
+
+  describe "#room_object" do
+    it "returns the room as a Lita::Room" do
+      expect(subject.room_object).to eq(room)
+    end
+  end
+
+  describe "#user" do
+    it "returns the user object" do
+      expect(subject.user).to eq(user)
+    end
+  end
+
+  context "when the private_message argument is true" do
+    let(:pm) { true }
+
+    it "is marked as a private message" do
+      expect(subject).to be_a_private_message
+    end
+  end
+
+  it "can be manually marked as private" do
+    subject.private_message!
+
+    expect(subject).to be_a_private_message
+  end
+
+  context "with a string for the room argument" do
+    let(:room) { "#channel" }
+
+    it "sets #room to the string" do
+      expect(subject.room).to eq(room)
+    end
+
+    it "sets #room_object to a Lita::Room with the string as its ID" do
+      expect(subject.room_object).to eq(Lita::Room.new(room))
+    end
+
+    context "room exists in database" do
+      let(:name) { "example" }
+
+      it "finds room by its ID" do
+        Lita::Room.create_or_update(room, name: name)
+        expect(subject.room_object.name).to eq(name)
+      end
+    end
+  end
+
+  it "requires either a user or a room" do
+    expect { described_class.new }.to raise_error(ArgumentError)
+  end
+end

data/spec/lita/store_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::Store do
+  it "has nil values by default" do
+    expect(subject[:foo]).to be_nil
+  end
+
+  it "sets and gets values" do
+    subject[:foo] = :bar
+
+    expect(subject[:foo]).to eq(:bar)
+  end
+
+  it "allows a custom internal store" do
+    subject = described_class.new(Hash.new { |h, k| h[k] = described_class.new })
+
+    subject[:foo][:bar] = :baz
+
+    expect(subject[:foo][:bar]).to eq(:baz)
+  end
+end

data/spec/lita/template_resolver_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::TemplateResolver do
+  subject do
+    described_class.new(template_root, template_name, adapter_name)
+  end
+
+  let(:adapter_name) { :shell }
+  let(:generic_template) { File.join(template_root, "basic.erb") }
+  let(:irc_template) { File.join(template_root, "basic.irc.erb") }
+  let(:template_name) { "basic" }
+  let(:template_root) { File.expand_path(File.join("..", "..", "templates"), __FILE__) }
+
+  describe "#resolve" do
+    context "when there is a template for the adapter" do
+      let(:adapter_name) { :irc }
+
+      it "returns the path to the adapter-specific template" do
+        expect(subject.resolve).to eq(irc_template)
+      end
+    end
+
+    context "when there is no template for the adapter" do
+      it "returns the path for the generic template" do
+        expect(subject.resolve).to eq(generic_template)
+      end
+    end
+
+    context "when there is no template with the given name" do
+      let(:template_name) { "nonexistent" }
+
+      it "raises an exception" do
+        expect { subject.resolve }.to raise_error(
+          Lita::MissingTemplateError,
+          %r{templates/nonexistent\.erb}
+        )
+      end
+    end
+  end
+end

data/spec/lita/template_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::Template do
+  describe ".from_file" do
+    context "with a path to an ERB template" do
+      subject do
+        described_class.from_file(File.expand_path("../templates/basic.erb", __dir__))
+      end
+
+      it "uses the source in the file" do
+        expect(subject.render).to eq("Template rendered from a file!")
+      end
+    end
+  end
+
+  describe "#add_helper" do
+    subject { described_class.new("<%= reverse_name(@first, @last) %>") }
+    let(:helper) do
+      Module.new do
+        def reverse_name(first, last)
+          "#{last}, #{first}"
+        end
+      end
+    end
+
+    it "adds the helper to the evaluation context" do
+      subject.add_helper(helper)
+
+      expect(subject.render(first: "Carl", last: "Pug")).to eq("Pug, Carl")
+    end
+  end
+
+  describe "#render" do
+    context "with a static source template" do
+      subject { described_class.new("Hello, Lita!") }
+
+      it "renders the text" do
+        expect(subject.render).to eq("Hello, Lita!")
+      end
+    end
+
+    context "with interpolation variables" do
+      subject { described_class.new("Hello, <%= @name %>!") }
+
+      it "renders the text with interpolated values" do
+        expect(subject.render(name: "Carl")).to eq("Hello, Carl!")
+      end
+    end
+  end
+end

data/spec/lita/timer_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::Timer do
+  let(:queue) { Queue.new }
+
+  before { allow(subject).to receive(:sleep) }
+
+  after { subject.stop }
+
+  it "runs single timers" do
+    subject = described_class.new { queue.push(true) }
+    expect(subject).to receive(:sleep).with(0).once
+    subject.start
+    expect(queue.pop(true)).to be(true)
+    expect { queue.pop(true) }.to raise_error(ThreadError)
+  end
+
+  it "runs recurring timers" do
+    halt = false
+    subject = described_class.new(interval: 1, recurring: true) do |timer|
+      queue.push(true)
+      timer.stop if halt
+      halt = true
+    end
+    expect(subject).to receive(:sleep).with(1).twice
+    subject.start
+    2.times { expect(queue.pop(true)).to be(true) }
+    expect { queue.pop(true) }.to raise_error(ThreadError)
+  end
+end

data/spec/lita/user_spec.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::User, lita: true do
+  describe ".create" do
+    it "creates and returns new users" do
+      user = described_class.create(1, name: "Carl")
+      expect(user.id).to eq("1")
+      expect(user.name).to eq("Carl")
+      persisted_user = described_class.find_by_id(1)
+      expect(user).to eq(persisted_user)
+    end
+
+    it "returns existing users" do
+      described_class.create(1, name: "Carl")
+      user = described_class.find_by_id(1)
+      expect(user.id).to eq("1")
+      expect(user.name).to eq("Carl")
+    end
+
+    it "merges and saves new metadata for existing users" do
+      described_class.create(1, name: "Carl")
+      described_class.create(1, name: "Mr. Carl", foo: "bar")
+      user = described_class.find_by_id(1)
+      expect(user.name).to eq("Mr. Carl")
+      expect(user.metadata["foo"]).to eq("bar")
+    end
+  end
+
+  describe ".find_by_id" do
+    it "finds users with no metadata stored" do
+      described_class.create(1)
+      user = described_class.find_by_id(1)
+      expect(user.id).to eq("1")
+    end
+  end
+
+  describe ".find_by_mention_name" do
+    it "returns nil if no user matches the provided mention name" do
+      expect(described_class.find_by_mention_name("carlthepug")).to be_nil
+    end
+
+    it "returns a user that matches the provided mention name" do
+      described_class.create(1, mention_name: "carlthepug")
+      user = described_class.find_by_mention_name("carlthepug")
+      expect(user.id).to eq("1")
+    end
+  end
+
+  describe ".find_by_name" do
+    it "returns nil if no user matches the provided name" do
+      expect(described_class.find_by_name("Carl")).to be_nil
+    end
+
+    it "returns existing users" do
+      described_class.create(1, name: "Carl")
+      user = described_class.find_by_name("Carl")
+      expect(user.id).to eq("1")
+    end
+  end
+
+  describe ".find_by_partial_name" do
+    before { described_class.create(1, name: "José Vicente Cuadra") }
+
+    it "finds users by partial name match" do
+      user = described_class.find_by_partial_name("José")
+      expect(user.id).to eq("1")
+    end
+
+    it "returns nil if no users' names start with the provided string" do
+      expect(described_class.find_by_partial_name("Foo")).to be_nil
+    end
+
+    it "returns nil if more than one match was found" do
+      described_class.create(2, name: "José Contreras")
+      expect(described_class.find_by_partial_name("José")).to be_nil
+    end
+  end
+
+  describe ".fuzzy_find" do
+    let!(:user) { described_class.create(1, name: "Carl the Pug", mention_name: "carlthepug") }
+
+    it "finds by ID" do
+      expect(described_class.fuzzy_find(1)).to eq(user)
+    end
+
+    it "finds by mention name" do
+      expect(described_class.fuzzy_find("carlthepug")).to eq(user)
+    end
+
+    it "finds by name" do
+      expect(described_class.fuzzy_find("Carl the Pug")).to eq(user)
+    end
+
+    it "finds by partial mention name" do
+      expect(described_class.fuzzy_find("Carl")).to eq(user)
+    end
+  end
+
+  describe "#mention_name" do
+    it "returns the user's mention name from metadata" do
+      subject = described_class.new(1, name: "Carl", mention_name: "carlthepug")
+      expect(subject.mention_name).to eq("carlthepug")
+    end
+
+    it "returns the user's name if there is no mention name in the metadata" do
+      subject = described_class.new(1, name: "Carl")
+      expect(subject.mention_name).to eq("Carl")
+    end
+  end
+
+  describe "#save" do
+    subject { described_class.new(1, name: "Carl", mention_name: "carlthepug") }
+
+    it "saves an ID to name mapping for the user in Redis" do
+      subject.save
+      expect(described_class.redis.hgetall("id:1")).to include("name" => "Carl")
+    end
+
+    it "saves a name to ID mapping for the user in Redis" do
+      subject.save
+      expect(described_class.redis.get("name:Carl")).to eq("1")
+    end
+
+    it "saves a mention name to ID mapping for the user in Redis" do
+      subject.save
+      expect(described_class.redis.get("mention_name:carlthepug")).to eq("1")
+    end
+
+    context "when a key is deleted" do
+      before do
+        subject.metadata["example"] = "hello"
+        subject.save
+        expect(described_class.redis.hkeys("id:1")).to include("example")
+        subject.metadata.delete("example")
+        subject.save
+      end
+
+      it "deletes that key from redis" do
+        expect(described_class.redis.hkeys("id:1")).not_to include("example")
+      end
+    end
+  end
+
+  describe "equality" do
+    it "considers two users equal if they share an ID and name" do
+      user_1 = described_class.new(1, name: "Carl")
+      user_2 = described_class.new(1, name: "Carl")
+      expect(user_1).to eq(user_2)
+      expect(user_1).to eql(user_2)
+    end
+
+    it "doesn't assume the comparison object is a Lita::User" do
+      user = described_class.new(1, name: "Carl")
+      expect(user).not_to eq("not a Lita::User object")
+      expect(user).not_to eql("not a Lita::User object")
+    end
+
+    it "consistently hashes equal users" do
+      user_1 = described_class.new(1, name: "Carl")
+      user_2 = described_class.new(1, name: "Carl")
+
+      expect(user_1.hash).to eq(user_2.hash)
+    end
+  end
+end

data/spec/lita/util_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::Util do
+  describe ".stringify_keys" do
+    it "converts symbol hash keys to strings" do
+      stringified = described_class.stringify_keys(foo: "bar")
+      expect(stringified).to eq("foo" => "bar")
+    end
+  end
+
+  describe ".underscore" do
+    it "converts camel cased strings into snake case" do
+      expect(described_class.underscore("FooBarBaz")).to eq("foo_bar_baz")
+    end
+  end
+end