volt 0.8.27.beta3 → 0.8.27.beta4

data/spec/models/user_spec.rb

@@ -11,7 +11,7 @@ describe Volt::User do
   describe '.login_field' do
     subject { Volt::User.login_field }
 
-    context 'when use_username is set to true' do
+    describe 'when use_username is set to true' do
       before do
         allow(Volt).to receive(:config).and_return FakeConfig.new
       end
@@ -21,7 +21,7 @@ describe Volt::User do
       end
     end
 
-    context 'when use_username is not set' do
+    describe 'when use_username is not set' do
       it "returns :email" do
         expect(subject).to eq :email
       end
@@ -34,7 +34,7 @@ describe Volt::User do
     subject { user.password = 'test' }
 
     if RUBY_PLATFORM != 'opal'
-      context 'when it is a Volt server' do
+      describe 'when it is a Volt server' do
         before do
           allow(BCrypt::Password).to receive(:create).with('test').
             and_return 'hashed-password'
@@ -54,15 +54,18 @@ describe Volt::User do
       end
     end
 
-    context 'when it is not a Volt server' do
+    describe 'when it is not a Volt server' do
       before do
         allow(Volt).to receive(:server?).and_return false
       end
 
+      subject { user.password = 'a valid test password' }
+
+
       it 'sets _password to passed value' do
         subject
 
-        expect(user._password).to eq 'test'
+        expect(user._password).to eq('a valid test password')
       end
     end
   end

data/spec/models/user_validation_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+
+describe Volt::UserValidatorHelpers do
+  context "with user" do
+    before do
+      allow(Volt).to receive(:user_id) { 294 }
+    end
+
+    it 'should assign user_id when owning by a user' do
+      todo = TestUserTodo.new
+      expect(todo._user_id).to eq(294)
+    end
+
+    it 'should not allow the user_id to be changed' do
+      todo = TestUserTodo.new
+      expect(todo._user_id).to eq(294)
+
+      todo._user_id = 500
+
+      expect(todo._user_id).to eq(294)
+    end
+  end
+end

data/spec/models/validations_spec.rb

@@ -16,6 +16,7 @@ describe Volt::Model do
   end
 
   it 'should return errors for all failed validations' do
