lita 3.3.1 → 4.0.0.rc1

data/spec/lita/builder_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe Lita::Builder, 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/config_spec.rb

@@ -37,30 +37,6 @@ describe Lita::Config do
     end
   end
 
-  describe ".load_user_config" do
-    it "loads and evals lita_config.rb" do
-      allow(File).to receive(:exist?).and_return(true)
-      allow(described_class).to receive(:load) do
-        Lita.configure { |config| config.robot.name = "Not Lita" }
-      end
-      described_class.load_user_config
-      expect(Lita.config.robot.name).to eq("Not Lita")
-    end
-
-    it "doesn't attempt to load lita_config.rb if it doesn't exist" do
-      allow(File).to receive(:exist?).and_return(false)
-      expect(described_class).not_to receive(:load)
-      described_class.load_user_config
-    end
-
-    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(Lita.logger).to receive(:fatal).with(/could not be processed/)
-      expect { described_class.load_user_config }.to raise_error(SystemExit)
-    end
-  end
-
   describe "#finalize" do
     it "freezes the configuration" do
       subject.finalize

data/spec/lita/configuration_spec.rb

@@ -0,0 +1,222 @@
+require "spec_helper"
+
+describe Lita::Configuration do
+  let(:config) { subject.finalize }
+
+  describe ".load_user_config" do
+    it "loads and evals lita_config.rb" do
+      allow(File).to receive(:exist?).and_return(true)
+      allow(described_class).to receive(:load) do
+        Lita.configure { |c| c.robot.name = "Not Lita" }
+      end
+      described_class.load_user_config
+      expect(Lita.config.robot.name).to eq("Not Lita")
+    end
+
+    it "doesn't attempt to load lita_config.rb if it doesn't exist" do
+      allow(File).to receive(:exist?).and_return(false)
+      expect(described_class).not_to receive(:load)
+      described_class.load_user_config
+    end
+
+    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(Lita.logger).to receive(:fatal).with(/could not be processed/)
+      expect { described_class.load_user_config }.to raise_error(SystemExit)
+    end
+  end
+
+  describe "a simple attribute" do
+    before { subject.config :simple }
+
+    it "is nil by default" do
+      expect(config.simple).to be_nil
+    end
+
+    it "can be set to anything" do
+      config.simple = 1
+      expect(config.simple).to eq(1)
+    end
+  end
+
+  describe "a typed attribute" do
+    before { subject.config :simple, type: Symbol }
+
+    it "is nil by default" do
+      expect(config.simple).to be_nil
+    end
+
+    it "can be set to a value of the type" do
+      config.simple = :foo
+      expect(config.simple).to eq(:foo)
+    end
+
+    it "raises if set to a value of the wrong type" do
+      expect { config.simple = "foo" }.to raise_error(TypeError)
+    end
+  end
+
+  describe "a composite typed attribute" do
+    before { subject.config :simple, types: [Symbol, String] }
+
+    it "is nil by default" do
+      expect(config.simple).to be_nil
+    end
+
+    it "can be set to a value of the first type" do
+      config.simple = :foo
+      expect(config.simple).to eq(:foo)
+    end
+
+    it "can be set to a value of the second type" do
+      config.simple = "foo"
+      expect(config.simple).to eq("foo")
+    end
+
+    it "raises if set to a value of the wrong type" do
+      expect { config.simple = 1 }.to raise_error(TypeError)
+    end
+  end
+
+  describe "an attribute with a default value" do
+    before { subject.config :simple, default: :foo }
+
+    it "starts with the default value" do
+      expect(config.simple).to eq(:foo)
+    end
+
+    it "can be reassigned" do
+      config.simple = :bar
+      expect(config.simple).to eq(:bar)
+    end
+  end
+
+  describe "a typed attribute with a default value" do
+    it "starts with the default value" do
+      subject.config :simple, type: Symbol, default: :foo
+      expect(config.simple).to eq(:foo)
+    end
+
+    it "raises if the default is a value of the wrong type" do
+      expect { subject.config :simple, type: Symbol, default: "foo" }.to raise_error(TypeError)
+    end
+  end
+
+  describe "a validated attribute" do
+    before do
+      subject.config :simple do
+        validate { |value| "must be true" unless value }
+      end
+    end
+
+    it "can be set to a value that passes validation" do
+      config.simple = true
+      expect(config.simple).to be(true)
+    end
+
+    it "raises if the validator raises due to an invalid value" do
+      expect { config.simple = false }.to raise_error(Lita::ValidationError, "must be true")
+    end
+  end
+
+  describe "a simple nested attribute" do
+    before do
+      subject.config :nested do
+        config :foo
+      end
+    end
+
+    it "is nil by default" do
+      expect(config.nested.foo).to be_nil
+    end
+
+    it "can be set to anything" do
+      config.nested.foo = :bar
+      expect(config.nested.foo).to eq(:bar)
+    end
+
+    it "prevents the parent from being assigned" do
+      expect { config.nested = "impossible" }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe "an attribute with all the options, validation, and nested attributes" do
+    before do
+      subject.config :nested, type: Symbol, default: :foo do
+        validate { "validation error" }
+
+        config :foo
+      end
+    end
+
+    it "cannot be set" do
+      expect { config.nested = "impossible" }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe "multiple nested attributes with options" do
+    before do
+      subject.config :nested do
+        config :foo, default: "foo" do
+          validate { |value| "must be bar" unless value == "bar" }
+        end
+
+        config :bar, type: Symbol
+      end
+    end
+
+    it "can get the first nested attribute" do
+      expect(config.nested.foo).to eq("foo")
+    end
+
+    it "can set the first nested attribute" do
+      config.nested.foo = "bar"
+      expect(config.nested.foo).to eq("bar")
+    end
+
+    it "has working validation" do
+      expect { config.nested.foo = "baz" }.to raise_error(Lita::ValidationError)
+    end
+
+    it "can get the second nested attribute" do
+      expect(config.nested.bar).to be_nil
+    end
+
+    it "can set the second nested attribute and options take effect" do
+      expect { config.nested.bar = "not a symbol" }.to raise_error(TypeError)
+    end
+  end
+
+  describe "#has_children?" do
+    it "is true when any attribute has been created" do
+      subject.config :foo
+
+      expect(subject.children?).to be_truthy
+    end
+
+    it "is false when no attributes have been created" do
+      expect(subject.children?).to be_falsy
+    end
+  end
+
+  describe "#combine" do
+    let(:config_2) do
+      config_2 = described_class.new
+      config_2.config(:bar)
+      config_2
+    end
+
+    it "sets the provided configuration as the value of the provided attribute" do
+      subject.combine(:foo, config_2)
+
+      expect(config.foo.bar).to be_nil
+    end
+
+    it "does not allow the combined configuration to be reassigned" do
+      subject.combine(:foo, config_2)
+
+      expect { config.foo = "bar" }.to raise_error(NoMethodError)
+    end
+  end
+end

data/spec/lita/configuration_validator_spec.rb

@@ -0,0 +1,112 @@
+require "spec_helper"
+
+describe Lita::ConfigurationValidator, lita: true do
+  subject { described_class.new(registry) }
+
+  describe "#call" do
+    it "has no effect if there are no plugins registered" do
+      expect { subject.call }.not_to raise_error
+    end
+
+    it "has no effect if all adapters have valid configuration" do
+      registry.register_adapter(:test) do
+        config :foo, required: true, default: :bar
+      end
+
+      expect { subject.call }.not_to raise_error
+    end
+
+    it "raises if a required adapter configuration attribute is missing" do
+      registry.register_adapter(:test) do
+        config :foo, required: true
+      end
+
+      expect { subject.call }.to raise_error(
+        Lita::ValidationError,
+        /Configuration attribute "foo" is required for "test" adapter/
+      )
+    end
+
+    it "has no effect if all adapters with nested configuration have valid configuration" do
+      registry.register_adapter(:test) do
+        config :foo do
+          config :bar, required: true, default: :baz
+        end
+      end
+
+      expect { subject.call }.not_to raise_error
+    end
+
+    it "raises if a required nested adapter configuration attribute is missing" do
+      registry.register_adapter(:test) do
+        config :foo do
+          config :bar, required: true
+        end
+      end
+
+      expect { subject.call }.to raise_error(
+        Lita::ValidationError,
+        /Configuration attribute "foo\.bar" is required for "test" adapter/
+      )
+    end
+
+    it "uses the right namespace for a nested attribute when a previous nesting has been visited" do
+      registry.register_adapter(:test) do
+        config :foo do
+          config :bar
+        end
+
+        config :one do
+          config :two, required: true
+        end
+      end
+
+      expect { subject.call }.to raise_error(
+        Lita::ValidationError,
+        /Configuration attribute "one\.two" is required for "test" adapter/
+      )
+    end
+
+    it "has no effect if all handlers have valid configuration" do
+      registry.register_handler(:test) do
+        config :foo, required: true, default: :bar
+      end
+
+      expect { subject.call }.not_to raise_error
+    end
+
+    it "raises if a required handler configuration attribute is missing" do
+      registry.register_handler(:test) do
+        config :foo, required: true
+      end
+
+      expect { subject.call }.to raise_error(
+        Lita::ValidationError,
+        /Configuration attribute "foo" is required for "test" handler/
+      )
+    end
+
+    it "has no effect if all handlers with nested configuration have valid configuration" do
+      registry.register_handler(:test) do
+        config :foo do
+          config :bar, required: true, default: :baz
+        end
+      end
+
+      expect { subject.call }.not_to raise_error
+    end
+
+    it "raises if a required nested handler configuration attribute is missing" do
+      registry.register_handler(:test) do
+        config :foo do
+          config :bar, required: true
+        end
+      end
+
+      expect { subject.call }.to raise_error(
+        Lita::ValidationError,
+        /Configuration attribute "foo\.bar" is required for "test" handler/
+      )
+    end
+  end
+end

data/spec/lita/daemon_spec.rb

@@ -11,8 +11,8 @@ describe Lita::Daemon do
     allow(File).to receive(:new).and_return("log")
     allow(File).to receive(:open)
     allow(File).to receive(:read)
-    allow_any_instance_of(described_class).to receive(:stdout).and_return(stdout)
-    allow_any_instance_of(described_class).to receive(:stderr).and_return(stderr)
+    stub_const("STDOUT", stdout)
+    stub_const("STDERR", stderr)
   end
 
   subject { described_class.new("/tmp/lita_pid", "/tmp/lita_log", false) }

data/spec/lita/default_configuration_spec.rb

@@ -0,0 +1,254 @@
+require "spec_helper"
+
+describe Lita::DefaultConfiguration, lita: true do
+  subject { described_class.new(registry) }
+
+  let(:config) { subject.finalize }
+
+  describe "adapter config" do
+    it "is an old-style config object" do
+      config.adapter.foo = "bar"
+
+      expect(config.adapter.foo).to eq("bar")
+    end
+
+    it "prints a deprecation warning on access" do
+      expect(Lita.logger).to receive(:warn).with(/config\.adapter is deprecated/)
+
+      config.adapter.foo = "bar"
+    end
+
+    it "allows hash-style access" do
+      config.adapter[:foo] = :bar
+
+      expect(config.adapter["foo"]).to eq(:bar)
+    end
+
+    it "outputs one deprecation warning per hash-style access" do
+      expect(Lita.logger).to receive(:warn).once
+
+      config.adapter[:foo] = :bar
+    end
+  end
+
+  describe "adapters config" do
+    context "with no adapters with config attributes" do
+      it "has an adapters attribute" do
+        expect(config).to respond_to(:adapters)
+      end
+    end
+
+    context "with one adapter with no configuration" do
+      it "has an attribute for the adapter" do
+        registry.register_adapter(:foo) {}
+        expect(config.adapters).to respond_to(:foo)
+      end
+    end
+
+    context "with an adapter with configuration" do
+      it "has an attribute for the handler with its own attributes" do
+        registry.register_adapter(:foo) { config :bar, default: :baz }
+
+        expect(config.adapters.foo.bar).to eq(:baz)
+      end
+    end
+  end
+
+  describe "handlers config" do
+    context "with no handlers with config attributes" do
+      it "has a handlers attribute" do
+        expect(config).to respond_to(:handlers)
+      end
+    end
+
+    context "with one handler with no configuration" do
+      it "has an attribute for the handler" do
+        registry.register_handler(:foo) {}
+
+        expect(config.handlers).to respond_to(:foo)
+      end
+    end
+
+    context "with a handler with configuration" do
+      it "has an attribute for the handler with its own attributes" do
+        registry.register_handler(:foo) { config :bar, default: :baz }
+
+        expect(config.handlers.foo.bar).to eq(:baz)
+      end
+    end
+
+    context "with a handler defining default_config" do
+      before do
+        registry.register_handler(:foo) do
+          def self.default_config(old_config)
+            old_config.bar = :baz
+          end
+        end
+      end
+
+      it "has an attribute for the handler with its own attributes" do
+        expect(config.handlers.foo.bar).to eq(:baz)
+      end
+    end
+  end
+
+  describe "http config" do
+    it "has a default host" do
+      expect(config.http.host).to eq("0.0.0.0")
+    end
+
+    it "can set the host" do
+      config.http.host = "127.0.0.1"
+
+      expect(config.http.host).to eq("127.0.0.1")
+    end
+
+    it "has a default port" do
+      expect(config.http.port).to eq(8080)
+    end
+
+    it "can set the port" do
+      config.http.port = 80
+
+      expect(config.http.port).to eq(80)
+    end
+
+    it "has a default minimum thread count" do
+      expect(config.http.min_threads).to eq(0)
+    end
+
+    it "can set the minimum threads" do
+      config.http.min_threads = 4
+
+      expect(config.http.min_threads).to eq(4)
+    end
+
+    it "has a default maximum thread count" do
+      expect(config.http.max_threads).to eq(16)
+    end
+
+    it "can set the maximum threads" do
+      config.http.max_threads = 8
+
+      expect(config.http.max_threads).to eq(8)
+    end
+
+    it "has an empty middleware stack" do
+      expect(config.http.middleware).to be_empty
+    end
+
+    it "can add middleware to the stack" do
+      middleware = double("a rack middleware")
+
+      config.http.middleware.push(middleware)
+
+      expect(config.http.middleware).to include(middleware)
+    end
+  end
+
+  describe "redis config" do
+    it "has empty default options" do
+      expect(config.redis).to eq({})
+    end
+
+    it "can set options" do
+      options = { port: 1234, password: "secret" }
+
+      config.redis = options
+
+      expect(config.redis).to eq(options)
+    end
+
+    it "can set options with struct-style access" do
+      config.redis.port = 1234
+
+      expect(config.redis.port).to eq(1234)
+    end
+
+    it "prints a deprecation warning for struct-style access" do
+      expect(Lita.logger).to receive(:warn).with(/struct-style access/i)
+
+      config.redis.port = 1234
+    end
+  end
+
+  describe "robot config" do
+    it "has a default name" do
+      expect(config.robot.name).to eq("Lita")
+    end
+
+    it "can set a name" do
+      config.robot.name = "Not Lita"
+
+      expect(config.robot.name).to eq("Not Lita")
+    end
+
+    it "has no default mention name" do
+      expect(config.robot.mention_name).to be_nil
+    end
+
+    it "can set a mention name" do
+      config.robot.mention_name = "notlita"
+
+      expect(config.robot.mention_name).to eq("notlita")
+    end
+
+    it "has no default alias" do
+      expect(config.robot.alias).to be_nil
+    end
+
+    it "can set an alias" do
+      config.robot.alias = "/"
+
+      expect(config.robot.alias).to eq("/")
+    end
+
+    it "has a default adapter" do
+      expect(config.robot.adapter).to eq(:shell)
+    end
+
+    it "can set an adapter" do
+      config.robot.adapter = :hipchat
+
+      expect(config.robot.adapter).to eq(:hipchat)
+    end
+
+    it "has a default locale" do
+      expect(config.robot.locale).to eq(I18n.locale)
+    end
+
+    it "can set a locale" do
+      config.robot.locale = :es
+
+      expect(config.robot.locale).to eq(:es)
+    end
+
+    it "has a default log level" do
+      expect(config.robot.log_level).to eq(:info)
+    end
+
+    it "can set a log level" do
+      config.robot.log_level = :debug
+
+      expect(config.robot.log_level).to eq(:debug)
+    end
+
+    it "allows strings and mixed case as log levels" do
+      expect { config.robot.log_level = "dEbUg" }.not_to raise_error
+    end
+
+    it "raises a validation error for invalid log levels" do
+      expect { config.robot.log_level = :not_a_level }.to raise_error(Lita::ValidationError)
+    end
+
+    it "has no default admins" do
+      expect(config.robot.admins).to be_nil
+    end
+
+    it "can set admins" do
+      config.robot.admins = %w(1 2 3)
+
+      expect(config.robot.admins).to eq(%w(1 2 3))
+    end
+  end
+end