volt 0.9.6 → 0.9.7.pre2

data/spec/models/persistors/page_spec.rb

@@ -1,19 +1,24 @@
 require 'spec_helper'
 
-module Volt
-  module Persistors
-    describe Page do
-      describe '#where' do
-        it 'searches for records in the page collection with the given values' do
-          juan  = Volt::Model.new(name: 'Juan', city: 'Quito', age: 13)
-          pedro = Volt::Model.new(name: 'Pedro', city: 'Quito', age: 15)
-          jose  = Volt::Model.new(name: 'Jose', city: 'Quito', age: 13)
+unless RUBY_PLATFORM == 'opal'
+  # TODO: this should run fine under opal
 
-          page = described_class.new [jose, juan, pedro]
+  module Volt
+    module Persistors
+      describe Page do
+        describe '#where' do
+          it 'searches for records in the page collection with the given values' do
+            juan  = Volt::Model.new(name: 'Juan', city: 'Quito', age: 13)
+            pedro = Volt::Model.new(name: 'Pedro', city: 'Quito', age: 15)
+            jose  = Volt::Model.new(name: 'Jose', city: 'Quito', age: 13)
 
-          expect(page.where age: 13, city: 'Quito').to match_array [juan, jose]
+            the_page._items = [jose, juan, pedro]
+
+            expect(the_page._items.where(age: 13, city: 'Quito')).to match_array [juan, jose]
+          end
         end
       end
     end
   end
+
 end

data/spec/models/persistors/store_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 require 'volt/models'
 
+
 describe Volt::Persistors::Store do
   it 'should tell the persistor when the model has changed' do
     persistor = double('volt/persistor')
@@ -38,22 +39,31 @@ describe Volt::Persistors::Store do
   end
 
   unless RUBY_PLATFORM == 'opal'
+    class ::Nester < Volt::Model
+    end
+
     before do
-      model = store._nesters.create(name: 'One').sync
+      model = store.nesters.create(name: 'One').sync
       model._subone = {name: 'Two'}
     end
 
     it 'should reload a model with nested hash models' do
-      model2 = store._nesters.first.sync
+      model2 = store.nesters.first.sync
 
       expect(model2.to_h.without(:id, :subone)).to eq(name: 'One')
       expect(model2._subone.to_h.without(:id)).to eq(name: 'Two')
     end
 
     it 'should reload nested hash models with the same parent persistor' do
-      model = store._nesters.first.sync
+      model = store.nesters.first.sync
       expect(model.persistor).to eq(model._subone.persistor)
     end
+
+    it 'should raise an error when accessing an model class on store (using sql)' do
+      expect do
+        store.wrong_models
+      end.to raise_error
+    end
   end
 
   unless RUBY_PLATFORM == 'opal'

data/spec/models/url_spec.rb

@@ -6,14 +6,15 @@ describe Volt::URL do
 
   let(:fake_location) do
     double(
-      'Location',
+      'Volt::Location',
       host: 'voltframework.com',
-      protocol: 'http:'
+      protocol: 'http:',
+      scheme: 'http'
     )
   end
 
   before do
-    allow(Location).to receive(:new).and_return fake_location
+    allow(Volt::Location).to receive(:new).and_return fake_location
     subject.parse uri
   end
 

data/spec/models/user_spec.rb

@@ -43,7 +43,7 @@ describe Volt::User do
       describe 'when it is a Volt server' do
         before do
           allow(BCrypt::Password).to receive(:create).with('test')
-            .and_return 'hashed-password'
+          .and_return 'hashed-password'
         end
 
         it 'encrypts password' do
@@ -60,7 +60,7 @@ describe Volt::User do
       end
 
       it 'should allow updates without validating the password' do
-        bob = store._users.buffer(name: 'Bob', email: 'bob@bob.com', password: '39sdjkdf932jklsd')
+        bob = store.users.buffer(name: 'Bob', email: 'bob@bob.com', password: '39sdjkdf932jklsd')
         bob.save!.sync
 
         Volt.as_user(bob) do
@@ -72,8 +72,11 @@ describe Volt::User do
           bob_buf.name = 'Jimmy'
 
           saved = false
-          bob_buf.save! do
+
+          bob_buf.save!.then do
             saved = true
