foobara 0.3.0 → 0.4.1

data/projects/typesystem/spec/common/error_collection_spec.rb

@@ -0,0 +1,77 @@
+RSpec.describe Foobara::ErrorCollection do
+  let(:error_collection) { described_class.new }
+
+  describe "#success?" do
+    context "when no errors" do
+      it { is_expected.to be_success }
+    end
+  end
+
+  describe "#add_error" do
+    let(:symbol) { :s }
+    let(:message) { "m" }
+    let(:context) { { foo: :bar } }
+
+    let(:error_class) do
+      Foobara::Error.subclass(symbol:, message:, context: { foo: :symbol }, is_fatal: true)
+    end
+    let(:error) { error_class.new(context:) }
+
+    context "when adding error instance" do
+      it "creates and adds an error" do
+        expect(error_collection).to be_empty
+
+        error_collection.add_error(error)
+
+        expect(error_collection).to_not be_empty
+        expect(error_collection.size).to eq(1)
+        error = error_collection.first
+        expect(error).to be_a(Foobara::Error)
+        expect(error.is_fatal).to be(true)
+        expect(error.symbol).to eq(symbol)
+        expect(error.message).to eq(message)
+        expect(error.context).to eq(context)
+      end
+    end
+
+    # Do we really need to support this?
+    context "when adding error by hash" do
+      around do |example|
+        Foobara::TypeDeclarations.with_validate_error_context_disabled do
+          example.run
+        end
+      end
+
+      let(:error_hash) do
+        {
+          symbol:,
+          message:,
+          context:
+        }
+      end
+
+      it "creates and adds an error" do
+        expect(error_collection).to be_empty
+
+        error_collection.add_error(error_hash)
+
+        expect(error_collection).to_not be_empty
+        expect(error_collection.size).to eq(1)
+        error = error_collection.first
+        expect(error).to be_a(Foobara::Error)
+        expect(error.symbol).to eq(symbol)
+        expect(error.message).to eq(message)
+        expect(error.context).to eq(context)
+      end
+    end
+
+    context "when passing the same error twice" do
+      it "explodes" do
+        error_collection.add_error(error)
+        expect {
+          error_collection.add_error(error)
+        }.to raise_error(described_class::ErrorAlreadySetError)
+      end
+    end
+  end
+end

data/projects/typesystem/spec/common/error_key_spec.rb

@@ -0,0 +1,56 @@
+RSpec.describe Foobara::ErrorKey do
+  let(:key) { described_class.new(category:, path:, runtime_path:, symbol:) }
+
+  let(:category) { "some_category" }
+  let(:path) { "some_path" }
+  let(:runtime_path) { "some_runtime_path" }
+  let(:symbol) { "some_symbol" }
+
+  describe ".prepend_path" do
+    subject { described_class.prepend_path(key, new_parts) }
+
+    let(:new_parts) { [:path1, :path2] }
+
+    context "when ErrorKey" do
+      it { is_expected.to eq("some_runtime_path>some_category.path1.path2.some_path.some_symbol") }
+    end
+
+    context "when String" do
+      let(:key) { super().to_s }
+
+      it { is_expected.to eq("some_runtime_path>some_category.path1.path2.some_path.some_symbol") }
+    end
+  end
+
+  describe ".prepend_runtime_path" do
+    subject { described_class.prepend_runtime_path(key, new_parts) }
+
+    let(:new_parts) { [:path1, :path2] }
+
+    context "when ErrorKey" do
+      it { is_expected.to eq("path1>path2>some_runtime_path>some_category.some_path.some_symbol") }
+    end
+
+    context "when String" do
+      let(:key) { super().to_s }
+
+      it { is_expected.to eq("path1>path2>some_runtime_path>some_category.some_path.some_symbol") }
+    end
+  end
+
+  describe ".to_h" do
+    subject { described_class.to_h(key) }
+
+    let(:key) { "path1>path2>some_category.some_path.some_symbol" }
+    let(:expected_hash) do
+      {
+        category: :some_category,
+        runtime_path: [:path1, :path2],
+        path: [:some_path],
+        symbol: :some_symbol
+      }
+    end
+
+    it { is_expected.to eq(expected_hash) }
+  end
+end

