volt 0.8.27.beta6 → 0.8.27.beta7

data/spec/integration/user_spec.rb

@@ -33,48 +33,48 @@ if ENV['BROWSER']
 
       expect(page).to have_content('Test Account 9550')
     end
-    #
-    # it 'should login and logout' do
-    #   visit '/'
-    #
-    #   # Add the user
-    #   $page.store._users << { email: 'test@test.com', password: 'awes0mesEcRet', name: 'Test Account 9550' }
-    #
-    #   click_link 'Login'
-    #
-    #   fields = all(:css, 'form .form-control')
-    #   fields[0].set('test@test.com')
-    #   fields[1].set('awes0mesEcRet')
-    #   click_button 'Login'
-    #
-    #   expect(page).to have_content('Test Account 9550')
-    #
-    #   # Click the logout link
-    #   click_link 'Test Account 9550'
-    #   click_link 'Logout'
-    #
-    #   expect(page).to_not have_content('Test Account 9550')
-    # end
-    #
-    # it 'should fail to create an account without a valid email and password' do
-    #   visit '/'
-    #
-    #   click_link 'Login'
-    #   click_link 'Signup here'
-    #
-    #   expect(page).to_not have_content('must be at least 8 characters')
-    #
-    #   fields = all(:css, 'form .form-control')
-    #
-    #   fields[0].set('test')
-    #   fields[1].set('awe')
-    #   fields[2].set('Tes')
-    #
-    #   # some capybara drivers don't trigger blur correctly
-    #   page.execute_script("$('.form-control').blur()")
-    #
-    #   expect(page).to have_content('must be at least 8 characters')
-    # end
+
+    it 'should login and logout' do
+      visit '/'
+
+      # Add the user
+      store._users! << { email: 'test@test.com', password: 'awes0mesEcRet', name: 'Test Account 9550' }
+
+      click_link 'Login'
+
+      fields = all(:css, 'form .form-control')
+      fields[0].set('test@test.com')
+      fields[1].set('awes0mesEcRet')
+      click_button 'Login'
+
+      expect(page).to have_content('Test Account 9550')
+
+      # Click the logout link
+      click_link 'Test Account 9550'
+      click_link 'Logout'
+
+      expect(page).to_not have_content('Test Account 9550')
+    end
+
+    it 'should fail to create an account without a valid email and password' do
+      visit '/'
+
+      click_link 'Login'
+      click_link 'Signup here'
+
+      expect(page).to_not have_content('must be at least 8 characters')
+
+      fields = all(:css, 'form .form-control')
+
+      fields[0].set('test')
+      fields[1].set('awe')
+      fields[2].set('Tes')
+
+      # some capybara drivers don't trigger blur correctly
+      page.execute_script("$('.form-control').blur()")
+
+      expect(page).to have_content('must be at least 8 characters')
+    end
   end
 
 end

data/spec/models/associations_spec.rb

@@ -14,20 +14,20 @@ describe Volt::Associations do
       # DataStore.new.drop_database
       # $page.instance_variable_set('@store', nil)
 
-      store._people << {name: 'Jimmy'}
+      store._people! << {name: 'Jimmy'}
       @person = store._people[0]
-      @person._addresses << {city: 'Bozeman'}
+      @person._addresses! << {city: 'Bozeman'}
       @person._addresses << {city: 'Portland'}
     end
 
     it 'should associate via belongs_to' do
-      address = store._addresses.fetch_first.sync
+      address = store._addresses!.fetch_first.sync
 
       expect(address.person.sync._id).to eq(@person._id)
     end
 
     it 'should associate via has_many' do
-      person = store._people.fetch_first.sync
+      person = store._people!.fetch_first.sync
 
       addresses = person.addresses.fetch.sync
       expect(addresses.size).to eq(2)

data/spec/models/buffer_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Volt::Buffer do
+  it 'should let you pass a block that evaluates to the then of the promise' do
+    buffer = the_page._items!.buffer
+
+    count = 0
+    result = buffer.save! do
+      count += 1
+    end
+
+    expect(count).to eq(1)
+    expect(result.class).to eq(Promise)
+  end
+end

data/spec/models/model_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'volt/models'
 
 class TestItem < Volt::Model
 end
@@ -53,9 +52,9 @@ describe Volt::Model do
     expect(!a._false1).to eq(true)
   end
 
-  it "should return a nil model for an underscore value that doesn't exist" do
+  it "should return an empty model for an underscore value that doesn't exist" do
     a = Volt::Model.new
-    expect(a._something.attributes).to eq(nil)
+    expect(a._something!.attributes).to eq({})
   end
 
   it 'should trigger changed once when a new value is assigned.' do
@@ -141,7 +140,7 @@ describe Volt::Model do
   it 'should trigger changed for any indicies after a deleted index' do
     model = Volt::Model.new
 
-    model._items << { _name: 'One' }
+    model._items! << { _name: 'One' }
     model._items << { _name: 'Two' }
     model._items << { _name: 'Three' }
 
@@ -157,7 +156,7 @@ describe Volt::Model do
   it 'should change the size and length when an item gets added' do
     model = Volt::Model.new
 
