foobara 0.5.10 → 0.6.2

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

@@ -1,420 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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