+    model.validate!
     expect(model.errors).to eq(
       count: ['must be a number'],
       description: ['needs to be longer'],
@@ -27,9 +28,10 @@ describe Volt::Model do
   end
 
   it 'should show all fields in marked errors once saved' do
-    model.save!
+    buffer = model.buffer
+    buffer.save!
 
-    expect(model.marked_errors.keys).to eq(
+    expect(buffer.marked_errors.keys).to eq(
       [:count, :description, :email, :name, :phone_number, :username]
     )
   end
@@ -72,6 +74,11 @@ describe Volt::Model do
       message = 'must be specified'
       it_should_behave_like 'a built in validation', :username, message
     end
+
+    it 'should fail on non-numbers' do
+      model._count = 'not a number'
+      expect(model.errors[:count]).to eq(['must be a number'])
+    end
   end
 
   describe 'validators with multiple criteria' do
@@ -98,11 +105,43 @@ describe Volt::Model do
     end
 
     context 'when one fails' do
-      before { model._special_field = 'regex' }
+      before do
+        # Prevent rollback for testing
+        allow(model).to receive(:revert_changes!)
+        model._special_field = 'regex'
+      end
 
       it 'returns an array with a single error' do
-        expect(model.errors).to eq({ special_field: [ proc_message ] })
+        expect(model.errors.to_h).to eq({ special_field: [ proc_message ] })
       end
     end
   end
-end
+
+  it 'should report if errors have happened in changed attributes' do
+    # Prevent revert_changes! so it doesn't revert on failed values
+    allow(model).to receive(:revert_changes!)
+
+    expect(model.error_in_changed_attributes?).to eq(false)
+
+    model._not_validated_attr = 'yes'
+    expect(model.error_in_changed_attributes?).to eq(false)
+
+    model._name = '5' # fail, too short
+    expect(model.changed?(:name)).to eq(true)
+    expect(model.error_in_changed_attributes?).to eq(true)
+
+    model._name = 'Jimmy'
+    expect(model.error_in_changed_attributes?).to eq(false)
+  end
+
+  it 'should revert changes which fail a validation' do
+    model._name = 'bob' # fails too short validation
+    expect(model._name).to eq(nil)
+
+    model._name = 'Jimmy' # long enough, passes
+    expect(model._name).to eq('Jimmy')
+
+    model._name = 'ok' # fails again
+    expect(model._name).to eq('Jimmy')
+  end
+end

data/spec/models/validators/email_validator_spec.rb

@@ -1,120 +1,147 @@
 require 'spec_helper'
 
-describe Volt::EmailValidator do
-  subject { Volt::EmailValidator.new(*params) }
-  let(:params) { [model, field_name, options] }
-
-  let(:model) { Volt::Model.new email: email }
-  let(:field_name) { :email }
-  let(:options) { true }
+describe Volt::Model do
+  let(:model) { test_model_class.new }
+
+  let(:test_model_class) do
+    Class.new(Volt::Model) do
+      validate :count, numericality: { min: 5, max: 10 }
+      validate :description, length: { message: 'needs to be longer',
+                                       length: 50 }
+      validate :email, email: true
+      validate :name, length: 4
+      validate :phone_number, phone_number: true
+      validate :username, presence: true
+    end
+  end
 
-  let(:valid_email) { 'test@example.com' }
-  let(:invalid_email) { 'test@example-com' }
-  let(:email) { valid_email }
+  it 'should return errors for all failed validations' do
+    model.validate!
+    expect(model.errors).to eq(
+      count: ['must be a number'],
+      description: ['needs to be longer'],
+      email: ['must be an email address'],
+      name: ['must be at least 4 characters'],
+      phone_number: ['must be a phone number with area or country code'],
+      username: ['must be specified']
+    )
+  end
 
-  describe '.validate' do
-    let(:result) { described_class.validate(*params.dup.insert(1, nil)) }
+  it 'should show all fields in marked errors once saved' do
+    buffer = model.buffer
+    buffer.save!
 
-    before do
-      allow(described_class).to receive(:new).and_return subject
-      allow(subject).to receive(:errors).and_call_original
+    expect(buffer.marked_errors.keys).to eq(
+      [:count, :description, :email, :name, :phone_number, :username]
+    )
+  end
 
-      result
+  describe 'builtin validations' do
+    shared_examples_for 'a built in validation' do |field, message|
+      specify do
+        expect { model.mark_field! field }
+          .to change { model.marked_errors }
+          .from({}).to({ field => [message ] })
+      end
     end
 
-    it 'initializes an email validator with the provided arguments' do
-      expect(described_class).to have_received(:new).with(*params)
+    describe 'numericality' do
+      message = 'must be a number'
+      it_should_behave_like 'a built in validation', :count, message
     end
 
-    it 'calls errors on the email validator' do
-      expect(subject).to have_received :errors
+    describe 'length' do
+      message = 'needs to be longer'
+      it_should_behave_like 'a built in validation', :description, message
     end
 
-    it 'returns the result of calling errors on the validator' do
-      expect(subject.errors).to eq result
+    describe 'email' do
+      message = 'must be an email address'
+      it_should_behave_like 'a built in validation', :email, message
     end
-  end
-
-  describe '#valid?' do
-    context 'when using the default regex' do
-      let(:options) { true }
 
-      context 'when the email is valid' do
-        let(:email) { valid_email }
-
-        specify { expect(subject.valid?).to eq true }
-      end
-
-      context 'when the email is missing a TLD' do
-        let(:email) { 'test@example' }
+    describe 'name' do
+      message = 'must be at least 4 characters'
+      it_should_behave_like 'a built in validation', :name, message
+    end
 
-        specify { expect(subject.valid?).to eq false }
-      end
+    describe 'phone_number' do
+      message = 'must be a phone number with area or country code'
+      it_should_behave_like 'a built in validation', :phone_number, message
+    end
 
-      context 'when the email TLD is only one character' do
-        let(:email) { 'test@example.c' }
+    describe 'presence' do
+      message = 'must be specified'
+      it_should_behave_like 'a built in validation', :username, message
+    end
 
-        specify { expect(subject.valid?).to eq false }
-      end
+    it 'should fail on non-numbers' do
+      model._count = 'not a number'
+      expect(model.errors[:count]).to eq(['must be a number'])
+    end
+  end
 
-      context 'when the email is missing an username' do
-        let(:email) { '@example.com' }
+  describe 'validators with multiple criteria' do
+    let(:regex_message) { 'regex failed' }
+    let(:proc_message) { 'proc failed' }
 
-        specify { expect(subject.valid?).to eq false }
+    let(:test_model_class) do
+      Class.new(Volt::Model) do
+        validate :special_field, format: [
+          { with: /regex/, message: 'regex failed' },
+          { with: ->(x) {x == false}, message: 'proc failed' }
+        ]
       end
+    end
 
-      context 'when the email is missing the @ symbol' do
-        let(:email) { 'test.example.com' }
+    context 'when multiple fail' do
+      before { model._special_field = 'nope' }
 
-        specify { expect(subject.valid?).to eq false }
+      it 'returns an array of errors' do
+        expect(model.errors).to eq({
+          special_field: [ regex_message, proc_message ]
+        })
       end
     end
 
-    context 'when using a custom regex' do
-      let(:options) { { with: /.+\@.+/ } }
-
-      context 'and the email qualifies' do
-        let(:email) { 'test@example' }
-
-        specify { expect(subject.valid?).to eq true }
+    context 'when one fails' do
+      before do
+        # Prevent rollback for testing
+        allow(model).to receive(:revert_changes!)
+        model._special_field = 'regex'
       end
 
-      context 'and the email does not qualify' do
-        let(:email) { 'test$example' }
-
-        specify { expect(subject.valid?).to eq false }
+      it 'returns an array with a single error' do
+        expect(model.errors.to_h).to eq({ special_field: [ proc_message ] })
       end
     end
   end
 
-  describe '#errors' do
-    context 'when the model has a valid email' do
-      let(:email) { valid_email }
+  it 'should report if errors have happened in changed attributes' do
+    # Prevent revert_changes! so it doesn't revert on failed values
+    allow(model).to receive(:revert_changes!)
 
-      it 'returns an empty error hash' do
-        expect(subject.errors).to eq({})
-      end
-    end
+    expect(model.error_in_changed_attributes?).to eq(false)
 
-    context 'when the model has an invalid email' do
-      let(:email) { invalid_email }
+    model._not_validated_attr = 'yes'
+    expect(model.error_in_changed_attributes?).to eq(false)
 
-      it 'returns an array of errors for email' do
-        expect(subject.errors).to eq(email: ['must be an email address'])
-      end
-    end
+    model._name = '5' # fail, too short
+    expect(model.changed?(:name)).to eq(true)
+    expect(model.error_in_changed_attributes?).to eq(true)
 
-    context 'when provided a custom error message' do
-      let(:options) { { message: custom_message } }
-      let(:custom_message) { 'this is a custom message' }
+    model._name = 'Jimmy'
+    expect(model.error_in_changed_attributes?).to eq(false)
+  end
 
-      context 'and the email is invalid' do
-        let(:email) { invalid_email }
+  it 'should revert changes which fail a validation' do
+    model._name = 'bob' # fails too short validation
+    expect(model._name).to eq(nil)
 
-        it 'returns errors with the custom message' do
-          expect(subject.errors).to eq(email: [custom_message])
-        end
-      end
-    end
+    model._name = 'Jimmy' # long enough, passes
+    expect(model._name).to eq('Jimmy')
+
+    model._name = 'ok' # fails again
+    expect(model._name).to eq('Jimmy')
   end
-end
+end

data/spec/models/validators/format_validator_spec.rb

@@ -1,10 +1,11 @@
 require 'spec_helper'
+require 'models/validators/shared_examples_for_validators'
 
 describe Volt::FormatValidator do
   subject { described_class.new(*init_params) }
 
   let(:init_params) { [ model, field_name ] }
-  let(:validate_params) { [ model, nil, field_name, options ] }
+  let(:validate_params) { [ model, field_name, options ] }
 
   let(:model) { Volt::Model.new field: field_content }
   let(:field_name) { :field }
@@ -26,9 +27,7 @@ describe Volt::FormatValidator do
 
   let(:validate) { described_class.validate(*validate_params) }
 
-  before do
-    allow(described_class).to receive(:new).and_return subject
-  end
+  it_behaves_like 'a format validator'
 
   context 'when no criteria is provided' do
     before { validate }
@@ -39,106 +38,4 @@ describe Volt::FormatValidator do
 
     specify { expect(subject).to be_valid }
   end
-
-  context 'when the only criterion is a regex' do
-    let(:options) { regex_opts }
-
-    before { validate }
-
-    context 'and the field matches' do
-      let(:field_content) { valid_content }
-
-      it 'should have no errors' do
-        expect(subject.errors).to eq({})
-      end
-
-      specify { expect(subject).to be_valid }
-    end
-
-    context 'and the field does not match' do
-      let(:field_content) { invalid_content }
-
-      it 'should report the related error message' do
-        expect(subject.errors).to eq field_name => [regex_message]
-      end
-
-      specify { expect(subject).to_not be_valid }
-    end
-  end
-
-  context 'when the only criterion is a block' do
-    let(:options) { proc_opts }
-
-    before { validate }
-
-    context 'and the field passes the block' do
-      let(:field_content) { valid_content }
-
-      it 'should have no errors' do
-        expect(subject.errors).to eq({})
-      end
-
-      specify { expect(subject).to be_valid }
-    end
-
-    context 'and the field fails the block' do
-      let(:field_content) { invalid_content }
-
-      it 'should report the related error message' do
-        expect(subject.errors).to eq field_name => [proc_message]
-      end
-
-      specify { expect(subject).to_not be_valid }
-    end
-  end
-
-  context 'when there is both regex and block criteria' do
-    let(:options) { [ regex_opts, proc_opts ] }
-
-    before { validate }
-
-    context 'and the field passes all criteria' do
-      let(:field_content) { valid_content }
-
-      it 'should have no errors' do
-        expect(subject.errors).to eq({})
-      end
-
-      specify { expect(subject).to be_valid }
-    end
-
-    context 'and the field fails the regex' do
-      let(:regex) { /^invalid/ }
-
-      it 'should report the related error message' do
-        expect(subject.errors).to eq field_name => [regex_message]
-      end
-
-      specify { expect(subject).to_not be_valid }
-    end
-
-    context 'and the field fails the block' do
-      let(:proc_regex) { /^invalid/ }
-
-      it 'should report the related error message' do
-        expect(subject.errors).to eq field_name => [proc_message]
-      end
-
-      specify { expect(subject).to_not be_valid }
-    end
-
-    context 'and the field fails both the regex and the block' do
-      let(:field_content) { invalid_content }
-
-      it 'should report the regex error message' do
-        expect(subject.errors[field_name]).to include regex_message
-      end
-
-      it 'should report the proc error message' do
-        expect(subject.errors[field_name]).to include proc_message
-      end
-
-      specify { expect(subject).to_not be_valid }
-    end
-  end
-end
+end

data/spec/models/validators/length_validator_spec.rb

@@ -2,22 +2,22 @@ require 'spec_helper'
 
 describe Volt::LengthValidator do
   subject { Volt::LengthValidator.validate(*params) }
-  let(:params) { [model, nil, field_name, options] }
+  let(:params) { [model, field_name, options] }
 
   let(:model) { Volt::Model.new name: name }
   let(:field_name) { :name }
   let(:name) { "John Doe" }
 
   describe '.validate' do
-    context 'when options is a Fixnum' do
+    describe 'when options is a Fixnum' do
       let(:options) { 5 }
 
-      context 'when name is "John Doe"' do
+      describe 'when name is "John Doe"' do
         let(:name) { "John Doe" }
         it { expect(subject).to eq({}) }
       end
 
-      context 'when name is "John"' do
+      describe 'when name is "John"' do
         let(:name) { "John" }
         it do
           expect(subject).to eq({
@@ -27,17 +27,17 @@ describe Volt::LengthValidator do
       end
     end
 
-    context 'when options is a Hash' do
+    describe 'when options is a Hash' do
       let(:options) do
         { length: 5, maximum: 10 }
       end
 
-      context 'when name is "John Doe"' do
+      describe 'when name is "John Doe"' do
         let(:name) { "John Doe" }
         it { expect(subject).to eq({}) }
       end
 
-      context 'when name is "John"' do
+      describe 'when name is "John"' do
         let(:name) { "John" }
         it do
           if RUBY_PLATFORM == 'opal'
@@ -52,7 +52,7 @@ describe Volt::LengthValidator do
         end
       end
 
-      context 'when name is "Zach Galifianakis"' do
+      describe 'when name is "Zach Galifianakis"' do
         let(:name) { "Zach Galifianakis" }
         it do
           if RUBY_PLATFORM == 'opal'
@@ -68,7 +68,7 @@ describe Volt::LengthValidator do
       end
     end
 
-    context 'when options not a Fixnum or a Hash' do
+    describe 'when options not a Fixnum or a Hash' do
       let(:options) { 'string' }
 
       it "raises an exception" do