volt 0.8.27.beta2 → 0.8.27.beta3

data/spec/extra_core/logger_spec.rb

@@ -0,0 +1,50 @@
+if RUBY_PLATFORM != 'opal'
+  describe Volt::VoltLogger do
+    let(:args)        { [5, :arg2] }
+    let(:class_name)  { 'ClassName' }
+    let(:method_name) { 'method_name' }
+    let(:run_time)    { 50 }
+
+    let(:logger) { Volt::VoltLogger.new }
+
+    let(:logger_with_opts) do
+      Volt::VoltLogger.new({
+        args: args,
+        class_name: class_name,
+        method_name: method_name,
+        run_time: run_time
+      })
+    end
+
+    it 'should log only severity and message wrapped in line breaks' do
+      expect(STDOUT).to receive(:write).with("\n\n[INFO] message\n")
+      logger.log(Logger::INFO, "message")
+    end
+
+    it 'should convert an array of arguments into a string' do
+      expect(logger_with_opts.args).to eq([5, :arg2])
+    end
+
+    context 'when STDOUT is a TTY' do
+      it 'should return a blue class name' do
+        expect(logger_with_opts.class_name).to eq("\e[1;34m#{class_name}\e[0;37m")
+      end
+
+      it 'should return a green method name' do
+        expect(logger_with_opts.method_name).to eq("\e[0;32m#{method_name}\e[0;37m")
+      end
+
+      it 'should return a green run time in milliseconds' do
+        expect(logger_with_opts.run_time).to eq("\e[0;32m#{run_time}ms\e[0;37m")
+      end
+    end
+
+    context 'when STDOUT is not a TTY' do
+      before { allow(STDOUT).to receive(:tty?).and_return(false) }
+
+      it 'should not add any terminal color codes' do
+        expect(logger_with_opts.class_name).to eq(class_name)
+      end
+    end
+  end
+end

data/spec/extra_core/string_transformations_spec.rb

@@ -44,5 +44,4 @@ describe '#camelize' do
     expect('HTMLTidy'.underscore).to eq('html_tidy')
     expect('HTMLTidyGenerator'.underscore).to eq('html_tidy_generator')
   end
-
 end

data/spec/integration/cookies_spec.rb

@@ -42,7 +42,6 @@ if ENV['BROWSER']
       page.evaluate_script('document.location.reload()')
 
       expect(page).to_not have_content('two: two')
-
     end
   end
-end
+end

data/spec/integration/flash_spec.rb

@@ -2,7 +2,7 @@
 if ENV['BROWSER'] && ENV['BROWSER'] != 'sauce'
   require 'spec_helper'
 
-  describe 'flash messages', type: :feature, :sauce => true do
+  describe 'flash messages', type: :feature, sauce: true do
     it 'should flash on sucesses, notices, warnings, and errors' do
       visit '/'
 
@@ -27,7 +27,6 @@ if ENV['BROWSER'] && ENV['BROWSER'] != 'sauce'
       expect(page).to have_content('An error message')
       find('.alert').click
       expect(page).to_not have_content('An error message')
-
     end
   end
-end
+end

data/spec/integration/list_spec.rb

@@ -1,7 +1,7 @@
 if ENV['BROWSER'] == 'firefox'
   require 'spec_helper'
 
-  describe 'todo example spec', type: :feature, :sauce => true do
+  describe 'todo example spec', type: :feature, sauce: true do
     before do
       visit '/'
 

data/spec/integration/templates_spec.rb

@@ -9,7 +9,6 @@ if ENV['BROWSER']
       click_link 'Bindings'
 
       expect(page).to have_title 'Bindings - KitchenSink'
-
     end
   end
 end

data/spec/integration/url_spec.rb

@@ -26,6 +26,5 @@ if ENV['BROWSER'] && ENV['BROWSER'] != 'phantom'
 
       expect(current_url).to match(/\/$/)
     end
-
   end
-end
+end

data/spec/integration/user_spec.rb

@@ -1,7 +1,7 @@
 if ENV['BROWSER']
   require 'spec_helper'
 
-  describe "user accounts", type: :feature, sauce: true do
+  describe 'user accounts', type: :feature, sauce: true do
     before(:each) do
       # Clear out db
       DataStore.new.drop_database
@@ -38,7 +38,7 @@ if ENV['BROWSER']
       visit '/'
 
       # Add the user
-      $page.store._users << {email: 'test@test.com', password: 'awes0mesEcRet', name: 'Test Account 9550'}
+      $page.store._users << { email: 'test@test.com', password: 'awes0mesEcRet', name: 'Test Account 9550' }
 
       click_link 'Login'
 
@@ -77,4 +77,4 @@ if ENV['BROWSER']
     end
   end
 