data/projects/typesystem/spec/common/outcome_spec.rb

@@ -0,0 +1,65 @@
+RSpec.describe Foobara::Outcome do
+  around do |example|
+    Foobara::TypeDeclarations.with_validate_error_context_disabled do
+      example.run
+    end
+  end
+
+  describe ".raise!" do
+    subject { described_class.raise!(errors) }
+
+    context "when errors present" do
+      let(:errors) { [Foobara::Error.new(message: "message")] }
+
+      it { is_expected_to_raise(Foobara::Error) }
+    end
+
+    context "when no errors" do
+      let(:errors) { [] }
+
+      it { is_expected_to_not_raise }
+    end
+  end
+
+  describe "#raise!" do
+    subject { outcome.raise! }
+
+    context "when error present" do
+      let(:outcome) { described_class.error(Foobara::Error.new(message: "message")) }
+
+      it { is_expected_to_raise(Foobara::Error) }
+    end
+
+    context "when errors present" do
+      let(:outcome) do
+        described_class.errors(
+          Foobara::Error.new(symbol: :error1, message: "message1"),
+          Foobara::Error.new(symbol: :error2, message: "message2")
+        )
+      end
+
+      it { is_expected_to_raise(Foobara::Outcome::UnsuccessfulOutcomeError, /message1, message2/) }
+    end
+
+    context "when no errors" do
+      let(:outcome) { described_class.success(:foo) }
+
+      it { is_expected_to_not_raise }
+    end
+  end
+
+  describe "#errors_sentence" do
+    subject { outcome.errors_sentence }
+
+    let(:outcome) do
+      described_class.errors(
+        [
+          Foobara::Error.new(symbol: :error1, message: "message1"),
+          Foobara::Error.new(symbol: :error2, message: "message2")
+        ]
+      )
+    end
+
+    it { is_expected.to eq("message1, and message2") }
+  end
+end

data/projects/typesystem/spec/common/possible_error_spec.rb

@@ -0,0 +1,17 @@
+RSpec.describe Foobara::PossibleError do
+  describe "#initialize" do
+    context "with key and error_class" do
+      let(:possible_error) { described_class.new(error_class, key:) }
+
+      let(:key) { "data.foo.bar.baz" }
+      let(:error_class) { Foobara::RuntimeError }
+
+      it "creates an instance" do
+        expect(possible_error.key.path).to eq([:foo, :bar])
+        expect(possible_error.key.symbol).to eq(:baz)
+        expect(possible_error.key.category).to eq(:data)
+        expect(possible_error.error_class).to eq(Foobara::RuntimeError)
+      end
+    end
+  end
+end

data/projects/typesystem/spec/concerns/concern_spec.rb

