volt 0.9.6 → 0.9.7.pre2

data/spec/queries/query_identifier_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe Volt::QueryIdentifier do
+  let(:ident) { subject }
+  it 'should call first on ident' do
+    expect(ident.name.to_query).to eq(["c", "ident", "name"])
+  end
+
+  it 'should group according to method calls' do
+    expect((ident.name < 5).to_query).to eq(["c", ["c", "ident", "name"], "<", 5])
+  end
+
+  it 'should group & into a Volt::QueryOp' do
+    query = ((ident.lat > 80) & (ident.lng < 50))
+    expect(query.to_query).to eq(
+      [
+        "c",
+        ["c", ["c", "ident", "lat"], ">", 80],
+        "&",
+        ["c", ["c", "ident", "lng"], "<", 50]
+      ]
+    )
+  end
+
+  it 'should place the . correctly when coercing' do
+    query = (5 < ident.lat)
+    expect(query.to_query).to eq(["c", 5, "<", ["c", "ident", "lat"]])
+  end
+
+  it 'should group | into a Volt::QueryOp' do
+    query = ((ident.lat > 80) & (ident.lng < 50)) | (ident.name == 'Bob')
+    expect(query.to_query).to eq(
+      [
+        "c",
+        [
+          "c",
+          ["c", ["c", "ident", "lat"], ">", 80],
+          '&',
+          ["c",
+           ["c", "ident", "lng"], "<", 50]
+        ],
+        '|',
+        ["c", ["c", "ident", "name"], "==", "Bob"]
+      ]
+    )
+  end
+
+  it 'should handle negation with ~' do
+    query = ((ident.name == 'Ryan') & ~(ident.lat > 40))
+    expect(query.to_query).to eq(
+      [
+        "c",
+        ["c", ["c", "ident", "name"], "==", "Ryan"],
+        "&",
+        ["c",
+         ["c", ["c", "ident", "lat"], ">", 40],
+         "~"
+         ]
+      ]
+    )
+  end
+
+  it 'should handle arrays as call arguments' do
+    query = (ident.name == [1,2,3])
+    expect(query.to_query).to eq(["c", ["c", "ident", "name"], "==", ["a", 1, 2, 3]])
+  end
+
+  it 'should handle =~' do
+    query = (ident.name =~ 'Bob')
+    expect(query.to_query).to eq(["c", ["c", "ident", "name"], "=~", "Bob"])
+  end
+
+  # This code fails until the following is fixed:
+  # https://github.com/opal/opal/issues/1138
+  # it 'should handle !~' do
+  #   query = (ident.name !~ 'Bob')
+  #   expect(query.to_query).to eq(["c", ["c", "ident", "name"], "!~", "Bob"])
+  # end
+
+  it 'should handle addition and comparison' do
+    query = (ident.pounds + 10 < 20)
+    expect(query.to_query).to eq(
+      [
+        "c",
+        [
+          "c",
+          ["c", "ident", "pounds"],
+          "+",
+          10
+        ],
+        "<",
+        20
+      ]
+    )
+  end
+
+  it 'should handle method calls like max'
+end

data/spec/queries/query_runner_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+if RUBY_PLATFORM != 'opal'
+  class ::QPost < Volt::Model
+    has_many :q_comments
+  end
+
+  class ::QComment < Volt::Model
+    belongs_to :q_post
+  end
+
+  describe Volt::QueryRunner do
+    it 'should run queries' do
+      data_store = double('data store')
+
+      query = [[:where, {user_id: 5}]]
+
+      result = [{id: 1, user_id: 5, title: 'Some post'}]
+      expect(data_store).to receive(:query).with('q_posts', query).and_return(result)
+
+      query_runner = Volt::QueryRunner.new(data_store, 'q_posts', query)
+
+      expect(query_runner.run).to eq(result)
+    end
+
+    it 'should run sub queries' do
+      data_store = double('data store')
+
+      query = [[:where, {user_id: 5}], [:includes, :q_comments]]
+
+      result1 = [
+        {id: 1, user_id: 5, title: 'Some post'},
+        {id: 2, user_id: 5, title: 'Another Post'}
+      ]
+      expect(data_store).to receive(:query).with(:q_posts, [[:where, {user_id: 5}]])
+      .and_return(result1)
+
+      query2 = [[:where, {:q_post_id=>[1, 2]}]]
+
+      result2 = [
+        {id: 4, q_post_id: 1, body: 'Some comment'},
+        {id: 5, q_post_id: 1, body: 'Another comment'},
+        {id: 6, q_post_id: 2, body: 'The best comment'}
+      ]
+      expect(data_store).to receive(:query).with(:q_comments, query2)
+      .and_return(result2)
+
+      query_runner = Volt::QueryRunner.new(data_store, :q_posts, query)
+
+      result3 = [
+        {id: 1, user_id: 5, title: 'Some post', q_comments: [
+           {id: 4, q_post_id: 1, body: 'Some comment'},
+           {id: 5, q_post_id: 1, body: 'Another comment'}
+        ]},
+        {id: 2, user_id: 5, title: 'Another Post', q_comments: [
+           {id: 6, q_post_id: 2, body: 'The best comment'}
+        ]}
+      ]
+
+      expect(query_runner.run).to eq(result3)
+    end
+  end
+end

