foobara 0.5.10 → 0.6.2

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

@@ -1,220 +0,0 @@
-# TODO: move this spec to the right project
-RSpec.describe Foobara::ModelAttributeHelpers::Concerns::AttributeHelpers do
-  after do
-    Foobara.reset_alls
-  end
-
-  before do
-    stub_class("SomeEntity", Foobara::Entity) do
-      attributes do
-        id :integer, :required, default: 10
-        name :string, :required
-        reviews [:integer], default: []
-      end
-      primary_key :id
-    end
-  end
-
-  describe ".attributes_for_update" do
-    it "calls attributes_for_aggregate_update" do
-      expect(SomeEntity.foobara_attributes_for_update(require_primary_key: false)).to be_a(Hash)
-    end
-  end
-
-  describe ".attributes_for_atom_update" do
-    before do
-      stub_class("SomeOtherEntity", Foobara::Entity) do
-        attributes do
-          id :integer
-          reviews :array do
-            stuff [SomeEntity], default: []
-          end
-        end
-        primary_key :id
-      end
-    end
-
-    it "returns a hash" do
-      expect(SomeOtherEntity.foobara_attributes_for_atom_update(require_primary_key: false)).to be_a(Hash)
-    end
-  end
-
-  describe ".attributes_for_create" do
-    before do
-      Foobara::Persistence.default_crud_driver = Foobara::Persistence::CrudDrivers::InMemory.new
-    end
-
-    let(:auth_user_class) do
-      stub_class("AuthUser", Foobara::Entity) do
-        attributes do
-          id :integer
-          username :string, :required
-        end
-
-        primary_key :id
-      end
-    end
-
-    let(:user_class) do
-      auth_user_class
-      w = writer
-      stub_class("User", Foobara::Entity) do
-        attributes do
-          id :integer
-          stuff do
-            things [:integer, AuthUser]
-          end
-          name :string, :required
-          ssn :string, :private
-        end
-        primary_key :id
-        delegate_attribute :username, [:stuff, :things, :"1", :username], writer: w
-      end
-    end
-    let(:writer) { true }
-
-    let(:for_create_declaration) do
-      for_create_type.declaration_data
-    end
-    let(:for_create_type) do
-      user_class.foobara_attributes_for_create(includes_primary_key:, include_private:, include_delegates:)
-    end
-
-    let(:includes_primary_key) { false }
-    let(:include_private) { true }
-    let(:include_delegates) { false }
-
-    it "removes the primary key" do
-      expect(for_create_declaration).to eq(
-        type: :attributes,
-        element_type_declarations: {
-          name: :string,
-          ssn: :string,
-          stuff: {
-            type: :attributes,
-            element_type_declarations: {
-              things: {
-                type: :tuple,
-                size: 2,
-                element_type_declarations: [
-                  :integer,
-                  :AuthUser
-                ]
-              }
-            }
-          }
-        },
-        required: [:name]
-      )
-    end
-
-    context "when there are delegated attributes and we set include_delegates" do
-      let(:include_delegates) { true }
-
-      it "includes the delegated attributes" do
-        expect(for_create_declaration).to eq(
-          type: :attributes,
-          element_type_declarations: {
-            name: :string,
-            ssn: :string,
-            username: :string,
-            stuff: {
-              type: :attributes,
-              element_type_declarations: {
-                things: {
-                  type: :tuple,
-                  size: 2,
-                  element_type_declarations: [
-                    :integer,
-                    :AuthUser
-                  ]
-                }
-              }
-            }
-          },
-          required: [:name]
-        )
-
-        AuthUser.transaction do
-          basil = AuthUser.create(username: "Basil")
-          barbara = User.create(name: "Barbara", stuff: { things: [100, basil] })
-
-          expect(barbara.username).to eq("Basil")
-          barbara.username = "NewName"
-          expect(basil.username).to eq("NewName")
-        end
-      end
-
-      context "when private attributes are excluded" do
-        let(:include_private) { false  }
-
-        it "does not include private attributes" do
-          expect(for_create_declaration).to eq(
-            type: :attributes,
-            element_type_declarations: {
-              name: :string,
-              username: :string,
-              stuff: {
-                type: :attributes,
-                element_type_declarations: {
-                  things: {
-                    type: :tuple,
-                    size: 2,
-                    element_type_declarations: [
-                      :integer,
-                      :AuthUser
-                    ]
-                  }
-                }
-              }
-            },
-            required: [:name]
-          )
-        end
-      end
-
-      context "when the primary key is included" do
-        let(:includes_primary_key) { true }
-
-        it "includes the primary key" do
-          expect(for_create_declaration).to eq(
-            type: :attributes,
-            element_type_declarations: {
-              id: :integer,
-              name: :string,
-              ssn: :string,
-              username: :string,
-              stuff: {
-                type: :attributes,
-                element_type_declarations: {
-                  things: {
-                    type: :tuple,
-                    size: 2,
-                    element_type_declarations: [
-                      :integer,
-                      :AuthUser
-                    ]
-                  }
-                }
-              }
-            },
-            required: [:name]
-          )
-        end
-      end
-    end
-  end
-
-  describe ".attributes_for_find_by" do
-    it "excludes required and defaults information" do
-      expect(SomeEntity.foobara_attributes_for_find_by).to eq(
-        type: :attributes,
-        element_type_declarations: {
-          id: :integer,
-          name: :string,
-          reviews: { type: :array, element_type_declaration: :integer }
-        }
-      )
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-RSpec.describe Foobara::Entity::Concerns::Callbacks do
-  around do |example|
-    Foobara::Persistence.default_crud_driver = Foobara::Persistence::CrudDrivers::InMemory.new
-
-    Foobara::Persistence.default_base.transaction do
-      example.run
-    end
-  end
-
-  after do
-    Foobara.reset_alls
-  end
-
-  let(:entity_class) do
-    stub_class = ->(klass) { stub_const(klass.name, klass) }
-
-    Class.new(Foobara::Entity) do
-      class << self
-        def name
-          "SomeEntity"
-        end
-      end
-
-      stub_class.call(self)
-
-      attributes pk: :integer,
-                 foo: :integer,
-                 bar: :symbol
-
-      primary_key :pk
-    end
-  end
-
-  describe ".after_any_action" do
-    let(:record) { entity_class.create(foo: 10) }
-
-    let(:calls) { [] }
-
-    before do
-      record.after_any_action do |**opts|
-        calls << opts
-      end
-    end
-
-    it "can create, load, and update records" do
-      expect(calls).to be_empty
-      expect(record).to be_dirty
-
-      record.foo = 11
-
-      expect(calls.size).to eq(1)
-      expect(calls.last).to eq(
-        record:,
-        action: :attribute_changed,
-        attribute_name: :foo,
-        old_value: 10,
-        new_value: 11
-      )
-    end
-  end
-end

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