@@ -0,0 +1,122 @@
+RSpec.describe "Foobara::Concern" do
+  context "when inheriting through another concern" do
+    let(:root_concern) do
+      stub_module "SomeModule" do
+        include Foobara::Concern
+
+        inherited_overridable_class_attr_accessor :some_delegated_value
+        inherited_overridable_class_attr_accessor :some_delegated_value2
+
+        on_include do
+          singleton_class.define_method :name_under do
+            Foobara::Util.underscore(name)
+          end
+        end
+      end
+
+      stub_module "SomeModule::ClassMethods" do
+        attr_accessor :some_non_delegated_value
+
+        def foo?
+          true
+        end
+      end
+
+      SomeModule
+    end
+
+    let(:sub_concern) do
+      r = root_concern
+
+      stub_module "SubConcern" do
+        include Foobara::Concern
+        include r
+      end
+    end
+
+    let(:klass) do
+      c = sub_concern
+
+      stub_class :SomeClass do
+        include c
+      end
+    end
+
+    it "passes class methods and effects of on_include through" do
+      expect(klass.singleton_class.ancestors.map(&:name)).to include("SubConcern::ClassMethods")
+      expect(klass.foo?).to be(true)
+      expect(klass.name_under).to eq("some_class")
+      klass.some_non_delegated_value = "hi!"
+      expect(klass.some_non_delegated_value).to eq("hi!")
+    end
+
+    context "when subclassing a class that included a concern with class methods" do
+      let(:subclass) do
+        stub_class :Subclass, klass
+      end
+
+      it "sets up the subclass and its instances correctly" do
+        expect(klass.singleton_class.ancestors.map(&:name)).to include("SubConcern::ClassMethods")
+        expect(klass.foo?).to be(true)
+        expect(klass.name_under).to eq("some_class")
+
+        klass.some_non_delegated_value = "foo"
+        expect(klass.some_non_delegated_value).to eq("foo")
+        expect(subclass.some_non_delegated_value).to be_nil
+        subclass.some_non_delegated_value = "bar"
+        expect(subclass.some_non_delegated_value).to eq("bar")
+        expect(klass.some_non_delegated_value).to eq("foo")
+      end
+    end
+
+    context "when there are delegated class methods" do
+      let(:class_a1) do
+        stub_class(:ClassA1).tap do |klass|
+          klass.include root_concern
+        end
+      end
+
+      let(:class_a2) do
+        stub_class(:ClassA2, ClassA1)
+      end
+
+      let(:class_a3) do
+        stub_class(:ClassA3, ClassA2)
+      end
+
+      let(:class_b1) do
+        stub_class(:ClassB1).tap do |klass|
+          klass.include root_concern
+        end
+      end
+
+      let(:all_classes) do
+        [class_a1, class_a2, class_a3, class_b1]
+      end
+
+      it "shares state in inheritance chains starting at its include." do
+        all_classes.each do |klass|
+          expect(klass.some_delegated_value).to be_nil
+        end
+
+        class_a1.some_delegated_value = "foo"
+        expect(class_a1.some_delegated_value).to eq("foo")
+        expect(class_a2.some_delegated_value).to eq("foo")
+        expect(class_a3.some_delegated_value).to eq("foo")
+        expect(class_b1.some_delegated_value).to be_nil
+
+        class_b1.some_delegated_value = "bar"
+        expect(class_a1.some_delegated_value).to eq("foo")
+        expect(class_a2.some_delegated_value).to eq("foo")
+        expect(class_a3.some_delegated_value).to eq("foo")
+        expect(class_b1.some_delegated_value).to eq("bar")
+
+        class_a3.some_delegated_value = "baz"
+        expect(class_a1.some_delegated_value).to eq("foo")
+        expect(class_a2.some_delegated_value).to eq("foo")
+        expect(class_a3.some_delegated_value).to eq("baz")
+        expect(class_b1.some_delegated_value).to eq("bar")
+      end
+    end
+  end
+end

data/projects/typesystem/spec/enumerated/accessors_spec.rb