-end
+end

data/spec/models/field_helpers_spec.rb

@@ -6,7 +6,7 @@ class ExampleModelWithField < Volt::Model
   field :value, Numeric
 end
 
-describe "field helpers" do
+describe 'field helpers' do
   it 'should allow a user to setup a field that can be written to and read' do
     model = ExampleModelWithField.new
 
@@ -26,4 +26,4 @@ describe "field helpers" do
       ExampleModelWithField.field :awesome, Array
     end.to raise_error(FieldHelpers::InvalidFieldClass)
   end
-end
+end

data/spec/models/model_spec.rb

@@ -8,7 +8,6 @@ class Item < Volt::Model
 end
 
 describe Volt::Model do
-
   it 'should allow _ methods to be used to store values without predefining them' do
     a = Volt::Model.new
     a._stash = 'yes'
@@ -131,7 +130,6 @@ describe Volt::Model do
     Volt::Computation.flush!
 
     expect(values).to eq([nil, 'one'])
-
   end
 
   it 'should trigger changed for any indicies after a deleted index' do
@@ -401,6 +399,27 @@ describe Volt::Model do
     end
   end
 
+  describe 'reserved attributes' do
+    let(:model) { Volt::Model.new }
+
+    it 'should prevent reserved attributes from being read with underscores' do
+      [:attributes, :parent, :path, :options, :persistor].each do |attr_name|
+        expect do
+          model.send(:"_#{attr_name}")
+        end.to raise_error(Volt::InvalidFieldName, "`#{attr_name}` is reserved and can not be used as a field")
+      end
+
+    end
+
+    it 'should prevent reserved attributes from being assigned directly' do
+      [:attributes, :parent, :path, :options, :persistor].each do |attr_name|
+        expect do
+          model.send(:"_#{attr_name}=", 'assign val')
+        end.to raise_error(Volt::InvalidFieldName, "`#{attr_name}` is reserved and can not be used as a field")
+      end
+    end
+  end
+
   describe 'persistors' do
     it 'should setup a new instance of the persistor with self' do
       persistor = double('volt/persistor')

data/spec/models/user_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+require 'volt/models/user'
+
+class FakeConfig
+  def public; self; end
+  def auth; self; end
+  def use_username; true; end
+end
+
+describe Volt::User do
+  describe '.login_field' do
+    subject { Volt::User.login_field }
+
+    context 'when use_username is set to true' do
+      before do
+        allow(Volt).to receive(:config).and_return FakeConfig.new
+      end
+
+      it "returns :username" do
+        expect(subject).to eq :username
+      end
+    end
+
+    context 'when use_username is not set' do
+      it "returns :email" do
+        expect(subject).to eq :email
+      end
+    end
+  end
+
+  describe '#password=' do
+    let!(:user) { Volt::User.new }
+
+    subject { user.password = 'test' }
+
+    if RUBY_PLATFORM != 'opal'
+      context 'when it is a Volt server' do
+        before do
+          allow(BCrypt::Password).to receive(:create).with('test').
+            and_return 'hashed-password'
+        end
+
+        it "encrypts password" do
+          subject
+
+          expect(BCrypt::Password).to have_received :create
+        end
+
+        it 'sets _hashed_password to passed value' do
+          subject
+
+          expect(user._hashed_password).to eq "hashed-password"
+        end
+      end
+    end
+
+    context 'when it is not a Volt server' do
+      before do
+        allow(Volt).to receive(:server?).and_return false
+      end
+
+      it 'sets _password to passed value' do
+        subject
+
+        expect(user._password).to eq 'test'
+      end
+    end
+  end
+end

data/spec/models/validations_spec.rb

@@ -1,17 +1,22 @@
 require 'spec_helper'
 
-class TestModel < Volt::Model
-  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
-
 describe Volt::Model do