@@ -1,213 +0,0 @@
-RSpec.describe Foobara::Entity::Concerns::Initialization do
-  describe "#run" do
-    after do
-      Foobara.reset_alls
-    end
-
-    before do
-      Foobara::Persistence.default_crud_driver = Foobara::Persistence::CrudDrivers::InMemory.new
-    end
-
-    let(:base_class) do
-      stub_class = ->(klass) { stub_const(klass.name, klass) }
-
-      Class.new(Foobara::Entity) do
-        abstract
-
-        class << self
-          def name
-            "Base"
-          end
-        end
-
-        stub_class.call(self)
-
-        attributes id: :integer
-
-        primary_key :id
-      end
-    end
-
-    let(:user_class) do
-      stub_class = ->(klass) { stub_const(klass.name, klass) }
-
-      Class.new(base_class) do
-        class << self
-          def name
-            "User"
-          end
-        end
-
-        stub_class.call(self)
-
-        attributes name: { type: :string, required: true }
-      end
-    end
-
-    let(:person_class) do
-      user_class
-
-      stub_class = ->(klass) { stub_const(klass.name, klass) }
-
-      Class.new(base_class) do
-        class << self
-          def name
-            "Person"
-          end
-        end
-
-        abstract
-
-        stub_class.call(self)
-
-        attributes user: User
-      end
-    end
-
-    let(:applicant_class) do
-      stub_class = ->(klass) { stub_const(klass.name, klass) }
-
-      Class.new(person_class) do
-        class << self
-          def name
-            "Applicant"
-          end
-        end
-
-        stub_class.call(self)
-
-        attributes is_active: :boolean
-
-        # TODO: make sure this isn't necessary outside of test suite where name is created later...
-        set_model_type
-      end
-    end
-
-    describe "creation through casting" do
-      def type_for_declaration(...)
-        Foobara::Domain.current.foobara_type_from_declaration(...)
-      end
-
-      let(:type) do
-        type_for_declaration([Applicant])
-      end
-
-      it "can create the record and nested associations, too" do
-        applicant_class.transaction do
-          expect(type.types_depended_on.map(&:type_symbol)).to contain_exactly(
-            :Applicant, :array, :attributes, :duck, :symbol
-          )
-
-          expect(type.deep_types_depended_on.map(&:type_symbol)).to contain_exactly(
-            :Applicant,
-            :User,
-            :array,
-            :associative_array,
-            :atomic_duck,
-            :attributes,
-            :boolean,
-            :detached_entity,
-            :duck,
-            :duckture,
-            :entity,
-            :integer,
-            :model,
-            :number,
-            :string,
-            :symbol
-          )
-
-          applicants = type.process_value!([
-                                             { user: { name: "Name1" }, is_active: false },
-                                             { user: { name: "Name2" }, is_active: true },
-                                             { user: { name: "Name3" }, is_active: false }
-                                           ])
-
-          expect(applicants).to all be_a(Applicant)
-          expect(applicants.map(&:id)).to all be_nil
-          expect(applicants.map(&:user).map(&:id)).to all be_nil
-
-          applicant = Applicant.find_by_attribute(:is_active, true)
-          expect(applicant.user.name).to eq("Name2")
-        end
-
-        User.transaction do
-          applicants = Applicant.all.to_a
-
-          expect(applicants).to all be_a(Applicant)
-          expect(applicants.map(&:id)).to all be_a(Integer)
-          expect(applicants.map(&:user).map(&:id)).to all be_a(Integer)
-
-          applicant = Applicant.find_by_attribute(:is_active, true)
-          expect(applicant.user.name).to eq("Name2")
-        end
-      end
-
-      context "when not allowed to create an association via casting" do
-        let(:user_class) do
-          stub_class = ->(klass) { stub_const(klass.name, klass) }
-
-          Class.new(base_class) do
-            class << self
-              def name
-                "User"
-              end
-
-              def can_be_created_through_casting?
-                false
-              end
-            end
-
-            stub_class.call(self)
-
-            attributes name: { type: :string, required: true }
-          end
-        end
-
-        it "fails when creating by hash but works when creating by foreign key" do
-          applicant_class.transaction do |tx|
-            outcome = type.process_value(
-              [
-                { user: { name: "Name1" }, is_active: false },
-                { user: { name: "Name2" }, is_active: true },
-                { user: { name: "Name3" }, is_active: false }
-              ]
-            )
-
-            expect(outcome).to_not be_success
-
-            error_hash = outcome.errors_hash
-
-            expect(error_hash.keys).to eq(
-              [
-                "data.0.user.cannot_cast",
-                "data.1.user.cannot_cast",
-                "data.2.user.cannot_cast"
-              ]
-            )
-
-            expect(outcome.errors.first.path).to eq([0, :user])
-
-            user1 = User.create(name: "Name1")
-            user2 = User.create(name: "Name2")
-            user3 = User.create(name: "Name3")
-
-            tx.flush!
-
-            outcome = type.process_value(
-              [
-                { user: user1.primary_key, is_active: false },
-                { user: user2.primary_key, is_active: true },
-                { user: user3.primary_key, is_active: false }
-              ]
-            )
-
-            expect(outcome).to be_success
-            applicants = Applicant.find_all_by_attribute(:is_active, true)
-            expect(applicants.map(&:user).map(&:name)).to eq(["Name2"])
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-RSpec.describe Foobara::Entity::Concerns::Mutations do
-  after do
-    Foobara.reset_alls
-  end
-
-  before do
-    Foobara::Persistence.default_crud_driver = Foobara::Persistence::CrudDrivers::InMemory.new
-  end
-
-  let(:capybara_class) do
-    stub_class "Capybara", Foobara::Entity do
-      attributes do
-        id :integer
-        name :string, :required
-        age :integer, :required
-      end
-
-      primary_key :id
-    end
-  end
-
-  describe "#update" do
-    it "updates the record in a persistent way" do
-      capybara = capybara_class.transaction do
-        Capybara.create(name: "Basil", age: 100)
-      end
-
-      expect {
-        Capybara.transaction do
-          record = Capybara.load(capybara.id)
-          record.update(age: 101)
-        end
-      }.to change {
-        Capybara.transaction { Capybara.load(capybara.id).age }
-      }.from(100).to(101)
-    end
-  end
-end

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

