rom-rails 0.2.1 → 0.3.0.beta1

data/spec/lib/generators/mapper_generator_spec.rb

@@ -14,19 +14,17 @@ describe ROM::Generators::MapperGenerator do
     expect(destination_root).to have_structure {
       directory 'app' do
         directory 'mappers' do
-          file 'users.rb' do
+          file 'user_mapper.rb' do
             contains <<-CONTENT.strip_heredoc
-              ROM.mappers do
-
-                define(:users) do
-                  # specify model and attributes ie
-                  #
-                  # model User
-                  #
-                  # attribute :name
-                  # attribute :email
-                end
-
+              class UserMapper < ROM::Mapper
+                # relation :users
+                #
+                # specify model and attributes ie
+                #
+                # model User
+                #
+                # attribute :name
+                # attribute :email
               end
             CONTENT
           end

data/spec/lib/generators/relation_generator_spec.rb

@@ -2,27 +2,30 @@ require 'spec_helper'
 
 require 'generators/rom/relation_generator'
 
-describe ROM::Generators::RelationGenerator do
+describe ROM::Generators::RelationGenerator, type: :generator do
   destination File.expand_path('../../../../tmp', __FILE__)
 
-  before(:all) do
+  before(:each) do
     prepare_destination
-    run_generator ['users']
   end
 
   specify do
+    run_generator ['users']
+    default_adapter = ROM.adapters.keys.first
+
     expect(destination_root).to have_structure {
       directory 'app' do
         directory 'relations' do
-          file 'users.rb' do
+          file 'users_relation.rb' do
             contains <<-CONTENT.strip_heredoc
-              ROM.relation(:users) do
+              class UsersRelation < ROM::Relation[:#{default_adapter}]
+                dataset :users
+
                 # define your methods here ie:
                 #
                 # def all
                 #   select(:id, :name).order(:id)
                 # end
-                #
               end
             CONTENT
           end
@@ -30,4 +33,11 @@ describe ROM::Generators::RelationGenerator do
       end
     }
   end
+
+  specify "with given adapter" do
+    run_generator ['users', '--adapter=memory']
+
+    relation = File.read(File.join(destination_root, 'app', 'relations', 'users_relation.rb'))
+    expect(relation).to include("class UsersRelation < ROM::Relation[:memory]")
+  end
 end

data/spec/spec_helper.rb

@@ -25,5 +25,5 @@ RSpec.configure do |config|
 end
 
 def rom
-  Rails.application.config.rom.env
+  ROM.env
 end

data/spec/unit/form_spec.rb

@@ -0,0 +1,297 @@
+require 'spec_helper'
+
+describe 'Form' do
+  subject(:form) do
+    Class.new(ROM::Model::Form) do
+      def self.name
+        'UserForm'
+      end
+
+      input do
+        set_model_name 'User'
+
+        attribute :email, String
+      end
+
+      validations do
+        validates :email, presence: true
+      end
+
+      def commit!(*args)
+        "it works #{args.inspect}"
+      end
+    end
+  end
+
+  describe '.build' do
+    it 'rejects blank strings from params' do
+      input = {
+        'name'  => 'Jane',
+        'hash'  => { 'one' => '', 'two' => 2 },
+        'array' => [{ 'three' => '', 'four' => 4 }, 5]
+      }
+
+      form_object = form.build(input)
+
+      expect(form_object.params).to eql(
+        name: 'Jane', hash: { two: 2 }, array: [{ four: 4 }, 5]
+      )
+    end
+  end
+
+  describe '.commands' do
+    it 'builds its own command registry' do
+      form = Class.new(ROM::Model::Form) {
+        inject_commands_for :tasks
+        commands users: :create
+        input { attribute :name }
+        validations { validates :name, presence: true }
+
+        def commit!
+          users.try { users.create.call(params) }
+        end
+      }
+
+      form_object = form.build(name: '').save
+
+      expect(form_object).not_to be_success
+      expect(form_object.errors[:name]).to include("can't be blank")
+      expect(rom.relations.users.first).to be(nil)
+
+      form_object = form.build(name: 'Jane').save
+
+      expect(form_object).to be_success
+      expect(rom.relations.users.first).to include(name: 'Jane')
+
+      expect(form_object.tasks).to be(rom.command(:tasks))
+    end
+  end
+
+  describe '.key' do
+    it 'returns default key' do
+      expect(form.key).to eql([:id])
+      expect(form.new({}, { id: 312 }).to_key).to eql([312])
+    end
+
+    it 'sets a custom composite key' do
+      form = Class.new(ROM::Model::Form) do
+        def self.name
+          'UserForm'
+        end
+
+        key :foo_id, :bar_id
+
+        input do
+          set_model_name 'User'
+
+          attribute :email, String
+        end
+      end
+
+      expect(form.key).to eql([:foo_id, :bar_id])
+      expect(form.new({}, { foo_id: 312, bar_id: 132 }).to_key).to eql([312, 132])
+    end
+  end
+
+  describe '.model_name' do
+    it 'delegates to Params.model_name' do
+      expect(form.model_name).to be(form.params.model_name)
+    end
+  end
+
+  describe 'input DSL' do
+    it 'defines params handler' do
+      expect(form.const_defined?(:Params)).to be(true)
+      expect(form.params.attribute_set.map(&:name)).to eql([:email])
+      expect(form.params.model_name).to eql('User')
+    end
+
+    it 'defines a model' do
+      expect(form.const_defined?(:Model)).to be(true)
+      expect(form.model.attribute_set.map(&:name)).to match_array([:id, :email])
+    end
+
+    it 'raises error when attribute is in conflict with form interface' do
+      expect {
+        Class.new(ROM::Model::Form) do
+          input do
+            attribute :commit!
+          end
+        end
+      }.to raise_error(ArgumentError, /commit! attribute is in conflict/)
+    end
+  end
+
+  describe 'validator DSL' do
+    it 'defines validator' do
+      expect(form.const_defined?(:Validator)).to be(true)
+
+      expect(form.validator).not_to be(nil)
+
+      expect { form.validator.call(email: 'jane@doe') }.not_to raise_error
+
+      expect { form.validator.call(email: '') }.to raise_error(
+        ROM::Model::ValidationError
+      )
+    end
+  end
+
+  describe '#model_name' do
+    it 'delegates to model' do
+      form_object = form.build
+      expect(form_object.model_name).to be(form_object.model.model_name)
+    end
+  end
+
+  describe '#persisted?' do
+    it 'delegates to model' do
+      form_object = form.build
+      expect(form_object).not_to be_persisted
+      expect(form_object.persisted?).to be(form_object.model.persisted?)
+
+      form_object = form.build({}, { id: 1 })
+      expect(form_object).to be_persisted
+      expect(form_object.persisted?).to be(form_object.model.persisted?)
+    end
+  end
+
+  describe '#to_model' do
+    context 'with a new model' do
+      it 'returns model object without key set' do
+        model = form.build(email: 'jane@doe').to_model
+
+        expect(model.id).to be(nil)
+        expect(model.model_name).to eql('User')
+        expect(model.to_key).to eql([])
+        expect(model.to_param).to be(nil)
+        expect(model).not_to be_persisted
+      end
+    end
+
+    context 'with a persisted model' do
+      it 'returns model object with key set' do
+        model = form.build({ email: 'jane@doe' }, { id: 312 }).to_model
+
+        expect(model.id).to be(312)
+        expect(model.model_name).to eql('User')
+        expect(model.to_key).to eql([312])
+        expect(model.to_param).to eql('312')
+        expect(model).to be_persisted
+      end
+    end
+  end
+
+  describe '#save' do
+    it 'commits the form without extra args' do
+      result = form.build({}).save.result
+      expect(result).to eql('it works []')
+    end
+
+    it 'commits the form with extra args' do
+      result = form.build({}).save(1, 2, 3).result
+      expect(result).to eql('it works [1, 2, 3]')
+    end
+  end
+
+  describe "#errors" do
+    context "with a new model" do
+      it "exposes an activemodel compatible error"  do
+        errors = form.build({}).errors
+
+        expect(errors).to be_instance_of(
+          ActiveModel::Errors
+        )
+
+        expect(errors[:email]).to eq []
+      end
+    end
+  end
+
+  describe "#attributes" do
+    it "returns processed attributes" do
+      form = Class.new(ROM::Model::Form) do
+        def self.name
+          'UserForm'
+        end
+
+        key :foo_id, :bar_id
+
+        input do
+          set_model_name 'User'
+
+          attribute :uid, Integer
+        end
+      end
+
+      form_object = form.build(uid: "12345")
+      expect(form_object.attributes[:uid]).to eq 12_345
+    end
+  end
+
+  describe "#validate!" do
+    it "runs validations and assigns errors" do
+      form_object = form.build({})
+      form_object.validate!
+
+      expect(form_object.errors[:email]).to include "can't be blank"
+    end
+
+    it "uses processed parameters" do
+      form = Class.new(ROM::Model::Form) do
+        def self.name
+          'UserForm'
+        end
+
+        key :foo_id, :bar_id
+
+        input do
+          set_model_name 'User'
+
+          attribute :email, String
+          attribute :country, String, default: "Unkown"
+        end
+
+        validations do
+          validates :email, presence: true
+          validates :country, presence: true
+        end
+      end
+
+      form_object = form.build(uid: "12345")
+      form_object.validate!
+
+      expect(form_object.errors[:country]).to be_blank
+    end
+  end
+
+  describe 'inheritance' do
+    let(:child_form) do
+      Class.new(form) do
+        def self.name
+          "NewUserForm"
+        end
+      end
+    end
+
+    it 'copies model_name' do
+      expect(child_form.model_name.name).to eql(form.model_name.name)
+    end
+
+    it 'copies input' do
+      expect(child_form.params.attribute_set[:email]).to_not be(nil)
+      expect(child_form.params).to_not be(form.params)
+    end
+
+    it 'copies model' do
+      expect(child_form.model.attribute_set[:email]).to_not be(nil)
+      expect(child_form.model).to_not be(form.model)
+    end
+
+    it 'copies validator' do
+      expect(child_form.validator.validators.first).to be_instance_of(
+        ActiveModel::Validations::PresenceValidator
+      )
+      expect(child_form.validator).to_not be(form.validator)
+    end
+  end
+end

data/spec/unit/validator_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe 'Validation' do
+  subject(:validator) { user_validator.new(params) }
+
+  let(:user_params) do
+    Class.new {
+      include ROM::Model::Params
+
+      attribute :name, String
+      attribute :email, String
+    }
+  end
+
+  let(:user_validator) do
+    Class.new {
+      include ROM::Model::Validator
+
+      relation :users
+
+      validates :name, presence: true, uniqueness: { message: 'TAKEN!' }
+      validates :email, uniqueness: true
+
+      def self.name
+        'UserValidator'
+      end
+    }
+  end
+
+  describe '#call' do
+    let(:params) { {} }
+
+    it 'raises validation error when params are not valid' do
+      expect { validator.call }.to raise_error(ROM::Model::ValidationError)
+    end
+  end
+
+  describe "#validate" do
+    let(:params) { {} }
+
+    it "sets errors when params are not valid" do
+      validator.validate
+      expect(validator.errors[:name]).to eql(["can't be blank"])
+    end
+  end
+
+  describe ':presence' do
+    let(:params) { user_params.new(name: '') }
+
+    it 'sets error messages' do
+      expect(validator).to_not be_valid
+      expect(validator.errors[:name]).to eql(["can't be blank"])
+    end
+  end
+
+  describe ':uniqueness' do
+    let(:params) { user_params.new(name: 'Jane', email: 'jane@doe.org') }
+
+    before do
+      rom.relations.users.insert(name: 'Jane', email: 'jane@doe.org')
+    end
+
+    it 'sets default error messages' do
+      expect(validator).to_not be_valid
+      expect(validator.errors[:email]).to eql(['has already been taken'])
+    end
+
+    it 'sets custom error messages' do
+      rom.relations.users.insert(name: 'Jane', email: 'jane@doe.org')
+
+      expect(validator).to_not be_valid
+      expect(validator.errors[:name]).to eql(['TAKEN!'])
+    end
+  end
+end