data/spec/queries/query_tracker_spec.rb

@@ -0,0 +1,141 @@
+# if RUBY_PLATFORM != 'opal'
+#   describe 'LiveQuery' do
+#     # LiveQueryStub behaves as the front-end would with the changes to a
+#     # live query.  Instead of passing changes to the models to the front
+#     # end, the changes are applied locally, then can be checked to see if
+#     # the correct transitions have taken place.
+#     class LiveQueryStub
+#       attr_reader :collection, :query, :items
+#       def initialize
+#         @collection = '_items'
+#         @query = {}
+#         @items = []
+#       end
+
+#       def notify_removed(ids, skip_channel)
+#         # Remove the id's that need to be removed
+#         @items.reject! { |item| ids.include?(item[:id]) }
+#       end
+
+#       def notify_added(index, data, skip_channel)
+#         @items.insert(index, data)
+#       end
+
+#       def notify_moved(id, index, skip_channel)
+#         item = @items.find { |item| item[:id] == id }
+#         @items.delete(item)
+
+#         @items.insert(index, item)
+#       end
+
+#       def notify_changed(id, data, skip_channel)
+#         item = @items.find { |item| item[:id] == id }
+#         idx  = @items.index(item)
+#         @items.delete(item)
+#         @items.insert(idx, data)
+#       end
+#     end
+
+#     before do
+#       # Setup a live query stub
+#       @live_query = LiveQueryStub.new
+#       data_store = double('volt/data store')
+
+#       # return an empty collection
+#       @items = []
+#       expect(data_store).to receive(:query).at_least(:once) { @items.dup }
+
+#       @query_tracker = QueryTracker.new(@live_query, data_store)
+#       @query_tracker.run
+#     end
+
+#     it 'should add items' do
+#       @items = [
+#         { id: 1, name: 'one' }
+#       ]
+
+#       expect(@live_query.items).to eq([])
+
+#       @query_tracker.run
+
+#       expect(@live_query.items).to eq(@items)
+#     end
+
+#     it 'should remove items' do
+#       @items = [
+#         { id: 1, name: 'one' },
+#         { id: 2, name: 'two' }
+#       ]
+#       @query_tracker.run
+#       expect(@live_query.items).to eq(@items)
+
+#       @items = [
+#         { id: 2, name: 'two' }
+#       ]
+#       @query_tracker.run
+#       expect(@live_query.items).to eq(@items)
+#     end
+
+#     it 'should move items' do
+#       @items = [
+#         { id: 1, name: 'one' },
+#         { id: 2, name: 'two' },
+#         { id: 3, name: 'three' }
+#       ]
+#       @query_tracker.run
+#       expect(@live_query.items).to eq(@items)
+
+#       @items = [
+#         { id: 2, name: 'two' },
+#         { id: 3, name: 'three' },
+#         { id: 1, name: 'one' }
+#       ]
+#       @query_tracker.run
+#       expect(@live_query.items).to eq(@items)
+#     end
+
+#     it 'should handle complex transforms' do
+#       @items = [
+#         { id: 1, name: 'one' },
+#         { id: 2, name: 'two' },
+#         { id: 3, name: 'three' },
+#         { id: 4, name: 'four' },
+#         { id: 5, name: 'five' }
+#       ]
+#       @query_tracker.run
+#       expect(@live_query.items).to eq(@items)
+
+#       @items = [
+#         { id: 7, name: 'seven' },
+#         { id: 4, name: 'four' },
+#         { id: 1, name: 'one' },
+#         { id: 5, name: 'five' },
+#         { id: 3, name: 'three' },
+#         { id: 6, name: 'five' }
+#       ]
+#       @query_tracker.run
+#       expect(@live_query.items).to eq(@items)
+#     end
+
+#     it 'should notify data hash has changed' do
+#       @items = [
+#         { id: 1, name: 'one' },
+#         { id: 2, name: 'two' },
+#         { id: 3, name: 'three' },
+#         { id: 4, name: 'four' },
+#         { id: 5, name: 'five' }
+#       ]
+#       @query_tracker.run
+#       @items = [
+#         { id: 1, name: 'some' },
+#         { id: 2, name: 'values' },
+#         { id: 3, name: 'have' },
+#         { id: 4, name: 'changed' },
+#         { id: 5, name: 'other' }
+#       ]
+#       expect(@live_query.items).to_not eq(@items)
+#       @query_tracker.run
+#       expect(@live_query.items).to eq(@items)
+#     end
+#   end
+# end