@@ -1,184 +0,0 @@
-RSpec.describe Foobara::Entity::Concerns::Queries do
-  after do
-    Foobara.reset_alls
-  end
-
-  before do
-    Foobara::Persistence.default_crud_driver = Foobara::Persistence::CrudDrivers::InMemory.new
-  end
-
-  let(:user_class) do
-    stub_class "User", Foobara::Entity do
-      attributes do
-        id :integer
-        name :string, :required
-        stuff [:integer]
-      end
-
-      primary_key :id
-    end
-  end
-
-  describe ".first" do
-    context "when records do not exist" do
-      it "is nil" do
-        user_class.transaction do
-          expect(user_class.first).to be_nil
-        end
-      end
-    end
-
-    context "when records exist" do
-      before do
-        user_class.transaction do
-          user_class.create(name: "n1")
-          user_class.create(name: "n2")
-        end
-      end
-
-      it "fetches a record" do
-        user_class.transaction do
-          expect(user_class.first).to be_a(user_class)
-        end
-      end
-    end
-  end
-
-  describe ".find_all_by_attribute_containing_any_of" do
-    let(:user1) do
-      user_class.create(name: "name1", stuff: [5, 6])
-    end
-
-    let(:user2) do
-      user_class.create(name: "name2", stuff: [7, 8])
-    end
-    let(:user3) do
-      user_class.create(name: "name3", stuff: [9, 10])
-    end
-
-    it "can find the records that contain the relevant values" do
-      user_class.transaction do
-        user1
-        user2
-        user3
-      end
-
-      user_class.transaction do
-        users = user_class.find_all_by_attribute_containing_any_of(:stuff, [6, 9])
-        expect(users.map(&:id)).to contain_exactly(1, 3)
-      end
-    end
-
-    context "when records are created in the same transaction as the query" do
-      it "can find the records that contain the relevant values" do
-        user_class.transaction do
-          user1
-          user2
-          user3
-
-          expect(user_class.find_all_by_attribute_containing_any_of(:stuff, [6, 9])).to contain_exactly(user1, user3)
-        end
-      end
-    end
-  end
-
-  describe ".load" do
-    context "when the record is already loaded" do
-      it "returns the record" do
-        user = user_class.transaction do
-          user_class.create(name: "Basil")
-        end
-
-        user_class.transaction do
-          user = user_class.load(user.id)
-          expect(user).to be_a(user_class)
-          expect(user.name).to eq("Basil")
-          user = user_class.load(user)
-          expect(user).to be_a(user_class)
-          expect(user.name).to eq("Basil")
-        end
-      end
-    end
-
-    context "with load_paths:" do
-      let(:outer_entity) do
-        user_class
-
-        stub_class "Outer", Foobara::Entity do
-          attributes do
-            id :integer
-            stuff :required do
-              users [User], :required
-            end
-          end
-
-          primary_key :id
-        end
-      end
-
-      let(:outer_record) do
-        outer_entity.transaction do
-          outer_entity.create(stuff: { users: })
-        end
-      end
-
-      let(:users) do
-        (0..3).map do |i|
-          User.create(name: "name#{i}")
-        end
-      end
-
-      it "can load records with various types of load_paths specified in different ways" do
-        record_id = outer_record.id
-
-        record = outer_entity.transaction do
-          outer_entity.load(record_id)
-        end
-        expect(record).to be_a(outer_entity)
-        expect(record.stuff[:users].map(&:loaded?)).to eq([false, false, false, false])
-
-        record = outer_entity.transaction do
-          outer_entity.load(record_id, load_paths: "stuff.users.2")
-        end
-        expect(record).to be_a(outer_entity)
-        expect(record.stuff[:users].map(&:loaded?)).to eq([false, false, true, false])
-
-        record = outer_entity.transaction do
-          outer_entity.load(record_id, load_paths: ["stuff.users.2"])
-        end
-        expect(record).to be_a(outer_entity)
-        expect(record.stuff[:users].map(&:loaded?)).to eq([false, false, true, false])
-
-        record = outer_entity.transaction do
-          outer_entity.load(record_id, load_paths: ["stuff", "users", "2"])
-        end
-        expect(record).to be_a(outer_entity)
-        expect(record.stuff[:users].map(&:loaded?)).to eq([false, false, true, false])
-
-        record = outer_entity.transaction do
-          outer_entity.load(record_id, load_paths: [:stuff, :users, :"2"])
-        end
-        expect(record).to be_a(outer_entity)
-        expect(record.stuff[:users].map(&:loaded?)).to eq([false, false, true, false])
-
-        record = outer_entity.transaction do
-          outer_entity.load(record_id, load_paths: [[:stuff, :users, :"2"]])
-        end
-        expect(record).to be_a(outer_entity)
-        expect(record.stuff[:users].map(&:loaded?)).to eq([false, false, true, false])
-
-        record = outer_entity.transaction do
-          outer_entity.load(record_id, load_paths: [[:stuff, :users, :"#"]])
-        end
-        expect(record).to be_a(outer_entity)
-        expect(record.stuff[:users].map(&:loaded?)).to eq([true, true, true, true])
-
-        record = outer_entity.transaction do
-          outer_entity.load(record_id, load_paths: [[:stuff, :users]])
-        end
-        expect(record).to be_a(outer_entity)
-        expect(record.stuff[:users].map(&:loaded?)).to eq([true, true, true, true])
-      end
-    end
-  end
-end