-    model._items << { _name: 'One' }
+    model._items! << { _name: 'One' }
     size = model._items.size
     length = model._items.length
 
@@ -178,30 +177,73 @@ describe Volt::Model do
   it 'should add doubly nested arrays' do
     model = Volt::Model.new
 
-    model._items << { name: 'Cool', lists: [] }
-    model._items[0]._lists << { name: 'worked' }
+    model._items! << { name: 'Cool', lists: [] }
+    model._items[0]._lists! << { name: 'worked' }
     expect(model._items[0]._lists[0]._name).to eq('worked')
   end
 
   it 'should make pushed subarrays into ArrayModels' do
     model = Volt::Model.new
 
-    model._items << { _name: 'Test', _lists: [] }
+    model._items! << { _name: 'Test', _lists: [] }
     expect(model._items[0]._lists.class).to eq(Volt::ArrayModel)
   end
 
   it 'should make assigned subarrays into ArrayModels' do
     model = Volt::Model.new
 
-    model._item._name = 'Test'
+    model._item!._name = 'Test'
     model._item._lists = []
     expect(model._item._lists.class).to eq(Volt::ArrayModel)
   end
 
+  it 'should call changed when an expanded reference changes' do
+    a = Volt::Model.new
+
+    count = 0
+    -> { a._blue ; count += 1 }.watch!
+
+    expect(count).to eq(1)
+
+    a._blue!
+    Volt::Computation.flush!
+
+    expect(count).to eq(2)
+  end
+
+  it 'should call size changed when adding to an ArrayModel' do
+    a = Volt::Model.new
+
+    count = 0
+    -> { count = a._todos.size }.watch!
+
+    expect(count).to eq(0)
+
+    a._todos << {label: 'Be active'}
+    Volt::Computation.flush!
+
+    expect(count).to eq(1)
+  end
+
+  it 'should track changes through an expansion' do
+    a = Volt::Model.new
+
+    last_count = 0
+    -> { last_count = a._todos.count(&:_checked) }.watch!
+
+    expect(last_count).to eq(0)
+
+    a._todos! << {checked: true}
+    Volt::Computation.flush!
+
+    expect(last_count).to eq(1)
+  end
+
   it 'should call changed when a the reference to a submodel is assigned to another value' do
     a = Volt::Model.new
 
     count = 0
+    a._blue!
     -> { a._blue && a._blue.respond_to?(:_green) && a._blue._green; count += 1 }.watch!
     expect(count).to eq(1)
 
@@ -215,7 +257,7 @@ describe Volt::Model do
     expect(count).to eq(3)
 
     a._blue = { green: 50 }
-    expect(a._blue._green).to eq(50)
+    expect(a._blue!._green).to eq(50)
     Volt::Computation.flush!
     expect(count).to eq(4)
   end
@@ -239,14 +281,14 @@ describe Volt::Model do
   it 'should let you append nested hashes' do
     a = Volt::Model.new
 
-    a._items << { name: { text: 'Name' } }
+    a._items! << { name: { text: 'Name' } }
 
-    expect(a._items[0]._name._text).to eq('Name')
+    expect(a._items[0]._name!._text).to eq('Name')
   end
 
   it 'should not call added too many times' do
     a = Volt::Model.new
-    a._lists << 1
+    a._lists! << 1
 
     count = 0
     a._lists.on('added') { count += 1 }
@@ -258,6 +300,9 @@ describe Volt::Model do
 
   it 'should propigate to different branches' do
     a = Volt::Model.new
+
+    # Expand first
+    a._new_item!
     count = 0
     -> do
       count += 1
@@ -273,11 +318,11 @@ describe Volt::Model do
   describe 'paths' do
     it 'should store the path' do
       a = Volt::Model.new
-      expect(a._test.path).to eq([:test])
+      expect(a._test!.path).to eq([:test])
       a._test = { _name: 'Yes' }
       expect(a._test.path).to eq([:test])
 
-      a._items << { _name: 'Yes' }
+      a._items! << { _name: 'Yes' }
       expect(a._items.path).to eq([:items])
       expect(a._items[0].path).to eq([:items, :[]])
     end
@@ -294,7 +339,7 @@ describe Volt::Model do
     it 'should handle nested paths' do
       a = Volt::Model.new
 
-      a._items << { name: 'Cool', lists: [{ name: 'One' }, { name: 'Two' }] }
+      a._items! << { name: 'Cool', lists: [{ name: 'One' }, { name: 'Two' }] }
 
       expect(a._items[0]._lists.path).to eq([:items, :[], :lists])
       expect(a._items[0]._lists[1].path).to eq([:items, :[], :lists, :[]])
@@ -303,7 +348,7 @@ describe Volt::Model do
     it 'should trigger added when added' do
       a = Volt::Model.new
       count = 0
-      b = a._items
+      b = a._items!
 
       b.on('added') { count += 1 }
       expect(count).to eq(0)
@@ -360,7 +405,7 @@ describe Volt::Model do
 
   it 'should convert to a hash, and unwrap all of the way down' do
     a = Volt::Model.new