-  it 'should validate the name' do
-    expect(TestModel.new.errors).to eq(
+  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
+
+  it 'should return errors for all failed validations' do
+    expect(model.errors).to eq(
       count: ['must be a number'],
       description: ['needs to be longer'],
       email: ['must be an email address'],
@@ -21,23 +26,7 @@ describe Volt::Model do
     )
   end
 
-  it 'should show marked validations once they are marked' do
-    model = TestModel.new
-
-    expect(model.marked_errors).to eq({})
-
-    model.mark_field!(:name)
-
-    expect(model.marked_errors).to eq(
-      name: ['must be at least 4 characters']
-    )
-  end
-
   it 'should show all fields in marked errors once saved' do
-    model = TestModel.new
-
-    expect(model.marked_errors).to eq({})
-
     model.save!
 
     expect(model.marked_errors.keys).to eq(
@@ -45,73 +34,75 @@ describe Volt::Model do
     )
   end
 
-  describe 'length' do
-    it 'should allow custom errors on length' do
-      model = TestModel.new
-
-      expect(model.marked_errors).to eq({})
-
-      model.mark_field!(:description)
-
-      expect(model.marked_errors).to eq(
-        description: ['needs to be longer']
-      )
+  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
-  end
-
-  describe 'presence' do
-    it 'should validate presence' do
-      model = TestModel.new
-
-      expect(model.marked_errors).to eq({})
 
-      model.mark_field!(:username)
+    describe 'numericality' do
+      message = 'must be a number'
+      it_should_behave_like 'a built in validation', :count, message
+    end
 
-      expect(model.marked_errors).to eq(
-        username: ['must be specified']
-      )
+    describe 'length' do
+      message = 'needs to be longer'
+      it_should_behave_like 'a built in validation', :description, message
     end
-  end
 
-  describe 'numericality' do
-    it 'should validate numericality' do
-      model = TestModel.new
+    describe 'email' do
+      message = 'must be an email address'
+      it_should_behave_like 'a built in validation', :email, message
+    end
 
-      expect(model.marked_errors).to eq({})
+    describe 'name' do
+      message = 'must be at least 4 characters'
+      it_should_behave_like 'a built in validation', :name, message
+    end
 
-      model.mark_field!(:count)
+    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
 
-      expect(model.marked_errors).to eq(
-        count: ['must be a number']
-      )
+    describe 'presence' do
+      message = 'must be specified'
+      it_should_behave_like 'a built in validation', :username, message
     end
   end
 
-  describe 'email' do
-    it 'should validate email' do
-      model = TestModel.new
-
-      expect(model.marked_errors).to eq({})
-
-      model.mark_field!(:email)
-
-      expect(model.marked_errors).to eq(
-        email: ['must be an email address']
-      )
+  describe 'validators with multiple criteria' do
+    let(:regex_message) { 'regex failed' }
+    let(:proc_message) { 'proc failed' }
+
+    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
-  end
 
-  describe 'phone_number' do
-    it 'should validate phone number' do
-      model = TestModel.new
+    context 'when multiple fail' do
+      before { model._special_field = 'nope' }
 
-      expect(model.marked_errors).to eq({})
+      it 'returns an array of errors' do
+        expect(model.errors).to eq({
+          special_field: [ regex_message, proc_message ]
+        })
+      end
+    end
 
-      model.mark_field!(:phone_number)
+    context 'when one fails' do
+      before { model._special_field = 'regex' }
 
-      expect(model.marked_errors).to eq(
-        phone_number: ['must be a phone number with area or country code']
-      )
+      it 'returns an array with a single error' do
+        expect(model.errors).to eq({ special_field: [ proc_message ] })
+      end
     end
   end
 end

data/spec/models/validators/email_validator_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Volt::EmailValidator do
   subject { Volt::EmailValidator.new(*params) }
-  let(:params) { [ model, field_name, options ] }
+  let(:params) { [model, field_name, options] }
 
   let(:model) { Volt::Model.new email: email }
   let(:field_name) { :email }
@@ -105,14 +105,14 @@ describe Volt::EmailValidator do
     end
 
     context 'when provided a custom error message' do
-      let(:options) { { error_message: custom_message } }
+      let(:options) { { message: custom_message } }
       let(:custom_message) { 'this is a custom message' }
 
       context 'and the email is invalid' do
         let(:email) { invalid_email }
 
         it 'returns errors with the custom message' do
-          expect(subject.errors).to eq(email: [ custom_message ])
+          expect(subject.errors).to eq(email: [custom_message])
         end
       end
     end

data/spec/models/validators/format_validator_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+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(:model) { Volt::Model.new field: field_content }
+  let(:field_name) { :field }
+  let(:options) { regex_opts }
+
+  let(:regex) { /^valid/ }
+  let(:proc_regex) { /^valid/ }
+  let(:test_proc) { ->(content) { proc_regex.match content } }
+
+  let(:proc_opts) { { with: test_proc, message: proc_message } }
+  let(:regex_opts) { { with: regex, message: regex_message } }
+
+  let(:proc_message) { 'proc is invalid' }
+  let(:regex_message) { 'regex is invalid' }
+
+  let(:field_content) { valid_content }
+  let(:invalid_content) { 'invalid_content' }
+  let(:valid_content) { 'valid_content' }
+
+  let(:validate) { described_class.validate(*validate_params) }
+
+  before do
+    allow(described_class).to receive(:new).and_return subject
+  end
+
+  context 'when no criteria is provided' do
+    before { validate }
+
+    it 'should have no errors' do
+      expect(subject.errors).to eq({})
+    end
+
+    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