@@ -0,0 +1,182 @@
+RSpec.describe Foobara::Enumerated::Accessors do
+  let(:enum_module) do
+    Module.new.tap do |m|
+      m.const_set(:FOO, :foo)
+      m.const_set(:BAR, :bar)
+      m.const_set(:BAZ, :baz)
+    end
+  end
+  let(:klass) do
+    Class.new do
+      include Foobara::Enumerated::Accessors
+
+      enumerated :some_enum, EnumModule
+    end
+  end
+  let(:object) { klass.new }
+
+  before do
+    stub_const("EnumModule", enum_module)
+  end
+
+  describe "setter/getter" do
+    subject {
+      object.some_enum = value
+      object.some_enum
+    }
+
+    context "when nil" do
+      let(:value) { nil }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "when valid symbol" do
+      let(:value) { :bar }
+
+      it { is_expected.to be :bar }
+    end
+
+    context "when valid string" do
+      let(:value) { "bar" }
+
+      it { is_expected.to be :bar }
+    end
+
+    context "when invalid value" do
+      let(:value) { "not a member of the enum" }
+
+      it { is_expected_to_raise(Foobara::Enumerated::Accessors::ValueNotAllowed) }
+    end
+  end
+
+  describe ".enumerated_type_metadata" do
+    it "gives the reflection information" do
+      meta = klass.enumerated_type_metadata[:some_enum]
+
+      expect(meta.keys).to contain_exactly(:values, :original_values_source, :values_source)
+      expect(meta[:original_values_source]).to be(EnumModule)
+      expect(meta[:values_source]).to be(EnumModule)
+
+      values = meta[:values]
+
+      expect(values).to be_a(Foobara::Enumerated::Values)
+      expect(values.all).to eq(BAR: :bar, BAZ: :baz, FOO: :foo)
+
+      expect(values.BAR).to be(:bar)
+      expect(values.BAZ).to be(:baz)
+      expect(values.FOO).to be(:foo)
+    end
+  end
+
+  describe "automatic enumeration module discovery" do
+    let(:klass) do
+      Class.new do
+        include Foobara::Enumerated::Accessors
+
+        enumerated :some_enum
+      end
+    end
+
+    context "when at top-level with expected name" do
+      before do
+        stub_const("SomeEnum", EnumModule)
+      end
+
+      describe ".enumerated_type_metadata" do
+        it "has the right module" do
+          meta = klass.enumerated_type_metadata[:some_enum]
+
+          expect(meta.keys).to contain_exactly(:values, :original_values_source, :values_source)
+          expect(meta[:original_values_source]).to be_nil
+          expect(meta[:values_source]).to be(EnumModule)
+
+          values = meta[:values]
+
+          expect(values).to be_a(Foobara::Enumerated::Values)
+          expect(values.all).to eq(BAR: :bar, BAZ: :baz, FOO: :foo)
+
+          expect(values.BAR).to be(:bar)
+          expect(values.BAZ).to be(:baz)
+          expect(values.FOO).to be(:foo)
+        end
+      end
+    end
+
+    context "when in class itself" do
+      let(:klass) do
+        Class.new do
+          const_set("SomeEnum", EnumModule)
+
+          include Foobara::Enumerated::Accessors
+
+          enumerated :some_enum
+        end
+      end
+
+      describe ".enumerated_type_metadata" do
+        it "has the right module" do
+          meta = klass.enumerated_type_metadata[:some_enum]
+
+          expect(meta.keys).to contain_exactly(:values, :original_values_source, :values_source)
+          expect(meta[:original_values_source]).to be_nil
+          expect(meta[:values_source]).to be(EnumModule)
+
+          values = meta[:values]
+
+          expect(values).to be_a(Foobara::Enumerated::Values)
+          expect(values.all).to eq(BAR: :bar, BAZ: :baz, FOO: :foo)
+
+          expect(values.BAR).to be(:bar)
+          expect(values.BAZ).to be(:baz)
+          expect(values.FOO).to be(:foo)
+        end
+      end
+    end
+
+    context "when in heirarchy" do
+      let(:mod) do
+        Module.new do
+          const_set("SomeEnum", EnumModule)
+        end
+      end
+
+      let(:klass) do
+        Class.new do
+          class << self
+            def name
+              "Mod::Klass"
+            end
+          end
+
+          include Foobara::Enumerated::Accessors
+
+          enumerated :some_enum
+        end
+      end
+
+      before do
+        stub_const("Mod", mod)
+      end
+
+      describe ".enumerated_type_metadata" do
+        it "has the right module" do
+          meta = klass.enumerated_type_metadata[:some_enum]
+
+          expect(meta.keys).to contain_exactly(:values, :original_values_source, :values_source)
+          expect(meta[:original_values_source]).to be_nil
+          expect(meta[:values_source]).to be(EnumModule)
+
+          values = meta[:values]
+
+          expect(values).to be_a(Foobara::Enumerated::Values)
+          expect(values.all).to eq(BAR: :bar, BAZ: :baz, FOO: :foo)
+
+          expect(values.BAR).to be(:bar)
+          expect(values.BAZ).to be(:baz)
+          expect(values.FOO).to be(:foo)
+        end
+      end
+    end
+  end
+end

data/projects/typesystem/spec/enumerated/enumerated_spec.rb

