lita 0.0.1 → 1.0.0

data/spec/lita/config_spec.rb

@@ -39,9 +39,8 @@ describe Lita::Config do
     it "raises an exception if lita_config.rb raises an exception" do
       allow(File).to receive(:exist?).and_return(true)
       allow(described_class).to receive(:load) { Lita.non_existent_method }
-      expect do
-        described_class.load_user_config
-      end.to raise_error(Lita::ConfigError)
+      expect(Lita.logger).to receive(:fatal).with(/could not be processed/)
+      expect { described_class.load_user_config }.to raise_error(SystemExit)
     end
   end
 end

data/spec/lita/handler_spec.rb

@@ -12,6 +12,7 @@ describe Lita::Handler do
     allow(message).to receive(:scan).and_return(matches)
     allow(message).to receive(:command?).and_return(false)
     allow(message).to receive(:source).and_return(source)
+    allow(message).to receive(:user).and_return(user)
     message
   end
 
@@ -19,10 +20,13 @@ describe Lita::Handler do
 
   let(:source) { double("Source") }
 
+  let(:user) { double("User") }
+
   let(:handler_class) do
     Class.new(described_class) do
       route(/\w{3}/, to: :foo)
       route(/\w{4}/, to: :blah, command: true)
+      route(/secret/, to: :secret, restrict_to: :admins)
 
       def foo(matches)
       end
@@ -30,6 +34,9 @@ describe Lita::Handler do
       def blah(matches)
       end
 
+      def secret(matches)
+      end
+
       def self.name
         "Lita::Handlers::Test"
       end
@@ -71,6 +78,20 @@ describe Lita::Handler do
       expect_any_instance_of(handler_class).not_to receive(:blah)
       handler_class.dispatch(robot, message)
     end
+
+    it "dispatches to restricted routes if the user is in the auth group" do
+      allow(message).to receive(:body).and_return("secret")
+      allow(Lita::Authorization).to receive(:user_in_group?).and_return(true)
+      expect_any_instance_of(handler_class).to receive(:secret)
+      handler_class.dispatch(robot, message)
+    end
+
+    it "doesn't route unauthorized users' messages to restricted routes" do
+      allow(message).to receive(:body).and_return("secret")
+      allow(Lita::Authorization).to receive(:user_in_group?).and_return(false)
+      expect_any_instance_of(handler_class).not_to receive(:secret)
+      handler_class.dispatch(robot, message)
+    end
   end
 
   describe "#args" do

data/spec/lita/handlers/authorization_spec.rb

@@ -0,0 +1,70 @@
+require "spec_helper"
+
+describe Lita::Handlers::Authorization, lita: true do
+  before { allow(robot).to receive(:send_messages) }
+
+  it { routes("#{robot.name}: auth add foo bar").to(:add) }
+  it { routes("#{robot.name}: auth add foo@bar.com baz").to(:add) }
+  it { routes("#{robot.name}: auth remove foo bar").to(:remove) }
+  it { routes("#{robot.name}: auth remove foo@bar.com baz").to(:remove) }
+
+  describe ".help" do
+    it "returns a hash of command help" do
+      expect(described_class.help).to be_a(Hash)
+    end
+  end
+
+  describe "#add" do
+    before do
+      allow(Lita::Authorization).to receive(:user_is_admin?).and_return(true)
+    end
+
+    it "replies with the proper format if the require commands are missing" do
+      expect_reply(/^Format:/)
+      send_test_message("#{robot.name}: auth add foo")
+    end
+
+    it "replies with a warning if target user is not known" do
+      expect_reply(/No user was found/)
+      send_test_message("#{robot.name}: auth add foo bar")
+    end
+
+    it "replies with success if the valid user ID and group were supplied" do
+      allow(Lita::User).to receive(:find_by_id).and_return(user)
+      expect_reply("#{user.name} was added to bar.")
+      send_test_message("#{robot.name}: auth add foo bar")
+    end
+
+    it "replies with success if the valid user ID and group were supplied" do
+      allow(Lita::User).to receive(:find_by_name).and_return(user)
+      expect_reply("#{user.name} was added to bar.")
+      send_test_message("#{robot.name}: auth add foo bar")
+    end
+
+    it "replies with a warning if the user was already in the group" do
+      allow(Lita::User).to receive(:find_by_id).and_return(user)
+      send_test_message("#{robot.name}: auth add foo bar")
+      expect_reply("#{user.name} was already in bar.")
+      send_test_message("#{robot.name}: auth add foo bar")
+    end
+  end
+
+  describe "#remove" do
+    before do
+      allow(Lita::Authorization).to receive(:user_is_admin?).and_return(true)
+      allow(Lita::User).to receive(:find_by_id).and_return(user)
+      send_test_message("#{robot.name}: auth add foo bar")
+    end
+
+    it "replies with success if the valid user ID and group were supplied" do
+      expect_reply("#{user.name} was removed from bar.")
+      send_test_message("#{robot.name}: auth remove foo bar")
+    end
+
+    it "replies with a warning if the user was already in the group" do
+      send_test_message("#{robot.name}: auth remove foo bar")
+      expect_reply("#{user.name} was not in bar.")
+      send_test_message("#{robot.name}: auth remove foo bar")
+    end
+  end
+end