data/spec/router/routes_spec.rb

@@ -63,18 +63,22 @@ describe Volt::Routes do
     end
 
     param_matches = @routes.instance_variable_get(:@param_matches)
-    expect(param_matches[:client].map { |v| v[0] }).to eq([
-      { view: 'blog' },
-      { view: 'blog/show', id: nil },
-      { view: 'blog/edit', id: nil },
-      { view: 'blog/tag', tag: nil },
-      { view: 'login', action: 'user', name: nil, id: nil }
-    ])
-
-    expect(param_matches[:get].map { |v| v[0] }).to eq([
-      { controller: 'articles', action: 'index' },
-      { controller: 'articles', action: 'show', id: nil }
-    ])
+    expect(param_matches[:client].map { |v| v[0] }).to eq(
+      [
+        { view: 'blog' },
+        { view: 'blog/show', id: nil },
+        { view: 'blog/edit', id: nil },
+        { view: 'blog/tag', tag: nil },
+        { view: 'login', action: 'user', name: nil, id: nil }
+      ]
+    )
+
+    expect(param_matches[:get].map { |v| v[0] }).to eq(
+      [
+        { controller: 'articles', action: 'index' },
+        { controller: 'articles', action: 'show', id: nil }
+      ]
+    )
   end
 
   it 'should match routes' do
@@ -92,6 +96,10 @@ describe Volt::Routes do
       put '/people', controller: 'people', action: 'update'
       patch '/people/1', controller: 'people', action: 'update'
       delete '/people/2', controller: 'people', action: 'destroy'
+      client '/pics/new/{{ new_id }}/two', controller: 'pics', action: 'new'
+      client '/pics/{{ pic_id }}/view/one', controller: 'pics', action: 'view'
+      client '/pics/{{ *pic_id }}', controller: 'pics', action: 'show'
+      get '/wide_match/{{ *path_parts }}', controller: 'wide_match', action: 'show'
     end
 
     params = @routes.url_to_params('/blog')
@@ -122,7 +130,7 @@ describe Volt::Routes do
     expect(params).to eq(controller: 'articles', action: 'index')
 
     params = @routes.url_to_params(:post, '/articles')
-    expect(params).to be_nil
+    expect(params).to eq(false)
 
     params = @routes.url_to_params(:post, '/comments')
     expect(params).to eq(controller: 'comments', action: 'create')
@@ -141,6 +149,29 @@ describe Volt::Routes do
 
     params = @routes.url_to_params(:put, '/articles/2/comments/9')
     expect(params).to eq(controller: 'comments', action: 'update', articles_id: '2', id: '9')
+
+    params = @routes.url_to_params('/pics/new/view/one')
+    expect(params).to eq({controller: "pics", action: "view", pic_id: "new"})
+
+    params = @routes.url_to_params('/pics/new/view/two')
+    expect(params).to eq({controller: "pics", action: "new", new_id: "view"})
+
+    params = @routes.url_to_params('/pics/new/view/three')
+    expect(params).to eq({controller: "pics", action: "show", pic_id: "new/view/three"})
+
+    params = @routes.url_to_params(:get, '/wide_match/some/image/path/file.png')
+    expect(params).to eq({controller: "wide_match", action: "show", path_parts: "some/image/path/file.png"})
+
+    params = @routes.url_to_params(:get, '/wide_match/http://something/cool.jpg')
+    expect(params).to eq({controller: "wide_match", action: "show", path_parts: "http://something/cool.jpg"})
+  end
+
+  it 'should raise an error if the splat match isn\'t at the end of the url' do
+    expect do
+      routes do
+        client '/blog/{{ *slug }}/after', view: 'blog'
+      end
+    end.to raise_error('The splat (*) operator can only be used at the end of a url')
   end
 
   it 'should go from params to url' do
@@ -279,16 +310,16 @@ describe Volt::Routes do
     params = @routes.url_to_params(:get, '/api/v1/articles/1')
     expect(params).to eq(controller: 'articles', action: 'show', id: '1')
 
