volt 0.9.3.pre1 → 0.9.3.pre2

data/spec/models/model_spec.rb

@@ -61,7 +61,7 @@ describe Volt::Model 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({})
+    expect(a._something!.attributes.without(:id)).to eq({})
   end
 
   it 'should trigger changed once when a new value is assigned.' do
@@ -425,7 +425,15 @@ describe Volt::Model do
       { name: 'Test1', other: { time: 'Now' } },
       { name: 'Test2', other: { time: 'Later' } }
     ]
-    expect(all_items).to eq(a)
+
+    # Remove id's nested
+    items = all_items.map do |hash|
+      hash.without(:id).map do |k,v|
+        v = v.without(:id) if v.is_a?(Hash)
+        [k,v]
+      end.to_h
+    end
+    expect(items).to eq(a)
   end
 
   describe 'model paths' do

data/spec/models/permissions_spec.rb

@@ -47,6 +47,13 @@ class ::TestUpdateReadCheck < Volt::Model
 end
 
 describe 'model permissions' do
+  let(:user_todo) { TestUserTodo.new }
+
+  it 'auto-associates users via own_by_user' do
+    #TODO: better assertions
+    expect(user_todo.respond_to?(:user)).to be(true)
+  end
+
   it 'should follow CRUD states when checking permissions' do
     todo = TestUserTodoWithCrudStates.new.buffer
 
@@ -111,6 +118,8 @@ describe 'model permissions' do
     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.new?).to eq(false)
+
       expect(model.create_check).to eq(true)
       expect(model.read_check).to eq(nil)
 

data/spec/models/persistors/store_spec.rb

@@ -27,4 +27,12 @@ describe Volt::Persistors::Store do
 
     @model << 4
   end
+
+  it 'passes removed() to changed() by default' do
+    model     = Volt::Model.new(abc: 123)
+    persistor = Volt::Persistors::Store.new(model)
+    expect(persistor.removed(:abc)).to eq(persistor.changed(:abc))
+    model._abc = 456
+    expect(persistor.removed(:abc)).to eq(persistor.changed(:abc))
+  end
 end

data/spec/page/bindings/content_binding_spec.rb

@@ -15,7 +15,7 @@ describe Volt::ContentBinding do
 
   it 'should render with a template' do
     context = { name: 'jimmy' }
-    binding = ->(page, target, context, id) { Volt::ContentBinding.new(page, target, context, id, proc { self[:name] }) }
+    binding = ->(volt_app, target, context, id) { Volt::ContentBinding.new(volt_app, target, context, id, proc { self[:name] }) }
 
     templates = {
       'main/main' => {
@@ -27,9 +27,13 @@ describe Volt::ContentBinding do
     page = double('volt/page')
     expect(page).to receive(:templates).and_return(templates)
 
+    volt_app = double('volt/app')
+    expect(volt_app).to receive(:page).and_return(page)
+
+
     dom = Volt::AttributeTarget.new(0)
 
-    Volt::TemplateRenderer.new(page, dom, context, 'main', 'main/main')
+    Volt::TemplateRenderer.new(volt_app, dom, context, 'main', 'main/main')
 
     expect(dom.to_html).to eq('hello jimmy')
   end

data/spec/page/bindings/each_binding_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+class ::TestEachBindingController < Volt::ModelController
+  model :page
+end
+
+describe Volt::EachBinding do
+  it 'should render an each binding' do
+    dom = Volt::AttributeTarget.new(0)
+    context = ::TestEachBindingController.new(volt_app)
+    context._items << {name: 'One'}
+    context._items << {name: 'Two'}
+
+
+    getter = Proc.new { context._items }
+    variable_name = 'item'
+    index_name = 'index'
+    template_name = 'main/item'
+
+    # Setup the each binding
+    each_binding = ->(volt_app, target, context, id) do
+      Volt::EachBinding.new(volt_app, target, context, id, getter,
+                            variable_name, index_name, template_name)
+    end
+
+    # Setup a content binding to make sure its passing the right item
+    content_binding = ->(volt_app, target, context, id) do
+      Volt::ContentBinding.new(volt_app, target, context, id,
+                               proc { item._name })
+    end
+
+    templates = {
+      'main/main' => {
+        'html' => 'hello <!-- $1 --><!-- $/1 -->',
+        'bindings' => { 1 => [each_binding] }
+      },
+      'main/item' => {
+        'html' => '<!-- $2 --><!-- $/2 -->, ',
+        'bindings' => {
+          2 => [content_binding]
+        }
+      }
+    }
+
+    page = double('volt/page')
+    expect(page).to receive(:templates).and_return(templates).at_least(1).times
+
+    volt_app = double('volt/app')
+    expect(volt_app).to receive(:page).and_return(page).at_least(1).times
+
+    Volt::TemplateRenderer.new(volt_app, dom, context, 'main', 'main/main')
+
+    expect(dom.to_html).to eq('hello One, Two, ')
+
+    context._items << {name: 'Three'}
+    Volt::Computation.flush!
+    expect(dom.to_html).to eq('hello One, Two, Three, ')
+  end
+end

data/spec/page/bindings/if_binding_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+class ::TestIfBindingController < Volt::ModelController
+  model :page
+end
+
+describe Volt::IfBinding do
+  it 'should render an if' do
+    dom = Volt::AttributeTarget.new(0)
+    context = ::TestIfBindingController.new(volt_app)
+    context._name = 'jimmy'
+
+    branches = [
+      [
+        proc { _name == 'jimmy' },
+        'main/if_true'
+      ],
+      [
+        nil,
+        'main/if_false'
+      ]
+    ]
+
+    binding = ->(volt_app, target, context, id) do
+      Volt::IfBinding.new(volt_app, target, context, 0, branches)
+    end
+
+    templates = {
+      'main/main' => {
+        'html' => 'hello <!-- $1 --><!-- $/1 -->',
+        'bindings' => { 1 => [binding] }
+      },
+      'main/if_true' => {
+        'html' => 'yes, true',
+        'bindings' => {}
+      },
+      'main/if_false' => {
+        'html' => 'no, false',
+        'bindings' => {}
+      }
+    }
+
+    page = double('volt/page')
+    expect(page).to receive(:templates).and_return(templates).at_least(1).times
+
+    volt_app = double('volt/app')
+    expect(volt_app).to receive(:page).and_return(page).at_least(1).times
+
+    Volt::TemplateRenderer.new(volt_app, dom, context, 'main', 'main/main')
+
+    expect(dom.to_html).to eq('yes, true')
+
+    context._name = 'bob'
+    Volt::Computation.flush!
+    expect(dom.to_html).to eq('no, false')
+  end
+end

data/spec/page/path_string_renderer_spec.rb

@@ -5,23 +5,23 @@ unless RUBY_PLATFORM == 'opal'
   describe Volt::PathStringRenderer do
     before do
       kitchen_sink_path = File.expand_path(File.join(File.dirname(__FILE__), '../apps/kitchen_sink'))
-      app = Volt::App.new(kitchen_sink_path)
-      @page = app.page
+      @volt_app = Volt::App.new(kitchen_sink_path)
+      @page = @volt_app.page
     end
 
     it 'should render a section' do
-      html = Volt::PathStringRenderer.new('main/mailers/welcome/subject', nil, @page).html
+      html = Volt::PathStringRenderer.new(@volt_app, 'main/mailers/welcome/subject', nil, @page).html
       expect(html).to eq("\n  Welcome to the site!\n\n")
     end
 
     it 'should render a section with a variable' do
-      html = Volt::PathStringRenderer.new('main/mailers/welcome/html', { name: 'Jimmy' }, @page).html
+      html = Volt::PathStringRenderer.new(@volt_app, 'main/mailers/welcome/html', { name: 'Jimmy' }, @page).html
       expect(html).to eq("\n  <h1>Welcome Jimmy</h1>\n\n  <p>Glad you signed up!</p>\n\n")
     end
 
     it 'Raises raises ViewLookupException if full_path is nil' do
       expect do
-        Volt::PathStringRenderer.new('', { name: 'Jimmy' }, Volt::Page.new).html
+        Volt::PathStringRenderer.new(@volt_app, '', { name: 'Jimmy' }, Volt::Page.new(@volt_app)).html
       end.to raise_error(Volt::ViewLookupException)
     end
   end

data/spec/reactive/computation_spec.rb

@@ -114,7 +114,7 @@ describe Volt::Computation do
 
   describe 'watch_and_resolve!' do
     it 'should resolve any returnted promises' do
-      promise = Promise.new.resolve('resolved')
+      promise = Promise.new
       count = 0
 
       -> { promise }.watch_and_resolve! do |result|
@@ -122,8 +122,72 @@ describe Volt::Computation do
         count += 1
       end
 
+      expect(count).to eq(0)
+
+      promise.resolve('resolved')
+
+      Volt::Computation.flush!
       expect(count).to eq(1)
     end
+
+    it 'should not resolve a promise if another value came in' do
+      dep = Volt::Dependency.new
+
+      promise = Promise.new
+      cur_val = promise
+
+      results = []
+      -> { dep.depend ; cur_val }.watch_and_resolve! do |val|
+        results << val
+      end
+
+      expect(results).to eq([])
+
+      cur_val = 5
+      dep.changed!
+      Volt::Computation.flush!
+
+      expect(results).to eq([5])
+
+      promise.resolve(10)
+      expect(results).to eq([5])
+    end
+
+    it 'should yield nil for an unresolved promise when asked' do
+      dep = Volt::Dependency.new
+
+      cur_val = Promise.new
+
+      results = []
+      -> { dep.depend ; cur_val }.watch_and_resolve!(true) do |val|
+        results << val
+      end
+
+      expect(results).to eq([nil])
+
+      cur_val.resolve(5)
+
+      expect(results).to eq([nil, 5])
+    end
+
+    it 'should not resolve if the computation was stopped' do
+      dep = Volt::Dependency.new
+
+      cur_val = Promise.new
+
+      results = []
+      computation = -> { dep.depend ; cur_val }.watch_and_resolve! do |val|
+        results << val
+      end
+
+      expect(results).to eq([])
+
+      computation.stop
+
+      cur_val.resolve(5)
+
+      expect(results).to eq([])
+    end
   end
 
   # Currently Class#class_variable_set/get isn't in opal

data/spec/router/routes_spec.rb

@@ -233,7 +233,7 @@ describe Volt::Routes do
 
     path, cleaned_params = @routes.params_to_url(params.to_h)
     expect(path).to eq('/blog')
-    expect(cleaned_params).to eq(index: '5')
+    expect(cleaned_params.without(:id)).to eq(index: '5')
   end
 
   it 'should handle routes with bindings in them' do

data/spec/server/html_parser/sandlebars_parser_spec.rb

@@ -37,20 +37,6 @@ class HTMLHandler
   end
 end
 
-def parse_url(url)
-  require 'open-uri'
-  html = open("http://#{url}").read
-
-  # html = File.read("/Users/ryanstout/Desktop/tests/#{url}1.html")
-
-  File.open("/Users/ryanstout/Desktop/tests/#{url}1.html", 'w') { |f| f.write(html) }
-
-  handler = HTMLHandler.new
-  Volt::SandlebarsParser.new(html, handler)
-
-  File.open("/Users/ryanstout/Desktop/tests/#{url}2.html", 'w') { |f| f.write(handler.html) }
-end
-
 describe Volt::SandlebarsParser do
   def test_html(html, match = nil)
     handler = HTMLHandler.new
@@ -176,15 +162,19 @@ describe Volt::SandlebarsParser do
     test_html(html)
   end
 
-  it 'should be fast' do
-    html = File.read(File.join(File.dirname(__FILE__), 'sample_page.html'))
-    handler = HTMLHandler.new
-    time = Benchmark.measure do
-      Volt::SandlebarsParser.new(html, handler)
-    end
+  # On jruby, hotspot will optimize this, but it takes a while, so we should
+  # just look for MRI performance regresions
+  if RUBY_PLATFORM != 'java'
+    it 'should be fast' do
+      html = File.read(File.join(File.dirname(__FILE__), 'sample_page.html'))
+      handler = HTMLHandler.new
+      time = Benchmark.measure do
+        Volt::SandlebarsParser.new(html, handler)
+      end
 
-    # Less than 100ms
-    expect(time.total).to be < 0.1
+      # Less than 100ms
+      expect(time.total).to be < 0.1
+    end
   end
 
   it 'should parse nested components' do

data/spec/server/message_bus/message_encoder_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+unless RUBY_PLATFORM == 'opal'
+  describe Volt::MessageBus do
+    before do
+      # Stub socket stuff
+      allow_any_instance_of(Volt::MessageBus).to receive(:connect_to_peers).and_return(nil)
+    end
+
+    describe "encryption" do
+      before do
+        @msg_bus_config = double('volt/config')
+
+        expect(Volt.config).to receive(:message_bus).and_return(@msg_bus_config)
+      end
+
+      it 'should get disabled state from Volt.config.message_bus.encryption_disabled' do
+        expect(@msg_bus_config).to receive(:disable_encryption).and_return(true)
+
+        encoder = Volt::MessageBus::MessageEncoder.new
+
+        expect(encoder.encrypted).to eq(false)
+      end
+
+      it 'should get enabled state from Volt.config.message_bus.encryption_disabled' do
+        expect(@msg_bus_config).to receive(:disable_encryption).and_return(false)
+
+        encoder = Volt::MessageBus::MessageEncoder.new
+
+        expect(encoder.encrypted).to eq(true)
+      end
+    end
+
+    it 'should encrypt and decrypt' do
+      message = 'this is my message that should be encrypted'
+      encoder = Volt::MessageBus::MessageEncoder.new
+
+      encrypted_message = encoder.encrypt(message)
+
+      # Should be encrypted
+      expect(encrypted_message).to_not eq(message)
+
+      decrypted_message = encoder.decrypt(encrypted_message)
+
+      expect(decrypted_message).to eq(message)
+    end
+
+  end
+end

data/spec/server/message_bus/peer_to_peer/peer_connection_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+unless RUBY_PLATFORM == 'opal'
+  describe Volt::MessageBus::PeerConnection do
+    describe 'pass the server_id back and forth' do
+      before do
+        @socket = double('socket')
+
+        @bus = double('message bus')
+        expect(@bus).to receive(:server_id).and_return('server one')
+        expect(@bus).to receive(:remove_duplicate_connections)
+
+        thread = double('thread')
+        allow(thread).to receive(:kill)
+        allow(Thread).to receive(:new).and_return(thread)
+
+        encoder = double('encoder')
+        expect(Volt::MessageBus::MessageEncoder).to receive(:new).and_return(encoder)
+
+        expect(encoder).to receive(:receive_message).with(@socket)
+          .and_return('server two')
+
+        expect(encoder).to receive(:send_message).with(@socket, 'server one')
+      end
+
+      it 'should on server' do
+        Volt::MessageBus::PeerConnection.new(@socket, nil, nil, @bus, true)
+      end
+
+      it 'should pass the server_id back and forth to client' do
+        Volt::MessageBus::PeerConnection.new(@socket, nil, nil, @bus)
+      end
+    end
+
+    class MessageBusDouble
+      def initialize(id, receiver)
+        @id = id
+        @receiver = receiver
+      end
+
+      def server_id
+        @id
+      end
+
+      def remove_duplicate_connections
+      end
+
+      def remove_peer_connection(conn)
+      end
+
+      def handle_message(message)
+        @receiver << message
+      end
+    end
+
+    # Disable for jruby for now
+    if RUBY_PLATFORM != 'java'
+      it 'should pass messages between two peer conections' do
+        responses1 = []
+        bus1 = MessageBusDouble.new('server one', responses1)
+
+        responses2 = []
+        bus2 = MessageBusDouble.new('server two', responses2)
+
+        server = TCPServer.new(0)
+        port = server.addr[1]
+
+        threads = []
+        threads << Thread.new do
+          @server = server.accept
+        end
+
+        threads << Thread.new do
+          @client = TCPSocket.new('localhost', port)
+        end
+
+        threads.each(&:join)
+
+        threads = []
+
+        conn1 = nil
+        threads << Thread.new do
+          conn1 = Volt::MessageBus::PeerConnection.new(@server, nil, nil, bus1, true)
+        end
+
+        conn2 = nil
+        threads << Thread.new do
+          conn2 = Volt::MessageBus::PeerConnection.new(@client, nil, nil, bus2)
+        end
+
+        threads.each(&:join)
+
+        conn1.publish('test message')
+
+        loop do
+          break if responses2.size > 0
+          sleep 0.05
+        end
+
+        expect(responses2).to eq(['test message'])
+
+        conn1.disconnect
+        conn2.disconnect
+
+      end
+    end
+  end
+end

data/spec/server/message_bus/peer_to_peer/peer_server_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+unless RUBY_PLATFORM == 'opal'
+  describe Volt::MessageBus::PeerServer do
+    describe "ip and ports" do
+      before do
+        allow_any_instance_of(Volt::MessageBus::PeerServer).to receive(:run_server)
+      end
+
+      it 'should use Volt.config.message_bus.bind_port_ranges to connect' do
+        config = double('volt/config')
+        expect(Volt.config).to receive(:message_bus).and_return(config)
+          .at_least(:once)
+
+        ports = [5000,6000,7000]
+
+        expect(config).to receive(:bind_port_ranges).and_return(ports)
+          .at_least(:once)
+
+        tried_ports = []
+
+        # Act like all sockets are in use to test NoAvailablePortException
+        expect(TCPServer).to receive(:new) do |port|
+          tried_ports << port
+        end.at_least(:once).and_raise(Errno::EADDRINUSE)
+
+        expect do
+          peer_server = Volt::MessageBus::PeerServer.new(nil)
+        end.to raise_error(Volt::MessageBus::NoAvailablePortException)
+
+        expect(tried_ports.sort).to eq(ports)
+      end
+    end
+
+    it 'should start a server that creates peer connections when accepted' do
+      expect(Thread).to receive(:new).and_yield
+      # The PeerConnection that will be created
+      new_peer = double('new peer connection')
+
+      message_bus = double('message bus')
+      expect(message_bus).to receive(:add_peer_connection) do |peer_conn|
+        expect(peer_conn).to eq(new_peer)
+        # Raise an exception to get out of the loop
+      end.and_raise(Exception)
+
+      # Stub the socket connection
+      socket = double('tcp server socket')
+
+      # Stub the incoming connection
+      connection = double('client socket connection')
+
+      expect(socket).to receive(:accept).and_return(connection)
+
+      expect(Thread).to receive(:start).with(connection).and_yield(connection)
+      expect(TCPServer).to receive(:new).and_return(socket)
+
+      expect(Volt::MessageBus::PeerConnection).to receive(:new)
+        .and_return(new_peer)
+
+      expect do
+        peer_server = Volt::MessageBus::PeerServer.new(message_bus)
+      end.to raise_error(Exception)
+    end
+
+  end
+end

data/spec/server/message_bus/peer_to_peer/socket_with_timeout_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+unless RUBY_PLATFORM == 'opal'
+  describe Volt::SocketWithTimeout do
+    it 'should setup a connection manually and then specify a timeout' do
+      allow_any_instance_of(Socket).to receive(:connect)
+
+      Volt::SocketWithTimeout.new('google.com', 80, 10)
+    end
+  end
+end

data/spec/server/message_bus/peer_to_peer_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+unless RUBY_PLATFORM == 'opal'
+  describe Volt::MessageBus::PeerToPeer do
+    before do
+      # Stub socket stuff
+      allow_any_instance_of(Volt::MessageBus::PeerToPeer).to receive(:connect_to_peers).and_return(nil)
+    end
+
+  end
+end

data/spec/server/rack/asset_files_spec.rb

@@ -19,7 +19,7 @@ if RUBY_PLATFORM != 'opal'
     it 'should list all JS files' do
       main = Volt::AssetFiles.new('main', @component_paths)
 
-      expect(main.javascript_files(nil)).to eq(['/assets/js/jquery-2.0.3.js', '/assets/js/volt_js_polyfills.js', '/assets/js/volt_watch.js', '/assets/js/bootstrap.js', '/assets/js/test2.js', '/assets/js/test3.js', '/assets/js/test1.js', '/assets/volt/page/page.js', '/components/main.js'])
+      expect(main.javascript_files(nil)).to eq(['/assets/js/jquery-2.0.3.js', '/assets/js/volt_js_polyfills.js', '/assets/js/volt_watch.js', '/assets/js/bootstrap.js', '/assets/js/test2.js', '/assets/js/test3.js', '/assets/js/test1.js', '/assets/volt/volt/app.js', '/components/main.js'])
     end
 
     it 'should raise an exception for a missing component gem' do

data/spec/server/rack/http_resource_spec.rb

@@ -34,10 +34,10 @@ if RUBY_PLATFORM != 'opal'
     end
 
     it 'should initialize the correct controller and call the correct action' do
-      http_resource = Volt::HttpResource.new(app, @routes)
+      http_resource = Volt::HttpResource.new(app, volt_app, @routes)
       env = Rack::MockRequest.env_for('http://example.com/stuff')
       request = Volt::HttpRequest.new(env)
-      controller = SimpleController.new({}, request)
+      controller = SimpleController.new(volt_app, {}, request)
       expect(SimpleController).to receive(:new).and_return(controller)
 
       response = http_resource.call(env)
@@ -47,7 +47,7 @@ if RUBY_PLATFORM != 'opal'
     end
 
     it 'should parse the correct params to the controller' do
-      http_resource = Volt::HttpResource.new(app, @routes)
+      http_resource = Volt::HttpResource.new(app, volt_app, @routes)
       env = Rack::MockRequest.env_for('http://example.com/stuff/99?test=another_param')
       request = Volt::HttpRequest.new(env)
 
@@ -57,7 +57,7 @@ if RUBY_PLATFORM != 'opal'
     end
 
     it 'should call the supplied app if routes are not matched and cause a 404' do
-      http_resource = Volt::HttpResource.new(app, @routes)
+      http_resource = Volt::HttpResource.new(app, volt_app, @routes)
       env = Rack::MockRequest.env_for('http://example.com/not_a_valid_param')
       request = Volt::HttpRequest.new(env)
       response = http_resource.call(env)