data/spec/lita/handlers/help_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe Lita::Handlers::Help, lita: true do
+  it { routes("#{robot.name}: help").to(:help) }
+  it { routes("#{robot.name}: help foo").to(:help) }
+
+  describe "#help" do
+    it "sends help information for all commands" do
+      expect_reply(/help - Lists.+help COMMAND - Lists/m)
+      send_test_message("#{robot.name}: help")
+    end
+
+    it "sends help information for commands starting with COMMAND" do
+      expect_reply(/help COMMAND - Lists/)
+      expect_no_reply(/help - Lists/)
+      send_test_message("#{robot.name}: help help command")
+    end
+  end
+end

data/spec/lita/message_spec.rb

@@ -59,4 +59,11 @@ describe Lita::Message do
       subject.scan
     end
   end
+
+  describe "#user" do
+    it "delegates to #source" do
+      expect(subject.source).to receive(:user)
+      subject.user
+    end
+  end
 end

data/spec/lita/robot_spec.rb

@@ -1,11 +1,12 @@
 require "spec_helper"
 
 describe Lita::Robot do
-  it "raises an exception if the specified adapter can't be found" do
+  it "logs and quits if the specified adapter can't be found" do
     adapter_registry = double("adapter_registry")
     allow(Lita).to receive(:adapters).and_return(adapter_registry)
     allow(adapter_registry).to receive(:[]).and_return(nil)
-    expect { subject }.to raise_error(Lita::UnknownAdapterError)
+    expect(Lita.logger).to receive(:fatal).with(/Unknown adapter/)
+    expect { subject }.to raise_error(SystemExit)
   end
 
   describe "#receive" do
@@ -25,18 +26,45 @@ describe Lita::Robot do
       expect_any_instance_of(Lita::Adapters::Shell).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
   end
 
   describe "#send_message" do
-    let(:message) { double("Message") }
+    let(:source) { double("Source") }
 
     it "delegates to the adapter" do
       expect_any_instance_of(
         Lita::Adapters::Shell
       ).to receive(:send_messages).with(
-        message, ["foo", "bar"]
+        source, ["foo", "bar"]
       )
