upgrow 0.0.2 → 0.0.3

data/test/upgrow/basic_model_test.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Upgrow
+  class BasicModelTest < ActiveSupport::TestCase
+    class SampleModel < BasicModel
+      attribute :title
+      attribute :body
+
+      belongs_to :user
+    end
+
+    class SubSampleModel < SampleModel
+      has_many :tags
+    end
+
+    setup do
+      @original_schema = BasicModel.schema.dup
+    end
+
+    teardown do
+      BasicModel.schema = @original_schema
+    end
+
+    test '.schema includes ID by default' do
+      assert_equal [:id, :title, :body], SampleModel.schema.attribute_names
+    end
+
+    test '.schema does not have associations by default' do
+      assert_empty BasicModel.schema.association_names
+    end
+
+    test '.schema includes the Model associations' do
+      assert_equal [:user], SampleModel.schema.association_names
+      assert_equal [:user, :tags], SubSampleModel.schema.association_names
+    end
+
+    test '.has_many defines an association in the Schema' do
+      BasicModel.has_many(:comments)
+      assert_equal [:comments], BasicModel.schema.association_names
+    end
+
+    test '.belongs_to defines an association in the Schema' do
+      BasicModel.belongs_to(:author)
+      assert_equal [:author], BasicModel.schema.association_names
+    end
+
+    test '.new requires all attributes' do
+      error = assert_raises(KeyError) do
+        SampleModel.new(title: 'volmer', id: 1)
+      end
+
+      assert_equal 'key not found: :body', error.message
+    end
+
+    test '.new optionally accepts associations' do
+      model = SampleModel.new(
+        title: 'volmer',
+        body: 'My long body',
+        id: 1,
+        user: :my_user
+      )
+
+      assert_equal :my_user, model.user
+    end
+
+    test '#respond_to? is true for association readers' do
+      model = SubSampleModel.new(id: 1, title: 'volmer', body: 'hello')
+
+      assert model.respond_to?(:user)
+      assert model.respond_to?(:tags)
+    end
+
+    test 'association reader raises Association Not Loaded Error for an association that was not loaded' do
+      model = SampleModel.new(
+        title: 'volmer',
+        body: 'My long body',
+        id: 1,
+      )
+
+      assert_raises(Model::AssociationNotLoadedError) { model.user }
+    end
+
+    test 'attribute readers work when association is not loaded' do
+      model = SampleModel.new(
+        title: 'volmer',
+        body: 'My long body',
+        id: 1,
+      )
+
+      assert_equal 'volmer', model.title
+    end
+  end
+end

data/test/upgrow/basic_repository_test.rb

@@ -4,36 +4,48 @@ require 'test_helper'
 
 module Upgrow
   class BasicRepositoryTest < ActiveSupport::TestCase
-    class User < Model; end
+    class User < BasicModel; end
+
+    class Car < BasicModel
+      attribute :wheels
+    end
 
     class UserRepository < BasicRepository; end
 
     class NoModelRepository < BasicRepository; end
 
     setup do
-      freeze_time
-
+      @original_base = UserRepository.base
+      @original_model_class = UserRepository.model_class
       @repository = UserRepository.new
     end
 
-    test '.new instantiates a new Repository with a base and a Model class' do
-      repository = UserRepository.new(base: :my_base, model_class: User)
+    teardown do
+      UserRepository.base = @original_base
+      UserRepository.model_class = @original_model_class
+    end
+
+    test '.base is nil by default' do
+      assert_nil UserRepository.base
+    end
 
-      assert_equal :my_base, repository.base
-      assert_equal User, repository.model_class
+    test '.base can be set' do
+      UserRepository.base = :my_base
+      assert_equal :my_base, UserRepository.base
     end
 
-    test '.new sets the base to nil by default' do
-      assert_nil @repository.base
+    test '.model_class is iferred based on the Repository name' do
+      assert_equal User, UserRepository.model_class
     end
 
-    test '.new sets the Model class by default to a constant derived from the Repository name' do
-      assert_equal User, @repository.model_class
+    test '.model_class can be set' do
+      UserRepository.model_class = :my_model_class
+      assert_equal :my_model_class, UserRepository.model_class
     end
 
-    test '.new raises a Name Error if the Model class is undefined' do
+    test '.model_class raises a Name Error if the Model class is undefined' do
       error = assert_raises(NameError) do
