rita 0.1.0 → 5.0.0.alpha.1

data/spec/lita/configuration_builder_spec.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::ConfigurationBuilder do
+  let(:config) { subject.build }
+
+  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 a non-config-validation 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(Lita.logger).to receive(:fatal).with(
+        /Configuration type error: "simple" must be one of: Symbol/
+      )
+      expect { config.simple = "foo" }.to raise_error(Lita::ValidationError)
+    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(Lita.logger).to receive(:fatal).with(
+        /Configuration type error: "simple" must be one of: Symbol, String/
+      )
+      expect { config.simple = 1 }.to raise_error(Lita::ValidationError)
+    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 'foo'" unless value == "foo" }
+      end
+    end
+
+    it "can be set to a value that passes validation" do
+      config.simple = "foo"
+      expect(config.simple).to eq("foo")
+    end
+
+    it "raises if the validator raises due to an invalid value" do
+      expect(Lita.logger).to receive(:fatal).with(
+        /Validation error on attribute "simple": must be 'foo'/
+      )
+      expect { config.simple = "bar" }.to raise_error(Lita::ValidationError)
+    end
+  end
+
+  describe "a validated attribute with a conflicting default value" do
+    it "raises a ValidationError" do
+      expect do
+        subject.config :simple, default: :foo do
+          validate { |value| "must be :bar" unless value == :bar }
+        end
+      end.to raise_error(Lita::ValidationError, /must be :bar/)
+    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 and nested attributes" do
+    before do
+      subject.config :nested, type: Symbol, default: :foo do
+        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: "bar" do
+          validate { |value| "must include bar" unless value.include?("bar") }
+        end
+
+        config :bar, type: Symbol
+      end
+    end
+
+    it "can get the first nested attribute" do
+      expect(config.nested.foo).to eq("bar")
+    end
+
+    it "can set the first nested attribute" do
+      config.nested.foo = "foo bar baz"
+      expect(config.nested.foo).to eq("foo bar baz")
+    end
+
+    it "has working validation" do
+      expect(Lita.logger).to receive(:fatal).with(
+        /Validation error on attribute "foo": must include bar/
+      )
+      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(Lita.logger).to receive(:fatal).with(
+        /Configuration type error: "bar" must be one of: Symbol/
+      )
+      expect { config.nested.bar = "not a symbol" }.to raise_error(Lita::ValidationError)
+    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,114 @@
+# frozen_string_literal: true
+
+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(:config_validator_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(:config_validator_test) do
+        config :foo, required: true
+      end
+
+      expect(Lita.logger).to receive(:fatal).with(
+        /Configuration attribute "foo" is required for "config_validator_test" adapter/
+      )
+      expect { subject.call }.to raise_error(SystemExit)
+    end
+
+    it "has no effect if all adapters with nested configuration have valid configuration" do
+      registry.register_adapter(:config_validator_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(:config_validator_test) do
+        config :foo do
+          config :bar, required: true
+        end
+      end
+
+      expect(Lita.logger).to receive(:fatal).with(
+        /Configuration attribute "foo\.bar" is required for "config_validator_test" adapter/
+      )
+      expect { subject.call }.to raise_error(SystemExit)
+    end
+
+    it "uses the right namespace for a nested attribute when a previous nesting has been visited" do
+      registry.register_adapter(:config_validator_test) do
+        config :foo do
+          config :bar
+        end
+
+        config :one do
+          config :two, required: true
+        end
+      end
+
+      expect(Lita.logger).to receive(:fatal).with(
+        /Configuration attribute "one\.two" is required for "config_validator_test" adapter/
+      )
+      expect { subject.call }.to raise_error(SystemExit)
+    end
+
+    it "has no effect if all handlers have valid configuration" do
+      registry.register_handler(:config_validator_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(:config_validator_test) do
+        config :foo, required: true
+      end
+
+      expect(Lita.logger).to receive(:fatal).with(
+        /Configuration attribute "foo" is required for "config_validator_test" handler/
+      )
+      expect { subject.call }.to raise_error(SystemExit)
+    end
+
+    it "has no effect if all handlers with nested configuration have valid configuration" do
+      registry.register_handler(:config_validator_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(:config_validator_test) do
+        config :foo do
+          config :bar, required: true
+        end
+      end
+
+      expect(Lita.logger).to receive(:fatal).with(
+        /Configuration attribute "foo\.bar" is required for "config_validator_test" handler/
+      )
+      expect { subject.call }.to raise_error(SystemExit)
+    end
+  end
+end

data/spec/lita/default_configuration_spec.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::DefaultConfiguration, lita: true do
+  subject { described_class.new(registry) }
+
+  let(:config) { subject.build }
+
+  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
+        # rubocop:disable Lint/EmptyBlock
+        registry.register_adapter(:foo) {}
+        # rubocop:enable Lint/EmptyBlock
+
+        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 no attribute for the handler" do
+        # rubocop:disable Lint/EmptyBlock
+        registry.register_handler(:foo) {}
+        # rubocop:enable Lint/EmptyBlock
+
+        expect(config.handlers).not_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
+  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).not_to be_empty
+    end
+
+    it "can add middleware with arguments" do
+      middleware = double("a rack middleware")
+
+      config.http.middleware.use(middleware, "argument") do
+        "block"
+      end
+
+      expect(config.http.middleware).not_to be_empty
+    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
+  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 no default locale" do
+      expect(config.robot.locale).to be_nil
+    end
+
+    it "can set a locale" do
+      config.robot.locale = :es
+
+      expect(config.robot.locale).to eq(:es)
+    end
+
+    it "has no default locale" do
+      expect(config.robot.default_locale).to be_nil
+    end
+
+    it "can set a default locale" do
+      config.robot.default_locale = :es
+
+      expect(config.robot.default_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 "has a default redis namespace" do
+      expect(config.robot.redis_namespace).to eq("lita.test")
+    end
+
+    it "can set a redis namespace" do
+      config.robot.redis_namespace = "mylitabot"
+
+      expect(config.robot.redis_namespace).to eq("mylitabot")
+    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(Lita.logger).to receive(:fatal).with(
+        /Validation error on attribute "log_level": must be one of/
+      )
+      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