-      subject.send_messages(message, "foo", "bar")
+      subject.send_messages(source, "foo", "bar")
+    end
+  end
+
+  describe "#set_topic" do
+    let(:source) { double("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
+    it "gracefully stops the adapter" do
+      expect_any_instance_of(Lita::Adapters::Shell).to receive(:shut_down)
+      subject.shut_down
     end
   end
 end

data/spec/lita/rspec_spec.rb

@@ -5,9 +5,11 @@ handler_class = Class.new(Lita::Handler) do
   route(/\w{4}/, to: :blah, command: true)
 
   def foo(matches)
+    reply "baz"
   end
 
   def blah(matches)
+    reply "bongo", "wongo"
   end
 
   def self.name
@@ -15,9 +17,33 @@ handler_class = Class.new(Lita::Handler) do
   end
 end
 
-describe handler_class, lita_handler: true do
+describe handler_class, lita: true do
   it { routes("foo").to(:foo) }
   it { routes("#{robot.name}: blah").to(:blah) }
   it { doesnt_route("blah").to(:blah) }
   it { does_not_route("blah").to(:blah) }
+
+  describe "#foo" do
+    it "replies with baz" do
+      expect_reply("baz")
+      send_test_message("foo")
+    end
+
+    it "doesn't reply with blam" do
+      expect_no_reply("blam")
+      send_test_message("foo")
+    end
+  end
+
+  describe "#blah" do
+    it "replies with bongo and wongo" do
+      expect_replies("bongo", "wongo")
+      send_test_message("#{robot.name}: blah")
+    end
+
+    it "doesn't reply with foo and bar" do
+      expect_no_replies("foo", "bar")
+      send_test_message("#{robot.name}: blah")
+    end
+  end
 end

data/spec/lita/user_spec.rb

@@ -0,0 +1,58 @@
+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(1)
+      expect(user).to eq(persisted_user)
+    end
+  end
+
+  describe ".find" do
+    before { described_class.create(1, name: "Carl") }
+
+    it "returns existing users" do
+      expect_any_instance_of(described_class).not_to receive(:save)
+      user = described_class.find(1, name: "Carl")
+      expect(user.id).to eq("1")
+      expect(user.name).to eq("Carl")
+    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 "#save" do
+    subject { described_class.new(1, name: "Carl") }
+
+    it "saves an ID to name mapping for the user in Redis" do
+      subject.save
+      expect(described_class.redis.hgetall("id:1")).to eq("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
+  end
+
+  describe "#==" do
+    it "considers two users equal if they share an ID and name" do
+      user1 = described_class.new(1, name: "Carl")
+      user2 = described_class.new(1, name: "Carl")
+      expect(user1).to eq(user2)
+    end
+  end
+end

data/spec/lita_spec.rb

@@ -1,6 +1,11 @@
 require "spec_helper"
 
 describe Lita do
+  before do
+    Lita.instance_variable_set(:@config, nil)
+    Lita.instance_variable_set(:@logger, nil)
+  end
+
   it "memoizes a hash of Adapters" do
     adapter_class = double("Adapter")
     described_class.register_adapter(:foo, adapter_class)
@@ -12,7 +17,9 @@ describe Lita do
     handler_class = double("Handler")
     described_class.register_handler(handler_class)
     described_class.register_handler(handler_class)
-    expect(described_class.handlers.to_a).to eq([handler_class])
+    original_size = described_class.handlers.to_a.size
+    new_size = (described_class.handlers.to_a - [handler_class]).size
+    expect(new_size).to eq(original_size - 1)
     expect(described_class.handlers).to eql(described_class.handlers)
   end
 
@@ -28,21 +35,44 @@ describe Lita do
     end
   end
 
+  describe ".logger" do
+    it "memoizes the logger" do
+      expect(described_class.logger).to be_a(Logger)
+      expect(described_class.logger).to eql(described_class.logger)
+    end
+
+    it "uses a custom log level" do
+      Lita.config.robot.log_level = :debug
+      expect(described_class.logger.level).to eq(Logger::DEBUG)
+    end
+
+    it "uses the info level if the config is nil" do
+      Lita.config.robot.log_level = nil
+      expect(described_class.logger.level).to eq(Logger::INFO)
+    end
+
+    it "uses the info level if the config level is invalid" do
+      Lita.config.robot.log_level = :foo
+      expect(described_class.logger.level).to eq(Logger::INFO)
+    end
+
+    it "logs messages with a custom format" do
+      stderr = StringIO.new
+      stub_const("STDERR", stderr)
+      Lita.logger.fatal "foo"
+      expect(stderr.string).to match(%r{^\[.+\] FATAL: foo$})
+    end
+  end
+
   describe ".redis" do
     it "memoizes a Redis::Namespace" do
-      expect(described_class.redis.namespace).to eq(
-        described_class::REDIS_NAMESPACE
-      )
+      expect(described_class.redis).to respond_to(:namespace)
       expect(described_class.redis).to eql(described_class.redis)
     end
   end
 
   describe ".run" do
-    it "laods the user config" do
-      expect(Lita::Config).to receive(:load_user_config)
-      allow_any_instance_of(Lita::Robot).to receive(:run)
-      described_class.run
-    end
+    before { Lita.config }
 
     it "runs a new Robot" do
       expect_any_instance_of(Lita::Robot).to receive(:run)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lita
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Jimmy Cuadra
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-15 00:00:00.000000000 Z
+date: 2013-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -118,6 +118,7 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .travis.yml
+- CHANGELOG.md
 - Gemfile
 - README.md
 - Rakefile
@@ -125,26 +126,33 @@ files:
 - lib/lita.rb
 - lib/lita/adapter.rb
 - lib/lita/adapters/shell.rb
+- lib/lita/authorization.rb
 - lib/lita/cli.rb
 - lib/lita/config.rb
-- lib/lita/errors.rb
 - lib/lita/handler.rb
+- lib/lita/handlers/authorization.rb
+- lib/lita/handlers/help.rb
 - lib/lita/message.rb
 - lib/lita/robot.rb
 - lib/lita/rspec.rb
 - lib/lita/source.rb
+- lib/lita/user.rb
 - lib/lita/version.rb
 - lita.gemspec
 - skeleton/Gemfile
 - skeleton/lita_config.rb
 - spec/lita/adapter_spec.rb
 - spec/lita/adapters/shell_spec.rb
+- spec/lita/authorization_spec.rb
 - spec/lita/config_spec.rb
 - spec/lita/handler_spec.rb
+- spec/lita/handlers/authorization_spec.rb
+- spec/lita/handlers/help_spec.rb
 - spec/lita/message_spec.rb
 - spec/lita/robot_spec.rb
 - spec/lita/rspec_spec.rb
 - spec/lita/source_spec.rb
+- spec/lita/user_spec.rb
 - spec/lita_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/jimmycuadra/lita
@@ -159,7 +167,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
@@ -174,12 +182,16 @@ summary: A multi-service chat bot with extendable behavior.
 test_files:
 - spec/lita/adapter_spec.rb
 - spec/lita/adapters/shell_spec.rb
+- spec/lita/authorization_spec.rb
 - spec/lita/config_spec.rb
 - spec/lita/handler_spec.rb
+- spec/lita/handlers/authorization_spec.rb
+- spec/lita/handlers/help_spec.rb
 - spec/lita/message_spec.rb
 - spec/lita/robot_spec.rb
 - spec/lita/rspec_spec.rb
 - spec/lita/source_spec.rb
+- spec/lita/user_spec.rb
 - spec/lita_spec.rb
 - spec/spec_helper.rb
 has_rdoc: