volt 0.9.6 → 0.9.7.pre2

data/spec/integration/save_spec.rb

@@ -8,6 +8,6 @@ describe 'saving', type: :feature, sauce: true do
 
     click_button 'Save'
 
-    expect(page).to have_content('#<Volt::Errors {"title"=>["must be at least 5 characters"]}>')
+    expect(page).to have_content('title must be at least 5 characters')
   end
 end

data/spec/integration/todos_spec.rb

@@ -4,6 +4,7 @@ describe 'todos app', type: :feature, sauce: true do
   ENTER_KEY = ENV["BROWSER"] == 'phantom' ? :Enter : :return
   it 'should add a todo and remove it' do
     visit '/todos'
+    store._todos
 
     fill_in 'newtodo', with: 'Todo 1'
     find('#newtodo').native.send_keys(ENTER_KEY)
@@ -18,15 +19,16 @@ describe 'todos app', type: :feature, sauce: true do
 
     # Make sure it deleted
     if ENV['BROWSER'] == 'phantom'
-        visit '/todos'
+      visit '/todos'
     else
-        page.driver.browser.navigate.refresh
+      page.driver.browser.navigate.refresh
     end
     expect(page).to_not have_content('Todo 1')
   end
 
   it 'should update a todo check state and persist' do
     visit '/todos'
+    store._todos
 
     fill_in 'newtodo', with: 'Todo 1'
     find('#newtodo').native.send_keys(ENTER_KEY)
@@ -36,11 +38,11 @@ describe 'todos app', type: :feature, sauce: true do
     find("input[type='checkbox']").click
 
     if ENV['BROWSER'] == 'phantom'
-        visit '/todos'
+      visit '/todos'
     else
-        page.evaluate_script('document.location.reload()')
+      page.evaluate_script('document.location.reload()')
     end
 
     expect(find("input[type='checkbox']").checked?).to eq(true)
   end
-end
+end

data/spec/models/array_model_spec.rb

@@ -4,8 +4,11 @@ require 'spec_helper'
 # ArrayModel specs here.
 describe Volt::ArrayModel do
   unless RUBY_PLATFORM == 'opal'
+    class Post < Volt::Model
+    end
+
     it 'should return a Promise for empty? on store' do
-      expect(store._posts.empty?.class).to eq(Promise)
+      expect(store.posts.empty?.class).to eq(Promise)
     end
   end
 
@@ -39,12 +42,23 @@ describe Volt::ArrayModel do
     expect(array.to_a.flatten.size).to eq(6)
   end
 
+  it 'should not equal another array model with the same content' do
+    a = Volt::ArrayModel.new([])
+    b = Volt::ArrayModel.new([])
+
+    expect(a == b).to eq(false)
+    expect(a == a).to eq(true)
+  end
+
   unless RUBY_PLATFORM == 'opal'
+    class Item < Volt::Model
+    end
+
     it 'should return a promise for store on .length, .size, and .count' do
-      store._items << {name: 'One'}
+      store.items << {name: 'One'}
 
       [:size, :count, :length].each do |method_name|
-        val = store._items.send(method_name)
+        val = store.items.send(method_name)
         expect(val.class).to eq(Promise)
         expect(val.sync).to eq(1)
       end

data/spec/models/associations_spec.rb

@@ -3,7 +3,6 @@ require 'spec_helper'
 class ::Person < Volt::Model
   has_many :addresses
 end
-
 class ::Address < Volt::Model
   belongs_to :person
   has_one :zip_info
@@ -30,6 +29,7 @@ describe Volt::Associations do
       it 'should associate via belongs_to' do
         address = store.addresses.first.sync
 
+        # binding.pry
         expect(address.person_id).to eq(@person.id)
         expect(address.person.sync.id).to eq(@person.id)
       end
@@ -90,5 +90,52 @@ describe Volt::Associations do
       expect(bob.addresses[0].sync.person_id).to eq(bob.id)
       expect(bob.id).to_not eq(nil)
     end
+
+    it 'should raise an exception when defining an association with an already used name' do
+      expect do
+        Class.new(Volt::Model) do
+          set_collection_name :temp1
+          has_many :ones
+          has_many :ones
+        end
+      end.to raise_error(/An association is already defined for `ones`/)
+    end
+
+    it 'should track association data' do
+      expect(AddressBelongToOption.associations[:someone]).to eq(
+        {
+          :type=>:belongs_to,
+          :collection=>:people,
+          :foreign_key=>:id,
+          :local_key=>:some_weird_id,
+          :to_many=>false
+        }
+      )
+
+      expect(Person.associations[:addresses]).to eq(
+        {
+          :type=>:has_many,
+          :to_many=>true,
+          :collection=>:addresses,
+          :foreign_key=>:person_id,
+          :local_key=>:id
+      })
+
+      expect(Address.associations[:zip_info]).to eq({
+                                                      :type=>:has_one,
+                                                      :to_many=>false,
+                                                      :collection=>:zip_infos,
+                                                      :foreign_key=>:address_id,
+                                                      :local_key=>:id
+      })
+    end
+
+    # it 'should let you assign belongs_to' do
+    #   bob = ::Person.new
+
+    #   address = ::Address.new
+
+    #   expect(address.person).to eq(nil)
+    # end
   end
 end

data/spec/models/field_helpers_spec.rb

@@ -27,7 +27,7 @@ describe 'field helpers' do
   it 'should raise an error when an invalid cast type is provided' do
     expect do
       ExampleModelWithField2.field :awesome, Range
-    end.to raise_error(FieldHelpers::InvalidFieldClass)
+    end.to raise_error(Volt::FieldHelpers::InvalidFieldClass)
   end
 
   it 'should convert numeric strings to Fixnum when Fixnum is specified as a type restriction' do
@@ -41,12 +41,16 @@ describe 'field helpers' do
     buf.value = 'cats'
     expect(buf.value).to eq('cats')
 
+    fail_called = false
     buf.validate!.fail do |error|
-      expect(error).to eq({})
+      fail_called = true
+      expect(error).to eq({'value' => ['must be a number']})
     end
+
+    expect(fail_called).to eq(true)
   end
 
   it 'should track the fields on the model class' do
-    expect(ExampleModelWithField.fields_data).to eq({name:[nil, {}], value:[[Numeric, NilClass], {}]})
+    expect(ExampleModelWithField.fields).to eq({:name=>[nil, {}], :value=>[[Numeric, NilClass], {}]})
   end
 end

data/spec/models/migrations/migration_runner_spec.rb

@@ -0,0 +1,69 @@
+unless RUBY_PLATFORM == 'opal'
+  require 'spec_helper'
+  require 'volt/models/migrations/migration_runner'
+
+  describe Volt::MigrationRunner do
+    let(:migration_app_path) { File.expand_path("#{File.dirname(__FILE__)}/../../apps/migrations") }
+    let(:migration_folder) { File.expand_path("#{migration_app_path}/config/db/migrations") }
+    let(:runner) { Volt::MigrationRunner.new }
+    after do
+    	# Migration runner changes the db, but doesn't touch store, so cleanup
+    	# manually after.
+      cleanup_db
+    end
+
+    it 'should run migrations that have not been run yet' do
+      expect(runner.has_version?(1445111704)).to eq(false)
+
+      runner.run_migration("#{migration_folder}/1445111704_migration1.rb", :up)
+
+      expect(runner.has_version?(1445111704)).to eq(true)
+    end
+
+    it 'should migrate up and down' do
+      count = runner.all_versions.size
+      expect(count).to eq(0)
+
+      expect(Volt).to receive(:root).and_return(migration_app_path).at_least(:once)
+
+      runner.run(:up)
+
+      count = runner.all_versions.size
+      expect(count).to eq(3)
+
+      runner.run(:down)
+
+      count = runner.all_versions.size
+      expect(count).to eq(0)
+    end
+
+    it 'should migrate up until a number' do
+      count = runner.all_versions.size
+      expect(count).to eq(0)
+
+      expect(Volt).to receive(:root).and_return(migration_app_path).at_least(:once)
+
+      runner.run(:up, 1445113517)
+
+      count = runner.all_versions.size
+      expect(count).to eq(2)
+    end
+
+    it 'should migrate down to a version number' do
+      count = runner.all_versions.size
+      expect(count).to eq(0)
+
+      expect(Volt).to receive(:root).and_return(migration_app_path).at_least(:once)
+
+      runner.run(:up)
+
+      count = runner.all_versions.size
+      expect(count).to eq(3)
+
+      runner.run(:down, 1445113517)
+
+      count = runner.all_versions.size
+      expect(count).to eq(1)
+    end
+  end
+end

data/spec/models/model_spec.rb

@@ -12,12 +12,21 @@ end
 class SubItem < Item
 end
 
+class Todo < Volt::Model
+  #  field :label, String
+end
+
 class TestAssignsMethod < Volt::Model
   def name=(val)
     self._name = val
   end
 end
 
+class TempModel < Volt::Model
+  temporary
+end
+
+
 describe Volt::Model do
   it 'delegates unary operator to its attributes' do
     model = Volt::Model.new
@@ -569,8 +578,8 @@ 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!
-      query2 = store._todos.limit(1)
+      query1 = store.todos
+      query2 = store.todos.limit(1)
 
       count = 0
 
@@ -579,7 +588,7 @@ describe Volt::Model do
 
       expect(count).to eq(0)
 
-      query1 << { label: 'One' }
+      query1.create({ label: 'One' })
 
       count = 0
       query2.all.each { |v| count += 1 }
@@ -605,7 +614,7 @@ describe Volt::Model do
     it 'fails if attempting to destroy while parentless' do
       model = Volt::Model.new(test: "yeah")
       expect { model.destroy }.to raise_error(RuntimeError,
-        'Model does not have a parent and cannot be deleted.')
+                                              'Model does not have a parent and cannot be deleted.')
     end
   end
 
@@ -619,10 +628,31 @@ describe Volt::Model do
     end
   end
 
-  it 'creates sub-arrays with correct classes' do
-    model = Volt::Model.new
-    model._items << {}
-    expect(model._items).to be_instance_of Items
+  describe "Wrapping" do
+    it 'creates sub-arrays with correct classes' do
+      model = Volt::Model.new
+      model._items << {}
+      expect(model._items).to be_instance_of Items
+    end
+
+    it 'creates sub-hashes when using nested hashes' do
+      model = Volt::Model.new({name: 'Bob', stuff: {arm: true, leg: true}})
+
+      expect(model._name).to eq('Bob')
+      expect(model._stuff._arm).to eq(true)
+    end
+
+    it 'should wrap subcollections on new' do
+      model = Volt::Model.new(name: 'Bob', items: [{name: 'Item 1'}, {name: 'Item 2'}])
+
+      expect(model._items[1]._name).to eq('Item 2')
+    end
+
+    it 'should new off of a collection' do
+      item = the_page._items.new({name: 'Bob'})
+      expect(item._name).to eq('Bob')
+      expect(item.class).to eq(Item)
+    end
   end
 
   it 'assigns the superclass\'s custom ArrayModel if it exists' do
@@ -630,4 +660,8 @@ describe Volt::Model do
     model._sub_items << {}
     expect(model._sub_items).to be_instance_of Items
   end
+
+  it 'should allow a temporary flag to be set' do
+    expect(TempModel.is_temporary).to eq(true)
+  end
 end

data/spec/models/permissions_spec.rb

@@ -91,9 +91,21 @@ describe 'model permissions' do
   # end
 
   if RUBY_PLATFORM != 'opal'
+    class TestDenyReadName < Volt::Model
+    end
+
+    class TestDenyDelete < Volt::Model
+    end
+
+    class TestUpdateReadCheck < Volt::Model
+    end
+
+    class TestPromisePermission < Volt::Model
+    end
+
     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'
 
@@ -102,7 +114,7 @@ describe 'model permissions' do
         # Clear the identity map, so we can load up a fresh copy
         model.save_to.persistor.clear_identity_map
 
-        reloaded = store._test_deny_read_names.first.sync
+        reloaded = store.test_deny_read_names.first.sync
 
         expect(reloaded._name).to eq(nil)
         expect(reloaded._other).to eq('should be visible')
@@ -110,13 +122,13 @@ 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
         count = 0
 
-        store._test_deny_deletes.delete(model).fail do |err|
+        store.test_deny_deletes.delete(model).fail do |err|
           # deleted
           count += 1
 
@@ -129,7 +141,7 @@ describe 'model permissions' do
     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
+      model = store.test_update_read_checks.append(name: 'Ryan').sync
 
       expect(model.new?).to eq(false)
 
@@ -144,7 +156,7 @@ describe 'model permissions' do
     end
 
     it 'should not check read permissions on buffer save on server' do
-      model = store._test_update_read_checks!.buffer
+      model = store.test_update_read_checks.buffer
 
       model._name = 'Ryan'
 
@@ -164,7 +176,7 @@ describe 'model permissions' do
     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
+      model = store.test_update_read_checks.append(name: 'Ryan').sync
 
       expect(model.read_check).to eq(nil)
 
@@ -174,7 +186,7 @@ describe 'model permissions' do
     end
 
     it 'should allow permission blocks to return a promise' do
-      promise = store._test_promise_permissions.create({})
+      promise = store.test_promise_permissions.create({})
 
       expect(promise.resolved?).to eq(false)
       expect(promise.rejected?).to eq(false)

data/spec/models/persistors/array_store_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+unless RUBY_PLATFORM == 'opal'
+  describe Volt::Persistors::ArrayStore do
+    it 'should make a Cursor using :where_with_block when passing a block to where' do
+      cursor = store._users.where({name: 'Bob'}) {|v| v.location == 'Bozeman' }
+
+      expect(cursor.options[:query]).to eq(
+        [
+          [
+            "where_with_block",
+            {:name=>"Bob"},
+          ["c", ["c", "ident", "location"], "==", "Bozeman"]]
+        ]
+      )
+    end
+  end
+end