-    expect(@routes.url_to_params(:post, '/api/v1/articles')).to be_nil
-    expect(@routes.url_to_params(:put, '/api/v1/articles/1')).to be_nil
-    expect(@routes.url_to_params(:delete, '/api/v1/articles/1')).to be_nil
+    expect(@routes.url_to_params(:post, '/api/v1/articles')).to eq(false)
+    expect(@routes.url_to_params(:put, '/api/v1/articles/1')).to eq(false)
+    expect(@routes.url_to_params(:delete, '/api/v1/articles/1')).to eq(false)
 
     routes do
       rest '/api/v1/articles', controller: 'articles', only: [:update, :destroy, :create]
     end
 
-    expect(@routes.url_to_params(:get, '/api/v1/articles')).to be_nil
-    expect(@routes.url_to_params(:get, '/api/v1/articles/1')).to be_nil
+    expect(@routes.url_to_params(:get, '/api/v1/articles')).to eq(false)
+    expect(@routes.url_to_params(:get, '/api/v1/articles/1')).to eq(false)
 
     params = @routes.url_to_params(:post, '/api/v1/articles')
     expect(params).to eq(controller: 'articles', action: 'create')
@@ -311,8 +342,8 @@ describe Volt::Routes do
     params = @routes.url_to_params(:get, '/api/v1/articles/1')
     expect(params).to eq(controller: 'articles', action: 'show', id: '1')
 
-    expect(@routes.url_to_params(:post, '/api/v1/articles')).to be_nil
-    expect(@routes.url_to_params(:put, '/api/v1/articles/1')).to be_nil
-    expect(@routes.url_to_params(:delete, '/api/v1/articles/1')).to be_nil
+    expect(@routes.url_to_params(:post, '/api/v1/articles')).to eq(false)
+    expect(@routes.url_to_params(:put, '/api/v1/articles/1')).to eq(false)
+    expect(@routes.url_to_params(:delete, '/api/v1/articles/1')).to eq(false)
   end
 end

data/spec/server/middleware/rack_content_types_spec.rb

@@ -0,0 +1,78 @@
+if RUBY_PLATFORM != 'opal'
+  require 'spec_helper'
+
+  describe Rack::HttpContentTypes do
+    include Rack::Test::Methods
+
+    let(:app) { Volt.current_app.middleware }
+
+    describe 'with default parser' do
+      it "allows you to setup parsers for content types" do
+        middleware = Rack::HttpContentTypes.new Volt, :parsers => { 'foo' => 'bar' } 
+        expect(middleware.parsers['foo']).to eq('bar')
+      end
+
+      it "allows you to setup error handlers" do
+        middleware = Rack::HttpContentTypes.new Volt, :handlers => { 'foo' => 'bar' } 
+        expect(middleware.handlers['foo']).to eq('bar')
+      end
+
+      it "parses params from Content-Type: application/json" do
+        payload = JSON.dump(:a => 1)
+        post '/simple_http', payload, { 'CONTENT_TYPE' => 'application/json' }
+        expect(last_response).to be_ok
+        expect(last_response.body).to match(/a: 1/)
+      end
+
+      it "does not handle params from unknown Content-type" do
+        payload = JSON.dump(:a => 1)
+        post '/simple_http', payload, { 'CONTENT_TYPE' => 'application/unknown' }
+        expect(last_response).to be_ok
+        expect(last_response.body).to_not match(/a: 1/)
+      end
+
+      it "matches Content-Type by regex" do
+        payload = JSON.dump(:a => 1)
+        post '/simple_http', payload, { 'CONTENT_TYPE' => 'application/vnd.foo+json' }
+        expect(last_response).to be_ok
+        expect(last_response.body).to match(/a: 1/)
+      end
+
+      it "handles custom json parser" do
+        Volt.setup do |config|
+          config.http_content_types = {
+            parsers:{
+              'application/json' => proc { |body| {'rick_says' => 'never gonna let you down'} }
+            }
+          }
+        end
+        payload = JSON.dump(:a => 1)
+        post '/simple_http', payload, { 'CONTENT_TYPE' => 'application/json' }
+        expect(last_response).to be_ok
+        expect(last_response.body).to match(/never gonna let you down/)
+      end
+    end
+
+    describe 'with custom parser' do
+      before do
+        Volt.setup do |config|
+          config.http_content_types = {
+            parsers: {
+              'application/roll' => proc { |body| {'rick_says' => 'never gonna give you up'}}
+            }
+          }
+        end
+      end
+
+      it "handles custom content types" do
+        #see spec/apps/kitchen_sink/config/app.rb
+        payload = JSON.dump(:a => 1)
+        post '/simple_http', payload, { 'CONTENT_TYPE' => 'application/roll' }
+        expect(last_response).to be_ok
+        expect(last_response.body).to match(/never gonna give you up/)
+      end
+    end
+
+
+  end
+end