foobara 0.3.0 → 0.4.1

data/projects/entities/spec/builtin_types/model_spec.rb

@@ -0,0 +1,420 @@
+RSpec.describe ":model" do
+  after do
+    Foobara.reset_alls
+    [
+      :SomeModel,
+      :SomeOrg,
+      :SomeDomain
+    ].each do |const|
+      Object.send(:remove_const, const) if Object.const_defined?(const)
+    end
+  end
+
+  let(:type) do
+    Foobara::Domain.current.foobara_type_from_declaration(type_declaration)
+  end
+
+  let(:type_declaration) do
+    {
+      type: :model,
+      name: model_name,
+      attributes_declaration:
+    }
+  end
+  let(:model_name) { "SomeModel" }
+  let(:attributes_declaration) do
+    {
+      foo: { type: :integer, max: 10 },
+      bar: { type: :string, required: true }
+    }
+  end
+
+  let(:constructed_model) { type.target_class }
+
+  describe ".organization_name" do
+    subject { constructed_model.organization_name }
+
+    it { is_expected.to be_a(String) }
+  end
+
+  describe ".domain_name" do
+    subject { constructed_model.domain_name }
+
+    it { is_expected.to be_a(String) }
+  end
+
+  it "creates a type that targets a Model subclass" do
+    expect(type).to be_a(Foobara::Types::Type)
+    expect(constructed_model.model_name).to eq("SomeModel")
+
+    value = constructed_model.new
+
+    expect(value.model_name).to eq("SomeModel")
+
+    expect(value).to be_a(Foobara::Model)
+    expect(value).to_not be_valid
+
+    value.foo = "10"
+
+    expect(value.foo).to be(10)
+    expect(value).to_not be_valid
+
+    value.bar = "baz"
+
+    expect(value).to be_valid
+    expect(value.validation_errors).to be_empty
+
+    value.foo = "invalid"
+
+    expect(value).to_not be_valid
+
+    expect(value.validation_errors.size).to eq(1)
+    expect(value.validation_errors.first.to_h).to eq(
+      key: "data.foo.cannot_cast",
+      path: [:foo],
+      runtime_path: [],
+      category: :data,
+      is_fatal: true,
+      symbol: :cannot_cast,
+      message: 'At foo: Cannot cast "invalid" to an integer. Expected it to be a Integer, ' \
+               "or be a string of digits optionally with a minus sign in front",
+      context: { cast_to: { type: :integer, max: 10 }, value: "invalid" }
+    )
+
+    value = constructed_model.new(foo: 4, bar: "baz")
+    expect(value).to be_valid
+
+    value.write_attribute!(:foo, 5)
+    expect(value.foo).to eq(5)
+
+    expect {
+      value.write_attribute!(:foo, "asdf")
+    }.to raise_error(Foobara::Value::Processor::Casting::CannotCastError)
+
+    value.write_attributes(foo: 6)
+    expect(value.foo).to eq(6)
+
+    value.write_attributes!(foo: 7)
+    expect(value.foo).to eq(7)
+
+    expect {
+      value.write_attributes!(foo: "asdf")
+    }.to raise_error(Foobara::Value::Processor::Casting::CannotCastError)
+  end
+
+  context "when mutable is false" do
+    it "cannot be written to" do
+      record = constructed_model.new({ foo: 4, bar: "baz" }, mutable: false)
+      expect {
+        record.bar = "asdf"
+      }.to raise_error(Foobara::Model::AttributeIsImmutableError)
+    end
+  end
+
+  context "when mutable is false at model class level" do
+    let(:type_declaration) do
+      {
+        type: :model,
+        name: model_name,
+        attributes_declaration:,
+        mutable: false
+      }
+    end
+
+    it "cannot be written to" do
+      record = constructed_model.new(foo: 4, bar: "baz")
+      expect {
+        record.bar = "asdf"
+      }.to raise_error(Foobara::Model::AttributeIsImmutableError)
+    end
+  end
+
+  context "when attribute isn't mutable" do
+    it "cannot be written to" do
+      record = constructed_model.new({ foo: 4, bar: "baz" }, mutable: [:foo])
+
+      expect {
+        record.bar = "asdf"
+      }.to raise_error(Foobara::Model::AttributeIsImmutableError)
+    end
+  end
+
+  context "when model has a domain but no organization (ie is in the global organization)" do
+    let(:domain) do
+      stub_module "SomeOrg" do
+        foobara_organization!
+      end
+
+      stub_module "SomeOrg::SomeDomain" do
+        foobara_domain!
+      end
+    end
+
+    let(:type_declaration) do
+      {
+        type: :model,
+        name: model_name,
+        attributes_declaration:,
+        model_module: domain.foobara_full_domain_name
+      }
+    end
+
+    describe "#full_model_name" do
+      subject { type.target_class.full_model_name }
+
+      it { is_expected.to eq("SomeOrg::SomeDomain::#{model_name}") }
+    end
+  end
+
+  context "when model is in global domain" do
+    let(:type_declaration) do
+      {
+        type: :model,
+        name: model_name,
+        attributes_declaration:
+      }
+    end
+
+    describe "#full_model_name" do
+      subject { type.target_class.full_model_name }
+
+      it { is_expected.to eq(model_name) }
+    end
+  end
+
+  it "sets model_class and model_base_class" do
+    expect(type.declaration_data[:model_class]).to eq("SomeModel")
+    expect(type.declaration_data[:model_base_class]).to eq("Foobara::Model")
+  end
+
+  it "extends duck" do
+    duck = Foobara::Namespace.global.foobara_lookup_type!(:duck)
+    expect(type.extends?(duck)).to be(true)
+  end
+
+  context "when model class name is given but doesn't exist" do
+    let(:type_declaration) do
+      {
+        type: :model,
+        name: model_name,
+        attributes_declaration:,
+        model_class: model_name,
+        model_base_class: "Foobara::Model"
+      }
+    end
+
+    it "creates the model class" do
+      Foobara::Model.deanonymize_class(type.target_class)
+      expect(type.target_class).to be(SomeModel)
+    end
+  end
+
+  context "when model name has a prefix" do
+    let(:type_declaration) do
+      {
+        type: :model,
+        name: model_name,
+        attributes_declaration:,
+        model_class: model_name,
+        model_base_class: "Foobara::Model",
+        model_module: some_domain_module
+      }
+    end
+
+    let(:some_domain_module) do
+      some_organization_module
+      stub_module("SomeOrg::SomeDomain") do
+        foobara_domain!
+      end
+    end
+    let(:some_organization_module) do
+      stub_module("SomeOrg") do
+        foobara_organization!
+      end
+    end
+
+    let(:model_name) { "SomePrefix::SomeModel" }
+
+    it "creates the model class" do
+      Foobara::Model.deanonymize_class(type.target_class)
+      expect(type.target_class).to be(SomeOrg::SomeDomain::SomePrefix::SomeModel)
+      expect(type.scoped_full_path).to eq(["SomeOrg", "SomeDomain", "SomePrefix", "SomeModel"])
+      expect(type.scoped_prefix).to eq(["SomePrefix"])
+    end
+  end
+
+  describe "#process_value!" do
+    let(:value) { type.process_value!(value_to_process) }
+
+    context "when instantiating via type declaration instead of class" do
+      let(:value_to_process) do
+        { foo: "10", bar: :baz }
+      end
+
+      it "constructs value" do
+        expect(value).to be_a(constructed_model)
+      end
+    end
+
+    context "when instantiating via model instance" do
+      let(:value_to_process) do
+        constructed_model.new(attributes)
+      end
+
+      let(:attributes) do
+        { "foo" => 10, "bar" => :baz }
+      end
+
+      it "constructs value" do
+        expect(value).to be_a(constructed_model)
+        expect(value).to be(value_to_process)
+        expect(value).to be_valid
+      end
+
+      context "when invalid attributes" do
+        let(:attributes) do
+          { foo: "invalid", bar: :baz }
+        end
+
+        it "explodes" do
+          expect { value }.to raise_error(
+            Foobara::Value::Processor::Casting::CannotCastError,
+            /Expected it to be a Integer, or be a string of digits optionally with a minus sign in front\z/
+          ) { |error| expect(error.path).to eq([:foo]) }
+        end
+      end
+    end
+  end
+
+  describe "#possible_errors" do
+    it "gives expected possible errors" do
+      expect(type.possible_errors.to_h { |p| [p.key.to_sym, p.error_class] }).to eq(
+        "data.cannot_cast": Foobara::Value::Processor::Casting::CannotCastError,
+        "data.missing_required_attribute": Foobara::BuiltinTypes::Attributes::SupportedValidators::Required::
+            MissingRequiredAttributeError,
+        "data.unexpected_attributes": Foobara::BuiltinTypes::Attributes::SupportedProcessors::
+            ElementTypeDeclarations::UnexpectedAttributesError,
+        "data.bar.missing_required_attribute": Foobara::BuiltinTypes::Attributes::SupportedValidators::Required::
+            MissingRequiredAttributeError,
+        "data.foo.cannot_cast": Foobara::Value::Processor::Casting::CannotCastError,
+        "data.foo.max_exceeded": Foobara::BuiltinTypes::Number::SupportedValidators::Max::MaxExceededError,
+        "data.bar.cannot_cast": Foobara::Value::Processor::Casting::CannotCastError
+      )
+    end
+  end
+
+  describe "registering model on a namespace" do
+    let(:namespace) do
+      domain.foobara_type_builder
+    end
+
+    let(:domain) do
+      Foobara::GlobalDomain
+    end
+
+    around do |example|
+      Foobara::Namespace.use domain do
+        example.run
+      end
+    end
+
+    before do
+      type
+      domain
+    end
+
+    it "can be used by symbol" do
+      expect(namespace.type_for_declaration(:SomeModel)).to be(type)
+    end
+
+    context "when used as attribute type" do
+      let(:new_type) do
+        namespace.type_for_declaration(
+          first_name: :string,
+          some_model: :SomeModel
+        )
+      end
+      let(:actual_value) do
+        new_type.process_value!(
+          first_name: "SomeFirstName",
+          some_model: {
+            foo: "2",
+            bar: :whatever
+          }
+        )
+      end
+      let(:expected_value) do
+        {
+          first_name: "SomeFirstName",
+          some_model: constructed_model.new({ foo: 2, bar: "whatever" }, validate: false)
+        }
+      end
+
+      it "can process a value" do
+        expect(actual_value).to eq(expected_value)
+        expect(actual_value).to_not be(expected_value)
+        expect(actual_value.hash).to eq(expected_value.hash)
+        expect(actual_value.eql?(expected_value)).to be(true)
+      end
+
+      describe "Foobara.manifest" do
+        it "contains the type for the model" do
+          type_manifest = Foobara.manifest[:type][:SomeModel]
+          expect(type_manifest[:declaration_data][:name]).to eq("SomeModel")
+        end
+      end
+    end
+  end
+
+  describe "using model_module to specify domain" do
+    let(:domain_module) {
+      stub_module "SomeDomain" do
+        foobara_domain!
+      end
+    }
+    let(:type_declaration) do
+      {
+        type: :model,
+        name: model_name,
+        attributes_declaration:,
+        model_module:
+      }
+    end
+    let(:model_module) { domain_module }
+    let(:type) do
+      domain_module.foobara_type_from_declaration(type_declaration)
+    end
+
+    let(:constructed_model) do
+      type.target_class
+    end
+
+    it "can be used by symbol" do
+      expect(type.name).to eq("SomeModel")
+      expect(domain_module.foobara_lookup_type!(:SomeModel)).to be(type)
+    end
+
+    it "is registered where expected" do
+      expect(type.full_type_name).to eq("SomeDomain::SomeModel")
+      expect(constructed_model.domain.foobara_domain_name).to eq("SomeDomain")
+      expect(constructed_model.domain).to be(domain_module)
+    end
+
+    context "when using domain name instead" do
+      let(:model_module) { "SomeDomain" }
+
+      it "still works" do
+        expect(type.full_type_name).to eq("SomeDomain::SomeModel")
+        expect(constructed_model.domain.foobara_domain_name).to eq("SomeDomain")
+      end
+    end
+  end
+
+  describe "#to_json" do
+    subject { instance.to_json }
+
+    let(:instance) { constructed_model.new(foo: 1, bar: "adf") }
+
+    it { is_expected.to eq('{"foo":1,"bar":"adf"}') }
+  end
+end

data/projects/entities/spec/detached_entity/casting_spec.rb

@@ -0,0 +1,31 @@
+RSpec.describe Foobara::DetachedEntity do
+  after { Foobara.reset_alls }
+
+  let(:detached_entity_class) do
+    stub_class("SomeDetachedEntity", described_class) do
+      attributes do
+        id :integer, :required
+        foo :string, :required
+      end
+
+      primary_key :id
+    end
+  end
+
+  context "when casting from a primary key" do
+    it "results in an unloaded DetachedEntity" do
+      outcome = detached_entity_class.model_type.process_value(5)
+      expect(outcome).to be_success
+
+      result = outcome.result
+
+      expect(result).to be_a(described_class)
+
+      expect(result).to_not be_loaded
+      expect(result.id).to eq(5)
+      expect {
+        result.foo
+      }.to raise_error(described_class::CannotReadAttributeOnUnloadedRecordError)
+    end
+  end
+end

data/projects/entities/spec/entity/concerns/associations_spec.rb

@@ -0,0 +1,73 @@
+RSpec.describe Foobara::Entity do
+  after { Foobara.reset_alls }
+
+  before do
+    Foobara::Persistence.default_crud_driver = Foobara::Persistence::CrudDrivers::InMemory.new
+
+    stub_class "InnerMostEntity", described_class do
+      attributes do
+        id :integer
+        name :string, :required
+        password :string, :required, :sensitive
+      end
+      primary_key :id
+    end
+    stub_class "InnerEntity", described_class do
+      attributes do
+        id :integer
+        name :string, :required
+        password :string, :required, :sensitive
+        inner_most_entity InnerMostEntity, :sensitive
+        inner_most_entities [InnerMostEntity], default: []
+      end
+      primary_key :id
+    end
+    stub_class "OuterMostEntity", described_class do
+      attributes do
+        id :integer
+        name :string, :required
+        password :string, :required, :sensitive
+        inner_entities1 [InnerEntity], :sensitive, default: []
+        inner_entities2 [InnerEntity], default: []
+      end
+      primary_key :id
+      # TODO: test using an invalid path! Should blow up upon declaring the delegated
+      # attribute not upon accessing it!
+      delegate_attribute :inner_name, [:inner_entities1, :"0", :inner_most_entity, :name]
+    end
+  end
+
+  describe ".construct_deep_associations" do
+    it "gives a mapping of data path to type" do
+      associations = Foobara::DetachedEntity.construct_deep_associations(OuterMostEntity.model_type)
+
+      expect(associations.keys).to contain_exactly(
+        "inner_entities1.#",
+        "inner_entities1.#.inner_most_entities.#",
+        "inner_entities1.#.inner_most_entity",
+        "inner_entities2.#",
+        "inner_entities2.#.inner_most_entities.#",
+        "inner_entities2.#.inner_most_entity"
+      )
+    end
+  end
+
+  describe ".model_type.type_at_path" do
+    it "returns the expected type" do
+      expect(
+        OuterMostEntity.model_type.type_at_path("inner_entities2.#.inner_most_entities.#.name")
+      ).to eq(Foobara::BuiltinTypes[:string])
+    end
+  end
+
+  describe ".construct_associations" do
+    it "gives a mapping of data path to type" do
+      associations = Foobara::DetachedEntity.construct_associations(OuterMostEntity.model_type)
+
+      expect(associations.keys).to contain_exactly(
+        "inner_entities1.#",
+        "inner_entities2.#"
+      )
+    end
+  end
+end