-    a._items << { name: 'Test1', other: { time: 'Now' } }
+    a._items! << { name: 'Test1', other: { time: 'Now' } }
     a._items << { name: 'Test2', other: { time: 'Later' } }
 
     item1 = a._items[0].to_h
@@ -382,25 +427,25 @@ describe Volt::Model do
     end
 
     it 'should set the model path' do
-      @model._object._name = 'Test'
+      @model._object!._name = 'Test'
       expect(@model._object.path).to eq([:object])
     end
 
     it 'should set the model path for a sub array' do
-      @model._items << { name: 'Bob' }
+      @model._items! << { name: 'Bob' }
       expect(@model._items.path).to eq([:items])
       expect(@model._items[0].path).to eq([:items, :[]])
     end
 
     it 'should set the model path for sub sub arrays' do
-      @model._lists << { name: 'List 1', items: [] }
-      expect(@model._lists[0]._items.path).to eq([:lists, :[], :items])
+      @model._lists! << { name: 'List 1', items: [] }
+      expect(@model._lists[0]._items!.path).to eq([:lists, :[], :items])
     end
 
     it 'should update the path when added from a model instance to a collection' do
       test_item = TestItem.new
 
-      @model._items << test_item
+      @model._items! << test_item
       expect(@model._items[0].path).to eq([:items, :[]])
     end
   end
@@ -440,7 +485,7 @@ describe Volt::Model do
         @model = Volt::Model.new
 
         # Should return a buffer of the right type
-        expect(@model._items.buffer.class).to eq(Item)
+        expect(@model._items!.buffer.class).to eq(Item)
 
         # Should insert as the right type
         @model._items << { _name: 'Item 1' }
@@ -482,7 +527,7 @@ describe Volt::Model do
 
   if RUBY_PLATFORM != 'opal'
     it 'should update other queries on the server when a new model is created' do
-      query1 = store._todos
+      query1 = store._todos!
       query2 = store._todos.limit(1)
 
       count = 0

data/spec/models/model_state_spec.rb

@@ -5,7 +5,7 @@ if RUBY_PLATFORM != 'opal'
 
   describe Volt::Model do
     it 'should stay loaded while a computaiton is watching some data' do
-      expect(store._items.loaded_state).to eq(:not_loaded)
+      expect(store._items!.loaded_state).to eq(:not_loaded)
 
       comp = -> { store._items.size }.watch!
 

data/spec/models/permissions_spec.rb

@@ -28,6 +28,25 @@ class ::TestDenyReadName < Volt::Model
   end
 end
 
+class ::TestUpdateReadCheck < Volt::Model
+  attr_accessor :create_check, :update_check, :read_check
+
+  permissions(:create) do
+    self.create_check = true
+    allow
+  end
+
+  permissions(:update) do
+    self.update_check = true
+    allow
+  end
+
+  permissions(:read) do
+    self.read_check = true
+    allow
+  end
+end
+
 describe "model permissions" do
   it 'should follow CRUD states when checking permissions' do
     todo = TestUserTodoWithCrudStates.new.buffer
@@ -61,7 +80,7 @@ describe "model permissions" do
   if RUBY_PLATFORM != 'opal'
     describe "read permissions" do
       it 'should deny read on a field' do
-        model = store._test_deny_read_names.buffer
+        model = store._test_deny_read_names!.buffer
         model._name = 'Jimmy'
         model._other = 'should be visible'
 
@@ -78,7 +97,7 @@ describe "model permissions" do
     end
 
     it 'should prevent delete if denied' do
-      model = store._test_deny_deletes.buffer
+      model = store._test_deny_deletes!.buffer
 
       model.save!.then do
         # Saved
@@ -92,5 +111,48 @@ describe "model permissions" do
         expect(count).to eq(1)
       end
     end
+
+    it 'should not check the read permissions when updating (so that all fields are present for the permissions check)' do
+      model = store._test_update_read_checks!.append({name: 'Ryan'}).sync
+
+      expect(model.create_check).to eq(true)
+      expect(model.read_check).to eq(nil)
+
+      # Update
+      model._name = 'Jimmy'
+
+      expect(model.read_check).to eq(nil)
+      expect(model.update_check).to eq(true)
+    end
+
+    it 'should not check read permissions on buffer save on server' do
+      model = store._test_update_read_checks!.buffer
+
+      model._name = 'Ryan'
+
+      # Create
+      model.save!
+
+      # Create happens on the save_to, not the buffer
+      expect(model.save_to.create_check).to eq(true)
+      expect(model.save_to.read_check).to eq(nil)
+
+      # Update
+      model._name = 'Jimmy'
+      model.save!
+
+      expect(model.save_to.read_check).to eq(nil)
+      expect(model.save_to.update_check).to eq(true)
+    end
+
+    it 'should not check read on delete, so all fields are available to the permissions block' do
+      model = store._test_update_read_checks!.append({name: 'Ryan'}).sync
+
+      expect(model.read_check).to eq(nil)
+
+      model.destroy
+
+      expect(model.read_check).to eq(nil)
+    end
   end
 end