-        NoModelRepository.new(base: :my_base)
+        NoModelRepository.model_class
       end
 
       assert_includes(
@@ -42,32 +54,41 @@ module Upgrow
       )
     end
 
-    test '.to_model returns a new Model with the given attributes as keyword arguments' do
-      model = @repository.to_model(
-        id: 1, created_at: Time.now, updated_at: Time.now
-      )
+    test '#base is inferred from the Repository class base' do
+      UserRepository.base = :my_base
+      assert_equal :my_base, UserRepository.new.base
+    end
+
+    test '#model_class is inferred from the Repository class Model class' do
+      UserRepository.model_class = :my_model_class
+      assert_equal :my_model_class, UserRepository.new.model_class
+    end
+
+    test '#to_model returns a new Model with the given attributes as keyword arguments' do
+      model = @repository.to_model(id: 1)
+
+      assert_equal 1, model.id
+    end
+
+    test '#to_model accepts a Model class explicitly' do
+      model = @repository.to_model(Car, id: 1, wheels: 4)
 
       assert_equal 1, model.id
-      assert_equal Time.now, model.created_at
-      assert_equal Time.now, model.updated_at
+      assert_equal 4, model.wheels
     end
 
-    test '.to_model accepts a Hash of Symbols' do
-      args = { id: 1, created_at: Time.now, updated_at: Time.now }
+    test '#to_model accepts a Hash of Symbols' do
+      args = { id: 1 }
       model = @repository.to_model(args)
 
       assert_equal 1, model.id
-      assert_equal Time.now, model.created_at
-      assert_equal Time.now, model.updated_at
     end
 
-    test '.to_model accepts a Hash of Strings' do
-      args = { 'id' => 1, 'created_at' => Time.now, 'updated_at' => Time.now }
+    test '#to_model accepts a Hash of Strings' do
+      args = { 'id' => 1 }
       model = @repository.to_model(args)
 
       assert_equal 1, model.id
-      assert_equal Time.now, model.created_at
-      assert_equal Time.now, model.updated_at
     end
   end
 end

data/test/upgrow/immutable_object_test.rb

@@ -13,12 +13,26 @@ module Upgrow
       attribute :name
     end
 
-    test '.attribute_names is empty by default' do
-      assert_empty ImmutableObject.attribute_names
+    setup do
+      @original_schema = Sample.schema
     end
 
-    test '.attribute_names returns a list of attribute names' do
-      assert_equal [:title, :body, :name], SubSample.attribute_names
+    teardown do
+      Sample.schema = @original_schema
+    end
+
+    test '.schema is empty by default' do
+      assert_empty ImmutableObject.schema.attribute_names
+    end
+
+    test '.schema can be set' do
+      Sample.schema = :my_schema
+
+      assert_equal :my_schema, Sample.schema
+    end
+
+    test '.schema contains all declared attributes' do
+      assert_equal [:title, :body, :name], SubSample.schema.attribute_names
     end
 
     test '.new creates a frozen instance with the given attributes' do
@@ -29,7 +43,7 @@ module Upgrow
       assert sample.frozen?
     end
 
-    test 'it does not allow members to be mutated' do
+    test 'it does not allow attributes to be mutated' do
       sample = Sample.new(title: 'volmer', body: 'hello')
 
       refute sample.respond_to?(:title=)
@@ -44,17 +58,39 @@ module Upgrow
       assert_equal 'Unknown attribute [:fake]', error.message
     end
 
-    test '.new requires inherited attributes' do
+    test '.new allows inherited attributes' do
       sub_sample = SubSample.new(title: 'volmer', body: 'hello', name: 'rafael')
       assert_equal 'volmer', sub_sample.title
       assert_equal 'hello', sub_sample.body
       assert_equal 'rafael', sub_sample.name
     end
 
-    test '#attributes returns the collection of attributes' do
+    test '.new allows omitting attributes' do
+      sub_sample = SubSample.new(title: 'volmer')
+      assert_equal 'volmer', sub_sample.title
+      assert_nil sub_sample.body
+      assert_nil sub_sample.name
+    end
+
+    test '#respond_to? is true for all attribute readers' do
+      sub_sample = SubSample.new(title: 'volmer')
+
+      assert sub_sample.respond_to?(:title)
+      assert sub_sample.respond_to?(:body)
+      assert sub_sample.respond_to?(:name)
+    end
+
+    test '#attributes returns the collection of frozen attributes' do
       sample = Sample.new(title: 'volmer', body: 'hello')
 
       assert_equal({ title: 'volmer', body: 'hello' }, sample.attributes)