+          end.fail do |err|
+            puts "User save error: #{err.inspect}"
           end
 
           expect(saved).to eq(true)

data/spec/models/user_validation_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-class TestUserTodo < Volt::Model
+class TestUserTodo2 < Volt::Model
   own_by_user
 
   permissions(:update) do
@@ -15,12 +15,12 @@ describe Volt::UserValidatorHelpers do
     end
 
     it 'should assign user_id when owning by a user' do
-      todo = TestUserTodo.new
+      todo = TestUserTodo2.new
       expect(todo._user_id).to eq(294)
     end
 
     it 'should not allow the user_id to be changed' do
-      todo = TestUserTodo.new
+      todo = TestUserTodo2.new
       expect(todo._user_id).to eq(294)
 
       todo._user_id = 500

data/spec/models/validations_spec.rb

@@ -5,6 +5,7 @@ describe Volt::Model do
 
   let(:test_model_class) do
     Class.new(Volt::Model) do
+      set_collection_name :test_model_classes
       validate :count, numericality: { min: 5, max: 10 }
       validate :description, length: { message: 'needs to be longer',
                                        length: 50 }
@@ -18,6 +19,7 @@ describe Volt::Model do
 
   let(:test_model_with_promises) do
     Class.new(Volt::Model) do
+      set_collection_name :test_model_with_promises
       attr_accessor :ran_promise
       validate do
         Promise.new.then do
@@ -109,6 +111,7 @@ describe Volt::Model do
 
     let(:test_model_class) do
       Class.new(Volt::Model) do