@@ -0,0 +1,32 @@
+RSpec.describe Foobara::Enumerated do
+  describe ".make_module" do
+    let(:mod) { described_class.make_module(*values) }
+
+    let(:values) do
+      [
+        :"foo-bar",
+        :"bar-baz"
+      ]
+    end
+
+    it "has expected constants" do
+      expect(mod::FOO_BAR).to eq(:"foo-bar")
+    end
+
+    it "has delegated methods" do
+      expect(mod.all_values).to match_array(values)
+    end
+
+    context "when passing an array" do
+      let(:mod) { described_class.make_module(values) }
+
+      it "has expected constants" do
+        expect(mod::FOO_BAR).to eq(:"foo-bar")
+      end
+
+      it "has delegated methods" do
+        expect(mod.all_values).to match_array(values)
+      end
+    end
+  end
+end

data/projects/typesystem/spec/enumerated/values_spec.rb

@@ -0,0 +1,67 @@
+RSpec.describe Foobara::Enumerated::Values do
+  let(:values) do
+    described_class.new(enum_declaration)
+  end
+
+  context "when module" do
+    let(:enum_declaration) do
+      Module.new.tap do |m|
+        m.const_set(:FOO, :foo)
+        m.const_set(:BAR, :bar)
+        m.const_set(:BAZ, :baz)
+      end
+    end
+
+    it "constructs the values" do
+      expect(values.all_names).to contain_exactly(:FOO, :BAR, :BAZ)
+    end
+  end
+
+  context "when hash" do
+    let(:enum_declaration) do
+      {
+        FOO: :foo,
+        BAR: :bar,
+        BAZ: :baz
+      }
+    end
+
+    it "constructs the values" do
+      expect(values.all_names).to contain_exactly(:FOO, :BAR, :BAZ)
+      expect(values.all).to eq(enum_declaration)
+    end
+
+    describe "#value?" do
+      it "is answers if it is a value" do
+        expect(values.value?(:foo)).to be true
+        expect(values.value?(:asdf)).to be false
+      end
+    end
+  end
+
+  context "when array" do
+    let(:enum_declaration) do
+      [
+        :FOO,
+        :BAR,
+        :BAZ
+      ]
+    end
+
+    it "constructs the values" do
+      expect(values.all_names).to contain_exactly(:FOO, :BAR, :BAZ)
+      expect(values.all).to eq(enum_declaration.to_h { |key| [key, key] })
+    end
+
+    context "when splatted" do
+      let(:values) do
+        described_class.new(*enum_declaration)
+      end
+
+      it "constructs the values" do
+        expect(values.all_names).to contain_exactly(:FOO, :BAR, :BAZ)
+        expect(values.all).to eq(enum_declaration.to_h { |key| [key, key] })
+      end
+    end
+  end
+end

data/projects/typesystem/spec/foobara/foobara_spec.rb

@@ -0,0 +1,45 @@
+RSpec.describe Foobara do
+  describe ".raise_if_production!" do
+    let(:method_name) { "reset_alls" }
+
+    context "when FOOBARA_ENV is nil" do
+      stub_env_var("FOOBARA_ENV", nil)
+
+      it "raises MethodCantBeCalledInProductionError" do
+        expect {
+          described_class.raise_if_production!(method_name)
+        }.to raise_error(Foobara::MethodCantBeCalledInProductionError)
+      end
+    end
+
+    context "when in production environment" do
+      stub_env_var("FOOBARA_ENV", "production")
+
+      it "raises MethodCantBeCalledInProductionError" do
+        expect {
+          described_class.raise_if_production!(method_name)
+        }.to raise_error(Foobara::MethodCantBeCalledInProductionError)
+      end
+    end
+
+    context "when in test environment" do
+      stub_env_var("FOOBARA_ENV", "test")
+
+      it "doesn't raise MethodCantBeCalledInProductionError" do
+        expect {
+          described_class.raise_if_production!(method_name)
+        }.to_not raise_error
+      end
+    end
+
+    context "when in development environment" do
+      stub_env_var("FOOBARA_ENV", "development")
+
+      it "doesn't raise MethodCantBeCalledInProductionError" do
+        expect {
+          described_class.raise_if_production!(method_name)
+        }.to_not raise_error
+      end
+    end
+  end
+end