+      assert sample.attributes.frozen?
+    end
+
+    test '#attributes returns attributes that were omitted' do
+      sample = Sample.new
+
+      assert_equal({ title: nil, body: nil }, sample.attributes)
     end
   end
 end

data/test/upgrow/input_test.rb

@@ -12,7 +12,7 @@ module Upgrow
       validates :title, presence: true
     end
 
-    test '#errors is an empty Active Model Errors' do
+    test '#errors is empty' do
       input = Input.new
       errors = input.errors
       assert_empty errors
@@ -61,5 +61,23 @@ module Upgrow
       input = SampleInput.new
       refute_predicate input, :valid?
     end
+
+    test '#errors is empty when validation is successful' do
+      input = SampleInput.new(title: 'volmer')
+      assert_predicate input, :valid?
+      assert_empty input.errors
+    end
+
+    test '#errors is populated when validation fails' do
+      input = SampleInput.new
+      refute_predicate input, :valid?
+      assert_predicate input.errors, :one?
+
+      error = input.errors.first
+
+      assert_equal :title, error.attribute
+      assert_equal :blank, error.type
+      assert_equal "Title can't be blank", error.full_message
+    end
   end
 end

data/test/upgrow/model_schema_test.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Upgrow
+  class ModelSchemaTest < ActiveSupport::TestCase
+    setup do
+      @schema = ModelSchema.new
+    end
+
+    test '#association_names is empty by default' do
+      assert_empty @schema.attribute_names
+    end
+
+    test '#association_names returns the defined associations' do
+      @schema.association(:user)
+      @schema.association(:tags)
+
+      assert_equal [:user, :tags], @schema.association_names
+    end
+
+    test '#association defines an association' do
+      @schema.association(:user)
+
+      assert_equal [:user], @schema.association_names
+    end
+
+    test '#association does not define the same association twice' do
+      @schema.association(:user)
+      @schema.association(:user)
+
+      assert_equal [:user], @schema.association_names
+    end
+
+    test '#dup creates a Schema with independent association names' do
+      @schema.association(:user)
+      new_schema = @schema.dup
+      new_schema.association(:tags)
+
+      assert_equal [:user], @schema.association_names
+      assert_equal [:user, :tags], new_schema.association_names
+    end
+  end
+end

data/test/upgrow/model_test.rb

@@ -2,26 +2,63 @@
 
 require 'test_helper'
 
+require 'upgrow/model'
+
 module Upgrow
   class ModelTest < ActiveSupport::TestCase
     class SampleModel < Model
-      attribute :title
-      attribute :body
     end
 
-    test '.attribute_names includes :id, :created_at, and :updated_at' do
-      expected = [:id, :created_at, :updated_at, :title, :body]
-      assert_equal expected, SampleModel.attribute_names
+    class SubSampleModel < SampleModel
+    end
+
+    class SampleModelWithAttribute < Model
+      attribute :phone
+    end
+
+    class SampleModelRecord
+      def self.attribute_names
+        ['id', 'name']
+      end
+    end
+
+    class SubSampleModelRecord
+      def self.attribute_names
+        ['email']
+      end
+    end
+
+    class SampleModelWithAttributeRecord
+      def self.attribute_names
+        ['id']
+      end
+    end
+
+    class OrphanedModel < Model
+    end
+
+    test '.schema is inferred from the Active Record with the Model name' do
+      assert_equal [:id, :name], SampleModel.schema.attribute_names
+    end
+
+    test '.schema is populated with inherited attributes' do
+      assert_equal [:email, :id, :name], SubSampleModel.schema.attribute_names
+    end
+
+    test '.schema includes explicit attributes as well as Active Record attributes' do
+      assert_equal [:id, :phone],
+        SampleModelWithAttribute.schema.attribute_names
     end
 
-    test '.new requires all attributes' do
-      error = assert_raises(KeyError) do
-        SampleModel.new(
-          title: 'volmer', id: 1, created_at: Time.now, updated_at: Time.now
-        )
+    test '.new raises a Name Error if the Record class is undefined' do
+      error = assert_raises(NameError) do
+        OrphanedModel.new
       end
 
-      assert_equal 'key not found: :body', error.message
+      assert_includes(
+        error.message,
+        'uninitialized constant Upgrow::ModelTest::OrphanedModelRecord'
+      )
     end
   end
 end