+        set_collection_name :test_model2_classes
         validate :special_field, format: [
           { with: /regex/, message: 'regex failed' },
           { with: ->(x) { x == false }, message: 'proc failed' }
@@ -169,6 +172,7 @@ describe Volt::Model do
     let(:model) { test_model_with_custom_validation.new }
     let(:test_model_with_custom_validation) do
       Class.new(Volt::Model) do
+        set_collection_name :test_model_with_custom_validations
         validations do
           validate :something, presence: true
           validate do

data/spec/models/validators/block_validations_spec.rb

@@ -6,6 +6,7 @@ unless RUBY_PLATFORM == 'opal'
 
     let(:test_model_class) do
       Class.new(Volt::Model) do
+        set_collection_name :test_model3_classes
         validations do
           if _is_ready == true
             validate :name, length: 5
@@ -16,6 +17,7 @@ unless RUBY_PLATFORM == 'opal'
 
     let(:test_model_action_pass_class) do
       Class.new(Volt::Model) do
+        set_collection_name :test_model_action_pass_classes
         validations do |action|
           # Only validation the name on update
           if action == :update
@@ -28,24 +30,26 @@ unless RUBY_PLATFORM == 'opal'
     it 'should run conditional validations in the validations block' do
       a = test_model_class.new(name: 'Jo')
 
-      a.validate!.sync
       expect(a.errors.size).to eq(0)
 
       a._is_ready = true
-      a.validate!.sync
 
       expect(a.errors.size).to eq(1)
     end
 
+
+    class ::Person < Volt::Model
+    end
+
     it 'should send the action name to the validations block' do
       jo = test_model_action_pass_class.new(name: 'Jo')
 
-      jo.validate!.sync
       expect(jo.errors.size).to eq(0)
 
-      store._people << jo
+      store.people << jo
+
+      jo._name = 'Joe'
 
-      jo.validate!.sync
       expect(jo.errors.size).to eq(1)
 
     end

data/spec/models/validators/email_validator_spec.rb

@@ -5,6 +5,7 @@ describe Volt::Model do
 
   let(:test_model_class) do
     Class.new(Volt::Model) do
+      set_collection_name :test_model4_classes
       validate :count, numericality: { min: 5, max: 10 }
       validate :description, length: { message: 'needs to be longer',
                                        length: 50 }
@@ -87,6 +88,7 @@ describe Volt::Model do
 
     let(:test_model_class) do
       Class.new(Volt::Model) do
+        set_collection_name :test_model5_classes
         validate :special_field, format: [
           { with: /regex/, message: 'regex failed' },
           { with: ->(x) { x == false }, message: 'proc failed' }

data/spec/models/validators/lifecycle_callbacks_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+class ::BeforeCallbacksTest < Volt::Model
+  before_validate :inc_validate_count
+  before_create :inc_create_count
+  before_save :inc_save_count
+  before_update :inc_update_count
+  attr_reader :validate_count, :create_count, :save_count, :update_count
+
+  field :name, String
+
+  def initialize(*)
+    @validate_count = 0
+    @create_count = 0
+    @save_count = 0
+    @update_count = 0
+    super
+  end
+
+  def inc_validate_count
+    @validate_count += 1
+  end
+
+  def inc_create_count
+    @create_count += 1
+  end
+
+  def inc_save_count
+    @save_count += 1
+  end
+
+  def inc_update_count
+    @update_count += 1
+  end
+end
+
+
+describe Volt::Models::Helpers::ChangeHelpers do
+  it 'should call before save before each save' do
+    model = the_page._before_callbacks_tests.create({name: 'One'})
+
+    expect(model.save_count).to eq(1)
+  end
+
+  it 'should call before_create before create' do
+    model = the_page._before_callbacks_tests.create({name: 'One'})
+
+    expect(model.create_count).to eq(1)
+  end
+
+  it 'should call before_update before update' do
+    model = the_page._before_callbacks_tests.create({name: 'One'})
+    expect(model.create_count).to eq(1)
+    expect(model.update_count).to eq(0)
+
+    model.name = 'New Name'
+    expect(model.create_count).to eq(1)
+    expect(model.update_count).to eq(1)
+
+    model.name = 'Another name'
+    expect(model.create_count).to eq(1)
+    expect(model.update_count).to eq(2)
+    expect(model.save_count).to eq(3)
+  end
+
+  # validation happens one extra time for the initial create
+  it 'should call before_validate before validate' do
+    model = the_page._before_callbacks_tests.create({name: 'One'})
+    expect(model.validate_count).to eq(2)
+
+    model.name = 'New Name'
+    expect(model.validate_count).to eq(3)
+  end
+
+  # it 'should not call anything on a buffer' do
+  #   model = the_page._before_callbacks_tests.buffer({name: 'One'})
+
+  #   model.save!
+
+  #   expect(model.create_count).to eq(0)
+  #   expect(model.update_count).to eq(0)
+  #   expect(model.save_count).to eq(0)
+  #   expect(model.validate_count).to eq(0)
+
+  # end
+end

data/spec/models/validators/unique_validator_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 
 unless RUBY_PLATFORM == 'opal'
   class Fridge < Volt::Model
+    field :name, String
     validate :name, unique: true
   end
 

data/spec/page/path_string_renderer_spec.rb

@@ -18,6 +18,11 @@ unless RUBY_PLATFORM == 'opal'
       expect(html).to eq("\n  <h1>Welcome Jimmy</h1>\n\n  <p>Glad you signed up!</p>\n\n")
     end
 
+    it 'should render with an attribute binding' do
+      html = Volt::PathStringRenderer.new(@volt_app, 'main/mailers/reset_password/html', { reset_url: 'http://resetthepassword.com/' }).html
+      expect(html).to eq("\n  Reset your password <a target=\"_new\" id=\"id0\" href=\"http://resetthepassword.com/\">here</a>.\n\n  <a id=\"id1\" href=\"http://resetthepassword.com/\">Reset Password</a>\n\n")
+    end
+
     it 'Raises raises ViewLookupException if full_path is nil' do
       expect do
         Volt::PathStringRenderer.new(@volt_app, '', { name: 'Jimmy' }).html

data/spec/queries/live_query_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+if RUBY_PLATFORM != 'opal'
+  describe 'LiveQuery' do
+    it 'should run a query' do
+      pool = double('volt/pool')
+      data_store = double('volt/data store')
+
+      expect(data_store).to receive(:query).with('_items', []).and_return([
+        { 'id' => 0, '_name' => 'one' }
+      ])
+
+      live_query = Volt::LiveQuery.new(volt_app, pool, data_store, '_items', {})
+    end
+  end
+end

data/spec/queries/query_association_splitter_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+if RUBY_PLATFORM != 'opal'
+  describe Volt::QueryAssociationSplitter do
+    it 'should split a query and return the associations' do
+      query = [:where, {name: 'Bob'}]
+      includes = ['includes', [:posts, [:posts, :comments], :links]]
+      new_query, associations = Volt::QueryAssociationSplitter.split([query, includes])
+
+      expect(new_query).to eq([query])
+      expect(associations).to eq({:posts=>{:comments=>{}}, :links=>{}})
+    end
+  end
+end

data/spec/queries/query_diff_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+if RUBY_PLATFORM != 'opal'
+  describe Volt::QueryDiff do
+    it 'should return a diff for moving records' do
+      a = [
+        {id: 1, name: 'Bob'},
+        {id: 2, name: 'Jim'},
+        {id: 3, name: 'Rob'}
+      ]
+      b = [
+        {id: 3, name: 'Rob'},
+        {id: 1, name: 'Bob'},
+        {id: 2, name: 'Jim'}
+      ]
+
+      diff = Volt::QueryDiff.new(a).run(b)
+
+      expect(diff).to eq([["m", 3, 0]])
+    end
+
+    it 'should return a diff moved records 2' do
+      a = [
+        {id: 1, name: 'Bob'},
+        {id: 2, name: 'Jim'},
+        {id: 3, name: 'Rob'},
+        {id: 4, name: 'Meg'}
+      ]
+      b = [
+        {id: 3, name: 'Rob'},
+        {id: 1, name: 'Bob'},
+        {id: 4, name: 'Meg'},
+        {id: 2, name: 'Jim'}
+      ]
+
+      diff = Volt::QueryDiff.new(a).run(b)
+
+      expect(diff).to eq([
+                           ["m", 3, 0],
+                           ["m", 4, 2]
+      ])
+    end
+
+    it 'should return a diff with removed records' do
+      a = [
+        {id: 1, name: 'Bob'},
+        {id: 2, name: 'Jim'},
+        {id: 3, name: 'Rob'}
+      ]
+      b = [
+        {id: 3, name: 'Rob'},
+        {id: 2, name: 'Jim'}
+      ]
+
+      diff = Volt::QueryDiff.new(a).run(b)
+
+      expect(diff).to eq([
+                           ["r", 1],
+                           ["m", 3, 0]
+      ])
+    end
+
+    it 'should return a diff for updated records' do
+      a = [
+        {id: 1, name: 'Bob'},
+        {id: 2, name: 'Jim'},
+        {id: 3, name: 'Rob'}
+      ]
+      b = [
+        {id: 2, name: 'Jim', admin: true},
+        {id: 1, name: 'Bobby'},
+        {id: 3, name: 'Rob'}
+      ]
+
+      diff = Volt::QueryDiff.new(a).run(b)
+
+      expect(diff).to eq(
+        [
+          ["m", 2, 0],
+          ["c", 1, {:id=>1, :name=>"Bobby"}],
+          ["c", 2, {:id=>2, :name=>"Jim", :admin=>true}]
+        ]
+      )
+    end
+
+    it 'should handle nested updates' do
+      a = [
+        {id: 1, name: 'Bob'},
+        {id: 2, name: 'Jim'},
+        {id: 3, name: 'Rob'}
+      ]
+      b = [
+        {id: 2, name: 'Jim', admin: true},
+        {id: 1, name: 'Bobby'},
+        {id: 3, name: 'Rob'}
+      ]
+
+      diff = Volt::QueryDiff.new(a).run(b)
+
+      expect(diff).to eq(
+        [
+          ["m", 2, 0],
+          ["c", 1, {:id=>1, :name=>"Bobby"}],
+          ["c", 2, {:id=>2, :name=>"Jim", :admin=>true}]
+        ]
+      )
+    end
+
+    it 'should handle complex transforms' do
+      a = [
+        {id: 1, name: 'Bob'},
+        {id: 2, name: 'Jim'},
+        {id: 3, name: 'Rob'}
+      ]
+      b = [
+        {id: 2, name: 'Jim', admin: true},
+        {id: 1, name: 'Bobby'},
+        {id: 3, name: 'Rob'}
+      ]
+
+      diff = Volt::QueryDiff.new(a).run(b)
+
+      expect(diff).to eq(
+        [
+          ["m", 2, 0],
+          ["c", 1, {:id=>1, :name=>"Bobby"}],
+          ["c", 2, {:id=>2, :name=>"Jim", :admin=>true}]
+        ]
+      )
+    end
+  end
+end